最短路径算法模板：Dijkstra/Floyd/Bellman-Ford模板

此处不解释算法，只写代码模板。

Dijkstra

邻接矩阵实现

#include
#include
#include
using namespace std;
const int MAX=0x3f3f3f3f;
int map[110][110];
int dis[110];
int visit[110];
/*
关于三个数组：map数组存的为点边的信息，比如map[1][2]=3，表示1号点和2号点的距离为3
dis数组存的为起始点与每个点的最短距离，比如dis[3]=5，表示起始点与3号点最短距离为5
visit数组存的为0或者1，1表示已经走过这个点。
*/
int n,m;
int dijkstra()
{
    int i,j,pos=1,min,sum=0;
    memset(visit,0,sizeof(visit));//初始化为0，表示开始都没走过
    for(i=1; i<=n; i++)
    {
        dis[i]=map[1][i];
    }
    visit[1]=1;
    dis[1]=0;
    int T=n-1;
    while(T--)
    {
        min=MAX;
        for(j=1; j<=n; j++)
        {
            if(visit[j]==0&&min>dis[j])
            {
                min=dis[j];
                pos=j;
            }
        }
        visit[pos]=1;//表示这个点已经走过
        for(j=1; j<=n; j++)
        {
            if(visit[j]==0&&dis[j]>min+map[pos][j])//更新dis的值
                dis[j]=map[pos][j]+min;
        }
    }
    return dis[n];
}
int main()
{
    int i,j;
    while(cin>>n>>m)//n表示n个点，m表示m条边
    {
        memset(map,MAX,sizeof(map));
        int a,b,c;
        for(i=1; i<=m; i++)
        {
            cin>>a>>b>>c;
            if(c

vector邻接表实现

#include 
#include 
#include 
#include 
#include 
#define INF 0x3f3f3f3f

using namespace std;

struct node
{
    int end;//终点
    int power;//权值
} t;

int n;//n为边数
vectorq[500001];//邻接表存储图的信息
int dis[500001];//距离数组
bool vis[500001];//标记数组

void Dijkstra(int start, int end)
{
    memset(vis, false, sizeof(vis));
    for(int i=0; i<=n; i++)
    {
        dis[i] = INF;
    }
    int len=q[start].size();
    for(int i=0; iq[pos][j].power+dis[pos] )
                dis[q[pos][j].end ] = q[pos][j].power + dis[pos];
        }
    }
    printf("%d\n", dis[end] );
}


int main()
{
    int m;
    while(scanf("%d %d", &n, &m)&&n&&m)//输入点和边
    {
        for(int i=0; i<=n; i++)
            q[i].clear();//将vector数组清空
        for(int i=0; i

Floyd

#include
#include 
#include
using namespace std;
const int MAX=0x3f3f3f3f;
int map[1100][1100];
void floyd(int n)
{
    for(int k=1; k<=n; k++)
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                map[i][j]=min(map[i][j],map[i][k]+map[k][j]);  //这里用了min函数，可能会多一点耗时。
}
int main()
{
    int i,j,n,m;    //读入n和m，n表示顶点个数，m表示边的条数
    cin>>n>>m;
    memset(map,MAX,sizeof(map));  //初始化
    for(i=1; i<=n; i++)
        for(j=1; j<=n; j++)
            if(i==j)
                map[i][j]=0;
    int a,b,c;
    for(i=1; i<=m; i++)
    {
        cin>>a>>b>>c;
        map[a][b]=c;//这是一个有向图
    }
    floyd(n);
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++)
        {
            cout<

Bellman-Ford

#include
#include
#include
using namespace std;
const int MAX=0x3f3f3f3f;
const int N=1010;
int nodenum, edgenum, source; //点，边，起点
typedef struct Edge
{
    int st;
    int ed;
    int power;
} Edge;
Edge edge[N];
int dis[N];
void inite()  //初始化图
{
    cin>>nodenum>>edgenum>>source;
    memset(dis,MAX,sizeof(dis));
    dis[source]=0;
    for(int i=1; i<=edgenum; i++)
    {
        cin>>edge[i].st>>edge[i].ed>>edge[i].power;
        if(edge[i].st == source)          //注意这里设置初始情况
            dis[edge[i].ed] = edge[i].power;
    }
}
void relax(int st,int ed,int power)  //松弛计算
{
    if(dis[ed]>dis[st]+power)
        dis[ed]=dis[st]+power;
}
bool Bellman_Ford()
{
    for(int i = 1; i <= nodenum - 1; i++)
        for(int j = 1; j <= edgenum; j++)
            relax(edge[j].st,edge[j].ed,edge[j].power);
    for(int i = 1; i <= edgenum; ++i)
    {
        if(dis[edge[i].ed] > dis[edge[i].st] + edge[i].power)
        {
            return 0;
        }
    }
    return 1;
}
int main()
{
    inite();
    if(Bellman_Ford())//如果没有负权
    {
        for(int i = 1; i <= nodenum; ++i) //每个点最短路
        {
            cout<

SPFA

poj 2387

#include
#include
#include
#include
#include
#include
#include
#include