图的储存pro

Dijkstar算法

通过找最近点依次向外松弛，通过不断更新最终达到源点向任意点的最短距离

#include<stdio.h>
int dis[1000];
int book[1000];
int e[1000][1000];
int inf=9999999;
int main()
{
  int i,j,n,m,t1,t2,t3,u,v,min;
  scanf("%d%d",&n,&m);
  
  //初始化
  for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      if(i==j)  e[i][j]=0;
      else      e[i][j]=inf;
  
  
  for(i=1;i<=m;i++)
  {
    scanf("%d%d%d",&t1,&t2,&t3);
    e[t1][t2]=t3;
  } 
  
  for(i=1;i<=n;i++)
    dis[i]=e[1][i];
    
  for(i=1;i<=n;i++)
    book[i]=0;
  book[1]=1;
  
  //算法核心 
  for(i=1;i<=n-1;i++)
  {
    min=inf;               //找到最近点，然后标记为确定值 
    for(j=1;j<=n;j++)
    {
      if(book[j]==0 && dis[j]<min)
      {
        min=dis[j];
        u=j;
      }
    }
    book[u]=1;
    for(v=1;v<=n;v++)     //对最近点的边进行松弛 
    {
      if(e[u][v]<inf)
      {
        if(dis[v]>dis[u]+e[u][v])
          dis[v]=dis[u]+e[u][v];
      }
    }
  }
  
  for(i=1;i<=n;i++)
    printf("%d ",dis[i]);
  return 0;
} 

邻接表

时间复杂度低，通过数组使其可以指向下一条边不必一一遍历
同一个源点的边一起遍历

#include<stdio.h>
int main()
{
  int n,m,i;
  int u[6],v[6],w[6];
  int first[5],next[5]; 
  scanf("%d %d",&n,&m);
  for(i=1;i<=n;i++)     
    first[i]=-1;      //数组first  1~n 的单元格储存1~n号定点的第一条边的编号(随着输入进行更新) 
  for(i=1;i<=m;i++)
  {
    scanf("%d %d %d",&u[i],&v[i],&w[i]);   //分别储存第几条边是从几号顶点到几号顶点 
    next[i]=first[u[i]];             //先存next再存first 
    first[u[i]]=i;
  }
  
  //遍历 
  for(i=1;i<=n;i++)
  {
    int k=first[i];          
    while(k!=-1)
    {
      printf("%d %d %d\n",u[k],v[k],w[k]);
      k=next[k];
    }
  }
  return 0; 
} 

解决负权边

Bellman Ford

#include<stdio.h>
int main()
{
  int dis[10],i,k,n,m,u[10],v[10],w[10];
  int inf=99999999;
  scanf("%d %d",&n,&m);
  
  //读入边
  for(i=1;i<=m;i++)
    scanf("%d %d %d",&u[i],&v[i],&w[i]);
  
  //初始化dis数组
  for(i=1;i<=n;i++)
    dis[i]=inf;
  dis[1]=0;
  
  //算法核心
  for(k=1;k<=n-1;k++)
    for(i=1;i<=m;i++)
      if(dis[v[i]] > dis[u[i]] + w[i])
        dis[v[i]] = dis[u[i]] + w[i];
  for(i=1;i<=n;i++)
    printf("%d ",dis[i]);
  return 0;
}