最短路 POJ2387

第一种迪杰斯特拉算法求最短路（时间复杂度为（n*n））

要求边的权值为正数

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int t,n;
int map[1010][1010];
bool vis[1010];
int div[1010];
int MAX=1<<29;

int main()
{
    while(scanf("%d%d",&t,&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(i==j)
                    map[i][j]=0;
                else
                    map[i][j]=map[j][i]=MAX;
            }
        }
        int fro,to,val;
        for(int i=0;i<t;i++)
        {
            scanf("%d%d%d",&fro,&to,&val);
            if(map[fro][to]>val)
                map[fro][to]=map[to][fro]=val;
        }
        memset(vis,false,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            div[i]=map[1][i];
        }
        for(int i=1;i<=n;i++)
        {
            int mi=MAX;
            int v;
            for(int j=1;j<=n;j++)
            {
                if(!vis[j]&&div[j]<mi)
                {
                    mi=div[j];
                    v=j;
                }
            }
            vis[v]=true;
            for(int j=1;j<=n;j++)
            {
                if(!vis[j]&&div[v]+map[v][j]<div[j])
                {
                    div[j]=div[v]+map[v][j];
                }
            }
        }
        cout<<div[n]<<endl;
    }
    return 0;
}

 第二种贝尔曼福德算法（时间复杂度为（n*m））

边的权值可以为负数，并且可以判断图中是否有负环

1　　 图的初始化等操作

2　　for i = 1 to |G.V| - 1   //  |G.V|  为图 G的点的总数

3　　　　for each edge(u,v)∈G.E   //G.E 为图 G 的边

4       　　　　relax(u,v,w) 也就是if  v.d>u.d+w(u,v)  ， v.d = u.d+w(u,v);

5　　for each edge(u,v)∈G.E

6 　　　　if v.d>u.d+w(u,v)  //v.d为出发源点到结点v的最短路径的估计值  u.d亦如此  w(u,v) 为u结点到v结点的权重值(通俗点就是u—>v的花费)。

7　　　　　　return false;

8　　return true

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int MAX=1<<29;
struct node
{
    int fro,to,val;
}bn[2010];
int t,n;
int div[1010];

int main()
{
    while(scanf("%d%d",&t,&n)!=EOF)
    {
        for(int i=1;i<=t;i++)
        {
            scanf("%d%d%d",&bn[i].fro,&bn[i].to,&bn[i].val);
        }
        div[1]=0;
        for(int i=2;i<=n;i++)
            div[i]=MAX;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=t;j++)
            {
                if(div[bn[j].fro]>div[bn[j].to]+bn[j].val)
                    div[bn[j].fro]=div[bn[j].to]+bn[j].val;
                if(div[bn[j].to]>div[bn[j].fro]+bn[j].val)
                    div[bn[j].to]=div[bn[j].fro]+bn[j].val;
            }
        }
        cout<<div[n]<<endl;
    }
    return 0;
}

 第三种spfa算法

const int MAXN=1010;
const int MAXM=20010;
int tot;
const long long INF=1e11;
int head[MAXN];
bool vis[MAXN];
int cnt[MAXN];
long long dist[MAXN];

struct Edge
{
    int to;
    int cost;
    int next;
}edge[MAXM];

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v,int w)
{
    edge[tot].to=v;
    edge[tot].cost=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}

bool SPFA(int start,int n)
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        dist[i]=INF;
    }
    vis[start]=true;
    dist[start]=0;
    queue<int>que;
    while(!que.empty())
        que.pop();
    que.push(start);
    memset(cnt,0,sizeof(cnt));
    cnt[start]=1;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(dist[v]>dist[u]+edge[i].cost)
            {
                dist[v]=dist[u]+edge[i].cost;
                if(!vis[v])
                {
                    vis[v]=true;
                    que.push(v);
                    if(++cnt[v]>n)
                        return false;
                }
            }
        }
    }
    return true;
}