最短路径

最短路径

最短路径的四种算法

bellman_ford
O(n*m)的时间复杂度
从一个点到另一个点，最多只有n-1步
把整张图更新n-1次

const int inf=0x3f3f3f3f;
const int M=10000;
struct node{
  int from,to,v;
}edge[M*10];
int dis[M];
int main(){
  int n,m;
  cin>>n>>m;
  memset(dis,inf,sizeof(dis));
  for(int i=1;i<=m;i++)
  {
    scanf("%d %d %d",&edge.from,&edge.to,&edge.v);
  }
  dis[1]=0;//最短路径，1-1的距离为0；
  for(int i=1;i<n;i++)//一个无向图，n个定点只需要n-1条边进行连接，所以只需要枚举n个定点即可
  {
    for(int j=1;j<=m;j++)//把每条边都拿出来，起点更新终点
    {
      int a=edge[j].from;
      int b=edge[j].to;
      int c=edge[j].v;
      if(dis[b]>dis[a]+c)//不断更新边
      {//第一次只能把一旁边的边枚举一下，然后找到最短的继续更新
        dis[b]=dis[a]+c;
      }//核心思想：每次一轮把起点更新为终点
    }
  }
  return 0;
}

Dijkstra
邻接矩阵O(n^2)//70分代码

//每次(n-1)用 离起点最近的点 去更新其他的点
//dis[i]最小的值
const int M=1000000;
const int inf=0x3f3f3f3f;
int dis[M],mp[M][M];//邻接矩阵
bool mark[M];
void Dijkstra(){O(n^2)
  memset(dis,inf,sizeof(dis));
  memset(mark,0,sizeof(mark));
  dis[1]=0;
  for(int i=1;i<n;i++)
  {
    int k=-1,mi=inf;
    for(int j=1;j<=n;j++)//每次从未使用过的点中找一个最小值
    {
      if(!mark[j]&&dis[j]<mi)
      {
        mi=dis[j];
        k=j;
      }
      if(k==-1)return;//永远不会被找到
    }
    mark[k]=true;//表示这个点使用过
    //用k更新其他点的距离
    for(int j=1;j<=n;j++)//更新的是其他点的，所以循环n次即可
    //长度是mp[k][j]
    //k------->j
    {
      if(!mark[j]&&dis[j]>dis[k]+mp[k][j])
      {
        dis[j]=dis[k]+mp[k][j];
      }
    }
  }
}
int main(){
  int n,m;
  cin>>n>>m;
  memset(mp,inf,sizeof(mp));
  for(int i=1;i<=m;i++)
  {
    int a,b,c;
    cin>>a>>b>>c;
    if(mp[a][b]>c)
    {
      mp[a][b]=c;
    }
  }
  Dijkstra();
  return 0;
}

优化1//运气好能满

//每次(n-1)用 离起点最近的点 去更新其他的点
//dis[i]最小的值
const int M=10000;
const int inf=0x3f3f3f3f;
int dis[M];
bool mark[M];
struct node{
  int to,v;
};
vector<node> edge[M];//邻接表
void Dijkstra(){O(n^2)
  memset(dis,inf,sizeof(dis));
  memset(mark,0,sizeof(mark));
  dis[1]=0;
  for(int i=1;i<n;i++)
  {
    int k=-1,mi=inf;
    for(int j=1;j<=n;j++)//每次从未使用过的点中找一个最小值
    {
      if(!mark[j]&&dis[j]<mi)
      {
        mi=dis[j];
        k=j;
      }
      if(k==-1)return;//永远不会被找到
    }
    mark[k]=true;//表示这个点使用过
    //用k更新其他点的距离
    for(int j=0;j<edge[k].size();j++)//更新的是其他点的，所以循环n次即可
    //k------->y
    {//枚举以k为起点，能到达的边
      int y=edge[k][j].to;
      int v=edge[k][j].v;
      if(!mark[y]&&dis[y]>dis[k]+v)
      {
        dis[y]=dis[k]+v;
      }
    }
  }
}
int main(){
  int n,m;
  cin>>n>>m;
  memset(mp,inf,sizeof(mp));
  for(int i=1;i<=m;i++)
  {
    int a,b,c;
    cin>>a>>b>>c;
    edge[a].push_back(node{b,c});//存结构体
  }
  Dijkstra();
  return 0;
}

优化2//100分算法（堆+Dijkstra）

//每次(n-1)用 离起点最近的点 去更新其他的点
//dis[i]最小的值
const int M=10000;
const int inf=0x3f3f3f3f;
int dis[M];
bool mark[M];
struct node{
  int to,v;
  bool operator < (const node &A)const{//运算符重载
    return v<A.v;
  }
};
vector<node> edge[M];//邻接表
priority_queue<node>Q;
void Dijkstra(){
  memset(dis,inf,sizeof(dis));
  memset(mark,0,sizeof(mark));
  dis[1]=0;
  Q.push((node){1,0});
  while(!Q.empty())
  {
    node tmp=Q.pop();
    Q.pop();
    int k=tmp.to;
    if(mark[k])continue;
    mark[k]=true;//表示这个点使用过
    //用k更新其他点的距离
    for(int j=0;j<edge[k].size();j++)//更新的是其他点的，所以循环n次即可
    //k------->y
    {//枚举以k为起点，能到达的边
      int y=edge[k][j].to;
      int v=edge[k][j].v;
      if(!mark[y]&&dis[y]>dis[k]+v)
      {
        dis[y]=dis[k]+v;
        Q.push((node){y,dis[y]});
      }
    }
  }
}
int main(){
  int n,m;
  cin>>n>>m;
  memset(mp,inf,sizeof(mp));
  for(int i=1;i<=m;i++)
  {
    int a,b,c;
    cin>>a>>b>>c;
    edge[a].push_back(node{b,c});//存结构体
  }
  Dijkstra();
  return 0;
}

SPFA(优化了bellman_ford)

const int inf=0x3f3f3f3f;
const int M=10000;
struct node{
  int to,v;
};
int dis[M];
queue<int>Q;
vector<node>edge[M];
bool mark[M];
int cnt[M];
int main(){
  int n,m,a,b,c;
  cin>>n>>m;
  memset(dis,inf,sizeof(dis));
  int f=false;
  for(int i=1;i<=m;i++)
  {
    scanf("%d %d %d",&a,&b,&c);
    edge[a].push_back((node){b,c});
  }
  dis[1]=0;
  Q.push(1);
  while(!Q.empty())//广度优先搜索
  {
    int k=Q.front();//每次把可能会更新其他的点那出来松弛相邻点
    Q.pop();
    mark[k]=0;//与BFS的区别
    for(int j=0;j<edge[k].size();j++)
    {
      int y=edge[k][j].to;
      int v=edge[k][j].v;
      if(dis[y]>dis[k]+v)
      {
        dis[y]=dis[k]+v;
        if(!mark[y])
        {
          Q.push(y);
          mark[y]=1;
          cnt[y]++;
          if(cnt[y]==n)f=true;
        }
      }
    }
  }
  return 0;
}

Floyd

const int M=105;
const int inf=0x3f3f3f3f;
int dis[M][M];

int main(){
  int n,m,a,b,c;
  cin>>n>>m;
  memset(dis,inf,sizeof(dis));
  for(int i=1;i<=n;i++)
  {
    dis[i][i]=0;
  }
  for(int i=1;i<=m;i++)
  {
    scanf("%d %d %d",&a,&b,&c);
    if(dis[a][b]>c)
    {
      dis[a][b]=c;
    }
    //floyd求任意两点间的最短距离
  }
  for(int k=1;k<=n;k++)
  {
    for(int i=1;i<=n;i++)
    {
      for(int j=1;j<=n;j++)
      {
        if(dis[i][j]>dis[i][k]+dis[k][j])//k是拐点
        {
          dis[i][j]=dis[i][k]+dis[k][j];//传递背包，动态规划
        }
      }
    }
  }
  return 0;
}