最短路

模板。

dijkstra。邻接矩阵+函数。

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

int n, m, a, b, c;

#define maxn 110
#define INF 10000000
int w[maxn][maxn];
int d[maxn];
bool v[maxn];
//int fa[maxn];//如果需要记录路径。
//点从1开始
void ini(){
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            w[i][j] = INF;
    //如果需要记录路径
//    for (int i = 1; i <= n; i++)
//        fa[i] = i;
}

void dijkstra(int s){
    memset(v, false, sizeof(v));
    for (int i = 1; i <= n; i++)
        d[i] = INF;
    d[s] = 0;
    //每次确定一个点到源点的最短路径。
    for (int i = 0; i < n; i++){
        int x, m = INF;
        //找出该点及该点最短路径
        for (int y = 1; y <= n; y++){
            if(!v[y] && d[y] <= m)
                m = d[x = y];
        }
        //标记该点已找到最短路径
        v[x] = true;
        //用该点松弛其他点
        for (int y = 1; y <= n; y++){
            d[y] = min(d[y], d[x] + w[x][y]);
            //如果要输出路径的话。将上面一行替换成下面四行。
//            if(d[y] > d[x] + w[x][y]){
//                d[y] = d[x] + w[x][y];
//                fa[y] = x;
//            }
        }
    }
}

int main()
{
    while(scanf("%d%d", &n,&m),n+m){
        ini();

        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &a, &b, &c);
            if(w[a][b] > c)
                w[a][b] = w[b][a] = c;
        }

        dijkstra(1);

        printf("%d\n", d[n]);
    }
    return 0;
}
//HDU2544无向正权图。

 dijkstra。邻接表+优先队选边时优化（n->logn）。

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;

int u, v, w;

#define maxn 110
#define INF 10000000
//点号从0开始，边号从0开始。

//边
struct Edge{
    int from, to, dist;
    Edge(int u, int v, int d):from(u),to(v),dist(d){}
};

//点
struct HeapNode{
    int d, u;
    bool operator < (const HeapNode& rhs) const{
        return d > rhs.d;
    }
};


int n, m;

vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
int d[maxn];
//记录路径
//int p[maxn];

void init(){
    for (int i = 0; i < n; i++)
        G[i].clear();
    edges.clear();
    //初始化路径
//    for (int i = 0; i < n; i++)
//        p[i] = i;
}

void AddEdge(int from, int to, int dist){
    edges.push_back(Edge(from, to, dist));
    int cnt = edges.size();
    G[from].push_back(cnt-1);//边从0开始标号
}

void dijkstra(int s){
    priority_queue<HeapNode> Q;
    for(int i = 0; i < n; i++)
        d[i] = INF;
    d[s] = 0;
    memset(done, false, sizeof(done));
    Q.push((HeapNode){0,s});

    //直到没有新的最短路产生。
    while(!Q.empty()){
        HeapNode x = Q.top();
        Q.pop();
        int u = x.u;

        if(done[u]) continue;//有可能一个点多次入队，如果已经找到了该点最短路，直接continue
        done[u] = true;

        //遍历该点的每条边
        for (int i = 0; i < G[u].size(); i++){
            Edge& e = edges[G[u][i]];
            //松弛该边上的点
            if(d[e.to] > d[u] + e.dist){
                d[e.to] = d[u] + e.dist;
                //记录路径
//                p[e.to] = G[u][i];
                //入队，等待选最短路，松弛其他点。
                Q.push((HeapNode){d[e.to], e.to});
            }
        }
    }
}

int main()
{
    while(~scanf("%d%d", &n, &m), n+m){
        init();
        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &u,&v,&w);
            u--;
            v--;
            AddEdge(u,v,w);
            AddEdge(v,u,w);
        }
        dijkstra(0);
        printf("%d\n", d[n-1]);
    }
    return 0;
}
//HDU2544无向正权

 spfa

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
#include <cstdio>

using namespace std;

#define maxn 110
#define INF 10000000
int u, v, w;
//点序号从0开始，边序号从0开始。
struct Edge{
    int from, to, dist;
    Edge(int u, int v, int w):from(u),to(v),dist(w){}
};

int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool inq[maxn];//是否在队列中
int d[maxn];
//int p[maxn];//记录路径
int cnt[maxn];//进队次数

void init(){
    for (int i = 0; i < n; i++)
        G[i].clear();
    edges.clear();
//    for (int i = 0; i < n; i++)//初始化路径
//        p[i] = i;
}

//无向图，调用2次加边函数。去一条回一条。
void AddEdge(int from, int to, int dist){
    edges.push_back((Edge){from, to, dist});
    int cont = edges.size();
    G[from].push_back(cont-1);
}

bool spfa(int s){
    //记录点的队列
    queue<int> Q;
    memset(inq, 0, sizeof(inq));
    memset(cnt, 0, sizeof(cnt));

    for(int i = 0; i < n; i++)
        d[i] = INF;
    d[s] = 0;
    inq[s] = true;
    Q.push(s);

    while(!Q.empty()){//取出一个点，松弛该点每条边
        int u = Q.front();
        Q.pop();
        inq[u] = false;
        for (int i = 0; i < G[u].size(); i++){
            Edge& e = edges[G[u][i]];
            //点u可达，判断是否能松弛e.to
            if(d[u] < INF && d[e.to] > d[u] + e.dist){
                d[e.to] = d[u] + e.dist;
//                p[e.to] = G[u][i];//记录路径
                if(!inq[e.to]){
                    Q.push(e.to);
                    inq[e.to] = true;
                    if(++cnt[e.to] > n)//每一次入队代表被松弛了一次，一共n个点，每个点最多被松弛n-1次。
                        return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    while(scanf("%d%d", &n, &m),n+m){
        init();
        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &u, &v, &w);
            u--;
            v--;
            AddEdge(u, v, w);
            AddEdge(v, u, w);
        }
        spfa(0);
        printf("%d\n", d[n-1]);
    }
    return 0;
}//HDU2544无向正权

 floyd

#include <iostream>
#include <cstdio>
using namespace std;

#define maxn 110
#define INF 10000000
int d[maxn][maxn];
int n, m;
int u, v, w;

void ini(){
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++){
            d[i][j] = INF;
        }
    }
}

void floyd(){
    for (int k = 0; k < n; k++)
    for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        d[i][j] = min(d[i][j], d[i][k]+d[k][j]);
}

int main()
{
    while(scanf("%d%d", &n, &m),n+m){
        ini();
        for (int i = 0; i < m; i++){
            scanf("%d%d%d", &u, &v, &w);
            u--;
            v--;
            d[u][v] = d[v][u] = w;//v到u的最短路就是边权。
        }
        floyd();
        printf("%d\n", d[0][n-1]);
    }
    return 0;
}
//HDU2544无向正权