vector<int> dijkstra(costMatrix[][])
{
....
....
return vector<int>pathPointindex
}
main()
{
vector<Point> availablePoints;
costMatrix[][]=createCostMatrix();
vector<int> indexes=dijikstra(costMatrix)
for(int i=0;i<indexes.size();i++)
cout << "path points are " << availablePoints[indexes[i]] << endl;
}
如果有人，请您发布代码。我不懒。但是我的项目已经在一天前跨越了截止日期。现在我失去了理解逻辑的希望。现在我想要这个功能。 “一个有需要的人确实是天使”。
编辑：特别感谢“Loki astari”的出色回答
答案 0 :(得分：38)
这是一种用于找到从A点到B点的最短路线的算法 在计算术语中，我们简化了由节点和弧组成的图形的路径。每个节点代表一个中间点，每个弧连接两个节点，并且（非负）权重表示在两个节点之间遍历的成本。
要实现该算法，您需要两个列表：
算法：
working.addNode(Start, 0); // No cost to get to start.
for( (node, cost) = working.popHead(); node != End; (node,cost) = working.popHead())
{
// If we have already processed this node ignore it.
if (finished.find(node))
{ continue;
}
// We have just removed a node from working.
// Because it is the top of the list it is guaranteed to be the shortest route to
// the node. If there is another route to the node it must go through one of the
// other nodes in the working list which means the cost to reach it will be higher
// (because working is sorted). Thus we have found the shortest route to the node.
// As we have found the shortest route to the node save it in finished.
finished.addNode(node,cost);
// For each arc leading from this node we need to find where we can get to.
foreach(arc in node.arcs())
{
dest = arc.dest();
if (NOT (finished.find(dest)))
{
// If the node is already in finished then we don't need to worry about it
// as that will be the shortest route other wise calculate the cost and add
// this new node to the working list.
destCost = arc.cost() + cost;
working.addNode(dest,destCost); // Note. Working is sorted list
}
}
}
所以如果你考虑这个算法。假设您从伦敦前往曼彻斯特。
finished = {} // empty.
working = { (London,0) }
使用以下费用矩阵：
L S O B N M W
(L) ondon - 50 60 100 130 - -
(S) outhampton 50 - 70 - - - -
(O) xford 60 70 - 50 - 200 -
(B) irmingham 100 - 50 - - 80 110
(N) orwich 130 - - - - - -
(M) anchester - - 200 80 - - 80
Ne(W) castle - - - 110 - 80 -
现在你将伦敦从工作清单中取出（因为它在头部）并将其放入完成的清单中。然后将所有直接连接到伦敦的城镇添加到工作清单中。
finished = { (London,0) }
working = { (Southampton, 50), (Oxford, 60), (Birmingham, 100), (Norwich,130) }
考虑工作区中的城镇是从伦敦扩展的泡沫的外缘。 Dijkstra算法的工作是继续扩大泡沫，直到我们击中曼彻斯特（没有回顾我们已经采取的任何步骤）。因此泡沫总是向外扩展，我们总是扩大泡沫中最小的部分。
所以下一步是抓住列表的头部并重复。从南安普敦出发，只有两个目的地。回到伦敦（我们在完成的清单中将其丢弃）和牛津。前往牛津的费用是从南安普敦到牛津的费用是50+（因此请注意它在工作清单中两次，但不要担心我们以后会丢弃它作为最佳路线）。
finished = { (London,0), (Southampton,50) }
working = { (Oxford, 60), (Birmingham, 100), (Oxford, 120), (Norwich,130) }
重复循环。名单的负责人是牛津大学。从牛津出发，我们可以去曼彻斯特（200），伯明翰（50）或回到伦敦（60）或南安普敦（请记住，我们需要增加牛津到上述每项费用的成本。请注意，从牛津我们可以有去了南安普敦但是我们已经找到了通往南安普敦的最短路线，所以不需要处理。这将留给我们：
finished = { (London,0), (Southampton,50), (Oxford, 60) }
working = { (Birmingham, 100), (Birmingham,110), (Oxford, 120), (Norwich,130), (Manchester,200)}
请注意，我们现在在工作清单中有曼彻斯特（这是我们的目的地）。但我们需要继续努力，因为我们可能会找到更短的路线。所以现在我们从伯明翰扩展。从那里我们可以去牛津（50），曼彻斯特（80），伦敦（100），纽卡斯尔（110）。这首先增加了前往伯明翰的费用：
finished = { (London,0), (Southampton,50), (Oxford, 60), (Birmingham, 100) }
working = { (Birmingham,110), (Oxford, 120), (Norwich,130), {Manchester, 180), (Manchester,200), (Newcastle, 210)}
接下来的两个节点。牛津和伯明翰已经在完成的名单中，所以我们可以忽略它们。因此，除非从诺里奇到曼彻斯特的路线不到50英里，否则我们将在此后的迭代中到达曼彻斯特。
答案 1 :(得分：13)
我建议你查看具有非常实用的apporach的TopCoder教程。
您需要了解STL优先级队列的工作原理，并确保图表中没有negative edge weights。
可以找到体面的完整实施here。您必须向其添加路径向量并实现RecoverPath方法，以便从源到接收器获取路径上的节点。要使用此解决方案，您还需要按以下方式将adjacency matrix转换为adjacency list：
for (int i=0;i<nNodes;i++)
for (int j=0;j<nNodes;j++){
if (costMatrix[i][j] != NO_EDGE_VALUE){
G[i].pb(make_pair(j,costMatrix[i],[j]));
}
}
编辑：如果您的图表密集，我会建议您使用Ford Bellman算法更简单，并且速度不应该慢得多。
EDIT2：计算你应该在标题中添加的路径
int P[MAX]; /*array with links to parents*/
for(i=0; i<=nodes; i++) P[i] = -1; /*magic unset value*/
// dijkstra
while(!Q.empty()) {
....
if(!F[v] && D[u]+w < D[v]) {
D[v] = D[u] + w;
/*By setting P[v] value we will remember what is the
previous node on path from source */
P[v] = u; // <-- added line
Q.push(pii(v, D[v]));
}
...
}
然后你必须添加RecoverPath方法（仅当路径存在时才有效）
vector<int> RecoverPath(int src, int dest){
vector<int> path;
int v = dest;
while (v != src) {
path.push_back(v);
v = P[v];
}
path.push_back(src);
std::reverse(path.begin(),path.end());
return path;
}
答案 2 :(得分：4)
#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <limits>
#include <set>
#include <utility>
#include <algorithm>
#include <iterator>
using namespace std;
typedef int vertex_t;
typedef double weight_t;
const weight_t max_weight = numeric_limits<double>::infinity();
struct neighbor {
vertex_t target;
weight_t weight;
neighbor(vertex_t arg_target, weight_t arg_weight)
: target(arg_target), weight(arg_weight) { }
};
typedef vector<vector<neighbor> > adjacency_list_t;
// Computing the shortest pathway
void
DijkstraComputePaths(vertex_t source,
const adjacency_list_t &adjacency_list,
vector<weight_t> &min_distance,
vector<vertex_t> &previous)
{
int n = adjacency_list.size();
min_distance.clear();
min_distance.resize(n, max_weight);
min_distance[source] = 0;
previous.clear();
previous.resize(n, -1);
set<pair<weight_t, vertex_t> > vertex_queue;
vertex_queue.insert(make_pair(min_distance[source], source));
while (!vertex_queue.empty())
{
weight_t dist = vertex_queue.begin()->first;
vertex_t u = vertex_queue.begin()->second;
vertex_queue.erase(vertex_queue.begin());
// Visit each edge exiting u
const vector<neighbor> &neighbors = adjacency_list[u];
for (vector<neighbor>::const_iterator neighbor_iter = neighbors.begin();
neighbor_iter != neighbors.end();
neighbor_iter++)
{
vertex_t v = neighbor_iter->target;
weight_t weight = neighbor_iter->weight;
weight_t distance_through_u = dist + weight;
if (distance_through_u < min_distance[v]) {
vertex_queue.erase(make_pair(min_distance[v], v));
min_distance[v] = distance_through_u;
previous[v] = u;
vertex_queue.insert(make_pair(min_distance[v], v));
}
}
} // while
}
答案 3 :(得分：2)
Dijkstra算法的主要思想很简单： 假设您有一组具有到达给定点A的已知最短路径的点。 然后我们假设我们想要为集合添加新的点C. 让我们找到集合中的哪些点与我们想要添加的点相关联。 让它成为点B（i） 因此，对于所有点B（i），我们将新找到A到B（i）和B（i）和C之间的距离之和。该距离中最小的将是A和C之间的最小距离。
答案 4 :(得分：1)
在c ++中实现
#include <cstdio>
#include <cstring>
#include <set>
#include <vector>
using namespace std;
#define pb push_back
#define mp make_pair
#define MAXN 50100
#define INF 1000000000
int N, M, d[MAXN]; vector<int> G[MAXN], C[MAXN];
set< pair<int, int> > T;
void solve(void)
{
int i, j, k, val, x;
for(i = 2; i <= N; i++) d[i] = INF;
T.insert( mp(0, 1) );
while( T.size() > 0 )
{
val = (*T.begin()).first, x = (*T.begin()).second;
T.erase(*T.begin());
for(i = 0; i < G[x].size(); i++)
if(d[ G[x][i] ] > val + C[x][i] )
d[ G[x][i] ] = val + C[x][i], T.insert(mp(d[G[x][i]],G[x][i]));
}
}
int main(void)
{
freopen("dijkstra.in", "rt", stdin);
freopen("dijkstra.out", "wt", stdout);
int i, a, b, c;
scanf("%d %d\n", &N, &M);
for(i = 1; i <= M; i++)
scanf("%d %d %d\n", &a, &b, &c), G[a].pb(b), C[a].pb(c);
solve();
for(i = 2; i <= N; i++)
printf("%d ", d[i] == INF ? 0 : d[i]);
return 0;
}
答案 5 :(得分：0)
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;
const size_t INT_MAX = 0xFFFFFFFF; // or any other value representing infinite distance.
首先创建一个包含源节点索引，目标节点索引和边缘＆＃34; weight＆＃34;（length）的结构边。
struct edge { size_t from; size_t to; size_t length; };
定义一个包含相邻邻居边的节点。
class Node
{
public:
void AddNeighborEdge( edge _NeighborEdge ) { m_neighborsEdges.push_back( _NeighborEdge ); }
vector<edge>::iterator FirstNeighborEdge() { return m_neighborsEdges.begin(); }
vector<edge>::iterator LastNeighborEdge() { return m_neighborsEdges.end(); }
private:
vector<edge> m_neighborsEdges;
};
class NeighborsDistanceUpdator将用作＆＃34;仿函数＆＃34;通过for_each算法，迭代传递并更新从图中当前节点到相邻邻居的最小距离。
class NeighborsDistanceUpdator
{
public:
NeighborsDistanceUpdator( vector<size_t>& _min_distance_from_source, queue< size_t >& _nodes_to_visit ) : m_min_distance_from_source( _min_distance_from_source ), m_nodes_to_visit( _nodes_to_visit )
{}
void operator()( edge& _edge )
{
size_t from = _edge.from;
size_t to = _edge.to;
if ( m_min_distance_from_source[ to ] > m_min_distance_from_source[ from ] + _edge.length )
{
m_min_distance_from_source[ to ] = m_min_distance_from_source[ from ] + _edge.length;
m_nodes_to_visit.push( to );
}
}
private:
vector<size_t>& m_min_distance_from_source;
queue< size_t >& m_nodes_to_visit;
};
对于dijkstra算法，只需在图中的所有节点上运行，并为每个节点更新距离源的最小距离（如果更少），同时保存要访问的相邻节点。
size_t dijkstra( map< size_t, Node >& _graph, size_t _sourceIndex, size_t _targetIndex )
{
vector<size_t> min_distance_from_source( _graph.size(), INT_MAX );
min_distance_from_source[ _sourceIndex ] = 0;
queue< size_t > nodes_to_visit;
nodes_to_visit.push( _sourceIndex );
NeighborsDistanceUpdator neighborsDistanceUpdator( min_distance_from_source, nodes_to_visit );
while ( ! nodes_to_visit.empty() )
{
size_t currNodeIndex = nodes_to_visit.front();
if ( currNodeIndex == _targetIndex ) return min_distance_from_source[ currNodeIndex ];
nodes_to_visit.pop();
vector<edge>::iterator firstNeighborEdge= _graph[ currNodeIndex ].FirstNeighborEdge();
vector<edge>::iterator lastNeighborEdge= _graph[ currNodeIndex ].LastNeighborEdge();
for_each( firstNeighborEdge, lastNeighborEdge, neighborsDistanceUpdator );
}
return INT_MAX;
}
...测试
int main()
{
Node node1;
Node node2;
Node node3;
Node node4;
map< size_t, Node > graph;
edge ed;
ed.from = 0;
ed.to = 1;
ed.length = 1;
node1.AddNeighborEdge( ed );
cout << "node: " << 0 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
ed.from = 0;
ed.to = 2;
ed.length = 4;
node1.AddNeighborEdge( ed );
graph.insert( make_pair( 0, node1 ) );
cout << "node: " << 0 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
ed.from = 1;
ed.to = 2;
ed.length = 1;
node2.AddNeighborEdge( ed );
cout << "node: " << 1 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
ed.from = 1;
ed.to = 3;
ed.length = 3;
node2.AddNeighborEdge( ed );
graph.insert( make_pair( 1, node2 ) );
cout << "node: " << 1 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
ed.from = 2;
ed.to = 3;
ed.length = 1;
node3.AddNeighborEdge( ed );
graph.insert( make_pair( 2, node3 ) );
cout << "node: " << 2 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
ed.from = 3;
ed.to = INT_MAX;
ed.length = INT_MAX;
node3.AddNeighborEdge( ed );
graph.insert( make_pair( 3, node4 ) );
cout << "node: " << 2 << " to: " << ed.to ;
cout << " lenth: " << ed.length << endl << endl;
cout << "min length from: 1 to 4 = " << dijkstra( graph, 0,3 ) << endl;
}