图（一）——最短路（Dijkstra）

图（一）——最短路

常用的最短路算法有Dijkstra，SPFA，Floyd,可根据题目不同选择不同算法

一.建边算法

1.邻接矩阵建边

int main()
{
	memset(a,0,sizeof(a));
	int x,y,v;
	//双向边
	a[x][y]=a[y][x]=v;//x,y之间有权值
	a[x][y]=a[y][x]=1;//x,y之间没有权值
	//单向边
	a[x][y]=v;//同上
	a[x][y]=1;
    return 0;
}

注：局限：数据太大，矩阵就存不下了，a[maxn][maxn],maxn=1e4应该就是最大的了
2.vector建边

vector<int>v[maxn];
struct node
{
	int to,val;//to为到哪里，val为权值
};
vector<node>v1[maxn];
int main()
{
	int n,x,y,val;
	for(int i=1;i<=n;i++)
		v[i].clear();
	v[x].push_back(y);//单向
	v1[x].push_back(node{y,val});//双向边，有权值
	v1[y].push_back(node{x,val});
	//赋值顺序不能打乱，必须按结构体中顺序赋值
    return 0;
}

注：局限：做题的时候容易卡内存，所以也只适用于数据较小的时候
3.邻接表建边（链式向前星）
常用

struct node
{
	int to,next,val;
}edge[maxn*2];//双向，=edge[maxn<<1];
void add(int x,int y,int val)//起点、终点、边权
{
	edge[cnt].to=y;//指向的那个点
	edge[cnt].next=head[x];//同一起点边的编号
	edge[cnt].val=val;//权值
	head[x]=cnt++;
	/*还可以写成
	edge[++cnt]=node{y,head[x],val};
	head[x]=cnt;*/
}
int main()
{
	int x,y,val,cnt=0;
	memset(head,-1,sizeof(head))//也可以循环初始化
	add(x,y,val);
    return 0;
}

注：代码不好懂，比较绕，可参考以下以下两个博客
https://blog.youkuaiyun.com/qq_39627843/article/details/78024890
https://www.cnblogs.com/wenruo/p/4680930.html

二.Dijkstra算法

可用来解决单源最短路问题，即起始点是固定的，只能算一固定点到其他所有点的最短路问题
大致思路：

1. 设定以V₀为起点，将V₀到其他所有点距离设置为INF（无穷大)。
2. 为访问的点{V₀,V₁,V₂,V₃,V₄,V₅}，在这些点中，距V₀最短的路径是dis[V₀→V₀]=0<INF,可更新为0，放出从V₀发出的所有边V₀→V₁，V₀→V₃，V₀→V₄，dis[V₀→V₁]=1<INF,dis[V₀→V₃]=4<INF，dis[V₀→V₄]=4<INF,都可以更新。
3. 还剩{V₁,V₂,V₃,V₄,V₅}，V₁到V₀的距离最小，放出从V₁出发的所有边V₁→V₃，dis[V₀→V₃]>dis[V₀→V₁→V₃]=3，所以可以以V₁为中介更新V₀→V₃的距离
4. 还剩{V₂,V₃,V₄,V₅}，V₃到V₀的距离最小，放出从V₃出发的所有边V₃→V₄，V₃→V₂，dis[V₀→V₂]=dis[V₀→V₁→V₃→V₂]<INF,可更新，dis[V₀→V₄]<dis[V₀→V₁→V₃→V₄]，不用更新
5. 还剩{V₂,V₄,V₅}，V₄到V₀的距离最小，放出从V₄出发的所有边V₄→V₅，dis[V₀→V₄→V₅]=7<INF，可更新
6. 还剩{V₂,V₅}，V₂到V₀的距离最小，放出从V₂出发的所有边V₂→V₅，dis[V₀→V₁→V₃→V₂→V₅]<dis[V₀→V₄→V₅]=6，可更新
7. 还剩{V₅}，dis[V₀→V₅]=6已得出，结束
注:INF可以赋值为0x3fffffff,赋值可用fill函数，或者直接用循环赋值，如果INF=0x3f3f3f3f,赋值可用memset函数，或者循环赋值

详细代码：
邻接矩阵版：

#include <iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<stack>
#include<vector>
#define INF 0x3fffffff
#define me(a,b) memset(a,b,sizeof(a))
#define X 200907
#define mod 10000
typedef long long ll;
const int maxn=1e3+10;
using namespace std;
int vis[maxn],mp[maxn][maxn],d[maxn];
using namespace std;
int n;
void dij(int s)
{
	fill(d,d+maxn,INF);//初始化
	me(vis,0);
	d[s]=0;//0到0的路径长度为0
	for(int i=1;i<=n;i++)//遍历找到距离最小的点
	{
		int minn=-1;//用于标记最小点的位置
		for(int j=1;j<=n;j++)
		{
			if(!vis[j])//这个点没有被走过
			{
				if(minn==-1||d[minn]>d[j])
					minn=j;
			}
		}//找到最小点，放开这个点到其他点的边
		if(d[minn]==INF)
			break;
		vis[minn]=1;//这个点已经走过
		for(int j=1;j<=n;j++)
		{
			if(!vis[j])
			{
			    if(d[j]>d[minn]+mp[minn][j])
					//以最小点为中介从0到j的距离和0直接到j的距离相比较
                    d[j]=d[minn]+mp[minn][j];
			}
		}
	}
}
int main()
{
	int m,x,y,val;
    while(scanf("%d%d",&n,&m)&&n+m)
    {
        for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
        {
        	mp[i][j]=INF;
        }//可写为fill(mp[0],mp[0]+maxn*maxn,INF)
        while(m--)
		{
	    	scanf("%d%d%d",&x,&y,&val);
	    	mp[x][y]=mp[y][x]=val;
	    }
	    dij(1);
	    printf("%d\n",d[n]);//找的是从0到n的最小路径
    }
    return 0;
}

注：用fill函数赋值时，一维的可直接赋为fill(mp,mp+maxn,INF)；而如果是二维的，赋值就变为fill(mp[0],mp[0]+maxn*maxn,INF)。因为需要的参数是指针（迭代器），不是值，所以一维迭代器用mp，二维迭代器用mp[0]。所以赋值最好用for循环，0、-1用memset.

vector版：
大部分代码和矩阵一样

int n;
……………………………………………………
struct node
{
	int to,val;
};
……………………………………………………
vector<node>v[maxn];
void dij(int s)
{
	fill(d,d+maxn,INF);//初始化
	me(vis,0);
	d[s]=0;//0到0的路径长度为0
	for(int i=1;i<=n;i++)//遍历找到距离最小的点
	{
		int minn=-1;//用于标记最小点的位置
		for(int j=1;j<=n;j++)
		{
			if(!vis[j])//这个点没有被走过
			{
				if(minn==-1||d[minn]>d[j])
					minn=j;
			}
		}//找到最小点，放开这个点到其他点的边
		if(d[minn]==INF)
			break;
		vis[minn]=1;//这个点已经走过
……………………………………………………………………………………………………………………………………………………
		for(int j=0;j<(int)v[minn].size();j++)
		{
			int to=v[minn][j].to;
			int val=v[minn][j].val;
			if(d[minn]+val<d[to])
				d[to]=d[minn]+val;
		}
……………………………………………………………………………………………………………………………………………………
	}
}
int main()
{
	int m,x,y,val;
    while(scanf("%d%d",&n,&m)&&n+m)
    {
……………………………………………………………………………………………………………………………………………………
        for(int i=1;i<=n;i++)
			v[i].clear();
        while(m--)
		{
	    	scanf("%d%d%d",&x,&y,&val);
	    	v[x].push_back(node{y,val});
	    	v[y].push_back(node{x,val});
	    }
……………………………………………………………………………………………………………………………………………………	    
	    dij(1);
	    printf("%d\n",d[n]);//找的是从0到n的最小路径
    }
    return 0;
}