UVA 11367 Full Tank? (dij+heap+dp)

最新推荐文章于 2022-05-17 02:00:42 发布

原创最新推荐文章于 2022-05-17 02:00:42 发布 · 645 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dij

Uva 专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一种结合最短路径算法与动态规划的方法，用于解决带有限制条件的最短路径问题。具体应用场景是在一个有单位距离油耗的图中寻找从起点到终点的最经济路径，考虑车辆可在各节点补充燃油。

题意：给定一张 $n$ 个点 $m$ 条边的无向图，每条边有个距离 $D(i,j)$ ,车辆每经过一个单位的距离消耗一单位的油。，有一辆车从点 $start$ 出发前往 $end$ ，车的油箱容量为 $c$ ,在每个节点 $V_i$ 上车辆可以以 $P_i$ 的价格补充 $1$ 单位的油，现在给定 $q$ 次询问，每次询问给定出发点 $start$ ,终点 $end$ ,油箱容量 $c$ ，问能否从起点出发到达终点，并输出最短距离

思路：最短路上的dp，如果求出所有的路径，那么我们需要做一次dp或者贪心来得到最小值，但实际上我们可以使用用heap优化的dij算法，以最小花费为权重，每次加一升油，来判断当前这个状态最远能走到那里。使用 $dp[u][j]$ 表示在 $V_u$ 还剩 $j$ 升油的最小花费，对于每个状态更新与 $V_i$ 相连的点的权重，状态转移方程为

d p [V v] [j - D (u, v)] = m i n (d p [V v] [j - D (u, v)], d p [V u] [j])

$dp[V_v][j-D(u,v)]=min(dp[V_v][j-D(u,v)],dp[V_u][j])$
同时，在更新完成之后，尝试在当前点加油，状态转移方程为

d p [V u] [j + 1] = m i n (d p [V u] [j + 1], d p [V u] [j] + P u)

$dp[V_u][j+1]=min(dp[V_u][j+1],dp[V_u][j]+P_u)$

总的时间复杂度为

O (T) = O (q * c * n * log m)

$O(T)=O(q*c*n*\log m)$

#include <cstdio>
#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <string.h>
#include <cstring>
#include <cstdlib>
#include <set>
#include <algorithm>
#include <cctype>
#include<cmath>
#include <sstream>

using namespace std;
#define sp system("pause");
typedef long long ll;
typedef pair<int, int> pii;

const int MAXN = 1050;
const double PI = acos(-1.0);

vector<pii>e[MAXN];

int pri[MAXN];
int dp[MAXN][120];

struct node
{
    int p, c, w;
    node(){}
    node(int a, int b, int c) :p(a), c(b), w(c){}
    friend bool operator<(const node &x, const node &y)
    {
        return x.w > y.w;
    }
};

int dij(int st, int en, int cap)
{
    for (int i = 0; i < MAXN; i++)for (int j = 0; j < 120; j++)dp[i][j] = 100000000;
    priority_queue<node>pq;
    dp[st][0] = 0;
    pq.push(node(st, 0, 0));
    while (!pq.empty())
    {
        node tmp = pq.top();
        pq.pop();
        if (tmp.p == en)return tmp.w;
        int u = tmp.p;
        for (int i = 0; i < e[tmp.p].size(); i++)
        {
            int v = e[u][i].first;
            int d = e[u][i].second;
            if (tmp.c-d>=0&&dp[v][tmp.c - d]>tmp.w)
            {
                dp[v][tmp.c - d] = tmp.w;
                pq.push(node(v, tmp.c - d, tmp.w));
            }
        }
        if (tmp.c < cap&&dp[u][tmp.c+1]>tmp.w+pri[u])
        {
            dp[u][tmp.c + 1] = tmp.w + pri[u];
            pq.push(node(u, tmp.c + 1, dp[u][tmp.c + 1]));
        }
    }
    return -1;
}

int main()
{
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 0; i < MAXN; i++)e[i].clear();
        for (int i = 0; i < n; i++)scanf("%d", pri + i);
        for (int i = 0; i < m; i++)
        {
            int x, y, z;
            scanf("%d%d%d", &x, &y, &z);
            e[x].push_back(pii(y, z));  
            e[y].push_back(pii(x, z));
        }
        int q;
        scanf("%d", &q);
        while (q--)
        {
            int c, st, en;
            scanf("%d%d%d", &c, &st, &en);
            int ans = dij(st, en, c);
            if (ans == -1)puts("impossible");
            else printf("%d\n", ans);
        }
    }
}