最小生成树和最短路径的对比

最小生成树：
uva 10034
kruskal

prim:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
using namespace std;
const int inf = 0xFFFFFFF;
const int maxn = 105;
double g[maxn][maxn];
double x[maxn], y[maxn];
int n;
int vis[maxn];
double d[maxn];
double distance(double x1, double y1,double x2,double y2) {

    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}

void prim() {
    double ans = 0;
    int i,j;
    memset(vis, 0, sizeof(vis));
    for(i=0; i<n; i++) d[i]=g[0][i];//到每个点的距离初始化成0点到各个点的距离
    double m;
    d[0] = 0;
    int x = 0;
    for(i=0; i<n; i++) {
        m = inf;
        for(j=0; j<n; j++) {
            if(d[j]<m && !vis[j]) {
                m=d[j];         
                x=j;
            }
        }//找到目前最短的
        vis[x] = 1;
        ans += m;
        if(m == inf) break;//所有的点都考虑过了
        for(j=0; j<n; j++) {
            if(d[j]>g[x][j] && !vis[j]) d[j]=g[x][j];//x到集合外任意一点的距离比之前考虑过得短就更新
        }
    }


    printf("%.2lf\n", ans);
}
int main() { 

    int kase, i, j;
    scanf("%d", &kase);
    while(kase--) {
        memset(g, 0, sizeof(g));    
        scanf("%d", &n);

        for(i=0; i<n; i++) {
            scanf("%lf%lf", &x[i], &y[i]);
        }
        for(i=0; i<n; i++) 
            for(j=0; j<n; j++) {
                g[i][j] = distance(x[i],y[i],x[j],y[j]);
            }
        prim();
        if(kase) printf("\n");

    }
    return 0;
} 

最短路径：
uva10801
题目大意：
有一层不超过100层的大楼， 有n个电梯，它们的速度都不同。 而且每个电梯只能到达指定的那些楼层，而且它们都有各自的速度（即上升一层或下降一层所用的时间）。 如果一个人在某层走出电梯，要换一个电梯乘，那么他要等60秒（不管要等的是那个电梯，即使是刚刚出来的那个电梯也要等60秒）。在0层搭电梯出发时不需要等待。
一个人从0层开始，目的地是k层， 现在要搭这些电梯，问最少需多少时间。
dijkstra算法

#include <iostream>
using namespace std;
#include <cstring>
#include <stdio.h>
#include <algorithm>
const int N =105;
const int INF = 0x3f3f3f3f;
int n,k,d[N],g[N][N],T[N];
int num[N];

void add(int a,int b, int c) {
    int dis=abs(b-a)*c;
    if(g[a][b]>dis) g[a][b]=g[b][a]=dis;
}

void solve() {
    int vis[N], i, j;
    memset(vis, 0, sizeof(vis));
    for(i=0; i<99; i++) {
        int x, m=INF, flag=0;
        for(j=0; j<100; j++) {
            if(!vis[j] && d[j]<m) {
                m=d[j];
                x=j;
                flag=1;
            }
        }
        if(!flag) return;
        vis[x]=1;
        for(j=0; j<100; j++)
            if(!vis[j] && d[j]>d[x]+g[x][j]+60) d[j]=d[x]+g[x][j]+60;
    }
}

int main() {
    int i, j, q, p;
    while(scanf("%d %d", &n, &k)!=EOF) {
        for(i=0; i<n; i++) scanf("%d", &T[i]);
        memset(d, INF, sizeof(d));
        memset(g, INF, sizeof(g));
        d[0]=0;
        for(i=0; i<n; i++) {
            int j=0;
            do {
                scanf("%d", &num[j++]);
            }while(getchar()!='\n');
            for(q=0; q<j; q++)
                for(p=0; p<q; p++) add(num[q],num[p],T[i]);
        }
        solve();
        if(k == 0)
            printf("0\n");
        else if(d[k] == INF)
            printf("IMPOSSIBLE\n");
        else
            printf("%d\n",d[k] - 60);
    }
    return 0;
}

我们会发现这两个算法很像，就是prim最后调整距离是直接判断d[j]>g[x][j],而最短路劲是计算经过最新纳入的点的总路径时候更小，即d[j]>d[x]+g[x][j]

SPFA

#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<utility>
using namespace std;

typedef pair<int,int>pii;
priority_queue<pii,vector<pii>,greater<pii> >q;

const int N = 105;
const int INF = 1000000000;  
int n, k, T[6], w[N][N], arr[N], d[N];
bool vis[N];


inline void read_graph() {
    int i, j, k;
    for(i=0; i<N; i++) {
        w[i][i] = INF;
        for(j=i+1; j<N; j++)
            w[i][j]=w[j][i]=INF;
    }
    for(i=0; i<n; i++) scanf("%d", &T[i]);

    char ch;
    for(i=0; i<n; i++) {
        int pos=0;
        do{
            scanf("%d", &arr[pos++]);
        }while(getchar()!='\n');

        for(j=0; j<pos; j++) {
            for(k=j; k<pos; k++) {
                int tmp = abs(arr[j]-arr[k])*T[i];
                if(tmp<w[arr[j]][arr[k]]) {
                    w[arr[j]][arr[k]]=w[arr[k]][arr[j]]=tmp;
                }
            }
        }
    }
}

void SPFA(int src) {

    int i, j;
    memset(vis, 0, sizeof(vis));
    for(i=0; i<N; i++) d[i]=INF;
    d[src] = 0;
    queue<int>q;
    q.push(src);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u]=false;
        for(i=0; i<N; i++) {
            if(u==0) {
                if(d[i]>d[u]+w[u][i]) {
                    d[i]=d[u]+w[u][i];
                    if(!vis[i]) {
                        vis[i]=true;
                        q.push(i);
                    }
                }
            }else {
                if(d[i]>d[u]+w[u][i]+60) {
                    d[i]=d[u]+w[u][i]+60;
                    if(!vis[i]) {
                        vis[i]=true;
                        q.push(i);
                    }
                }
            }
        }
    }
}


int main() {
    while(scanf("%d%d", &n, &k) != EOF) {
        read_graph();
        SPFA(0);
        if(d[k]!=INF) printf("%d\n", d[k]);  
        else printf("IMPOSSIBLE\n");  

    }
    return 0;
}

floyd
这个最短路径是通过枚举可通过的中间点来计算出
代码:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn = 105;
const int inf = 10005;
int n, k, t[maxn], f[maxn][maxn];
int num[maxn];
int flag;
void add(int a, int b, int c) {
    f[a][b]  = f[b][a] = min(min(f[a][b], f[b][a]), abs(a-b)*c);
}

void deal() {
    int i, j, z;
    for(i=0; i<=flag; i++)
        for(j=0; j<=flag; j++)
            for(z=0; z<=flag; z++) {
                f[j][z]=min(f[j][z],f[j][i]+f[i][z]+60);
            }
}
int main() {
    int i, j, k;
    while(scanf("%d%d", &n, &k) != EOF) {
        memset(f, inf, sizeof(f));
        for(i=0; i<n; i++) {
            scanf("%d", &t[i]);
        }
        char ch;
        for(i=0; i<n; i++) {
            ch = '\0';
            for(j=0; ch!='\n'; j++) {
                scanf("%d%c", &num[j], &ch);
                flag=max(flag, num[j]);

            for(int k=0; k<j; k++) {
                add(num[j], num[k], t[i]);
            }
            }
        }
        deal();
        if(k==0) printf("0\n");
        else if(f[0][k]<inf) printf("%d\n" ,f[0][k]);
        else printf("IMPOSSIBLE\n");
    }
    return 0;
}