图论 dijkstra floyd spfa

图论

数据结构

两种存法

邻接表

临接矩阵

dijkstra用邻接矩阵存的时候还需要处理下重边，如果用邻接表存就不用处理。矩阵1个边只能有1个值，所以要处理，保证存的是最小值，但邻接表重边也可以存多次，在算法里保证最小。

优化版Dijkstra

用堆来维护，所以其实堆里存的是一个pair

堆需要在维护的时候保留编号

int dijkstra()
{
  memset(dist,0x3f,sizeof dist);
  dist[1]=0;
  priority_queue<PII,vector<PII>,greater<PII>> heap;//小根堆
}

Dijktra不能处理负权边，所以Bellman-Ford算法闪亮登场

存在负权回路，不一定存在最短路，但是我们可以求不超过k条边的最短路径，n次迭代，每次循环所有边。时间复杂度$o(n\ast m)$

边随便存,三角不等式,在算法结束后一定满足,$dist[b]<=dist[a]+w$（松弛操作）

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=510,M=10010；
struct Edge{
  int a,b,c;
}edge[M];

int n,m,k;

int dist[N];
int last[N];

void bellman_ford()
{
  memset(dist,0x3f,sizeof dist);
  dist[1]=0;
  //不超过k次
  for(int i=0;i<k;i++)
  {
    //加备份，防止串联
    //不会使用已经更新的权重来更新
    memcpy(last,dist,sizeof dist);
    for(int j=0;j<m;j++){
      auto e = edge[j];
      //这里我们是拿last数组里的来比
      dist[e.b] = min(dist[e.b],last[e.a]+e.c);
    }
  }
}
int main()
{
  scanf("%d%d%d",&n,&m,&k);
  for(int i=0;i<m;i++)
  {
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    edges[i]={a,b,c};
  }
  bellman_ford();
  if(dist[n]>0x3f3f3f3f/2) puts("impossible");
  else printf("%d\n",dist[N]);
  return 0;
}

SPFA进行优化

算法过程像Dijkstra，是对 bellman-ford的优化，在bellman-ford中是暴力对所有边进行松弛优化。

时间复杂度一般$O(n)$最坏$O(nm)$

spfa也能解决权值为正的图的最短距离问题，且一般情况下比Dijkstra算法还好

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=100010;

int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];
void add(int a,int b,int c)
{
  e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
  memset(dist,0x3f,sizeof dist);
  dist[1]=0;
  queue<int> q;
  q.push(1);
  st[1]=true;
  while(q.size())
  {
    int t= q.front();
    q.pop();
    st[t]=false;//st数组去掉之后不影响算法正确性，但队列中会存储重复元素，效率会下降。
    //st数组的作用是判断是否在队列中，如果重复入队，效率会下降。
    for(int i=h[t];i!=-1;i=ne[i])
    {
      int j=e[i];
      if(dist[j]>dist[t]+w[i])
      {
        dist[j]=dist[t]+w[i];
        //不管j是否在队列中，都会更新dist[j]；如果j不在队列中，才会将j插入队列。
        if(!st[j])
        {
          q.push(j);
          st[j]=true;
        }
      }
    }
  }
  return dist[n];
}


int main()
{
	scanf("%d%d",&n,&m);
  memset(h,-1,sizeof h);
  while(m--){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    add(a,b,c);
  }
  int t = spfa();
  
  if(t==0x3f3f3f3f) puts("impossible");//这个不需要因为队列里都是由起点更新到的点，不存在bellman-ford算法中未更新的点同样被边更新的情况。
  else printf("%d\n",t);
  
  return 0;
}

Spfa判断负环，利用抽屉原理

dist[x];//表示最短距离
cnt[x];//表示边数
//如果cnt[n]>=n,说明存在环

Floyd

求多源最短路，可以处理负权，但是不能处理负权回路

用领接矩阵存储

3层循环，基于动态规划，状态表示三维，时间复杂度$O(n^3)$

#include<iostream>
using namespace std;
const int N=210,M=2e+10,INF=1e9;
int n,m,k,x,y,z;
int d[N][N];


void floyd(){
 	for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
        d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
  
}

int main(){
  cin>>n>>m>>k;
  for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
      if(i==j) 
        d[i][j]=0;
  		else d[i][j]=INF;
  while(m--){
    cin>>x>>y>>z;
    d[x][y]=min(d[x][y],z);
    //保留最小边
  }
  floyd();
  while(k--){
    cin>>x>>y;
    if(d[x][y]>INF/2)puts("impossible");
    //由于负权边的存在所以约大过INF/2也很合理
    else cout<<d[x][y]<<endl;
  }
  return 0;
  		
}