dij算法为什么不能处理负权，以及dij算法变种

对于上面那张图，是可以用dij算法求解出正确答案，但那只是巧合而已。

我们再看看下面这张图。

dist[4] 是不会被正确计算的。 因为dij算法认为从队列出来的点，（假设为u)肯定是已经求出最短路的点，标记点u。并用点u更新其它点。

所以如果存在负权使得这个点的权值更小，那么会更新dist[u], 但是因为这个点已经被标记了，所以dij算法不会用这个点来更新其它点，所以就导致了算法的错误。

归结原因，dij算法在存在负权的时候，过早得确立某个点最短路，以至于如果这个点不是最短路，就会导致错误。

如下面的算法所示

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;

 const int N =  + ;
 struct Edge
 {
     int to,dist;
     bool operator<(const Edge&rhs)const
     {
         return dist > rhs.dist;
     }
 };
 vector<Edge> g[N];
 int dist[N];
 bool vis[N];
 void dij(int start, int n)
 {
     memset(vis,,sizeof(vis));
     for(int i=; i<=n; ++i)
         dist[i] = INF;
     priority_queue<Edge> q;
     Edge tmp,cur;
     dist[start] = cur.dist = ;
     cur.to = start;
     q.push(cur);
     while(!q.empty())
     {
         cur = q.top(); q.pop();
         int u = cur.to;

         /*
         如果u被用来更新过其它点，那么即使存在负权使得dist[u]变小，
         那么dij算法也不会再用u来更新其它点，这就是dij不能处理负权回路的原因
         */
         if(vis[u]) continue;
         vis[u] = true;
         for(int i=; i<g[u].size(); ++i)
         {
             int v = g[u][i].to;
             if(dist[v] > dist[u] + g[u][i].dist)
             {
                 tmp.dist = dist[v] = dist[u] + g[u][i].dist;
                 tmp.to = v;
                 q.push(tmp);
             }
         }
     }

 }

 int main()
 {
     int n,m,a,b,c,i;
     Edge tmp;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         for(i=; i<m; ++i)
         {
             scanf("%d%d%d",&a,&b,&c);
             tmp.to = b;
             tmp.dist=  c;
             g[a].push_back(tmp);
         }
         dij(,n);
         for(i=; i<=n; ++i)
             printf("%d ",dist[i]);
         puts("");
     }
     return ;
 }

4 4
1 2 3
1 3 2
2 3 -2
3 4 2
dist[0->4] = 0 3 1 4; wrong

那么我们可以对上面的算法进行改进，上面算法的问题在于，一个点如果被标记以后，那么这个点是不会用来更新其它点的，哪怕到这个点的最短路径减小了，也不会用来更新其它点。

所以新的改进是我们允许一个点出队列多次，只要这个点对最短路的更新有贡献。

只要dist[u]>=cur.dist   ,  那么我们就认为点u可能对最短路的更新有贡献，所以让点u去更新最短路。

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 typedef long long LL;
 const int INF = <<;
 /*
 3 3
 1 2 3
 1 3 2
 2 3 -2

 4 4
 1 2 3
 1 3 2
 2 3 -2
 3 4 2
 dist[0->4] = 0 3 1 3; correct

 */
 const int N =  + ;
 struct Edge
 {
     int to,dist;
     bool operator<(const Edge&rhs)const
     {
         return dist > rhs.dist;
     }
 };
 vector<Edge> g[N];
 int dist[N];
 //允许一个点入队列多次，是spfa算法， 可以看做是dij的变种或者bellman的变种
 void spfa(int start, int n)
 {
     for(int i=; i<=n; ++i)
         dist[i] = INF;
     priority_queue<Edge> q;
     Edge tmp,cur;
     dist[start] = cur.dist = ;
     cur.to = start;
     q.push(cur);
     while(!q.empty())
     {
         cur = q.top(); q.pop();
         int u = cur.to;
         if(dist[u]<cur.dist) continue; //这里就是允许点u用来多次更新其它点的关键
         for(int i=; i<g[u].size(); ++i)
         {
             int v = g[u][i].to;
             if(dist[v] > dist[u] + g[u][i].dist)
             {
                 tmp.dist = dist[v] = dist[u] + g[u][i].dist;
                 tmp.to = v;
                 q.push(tmp);
             }
         }
     }

 }

 int main()
 {
     int n,m,a,b,c,i;
     Edge tmp;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         for(i=; i<m; ++i)
         {
             scanf("%d%d%d",&a,&b,&c);
             tmp.to = b;
             tmp.dist=  c;
             g[a].push_back(tmp);
         }
         dij(,n);
         for(i=; i<=n; ++i)
             printf("%d ",dist[i]);
         puts("");
     }
     return ;
 }

4 4
1 2 3
1 3 2
2 3 -2
3 4 2
dist[0->4] = 0 3 1 3; correct