hdu2544(最短路径/三种算法)

hdu2544"最短路"

Dijkstra算法(多米诺骨牌模型)

复杂度：O(E*logV)
AC代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
#include<queue>
const int maxn = 105;
const int INF = 1000000;
//map：数组模拟邻接表
int vex[maxn], ecot;
struct Edge
{
    int to, w, next;//到达点的id，权值，下一条边的id；
}edge[maxn*maxn]; //没有重复边
void init()
{
    for(int i = 0; i < maxn; i++){
        vex[i] = -1;
    }
    ecot = 0;
}
void addEdge(int u, int v, int w)
{
    edge[ecot].to = v;
    edge[ecot].w = w;
    edge[ecot].next = vex[u];
    vex[u] = ecot++;
}
//
int n, m;
//
struct Node
{
    int to, s_dis; //到达的点，改点到原点的距离
    Node(){}
    Node(int t, int dis){to = t; s_dis = dis;}
    bool operator<(const Node& n)const
    {
        return s_dis > n.s_dis;
    }
};
void dijkstra()//多米诺模型
{
    int dis[maxn];
    bool done[maxn];
    //init
    for(int i = 0; i < maxn; i++){
        dis[i] = INF;
        done[i] = false;
    }
    //
    priority_queue<Node> q;//保存多米诺正在前往的点的信息
    dis[1] = 0;
    Node node(1, dis[1]);
    q.push(node);

    while(!q.empty()){
        node = q.top();//被取出的点的dis[node.to]停止更新
        q.pop();
        if(done[node.to])//如果该点已经到达
            continue; //重新取点
        done[node.to] = true; //到达标记
        //最新的点可以出发新的路
        for(int i = vex[node.to]; i != -1; i = edge[i].next){
            if(done[edge[i].to]){//如果这条路的通往的点被到达过
                continue; //换一条路试试
            }
            if(dis[edge[i].to] > node.s_dis + edge[i].w){//如果经过node.to比之前短路程还要短
                dis[edge[i].to] = node.s_dis + edge[i].w; //更新最短距离
                q.push(Node(edge[i].to, dis[edge[i].to]));//触发更短的多米诺骨牌
            }
        }
    }
    printf("%d\n", dis[n]);
}
int main()
{
    //freopen("in.txt", "r", stdin);
    while(scanf("%d%d", &n, &m)){
        if(!n && !m)return 0;
        init();
        int u, v, w;
        while(m--){
            scanf("%d%d%d", &u, &v, &w);
            addEdge(u, v, w);
            addEdge(v, u, w);
        }
        dijkstra();
    }

    return 0;
}

Bellman-Ford（警察问路模型）

复杂度：O(V*E)
AC代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 105;
const int INF = 1000000;
//map:bellman
struct Edge
{
    int from, to, w;
}edge[maxn*maxn];
int eNum;
void addEdge(int u, int v, int w)
{
    edge[eNum].from = u;
    edge[eNum].to = v;
    edge[eNum++].w = w;
}
//
int n, m;

void Bellman()
{
    int dis[maxn]; //dis[i]:从原点到点i的距离
    //init
    for(int i = 0; i < maxn; i++){
        dis[i] = INF;
    }
    dis[1] = 0; //点1是起点:第一次更新dis
    //警察问路模型
    bool update = true; //上一次pre进行了更新时，true;
    int k = 0;
    while(update){
        k++;
        if(k > n){//如果连续更新n+1次，则有负圈(其实本题不可能出现)
//            printf("有负圈");
            break;
        }
        update = false; //默认无更新
        for(int i = 0; i < eNum; i++){//扫描所有边，所有点进行问路
            if(dis[edge[i].to] > dis[edge[i].from] + edge[i].w){//到达点to,经过点from更快
                update = true; //有更新， 标记
                dis[edge[i].to] = dis[edge[i].from] + edge[i].w;
            }
        }
    }

    printf("%d\n", dis[n]);
}

int main()
{
    //freopen("in.txt", "r", stdin);
    while(scanf("%d%d", &n, &m)){
        if( 0 == n && 0 == m)break;
        eNum = 0; //init
        int u, v, w;
        while(m--){
            scanf("%d%d%d", &u, &v, &w);
            addEdge(u, v, w);
            addEdge(v, u, w);
        }
        Bellman();
    }
    return 0;
}

Floyd-Warshall（动态规划思想）

复杂度：O(VVV)
AC代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 105;
const int INF = 1000000;
//map：邻接矩阵
int dp[maxn][maxn];//dp[i][j]:表示点i到点j的最短距离
//
int n, m;
void init()//写入地图：初始化dp
{
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
        dp[i][j] = INF;

    int u, v, w;
    while(m--){
        scanf("%d%d%d", &u, &v, &w);
        dp[u][v] = dp[v][u] = w;
    }
}
void solve()
{
    for(int k = 1; k <= n; k++){//选取一个中间点k
        for(int i = 1; i <= n; i++){//起点
            if(dp[i][k] != INF)//
            for(int j = 1; j <= n; j++){
//                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);//用下面的更快
                if(dp[i][j] > dp[i][k] + dp[k][j]){
                    dp[i][j] = dp[i][k] + dp[k][j];
                }
            }
        }
    }
    printf("%d\n", dp[1][n]);
}

int main()
{
    //freopen("in.txt", "r", stdin);
    while(scanf("%d%d", &n, &m)){
        if( 0 == n && 0 == m)break;
        init();
        solve();
    }
    return 0;
}