Question

所以我试图使用修改后的Bellman Ford算法来找到从起始顶点到结束顶点的最短路径但是我不能超过一定距离。所以给出一个带边的图：

0 1 100 30
0 4 125 50
1 2 50 250 
1 2 150 50 
4 2 100 40 
2 3 90 60 
4 3 125 150

其中每一行代表一条边，第一个值是起始顶点，第二个值是结束顶点，第三个是成本，第四个是距离。使用我现在的代码，当我尝试找到从0到3的最便宜路径而不超过140时，它产生0（默认情况下没有找到路径）而不是340（最便宜路径的成本）。有关如何更改代码的任何建议。

要将代码复制到下面，因为这个网站不允许我做任何其他事情。

 static void BellmanFord(struct Graph *graph, int source, int ending, int max){

 int edges = graph->edgeCount;
 int vertices = graph->verticesCount;
 int* money = (int*)malloc(sizeof(int) * vertices);
 int* distance = (int*)malloc(sizeof(int) * vertices);

 for (int I = 0; I < vertices; I++){
       distance[I] = INT_MAX;
       money[I] = INT_MAX;
  }
  distance[source] = 0;
  money[source] = 0;

 for (int I = 1; I <= vertices - 1; ++I){
      for int j = 0; j < edges; ++j){
           int u = graph->edge[j].Source;
           int v = graph->edge[j].Destination;
           int Cost = graph->edge[j].cost;
           int Duration = graph->edge[j].duration;

           if ((money[u] != INT_MAX) && (money[u] + Cost < money[v])){
               if (distance[u] + Duration <= max){
                    money[v] = money[u] + Cost;
                    distance[v] = distance[u] + Duration;
                }
           }
      }
  }

  if (money[ending] == INT_MAX) cout << "0" << endl;
  else cout << money[ending] << endl;
}

请帮忙！这可能不是那么难，但总决赛正在强调我

Answer 1

这个问题，被称为“约束最短路径”问题，比这更难解决。你提供的算法没有解决它，根据图的结构，只有可能捕获解决方案，只有运气。

如果此算法应用于您提供的图表max-distance = 140，则无法找到解决方案0-->1-->2-->3（使用边1 2 150 50），总费用为340距离为140.

我们可以通过在更新时将更新记录到节点来观察失败的原因，结果如下：

from node       toNode      newCost      newDistance

0                1              100          30

0                4              125          50

1                2              250          80

4                2              225          90

这里的算法被卡住了，不能再进一步了，因为从这一点开始的任何进展都会导致路径超过最大距离（140）。如您所见，节点2在遵循最大距离约束的同时找到了路径0-->4--2，它是节点0中成本最低的路径。但是现在，从2到3的任何进度都将超过140的距离（它将是150，因为2> 3的距离为60.）

使用max-distance=150再次运行会找到路径0 - >＆gt; 4-＆gt; 3，费用为315，距离为150.

from node       toNode      newCost      newDistance

0                1              100          30

0                4              125          50

1                2              250          80

4                2              225          90

2                3              315         150

显然，这不是尊重距离约束的最低成本路径;在第一个例子中，正确的应该是相同的（它找不到）。这再次证明了算法的失败;这次它提供了一个解决方案但不是最佳解决方案。

总之，这不是编程错误或代码中的错误，只是算法不适合所述问题。

Answer 2

好的，就在

之前

if (money[ending] == INT_MAX) cout << "0" << endl;

我添加了一些使其有效的代码，但我想知道它是否适用于每个案例，或者是否需要稍作修改。

   if (money[ending] == INT_MAX){
       for (int j = 0; j < edges; ++j){
             int u = graph->edge[j].Source;
             int v = graph->edge[j].Destination;
             int Cost = graph->edge[j].cost;
             int Duration = graph->edge[j].duration;

             if ((distance[u] != INT_MAX) && (distance[u] +Duration < distance[v])){
                 if (distance[u] + Duration <= max){
                      money[v] = money[u] + Cost;
                       distance[v] = distance[u] + Duration;
                  }
             }
       }
 }

最短路径有两个变量

2 个答案: