HDU 2544 最短路（单源最短路 dijkstra / floyd / dijkstra（堆优化）/dijkstra+邻接链表+堆优化）

题意：

中文题目大家应该都看得懂。

思路：

用dijkstra算法寻找最短路。

dijskstra算法的精髓是：一条两顶点间的最短路径包含路径上其他的最短路径。
举个例子：有这么一条1到6的最短路径 1 -> 2 -> 4 -> 6 那么从1到4的最短路则为 1-> 2 -> 4
证明：反证法，假设不是最短路，那么必能找到一条比这个更短的路径，而如果是这样的话，原命题1到6的最短路径就不成立了，由此得证。

基本思想：贪心
操作：
设置一个顶点集合S，从源点到S中顶点的最短路径权值已经确定，通过反复从V-S中选取具有最短路径估计的顶点u，将u加入S中，并松弛所有u的出边，求得最短路径

也可以用floyd，暴力的对每个点进行可能的松弛。

int dis[110][110];
void floyd(int n){ // n is the number of node
    for(int k = 1;k <= n;k++){
        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= n;j++){
                if(dis[i][j] > dis[i][k]+dis[k][j])
                    dis[i][j] = dis[i][k]+dis[k][j];
            }
        }
    }
}

AC代码：

dijkstra:

#include <iostream>
#include <cstdio>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

struct edge{
    int y;
    int v;
};

vector<edge> v[110];
int dis[110];
bool vis[110];

void dijkstra(int N){
    int n = 1;
    for(int i = 0;i < v[1].size();i++){
        dis[v[1][i].y] = v[1][i].v;
    }
    int temp = 0x3f3f3f3f;
    int pos;
    for(int i = 1;i <= N;i++){
        if(vis[i] == false && dis[i] < temp)
            temp = dis[i],pos = i;
    }
    vis[1] = true;
    while(n != N){
        for(int i = 0;i < v[pos].size();i++){
            if(v[pos][i].v + dis[pos] < dis[v[pos][i].y]){
                dis[v[pos][i].y] = v[pos][i].v + dis[pos];
            }
        }
        vis[pos] = true;
        temp = 0x3f3f3f3f;
        for(int i = 2;i <= N;i++){
            if(vis[i] == false && dis[i] < temp)
                temp = dis[i],pos = i;
        }
        n++;
    }
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m),m){
        memset(vis,false,sizeof(vis));
        memset(dis,0x3f3f3f3f,sizeof(dis));//注意初始化为最大值
        int x,temp2;
        edge temp;
        for(int i = 1;i <= m;i++){
            scanf("%d%d%d",&x,&temp.y,&temp.v);
            v[x].push_back(temp);
            temp2 = x;
            x = temp.y;
            temp.y = temp2;
            v[x].push_back(temp);
        }
        dijkstra(n);
        printf("%d\n",dis[n]);
        for(int i = 1;i < 101;i++){//注意清空
            v[i].clear();
        }
    }
    return 0;
}

floyd

#include <iostream>
#include <cstdio>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

int dis[110][110];

void floyd(int n){
    for(int k = 1;k <= n;k++){
        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= n;j++){
                if(dis[i][j] > dis[i][k]+dis[k][j])
                    dis[i][j] = dis[i][k]+dis[k][j];
            }
        }
    }
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m),m){
        memset(dis,0x3f3f3f3f,sizeof(dis));
        int x,y,z;
        for(int i = 1;i <= m;i++){
            scanf("%d%d%d",&x,&y,&z);
            dis[x][y] = z;
            dis[y][x] = z;
        }
        for(int i = 1;i <= n;i++){//没必要
            dis[i][i] = 0;
        }
        floyd(n);
        printf("%d\n",dis[1][n]);
    }
    return 0;
}

也可以用优先队列优化dijkstra：

#include <iostream>
#include <cstdio>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

struct edge{
    int y;
    int v;
    bool operator < (const edge &b)const {
        return v > b.v;
    }
};

vector<edge> v[110];
int dis[110];
bool vis[110];//是否已得到最短路
//bool vi[110];//是否以此点松驰过

void dijkstra(){
    priority_queue<edge> q;
    edge temp;
    for(int i = 0;i < v[1].size();i++){
        dis[v[1][i].y] = v[1][i].v;
        temp.y = v[1][i].y;
        temp.v = v[1][i].v;
        q.push(temp);
    }
    vis[1] = true;
    int pos = q.top().y;
    while(!q.empty()){
        for(int i = 0;vis[pos] == false && i < v[pos].size();i++){
            if(v[pos][i].v + dis[pos] < dis[v[pos][i].y]){
                dis[v[pos][i].y] = v[pos][i].v + dis[pos];
                temp.y = v[pos][i].y;
                temp.v = dis[v[pos][i].y];
                q.push(temp);
            }
        }
        vis[pos] = true;
        q.pop(); // 注意：这行和下一行不能调换，否则可能遇到最后一个元素需要松弛而没有松弛就跳出循环的悲剧。
        pos = q.top().y;
    }
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m),m){
        memset(vis,false,sizeof(vis));
        memset(dis,0x3f3f3f3f,sizeof(dis));//注意初始化为最大值
        int x,temp2;
        edge temp;
        for(int i = 1;i <= m;i++){
            scanf("%d%d%d",&x,&temp.y,&temp.v);
            v[x].push_back(temp);
            temp2 = x;
            x = temp.y;
            temp.y = temp2;
            v[x].push_back(temp);
        }
        dijkstra();
        printf("%d\n",dis[n]);
        for(int i = 1;i < 101;i++){//注意清空
            v[i].clear();
        }
    }
    return 0;
}

AC代码：（最终版本）

#include <iostream>
#include <cstdio>
#include <string.h>
#include <queue>
typedef long long int lli;
using namespace std;

const int NODE = 110;
const int EDGE = 10001;
lli dis[NODE];
bool vis[NODE];// 是否已经松弛过
int head[NODE];//memset(head,-1,sizeof(head));
int cnte;//多样例时注意清零
struct edge{
    int to;
    int v;
    int next;
    bool operator < (const edge &b)const {
        return v > b.v;
    }
}edg[2*EDGE];
void addedge(int x,int y,int v){
    edg[++cnte].to = y;
    edg[cnte].v = v;
    edg[cnte].next = head[x];
    head[x] = cnte;
}
void dijkstra(int start){
    priority_queue<edge> q;
    int now = head[start];
    while(now != -1){
        dis[edg[now].to] = edg[now].v;
        q.push(edg[now]);
        now = edg[now].next;
    }
    vis[start] = true;
    dis[start] = 0;
    int pos;
    while(!q.empty()){
        pos = q.top().to;
        now = head[pos];
        while(vis[pos] == false && now != -1){
            if(edg[now].v + dis[pos] < dis[edg[now].to]){
                dis[edg[now].to] = edg[now].v + dis[pos];
                edge temp;
                temp.to = edg[now].to;
                temp.v = dis[edg[now].to];
                q.push(temp);
            }
            now = edg[now].next;
        }
        vis[pos] = true;
        q.pop();
    }
}

int main()
{
    int n,m;
    int x,y,z;
    while(scanf("%d%d",&n,&m),m){
        if(n == 1){
            printf("0\n");
        }
        cnte = 0;
        memset(vis,false,sizeof(vis));
        memset(head,-1,sizeof(head));
        memset(dis,0x3f3f3f3f,sizeof(dis));//注意初始化为最大值
        for(int i = 1;i <= m;i++){
            scanf("%d%d%d",&x,&y,&z);
            addedge(x,y,z);
            addedge(y,x,z);
        }
        dijkstra(1);
        printf("%I64d\n",dis[n]);
    }
    return 0;
}