最短路径

Dijkstra算法（迪杰斯特拉算法）

基本思想

对图G(V,E)设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与起点s的最短距离最小的一个顶点（记为u），访问并加入集合s。之后，令顶点u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离。这样的操作执行n次（n为顶点个数），直到集合s已包含所有顶点。

算法步骤

1. 集合s可以用一个标记数组vis【】来实现，即当vis【i】==1时表示顶点v已经被访问，当vis【i】==0时表示顶点v未被访问。
2. 令int型数组d[]表示起点s到达顶点v的最短距离，初始时除了起点的d[s]赋为0，其余顶点都赋为一个很大的数
   
   代码实现

举例
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input
输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。
Output
对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间
Sample Input

2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output

3
2

邻接矩阵AC代码

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include<math.h>
#include<stdlib.h>
#include<queue>
#include<set>
#define ll  long long
using namespace std;
const int maxn = 1e2+10;
const int INF=0x3f3f3f;
int n,m;
int g[maxn][maxn];//每两个路口之间的距离
int d[maxn];//最短距离
int vis[maxn];//标记数组
void dij(int start)//start为起点
{
    fill(d,d+maxn,INF);
    d[start]=0;//自个到自个的距离为0
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++)
    {
        int u=-1;
        int mm=INF;
        for(int j=1; j<=n; j++)
        {
            if(vis[j]==0&&d[j]<mm)//路口j未访问并且找到当前最短距离
            {
                u=j;//标记这个路口
                mm=d[j];
            }
        }
        if(u==-1)//找不到最短距离，剩下的顶点与起点不通
            return ;
        vis[u]=1;
        for(int v=1; v<=n; v++)
        {
            if(vis[v]==0&&g[u][v]!=INF&&d[u]+g[u][v]<d[v])//v未访问并且已u为中介可以使路径更优
                d[v]=d[u]+g[u][v];
        }
    }

}
int main()
{
    while(scanf("%d%d",&n,&m)&&(n+m))
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            g[i][j]=INF;
        int x,y,bian;
        while(m--)
        {

            scanf("%d%d%d",&x,&y,&bian);
            g[x][y]=g[y][x]=bian;//没有考虑重边
        }
        dij(1);
       printf("%d\n",d[n]);
    }
    return 0;

voctor代码实现

邻接表链式前向星代码实现

<span style="font-size:12px;">#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f
#define maxn 110//点数 
#define maxm 10010//边数 
using namespace std;
int dis[maxn];//储存起点到当前点的最短路 
int visit[maxn];//标记当前点是否在队列中 
int head[maxn];
int n,top;
 
struct node
{
	int to,val,next;
}edge[maxm];
 
void add(int a,int b,int c)//建立邻接表 
{
	edge[top].to=b;
	edge[top].val=c;
	edge[top].next=head[a];//指向上一个，edge[].next指向的是前一个，相当于链表里的指针的作用   
	head[a]=top++;
}
 
void spfa(int start)
{
	int i,j,next,u,v;
	queue<int>q;
	for(i=1;i<=n;++i)
	   dis[i]=INF;
	dis[start]=0;
	visit[start]=1;
	q.push(start);
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		visit[u]=0;//消除标记 
		for(i=head[u];i!=-1;i=edge[i].next)//遍历以u为前点的所有边 
		{
			v=edge[i].to;
			if(dis[v]>dis[u]+edge[i].val)
			{
				dis[v]=dis[u]+edge[i].val;
				if(!visit[v])
				{
					visit[v]=1;
					q.push(v);
				}
			}
		}
	}
	printf("%d\n",dis[n]);
}
 
int main()
{
	int m,i,a,b,c;
	while(scanf("%d%d",&n,&m)&&n||m)
	{
		top=0;//建表从零开始 
		for(i=1;i<=n;++i)
		{
			visit[i]=0;
			head[i]=-1;
		}
		while(m--)
		{
			scanf("%d%d%d",&a,&b,&c);
			add(a,b,c);
			add(b,a,c);
		}
		spfa(1);
	}
	return 0;
}</span>

这里涉及到了链式前向星

一位大佬的讲解
Bellman-Ford算法

Bellman-Ford算法设置一个数组d，用来存放从源点到达各个顶点的最短距离。同时Bellman-Ford算法返回一个bool值，如果其中存放从源点可达的负环，那麽函数将返回false；否则，函数将返回true，此时数组d中存放的值就是从源点到达各顶点的最短距离。

主要思路如下面伪代码所示。需要对图中的边进行V-1轮操作，每轮都遍历图中的所有边：对每条边u->v,如果以u为中介点可以使d[v]更小，即d[u]+length[u->v]<d[v]成立时，就用d[u]+length[u->v]更新d[v]。同时也可以看出，Bellman-Ford算法的时间复杂度是O(VE),其中n是顶点个数，E是边数。

用邻接表会比较方便，如果使用邻接矩阵，则时间复杂度会上升到O(V^3)
代码实现

沸洛依德算法

代码实现

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include<math.h>
#include<stdlib.h>
#include<queue>
#include<set>
#define ll  long long
using namespace std;
const int maxn = 2e2+10;
const int INF=0x3f3f3f;
int dis[maxn][maxn];
int n,m;
void floyd()
{
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            for(int k=0; k<n; k++)
            {
                if(dis[j][i]!=INF&&dis[i][k]!=EOF&&dis[j][i]+dis[i][k]<dis[j][k])
                    dis[j][k]=dis[j][i]+dis[i][k];
            }
}


int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        fill(dis[0],dis[0]+maxn*maxn,INF);
        for(int i=0; i<n; i++)
            dis[i][i]=0;
        int x,y,w;
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&w);
            if(dis[x][y]>w)
            dis[x][y]=dis[y][x]=w;
        }
        floyd();
        int st,ed;
        scanf("%d%d",&st,&ed);
        if(dis[st][ed]==INF)
            printf("-1\n");
        else
            printf("%d\n",dis[st][ed]);
    }

    return 0;
}