最短路径

 

#include <iostream>
#include <cstdio>
#define Max 100000
#define Inf 100000000
using namespace std;
struct edge
{//边的结构体
    int from;
    int value;
    int to;
};
edge G[Max];//边集建图
int V,E;//顶点数与边数
int d[Max];//距离数组
void short_path(int start)
{
    for(int i=0;i<V;i++)
        d[i]=Inf;
    d[start]=0;
    bool flog;
    while(1)
    {
        flog=true;
        for(int i=0;i<E;i++)//边循环
        {
            if(d[G[i].to]>d[G[i].from]+G[i].value)
            {
                d[G[i].to]=d[G[i].from]+G[i].value;
                flog=false;
            }
            if(d[G[i].from]>d[G[i].to]+G[i].value)
            {
                d[G[i].from]=d[G[i].to]+G[i].value;
                flog=false;
            }
        }
        if(flog)//直到距离都不变为止
            break;
    }
}
int main()
{
    scanf("%d%d",&V,&E);
    for(int i=0;i<E;i++)
        scanf("%d%d%d",&G[i].from,&G[i].to,&G[i].value);
    short_path(0);
    for(int i=0;i<V;i++)
        printf("%d: %d\n",i,d[i]);
    return 0;
}

#include <iostream>
#include <cstdio>
#define Max 10000
#define Inf 10000000
using namespace std;

int G[Max][Max];//邻接矩阵法表示图
int d[Max];
bool use[Max];
int V,E;

void short_path(int start)//传统的dijstra算法
{
    for(int i=0; i<V; i++)
    {
        d[i]=Inf;
        use[i]=true;
    }
    d[start]=0;
    int MIn;
    for(int i=0; i<V; i++)
    {
        MIn=-1;
        for(int j=0; j<V; j++) //选取最短距离
        {
            if(use[j])
            {
                if(MIn==-1)
                    MIn=j;
                else if(d[MIn]>d[j])
                    MIn=j;
            }
        }
        if(MIn!=-1)
        {
            use[MIn]=false;
            for(int j=0; j<V; j++)//更新最短距离
            {
                if(use[j])
                {
                    if(d[j]>G[MIn][j]+d[MIn])
                        d[j]=G[MIn][j]+d[MIn];
                }
            }
        }
    }
}

int main()
{
    scanf("%d%d",&V,&E);
    int a,b,c;

    for(int i=0; i<V; i++)//邻接矩阵初始化
        for(int j=0; j<V; j++)
            G[i][j]=Inf;

    for(int i=0; i<E; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        G[a][b]=c;
        G[b][a]=c;
    }
    short_path(0);
    for(int i=0; i<V; i++)
        printf("%d: %d\n",i,d[i]);
    return 0;
}

#include <iostream>
#include <queue>
#include <stdio.h>
#include <vector>
#define Max 1000
#define Inf 10000000
using namespace std;

struct edge//边结构体
{
    int to;
    int cost;
    friend bool operator < (edge a,edge b)//为构建优先队列重载<
    {
        return a.cost>b.cost;
    }
};
int V,E;
vector<edge> G[Max];//邻接链表表示图
int d[Max];
bool use[Max];

void short_path(int start)//优先队列优化后的dijstra算法
{
    for(int i=0; i<V; i++)
    {
        d[i]=Inf;
        use[i]=true;
    }
    d[start]=0;
    edge x,y;
    x.to=start;
    x.cost=0;
    priority_queue<edge> Que;//小顶堆优先队列
    Que.push(x);
    while(!Que.empty())
    {
        x=Que.top();//选取最小距离
        Que.pop();
        use[x.to]=false;
        for(int i=0; i<G[x.to].size(); i++) //用选取的点更新C_2集合中点的最短距离
        {
            y=G[x.to][i];
            if(use[y.to]&&d[y.to]>d[x.to]+y.cost)
            {
                edge K;
                K.to=y.to;
                K.cost=d[y.to]=d[x.to]+y.cost;
                Que.push(K);
            }

        }
    }
}

int main()
{
    scanf("%d%d",&V,&E);
    int a,b,c;
    edge x,y;
    for(int i=0; i<E; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        x.to=b;
        y.to=a;
        x.cost=y.cost=c;
        G[a].push_back(x);
        G[b].push_back(y);
    }
    short_path(0);
    for(int i=0;i<V;i++)
    {
        printf("%d: %d\n",i,d[i]);
    }
    return 0;
}

 

#include <iostream>
#include <cstdio>
#define Max 1000
#define Inf 1000000
using namespace std;

int G[Max][Max];//邻接矩阵
int V,E;
int d[Max][Max];

void short_path()
{
    for(int k=0; k<V; k++) //中间点的循环
    {
        for(int i=0; i<V; i++)
        {
            for(int j=0; j<V; j++)
            {
                if(d[i][j]>d[i][k]+d[k][j])
                    d[i][j]=d[i][k]+d[k][j];
            }
        }
    }
}

int main()
{
    scanf("%d%d",&V,&E);
    int a,b,c;
    for(int i=0; i<V; i++)
        for(int j=0; j<V; j++)
        {
            if(i==j)
                G[i][j]=d[i][j]=0;
            else
                G[i][j]=d[i][j]=Inf;
        }

    for(int i=0; i<E; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        d[a][b]=d[b][a]=G[a][b]=G[b][a]=c;//构建图同时初始化最短路径
    }
    short_path();
    for(int i=0; i<V; i++)
    {
        for(int j=0; j<V; j++)
        {
            printf("%d ",d[i][j]);
        }
        printf("\n");
    }
    return 0;
}

 

#include <iostream>
#include <queue>
#include <stdio.h>
#include <vector>
#define Max 1000
#define Inf 10000000
using namespace std;

struct edge//边结构体
{
    int to;
    int cost;
    friend bool operator < (edge a,edge b)//为构建优先队列重载<
    {
        return a.cost>b.cost;
    }
};
int V,E;
vector<edge> G[Max];//邻接链表表示图
int d[Max];
bool use[Max];
int pre[Max];//记录每个节点的最后的前驱

void short_path(int start)//优先队列优化后的dijstra算法
{
    for(int i=0; i<V; i++)
    {
        d[i]=Inf;
        use[i]=true;
    }
    d[start]=0;
    edge x,y;
    x.to=start;
    x.cost=0;
    pre[start]=-1;//作为端点
    priority_queue<edge> Que;//小顶堆优先队列
    Que.push(x);
    while(!Que.empty())
    {
        x=Que.top();//选取最小距离
        Que.pop();
        use[x.to]=false;
        for(int i=0; i<G[x.to].size(); i++) //用选取的点更新C_2集合中点的最短距离
        {
            y=G[x.to][i];
            if(use[y.to]&&d[y.to]>d[x.to]+y.cost)
            {
                edge K;
                K.to=y.to;
                K.cost=d[y.to]=d[x.to]+y.cost;
                Que.push(K);
                pre[y.to]=x.to;
            }

        }
    }
}

int main()
{
    scanf("%d%d",&V,&E);
    int a,b,c;
    edge x,y;
    for(int i=0; i<E; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        x.to=b;
        y.to=a;
        x.cost=y.cost=c;
        G[a].push_back(x);
        G[b].push_back(y);
    }
    short_path(0);
    int p=pre[V-1];
    printf("%d",V-1);
    while(p!=-1)
    {
        printf("——>%d",p);
        p=pre[p];
    }
    printf("  :%d\n",d[V-1]);
    return 0;
}