最短路径

• Dijkstra 算法 只算一个点到其它点的最短路径效率高
  取一点v[0]作起点，相信点为权值否则为无限大
  找与v[0]相邻最近的点v[k]
  比较是直接连短还是经过v[k]更短并更新
  ** 不能用于算有带负权值边的最短路径 **
• Floyd 算法 权重可以为负，但不能有权重为负的回路
  可以用来算全局最短路径但效率较低

Dijkstra

#include<bits/stdc++.h>
using namespace std;
int e[10][10],dis[10],book[10],i,j,n,m,u,v,w,minn,k,s;
const int inf=9999;
int main()
{
    cin>>n>>m>>s;
    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++)
    {
        cin>>u>>v>>w;
        e[u][v]=w;
    }
    for(i=1;i<=n;i++)//备份一下之前的
    dis[i]=e[s][i]; 
    for(i=1;i<=n;i++)//记录哪几条边已经测完了
    book[i]=0;
    book[s]=1;
    for(i=0;i<n-1;i++)
    {
        minn=inf;
        for(j=1;j<=n;j++)//找最小边
        {
            if(book[j]==0&&dis[j]<minn)
            {
                minn = dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(k=1;k<=n;k++)//看看是不是借用这条边比目前的距离短
        {
            if(dis[k]>dis[u]+e[u][k])
            dis[k]=dis[u]+e[u][k];
        }
    }
    for(i=1;i<=n;i++)
    cout<<dis[i]<<" ";
    return 0;
}

/*邻接矩阵dijkstra算法*/
#include <iostream>
using namespace std;
#define FINITY 9999
#define M 20
int i, j, k, u, v, w; //u->v代表u到顶点v的权值为w
typedef char vertex;
typedef int edget;
typedef struct
{
    vertex vexs[M];
    edget edges[M][M];
    int n, e;
} Mgraph;
void creat(Mgraph *g)
{
    int i, j, k, w;
    cin >> g->n >> g->e;
    for (i = 0; i < g->n; i++)
        cin >> g->vexs[i];
    for (i = 0; i < g->n; i++)
        for (j = 0; j < g->n; j++)
            if (i == j)
                g->edges[i][j] = 0;
            else
                g->edges[i][j] = FINITY;
    for (k = 0; k < g->e; k++)
    {
        cin >> u >> v >> w;
        g->edges[u][v] = w;
    }
}
void print(Mgraph g)
{ /*辅助函数，输出邻接矩阵表示的图g*/
    int i, j;

    for (i = 0; i < g.n; i++)
    {
        printf("%c ", g.vexs[i]);
    }
    printf("\n");
    for (i = 0; i < g.n; i++)
    {
        for (j = 0; j < g.n; j++)
        {
            printf("%6d", g.edges[i][j]);
        }
        printf("\n");
    }
}
typedef int dist[M];//距离向量，distance
typedef int path[M];//路径向量
void dijkstra(Mgraph g,int v0,path p,dist d)
{
    bool final[M];
    int i,j,v,minn,x;
    //初始化集合p与距离d
    for(v=0;v<g.n;v++)
    {
        final[v] = false;
        d[v] = g.edges[v0][v];
        if(d[v]<FINITY&&d[v]!=0) p[v]=v0;else p[v] = -1;
    }
    //第二步，依次找出n-1个结点加入d
    for(i=1;i<g.n;i++)
    {
        minn = FINITY;
        for(k=0;k<g.n;++k)
            if(!final[k]&&d[k]<minn){v=k;minn = d[k];}
        if(minn ==FINITY) return ;
        final[v] = true;
        //第三步修改d与各结点中的距离
        for(k=0;k<g.n;++k)
        {
            if(!final[k]&&(minn+g.edges[v][k]<d[k]))
            {
                d[k] = minn+g.edges[v][k];
                p[k] = v;
            }
        }
        printf(" [%d] ",i);
        for (k=0;k<g.n;++k)
         printf("%3d",d[k]);
        for (k=0;k<g.n;++k)
         printf("%3d",p[k]);
        printf("\n");
    }
}
int main()
{
    Mgraph g;int v0=0;path p; dist d;
    creat(&g);
   dijkstra(g,v0,p,d);
    return 0;
}

//静态邻接表
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
const long edge_maxn = 1005;  //边的最大上限
const long point_maxn = 105;  //点的最大上限
struct node
{/*node存储边，一个edge代表一条边*/
    int v;  //终点位置
    int w;  //权值
    int next;  //同一起点的下一条边存储在edge数组中的位置（理解了这个静态邻接表就可以了）
}edge[edge_maxn];
int pre[point_maxn];  //以该点为起点的第一条边存储在edge数组中的位置
int n; //点的数量
int m; //边的数量
void Init()
{
    memset(pre,-1,sizeof(pre));
    int Index = 1;
    int i,x,y,w;
    for(i=0;i<m;i++)
    {
        scanf("%d%d%d",&x,&y,&w);
        edge[Index].v = y;
        edge[Index].w = w;
        edge[Index].next = pre[x];  //保存x起点的上一条边在edge数组中的位置
        pre[x] = Index++;  //位置更新
    }
}//采用从头开始插入，pre[i]代表着哪个点为起点链表的头在edge[]中的位置
void print()
{
   for(int i=1;i<=n;i++)
    {
        printf("%d ",i);
        for(int j=pre[i];j!=-1;j=edge[j].next)
        {
            printf(" -> %d value is %d ",edge[j].v,edge[j].w);
        }
        printf("\n");
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF && (n!=0 || m!=0))
    {
        Init();
        print();
    }
    return 0;
}

静态邻接表加上Dijkstra

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
long long  const maxx = 2147483647;
struct node{
    long long v;//到哪个顶点
    long long w;//权值
    long long next;
}edge[550000];
struct Node{
    long long w,step;
    bool operator<(const Node &rhs)const{
        return w>rhs.w;
    }
};
long long pre[20000],vis[20000];
long long dis[20005];
long long n,m,s;
void init()
{
    memset(pre,-1,sizeof(pre));
    long long index = 1;
    long long i,x,y,w;
    for(i=0;i<m;i++)
    {
        cin>>x>>y>>w;
        edge[index].v = y;
        edge[index].w = w;
        edge[index].next = pre[x];//pre其实就是这个顶点的上条边在edge的位置
        pre[x] = index++;
    }
}
void Dijkstra()
{
    priority_queue<Node> q;
    for(long long i=1;i<=n;i++)
    {
        dis[i] = maxx;
    }
    dis[s] = 0;
    q.push((Node){0,s});
    while(!q.empty())
    {
        Node x = q.top();
        q.pop();
        long long c = x.step;
        if(vis[c])continue;//意思就是这个顶点已经借用更新过位置了
        vis[c]=1;
        for(long long i=pre[c];i!=-1;i=edge[i].next)
        {
            long long v=edge[i].v;
            if(dis[v]>dis[c]+edge[i].w)
            {
                dis[v] = dis[c]+edge[i].w;
                q.push((Node){dis[v],v});
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s;
    init();
    Dijkstra();
    for(long long i=1;i<=n;i++)
    {
        cout<<dis[i]<<" ";
    }
    return 0;
}

Floyd

#include <bits/stdc++.h>
using namespace std;
int e[10][10],k,i,j,n,m,u,v,w;
const int inf = 9999;
int main()
{
    cin>>n>>m;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(i==j)
            e[i][j]=0;
            else 
            e[i][j]=inf;
        }
        
    }
    for(i=0;i<m;i++)
    {
        cin>>u>>v>>w;
        e[u][v] = w;
    }
    for(k=0;k<n;k++)//核心语句
    for(i=0;i<n;i++)
    for(j=0;j<n;j++)
    if(e[i][j]>e[i][k]+e[k][j])
    e[i][j]=e[i][k]+e[k][j];
        for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            printf("%6d",e[i][j]);
        }
        cout<<endl;
    }
    return 0;
}