POJ 3635 Full Tank（最短路径变形 + 优先队列）

题意：

给 n 个城市 m 条路，每个城市有个加油站，但是收费单价不同，现给你几个查询并给定汽车的装油量， 问你从 S 城市到 T 城市的最小费用。

思路：

1. 如果是一条路径上面的加油站问题，比较容易解决，有动规方程：dp[i][j] 即到 i 站还剩下 j 升油的费用;

2. 现在涉及到图中的类似问题，并且数据规模还挺大的，直接针对每条边都进行一次转移，会 TLE，因为中间产生了很多无用的状态;

3. 因为要求最小费用，如果到达 T 时恰好油量为 0，则此时肯定是最优解的条件之一了。所以这个时候我们借鉴 dijstra 中最短路径的思路，

   每次只加 1 升油，等价于把每个加油站又分解为 C + 1 个点，利用贪心的策略，每次寻找最小的费用即可.

 

#include <iostream>

#include <algorithm>

#include <queue>

using namespace std;



const int MAXN = 1010;

const int MAXM = 110;

const int INFS = 0x3fffffff;



struct ST {

    int u, fuel, cost;

    ST(int _u, int _fuel, int _cost) : u(_u), fuel(_fuel), cost(_cost) {}

    bool operator < (const ST& other) const { return cost > other.cost; }

};



struct edge {

    int v, d;

    edge* next;

} *V[MAXN], ES[MAXN*10*2];



int EC, price[MAXN], dp[MAXN][MAXM];

bool vis[MAXN][MAXM];



void addedge(int u, int v, int d) {

    ES[++EC].next = V[u];

    V[u] = ES + EC;

    V[u]->v = v; V[u]->d = d;

}



int bfs(int s, int t, int vol) {

    priority_queue<ST> Q;

    Q.push(ST(s, 0, 0));

    dp[s][0] = 0;



    while (!Q.empty()) {

        int u = Q.top().u;

        int fuel = Q.top().fuel;

        int cost = Q.top().cost;

        Q.pop();



        vis[u][fuel] = true;



        if (u == t)

            return cost;



        if (fuel + 1 <= vol && !vis[u][fuel+1] &&

            dp[u][fuel+1] > dp[u][fuel] + price[u]) {

                dp[u][fuel+1] = dp[u][fuel] + price[u];

                Q.push(ST(u, fuel+1, dp[u][fuel+1]));

        }



        for (edge* e = V[u]; e; e = e->next) {

            int v = e->v;

            int f = fuel - e->d;

            if (f >= 0 && !vis[v][f] && dp[v][f] > cost) {

                dp[v][f] = cost;

                Q.push(ST(v, f, cost));

            }

        }

    }

    return -1;

}



int main() {

    int n, m;

    while (~scanf("%d%d", &n, &m)) {

        for (int i = 0; i < n; i++)

            scanf("%d", &price[i]);



        EC = 0;

        memset(V, 0, sizeof(V));

        for (int i = 0; i < m; i++) {

            int u, v, d;

            scanf("%d%d%d", &u, &v, &d);

            addedge(u, v, d);

            addedge(v, u, d);

        }

        int cases;

        scanf("%d", &cases);

        while (cases--) {

            int vol, s, t;

            scanf("%d%d%d", &vol, &s, &t);



            for (int i = 0; i <= n; i++)

                for (int j = 0; j <= vol; j++)

                    dp[i][j] = INFS, vis[i][j] = false;



            int ans = bfs(s, t, vol);

            if (ans != -1)

                printf("%d\n", ans);

            else

                printf("impossible\n");

        }

    }



    return 0;

}