最短路径：Bellman-Ford算法

Dijkstra算法可以很好地解决无负权图的最短路径问题，但要是出现了负权边就会失效，这时应该使用Bellman-Ford算法（BF算法），可以解决单源最短路径问题，也可以处理有负权边的情况。

如上图所示，环可以分为零环、正环、负环三种情况（边权之和分别为0、正、负）。零环和正环不会影响最短路径；如果图中有负环，且从源点可以达到，就会影响最短路径的求解。

BF算法的主要思路：和Dijkstra算法相同，设置一个数组dis[]存放起点到各个顶点的最短距离。同时BF算法返回一个bool值，如果图中存在从起点可以到达的负环则返回false；否则返回true，dis[]数组中的值就是最短路径。对图中的边进行n-1轮操作（n为顶点个数），每轮都遍历图中所有的边：对每条边u->v，如果以u为中介点可以使dis[v]更小，则更新dis[v]。此时再对所有边进行一轮操作，判断是否有哪条边仍然满足dis[u]+length[u->v]<dis[v]，如果有说明存在负环返回false，没有则已达到最优返回true。

由于BF算法需要遍历所有的边，使用邻接表更加方便。

struct Node{
	int v;    //边的目标顶点
	int d;    //边权
}

int n;
vector<Node> Adj[MAXV];
int dis[MAXV];

bool Bellman(int s){
	fill(dis,dis+MAXV,INF);
	dis[s]=0;
	for(int i=0;i<n-1;i++){
		for(int u=0;u<n;u++){
			for(int j=0;j<Adj[u].size();j++){
				int v=Adj[u][j].v;
				if(dis[v]>dis[u]+Adj[u][j].d)
					dis[v]=dis[u]+Adj[u][j].d;
			}
		}
	}
	//判断负环
	for(int u=0;u<n;u++){
		for(int i=0;i<Adj[u].size();i++){
			int v=Adj[u][i].v;
			if(dis[v]>dis[u]+Adj[u][j].d)
				return false;
		}
	}
	return true;
}

在BF算法中，最短路径的求解方法以及有点权和边权时的做法都与Dijkstra算法是相同的。唯一不同的是计算最短路径的条数，由于会多次访问已经计算过的顶点，需设置记录前驱的数组set< int > pre[MAXV]，当遇到一条和当前最短路径长度相同的路径时，须重新计算最短路径条数。

用Bellman-Ford算法重写PAT1003：

#include <stdio.h>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;

struct Node{
    int v;
    int d;
};

const int MAXV=510;
const int INF=1000000000;
int n,m,s,d;
vector<Node> Adj[MAXV];
int dis[MAXV];
int weight[MAXV];
int w[MAXV];
int num[MAXV];
set<int> pre[MAXV];

bool Bellman(int s){
    fill(dis,dis+MAXV,INF);
    dis[s]=0;
    fill(w,w+MAXV,0);
    w[s]=weight[s];
    fill(num,num+MAXV,0);
    num[s]=1;
    for(int i=0;i<n-1;i++){
        for(int u=0;u<n;u++){
            for(int j=0;j<Adj[u].size();j++){
                int v=Adj[u][j].v;
                if(dis[v]>dis[u]+Adj[u][j].d){
                    dis[v]=dis[u]+Adj[u][j].d;
                    w[v]=w[u]+weight[v];
                    num[v]=num[u];
                    pre[v].clear();
                    pre[v].insert(u);
                }
                else if(dis[v]==dis[u]+Adj[u][j].d){
                    if(w[v]<w[u]+weight[v]){
                        w[v]=w[u]+weight[v];
                    }
                    num[v]=0;
                    pre[v].insert(u);
                    for(set<int>::iterator it=pre[v].begin();it!=pre[v].end();it++){
                        num[v]+=num[*it];
                    }
                }
            }
        }
    }
    for(int u=0;u<n;u++){
        for(int i=0;i<Adj[u].size();i++){
            int v=Adj[u][i].v;
            if(dis[v]>dis[u]+Adj[u][i].d)
                return false;
        }
    }
    return true;
}

int main(){
    int c1,c2,length;
    scanf("%d%d%d%d",&n,&m,&s,&d);
    for(int i=0;i<n;i++)
        scanf("%d",&weight[i]);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&c1,&c2,&length);
        Node e1,e2;
        e1.v=c2;
        e1.d=e2.d=length;
        e2.v=c1;
        Adj[c1].push_back(e1);
        Adj[c2].push_back(e2);
    }
    Bellman(s);
    printf("%d %d\n",num[d],w[d]);
    return 0;
}