单源最短路总结

动态更新中

A Dijkstra

先贴模板，邻接表形式的（吉林大学的模板）

#define INF 0x03F3F3F3F
const int N;
int path[N], vis[N];
void Dijkstra(int cost[][N], int lowcost[N], int n, int beg){
     int i, j, min;
     memset(vis, 0, sizeof(vis));
     vis[beg] = 1;
     for (i=0; i<n; i++){
      lowcost[i] = cost[beg][i]; path[i] = beg;
    }
    lowcost[beg] = 0;
    path[beg] = -1;  // 树根的标记
    int pre = beg;
    for (i=1; i<n; i++){
        min = INF;
        for (j=0; j<n; j++)
    // 下面的加法可能导致溢出,INF不能取太大
        if (vis[j]==0 && lowcost[pre]+cost[pre][j]<lowcost[j]){
            lowcost[j] = lowcost[pre] + cost[pre][j];
            path[j] = pre;
        }
        for (j=0; j<n; j++)
            if (vis[j] == 0 && lowcost[j] < min){
                min = lowcost[j]; pre = j;
            }
        vis[pre] = 1;
    }
}

再贴链式前向星+优先队列的，适合于大量节点跟边的（这个其实求的是源点到各个点的最短路径的和）poj 1511可以用

//
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

#define ll long long
const int INF = 1000000100;
const int N =  1000000+10;
int head[N],lowcost[N],path[N],vis[N],n,m;

struct Edge{
    int to,next;
    int w;
}e[N];
struct qnode{
    int v,c;//c--cost
    qnode(int vv=0,int cc=0):v(vv),c(cc){}
    bool operator< (const qnode& r) const{ return c>r.c; }
};
void Addedge(int u, int v, int w, int k)
{
    e[k].w=w;
    e[k].to=v;
    e[k].next=head[u];
    head[u]=k;
}

void Init()
{
    int u,v,w;
    memset(head,-1,sizeof(head));
    memset(path,-1,sizeof(path));
    memset(vis, 0, sizeof(vis));
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n;i++)lowcost[i]=INF;
    for(int i=0;i<m;i++)
        scanf("%d%d%d",&u,&v,&w),Addedge(u-1,v-1,w,i);
}


void Dij(const int src)
{
    qnode mv;
    int i,j,k,pre;
    priority_queue<qnode>que;
    vis[src]=1,lowcost[src]=0;
    que.push(qnode(src,0));
    for(pre=src,i=1;i<n;i++)
    {
        for(j=head[pre];j!=-1;j=e[j].next)
        {
            k=e[j].to;
            if(!vis[k] && lowcost[pre]+e[j].w<lowcost[k])
            {
                lowcost[k]=lowcost[pre]+e[j].w;
                que.push(qnode(e[j].to,lowcost[k]));
                path[k]=pre;
            }
        }
        while(!que.empty() && vis[que.top().v] == 1)que.pop();
        if(que.empty())break;
        mv=que.top();que.pop();
        vis[pre=mv.v]=1;
    }
}

int solve()
{
    int ans=0;
    for(int i=1;i<n;i++)
        ans+=lowcost[i];
    return ans;
}

int main()
{
    //freopen("poj1511.txt","r",stdin);
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        Init();
        Dij(0);
        printf("%d\n",solve());
    }
    return 0;
}

一、注意题目中规定的源点到底是0还是n，以及0到底是不是顶点，看好自己的模板，别用错

二、注意输入的时候判重边

w=min(w,cost[u][v]);

三、单源最短路其实把<改为>是可以变成单源最长路的

如zoj 1655  每条路的权值是货物经损耗之后留下的比率，所以越大越好 

此时的初始化：将四、里的几处，按照题意相应做更改

四、最短路初始化：

cost[][]在读入之前初始化为最大值，lowcost[]初始化为最大值，另外在求最短路的过程中，min那个参数初始化为最大值

B、Bellman-Ford

模板一：矩阵存储

//邻接矩阵存储 O(n^3)+输出
#include <cstdio>
#include <cstring>

using namespace std;

const int INF = 1000000; //无穷大
const int MAXN = 8; //顶点个数

int n,m;
int e[MAXN][MAXN],dist[MAXN],path[MAXN];

void Bellman(int v0)//v0--soure
{
    int i,j,l,u,k;
    for(i=0;i<n;i++)//一条边的时候
    {
        dist[i]=e[v0][i];
        if(i!=v0 && dist[i]<INF)path[i]=v0;
        else path[i]=-1;
    }
    for(k=2;k<n;k++)
    {
        for(u=0;u<n;u++)
        {
            if(u!=v0)
            {
                for(j=0;j<n;j++)
                {
                    if(e[j][u]<INF && dist[j]+e[j][u]<dist[u])
                    {
                        dist[u]=dist[j]+e[j][u];
                        path[u]=j;
                    }
                }
            }
        }
    }
}

void output()
{
    int shortest[MAXN];
    for(int i=1;i<n;i++)
    {
        printf("%d\t", dist[i]);
        memset(shortest, 0, sizeof(shortest));
        int k=0;
        shortest[k]=i;
        while(path[shortest[k]]!=0)
        {
            k++;shortest[k]=path[ shortest[k-1] ];
        }
        k++;shortest[k]=0;
        for(int j=k;j>0;j--)
            printf("%d-",shortest[j]);
        printf("%d\n",shortest[0]);
    }
}

int main()
{
    int u,v,w;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&u,&v,&w); //权值按整数
        e[u][v]=w;   //有向边
    }
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        {
            if(i == j)e[i][j]=0;
            else if(e[i][j]==0)e[i][j]=INF;
        }
    Bellman(0);
    output();

    return 0;
}

模板二：链式前向星（poj2240的模板  比例路径）：

#include<cstdio>
#include<cstring>
#include <string>
#include <map>
#include <iostream>
using namespace std;
//#define INF 0x0f0f0f0f
const double INF = 0;
#define MAXN 1011
#define Max(a,b) (a)>(b)?(a):(b)
struct Node{
   int to;
   double w;
   int next;
}edge[MAXN];
int head[MAXN],s,n,m,path[MAXN];
double dist[MAXN];//注意w以及该数组的类型
using namespace std;
void init()
{
    memset(head,-1,sizeof(head));
    memset(path,-1,sizeof(path));

}

void addEdge(int u,int v,double w,int k)
{
    edge[k].to=v;
    edge[k].w=w;
    edge[k].next=head[u];
    head[u]=k;/*起点为u的边为edge[k]*/
}
int Bellman_Ford(int v0)//v0--soure
{
    for(int i=0;i<n;i++)dist[i]=0;//1.0;
    dist[v0]=1;
    int i,j,l,u,k;

    for(int i=1;i<n;i++)
        for(u=0;u<n;u++)
        {
            for(j=head[u];j!=-1;j=edge[j].next)
            {
                if(dist[u]*edge[j].w>dist[edge[j].to])
                {
                        dist[edge[j].to]= dist[u]*edge[j].w;
                        path[edge[j].to]=u;
                }
            }

        }

    for(int j=0;j<n;j++)
    {
        for(k=head[j];k!=-1;k=edge[k].next)
        {
            if(edge[k].to == v0 && dist[j]*edge[k].w>1.0)//dist[edge[k].to])
                return 1;
        }
    }
    return 0;
}

int main()
{
    //freopen("poj2240.txt","r",stdin);
    int icase=0,flag;
    double w;
    string u,v;
    string str;
    while(scanf("%d",&n) && n)
    {
        init();
        map<string, int>ss;
        for(int i=0;i<n;i++)
        {
            cin>>str;
            ss[str]=i;
        }
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            cin >> u >> w >> v;
            addEdge(ss[u],ss[v],w,i);
        }
        flag=1;
        for(int i=0;i<n;i++)
        {
            if(Bellman_Ford(i)){flag=0;printf("Case %d: Yes\n",++icase);break;}

        }
        if(flag) printf("Case %d: No\n",++icase);
    }
    return 0;
}

一、注意dist的初始化，如果找所有的环的话，那么需要以所有的点为原点遍历，那么dist就需要初始化很多次，所以吧这个代码放到Bellman_Flod函数里面

二、 Bellman-Ford求环，可以将原来的n-1次循环（就是最多经过n-1条边时最短路径），改为n次循环，当然也可以再把判负权的代码改了，相当于第n次。  这就是我下面贴的两个版本的代码：