在将dijkstra算法应用于此时，我该如何处理以下情况？

Question

所以，我正在解决以下问题：http://www.spoj.com/problems/ROADS/en/

以数字 1 ... N 命名的 N 个城市与单向道路相连。每条道路都有两个与之相关的参数：道路长度和道路需要支付的通行费（以硬币数量表示）。鲍勃和爱丽丝曾经住在城市 1。在注意到爱丽丝在他们喜欢玩的纸牌游戏中作弊后，鲍勃与她分手并决定搬走 - 到城市 N。他想尽快到达那里可能，但他缺钱。我们想帮助 Bob 找到他有钱可以负担的从城市 1 到城市 N 的最短路径。

输入

输入以测试用例的数量 t 开始。然后是 t 个测试用例。每个测试用例的第一行包含整数 K，0

输出

对于每个测试用例，输出一行包含从城市 1 到城市 N 的最短路径的总长度，其总通行费小于或等于 K 个硬币。如果该路径不存在，则输出-1。

现在，我所做的是，我尝试使用 djikstra 的算法，如下所示：

我不是只有一个节点作为状态，而是 节点和硬币作为一种状态，然后应用dijkstra。 长度是状态之间的权重。 我在不超过总硬币的情况下最小化长度。

我的代码如下：

using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair

class node
{
public:
    int vertex;
    int roadlength;
    int toll;
};

int dist[101][101]; // for storing roadlength
bool visited[101][10001];
int cost[101][101]; // for storing cost
int ans[101][10001]; // actual distance being stored here
void djikstra(int totalcoins, int n);

bool operator < (node a, node b)
{
    if (a.roadlength != b.roadlength)
        return a.roadlength < b.roadlength;
    else if (a.toll != b.toll)
        return a.toll < b.toll;
    return a.vertex < b.vertex;
}

int main (void)
{
    int a,b,c,d;
    int r,t,k,n,i,j;
    cin>>t;
    while (t != 0)
    {
        cin>>k>>n>>r;
        for (i = 1; i <= 101; i++)
            for (j = 1; j <= 101; j++)
                dist[i][j] = INT_MAX;

        for (i = 0; i <= n; i++)
            for (j = 0; j <= k; j++)
                ans[i][j] = INT_MAX;

        for ( i = 0; i <= n; i++ )
            for (j = 0; j <= k; j++ )
                visited[i][j] = false;

        for (i = 0; i < r; i++)
        {
            cin>>a>>b>>c>>d;
            if (a != b)
            {
                dist[a][b] = c;
                cost[a][b] = d;
            }
        }
        djikstra(k,n);
        int minlength = INT_MAX;
        for (i = 1; i <= k; i++)
        {
            if (ans[n][i] < minlength)
                minlength = ans[n][i];
        }
        if (minlength == INT_MAX)
            cout<<"-1\n";
        else
            cout<<minlength<<"\n";
        t--;
    }
    cout<<"\n";
    return 0;
}

void djikstra(int totalcoins, int n)
{
    set<node> myset;
    myset.insert((node){1,0,0});
    ans[1][0] = 0;
    while (!myset.empty())
    {
        auto it = myset.begin();
        myset.erase(it);
        int curvertex = it->vertex;
        int a = it->roadlength;
        int b = it->toll;
        if (visited[curvertex][b] == true)
            continue;
        else
        {
            visited[curvertex][b] = true;
            for (int i = 1; i <= n; i++)
            {
                if (dist[curvertex][i] != INT_MAX)
                {
                    int foo = b + cost[curvertex][i];
                    if (foo <= totalcoins)
                    {
                        if (ans[i][foo] >= ans[curvertex][b] + cost[curvertex][i])
                        {
                            ans[i][foo] = ans[curvertex][b] + cost[curvertex][i];
                            myset.insert((node){i,ans[i][foo],foo});
                        }
                    }
                }
            }
        }
    }
}

现在，我有两个疑问：

1. 首先，对于问题的第一个给定测试用例，我的输出不正确，即

   Sample Input:

   2
   5
   6
   7
   1 2 2 3
   2 4 3 3
   3 4 2 4
   1 3 4 1
   4 6 2 1
   3 5 2 0
   5 4 3 2
   0
   4
   4
   1 4 5 2
   1 2 1 0
   2 3 1 1
   3 4 1 0
   
   Sample Output:
   11
   -1
   

我的输出结果是4 -1，这对于第一个测试用例来说是错误的。我哪里错了？

1. 如何处理具有多个边缘的情况？也就是问题提到，Notice that different roads may have the same source and destination cities.这种情况怎么处理？

Answer 1

存储道路的简单方法是作为向量的向量。对于每个起点城市，您都希望拥有从该城市通往的所有道路的矢量。

因此，当您处理已发现的通往某个城市的“最佳”路径时，您将遍历该城市的所有道路，以查看它们是否可能是通往其他城市的“最佳”路径。

和以前一样，您有两个相互影响的“最佳”定义，而不是简单地组合成一个定义。最短更重要，因此“最佳”的主要定义是最短的，仅在平局的情况下才考虑最便宜。但是您还需要仅考虑最便宜的“最佳”的替代定义。

正如我针对另一个问题所建议的那样，您可以按照“最佳”的主要定义进行排序，这样您就始终先处理该定义中较好的路径，然后再处理较差的路径。然后，您需要针对“最佳”的第二个定义跟踪迄今为止所见的最佳，以便您仅在第二个定义中没有更好的路径时从处理中修剪路径，而这些路径在您已经处理的第一个定义优先级。

Answer 2

我没有读过你的代码，但是我可以告诉你这个问题不能用未经修改的 Dijkstra 算法解决。

这个问题至少和二进制 knapsack problem 一样难。如何？这个想法是在所述问题中构建背包问题。由于已知背包问题在多项式时间内无法解决，因此上述问题也不是。由于 Dijkstra 算法是多项式算法，因此不能适用。

考虑一个具有一组D 多个值X 和一个最大值m = max(X) 的二元背包问题。现在构建提出的问题：

假设有D + 1 城市n 通过两条道路与城市n + 1 相连。让城市1 到D 唯一对应X 中的一个值v。让从这样一个城市n 出发的两条道路只通往城市n + 1，一条成本为v，距离为m - v + 1，另一条成本为0，距离为m + 1。

从本质上讲，“一分钱一分货”——每花一分钱，您的行程就会缩短一个单位。

这将问题重新定义为“鲍勃只在每次通行费上不花钱或只花钱一次，最多可以花多少钱？”这和我们一开始的二元背包问题是一样的。

因此，如果我们解决了所述问题，我们也可以解决二元背包问题，因此所述问题不能比二元背包问题更“有效”——使用 Dijkstra 算法。