最短路算法

1.Dijkstra算法

算法思想：$dijkstra$ 算法采用的是贪心的思想。

（1）定义一个$dis$数组，$dis[i]$ 表示i点到源点的最短路径，设源点的 $dis$ 值为0，其他 $dis$ 值为 $\infty$ 。
（2）选出其中的最小 $dis$ 值，进行标记并更新它相邻的 $dis$ 值。

（3）不断循环操作（2）。

优点：dijkstra 算法可以广泛使用于大多数题目。

缺点： dijkstra 算法不能在图中有负权环时使用。

核心代码：

void dijkstra()
{
    for(int i=1;i<=n;i++)d[i]=INF;
    dis[1]=0;
    for(int i=1;i<=n;i++)
    {
        int mark=-1;
        mindis=INF;
        for(int k=1;k<=n;k++)
        {
            for(int j=head[i];j;j=edge[j].nxt)
            {
                if(!vis[edge[j].to]&&edge[j].dis<mindis)
                {
                    mindis=edge[j].dis;
                    mark=edge[j].to;
                }
            }
        }
        vis[mark]=1;
        for(int i=head[mark];i;i=edge[i].nxt)
        {
            if(!vis[edge[i].to])
            {
                d[edge[i].to]=min(d[edge[i].to],d[mark]+edge[i].dis);
            }
        }
    }
}

堆优化：

struct node{
	int dis,pos;
	bool operator<(const node &x) const
	{
		return x.dis<dis;
	}
};
inline void dij(int s)
{
	for(int i=1;i<=n;i++) dis[i]=0x3f3f3f3f3f3f3f3f, vis[i]=0;
	priority_queue<node> q;
	dis[s]=0, q.push((node){0, s});
	while(q.size())
	{
		int u=q.top().pos;
		q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		for(int i=head[u];i;i=edge[i].next)
		{
			int v=edge[i].to;
			if(dis[v]>dis[u]+edge[i].w)
			{
				dis[v]=edge[i].w+dis[u];
				q.push((node){dis[v], v});
			}
		}
	}
}

2. Bellmax-ford算法

（1） 定义一个 $dis$ 数组，$dis[i]$ 表示 $i$ 点到源点的最短路径，设源点的 $dis$ 值为0，其他 $dis$ 值为 $\infty$ 。

（2） 从图的任意边开始，对每一条边进行松弛操作（对于边 $u>v$ ,如果 $dis[v]>dis[u]+w[u][v]$,$dis[v]=dis[u]+w[u][v]$ , $w$ 为图的权值）①，重复点数-1次。

（3）最后再进行一边松弛操作，如果存在①，则存在负权环。

优点：Bellman-ford算法边的权值可以为负数，并可检测负权回路。

缺点：时间复杂度过高。

核心代码：

 
 
bool bellman（int v0）    
{
	for(int i=1;i<=nv-1;i++)
	{
		for(int j=1;j<=ne;j++)
		{
			if(dis[edge[j].a]+edge[j].w<dis[edge[j].b])
			{
				dis[edge[j].b]=dis[edge[j].a]+edge[j].w;
			}
                }
		for(int j=1;j<=ne;j++)
		{
			if(d[edge[j].a]+edge[j].w<dis[edge[j].b])
			{
				return 0;
			}
            	}
		return 1;
	}
 }

3. SPFA算法：

算法思想：SPFA算法实际是$Bellman-ford$算法的队列优化。

（1） 定义一个$dis$数组，$dis[i]$ 表示i点到源点的最短路径，设源点的 $dis$ 值为0，其他 $dis$ 值为 $\infty$ 。定义队列 $q$ ，源点进队。

（2） 从队列中取出队首元素 $u$，标记节点 $u$ 出队，对u相连的所有节点 $v$ 进行松弛操作。如果松弛成功，检查节点 $v$ 进队次数，如果超过 $|V|$，则说明出现负权环，算法结束；否则，修改 $dis[v]$ ，检查节点 $v$ 是否在队列中，如果不在，节点 $v$ 进队。

（3） 重复操作（2）。

优点：可以解决负权环问题。

核心代码：

void spfa(int u)
{
    queue<int> q;   
    q.push(u), dis[u]=0, vis[u]=1;
    while(!q.empty())
    {
        int now=q.front();   
        q.pop();       
        vis[now]=0;      
        for(int i=head[u];i;i=edge[i].next)  
        {
            int v=edge[i].first;          
            if(dis[v]>dis[u]+edge[i].w||dis[v]<0)
            {
            	dis[v]=dis[u]+edge[i].w;
			}
			if(vis[v]==1)
        	{
        	    vis[v]=1;  
        		q.push(v);
        	}
        }   
    }
}

4. Floyd算法

算法思想：Floyd算法是基于动态规划思想的。

（1） 定义 $dp[k][i][j]$ 表示从点i到点j只允许经过前k个点得到的最短路径。

（2） 如果经过第$k$个点，那么 $dp[k][i][j]=dp[k-1][i][k]+dp[k-1][k][j]$。

（3） 如果经过第k个点，那么 $dp[k][i][j]=dp[k-1][i][j]$。

（4） $dp[k][i][j]=min(dp[k-1][i][j],dp[k-1][i][k]+dp[k-1][k][j])$。

（5） 边界：$dp[0][i][j]=g[i][j],g[i][j]$指$i$到$j$的边权，当无法到达时可以设为 $\infty$。

优点：稠密图效果佳，边权可为负。

核心代码：

memset(dis, 0x7f, sizeof(dis));
for(int i=1;i<=m;i++)
{
    int u, v;
    cin>>u>>v;
   	dis[u][v]=dis[v][u]=w[u][v];
}
 
for(int k=1;k<=n;k++)
{
    for(int i=1;i<=n;i++)
    {
    	for(int j=1;j<=n;j++)
    	{
    		if((i!=j)&&(i!=k)&&(j!=k))
    		{
    			if(dis[i][j]>dis[i][k]+dis[k][j])
    			{
    				dis[i][j]=dis[i][k]+dis[k][j];
                }
			}
		}
	}
}
 

---

our story begins.