周更1（最短路）

1、POJ - 1062 昂贵的聘礼

题意：你想娶酋长的女儿，但酋长要求你给一定数额金钱的聘礼。除了金钱外，酋长也允许你用部落里其他人的某物品加上一点钱作为聘礼。而其他人的物品也可以通过指定的另外一些人的某物品加上一些金钱获得。部落里的每个人有一个等级。你的整个交易过程涉及的人的等级只能在一个限定的差值内。问你最少需要多少金钱才能娶到酋长女儿。假定每个人只有一个物品。

思路：对冒险者的等级进行枚举，冒险者只能和在他等级以上的人进行交易。这样枚举的好处是能够把所有的情况都考虑进去。

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int INF=0x3f3f3f3f;
int map[200][200],n,m;
int vis[2000100],dis[1001000],sum=0;
int rankk[100100],val[1010000];

int check(int x)        //判断是否能交换成功
{
    if(rankk[x]>=rankk[0]&&rankk[x]-rankk[0]<=m||m==0) return true;
    return false;

}

int dijkstra()
{
    for(int i=1;i<=n;i++){
        dis[i]=val[i];
        vis[i]=0;
    }
    int j,k,tmp;
    for(int i=1;i<=n;i++){
        tmp=INF;
        for(int j=1;j<=n;j++){
            if(!vis[j]&&tmp>dis[j]){
                k=j;
                tmp=dis[j];
            }
        }
        if(tmp==INF) break;
        vis[k]=1;
        if(!check(k)) continue;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&check(j)&&dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
    }
    return dis[1];
}

int main()
{
    int x,a,b;
    cin>>m>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            map[i][j]=INF;
        }
        map[i][i]=0;
    }
    for(int i=1;i<=n;i++){
        cin>>val[i]>>rankk[i]>>x;
        while(x--){
            cin>>a>>b;
            map[a][i]=b;
        }
    }
    int ans=INF;
    for(int i=1;i<=n;i++){      //对冒险者的等级进行枚举
        rankk[0]=rankk[i];
        ans=min(ans,dijkstra());
    }
    printf("%d
",ans);
    return 0;
}

2、HDU - 4370 0 or 1

题意：

给定一个 n*n 的矩阵 C，构造一个符合以下条件的矩阵 X：

　　1、X12+X13+...+X1n=1

　　2、X1n+X2n+...+X(n−1)n=1

　　3、∑Xki=∑Xij (1<k<n,1<=j<=n)

求 ∑i=i,j=1nCij∗Xij 的最小值。

思路：

　　1、表示点 1 的出度为 1

　　2、表示点 n 的入度为 1

　　3、除了点 1 和点 n 外的其他点出入度相等

故有答案两种情况，一种情况是从1~n跑一遍最短路，另一种是从1出发，走一个环（不能是自环），回到1；从n出发，走一个环，回到n。求两种情况中最短的路。

#include<iostream>
#include<cstdio>
#include<cstring>
#define ll long long
using namespace std;

const ll INF=1e9;
const int N=310;

int n,vis[N];
ll map[N][N],dis[N];

void Dijkstra(int src){
    int i;
    for(i=1;i<=n;i++){
        dis[i]=map[src][i];
        vis[i]=0;
    }
    dis[src]=INF;
    int j,k,tmp;
    for(i=1;i<=n;i++){
        tmp=INF;
        for(j=1;j<=n;j++)
            if(!vis[j] && tmp>dis[j]){
                k=j;
                tmp=dis[j];
            }
        vis[k]=1;
        for(j=1;j<=n;j++)
            if(!vis[j] && dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
    }
}

int main()
{
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%lld",&map[i][j]);
        Dijkstra(1);
        ll m=dis[1];
        ll ans=dis[n];
        Dijkstra(n);
        ans=min(m+dis[n],ans);
        printf("%lld
",ans);
    }
    return 0;
}

3、POJ - 1847 Tram

题意：在一个交通网络上有N个路口, 每个路口指向多个方向, 默认驶向第一个方向, 驶向其他方向时需要进行一次操作, 求从a到b最小的操作数。

思路：第一组初始设为0，后边的要改方向的路径权值为1，到不了的为INF，求最短路。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#define ll long long
using namespace std;

const int N = 200;
const int INF = 0x3f3f3f3f;
int map[N][N],dis[N],vis[N];
int n,x,y;

void Dijkstra(int src){
    int i;
    for(i=1;i<=n;i++){
        dis[i]=map[src][i];
        vis[i]=0;
    }
    dis[src]=0;
    vis[src]=1;
    int j,k,tmp;
    for(i=1;i<=n;i++){
        tmp=INF;
        for(j=1;j<=n;j++)
            if(!vis[j] && tmp>dis[j]){
                k=j;
                tmp=dis[j];
            }
        if(tmp==INF)
            break;
        vis[k]=1;
        for(j=1;j<=n;j++)
            if(!vis[j] && dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
    }
}

int main()
{
    scanf("%d%d%d",&n,&x,&y);
    int b,c;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++)
            map[i][j]=INF;
        map[i][i]=0;
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&b);
        for(int j=0;j<b;j++){
            scanf("%d",&c);
            if(j==0) map[i][c]=0;
            else map[i][c]=1;
        }
    }
    Dijkstra(x);
    if(dis[y]==INF) printf("-1
");
    else printf("%d
",dis[y]);
    return 0;
}

4、POJ - 3259 Wormholes

题意：是否能通过虫洞回到过去；虫洞是一条单向路，不但会把你传送到目的地，而且时间会倒退。我们把虫洞看成是一条负权路，问题就转化成求一个图中是否存在负权回路；

思路：简单的Bellman-Ford算法求负环

#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;

int n,m,p;
const int INF=0x3f3f3f3f;
const int N=600;
int map[N][N];

bool floyd()
{
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(map[i][k]+map[k][j]<map[i][j])
                    map[i][j]=map[i][k]+map[k][j];
            }
            if(map[i][i]<0) return true;
        }
    }
    return false;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&n,&m,&p);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                map[i][j]=INF;
            }
            map[i][i]=0;
        }
        int u,v,w;
        for(int i=2;i<=m+1;i++){
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=map[v][u]=w;
        }
        for(int i=m+2;i<=m+p+1;i++){
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=-w;
        }
        if(floyd()) printf("YES
");
        else printf("NO
");
    }
    return 0;
}

5、POJ - 1797 Heavy Transportation

题意：N个点，M条边，每条边有权值。求一条1号点到N号点的路径，要求使得路径中的边权最小值最大。

思路：重点是维护dis数组，dis[j]=max(dis[j],min(dis[k],map[k][j]))。

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

const int INF=1e7;
const int N=1001;
int maxn;
int n,m,s,t;
int map[N][N],dis[N],vis[N];

void Dijkstra(int src){
    int i;
    for(i=1;i<=n;i++){
        dis[i]=map[src][i];
        vis[i]=0;
    }
    dis[src]=0;
    vis[src]=1;
    int j,k;
    for(i=1;i<=n;i++){
        k=-1;
        maxn=0;
        for(j=1;j<=n;j++)
            if(!vis[j] && maxn<dis[j]){
                k=j;
                maxn=dis[j];
            }
        if(k==n) return;
        vis[k]=1;
        for(j=1;j<=n;j++)
            if(!vis[j]){
                dis[j]=max(dis[j],min(dis[k],map[k][j]));   //维护dis数组
            }
    }
}

int main()
{
    int t;
    cin>>t;
    int k=0;
    while(t--){
        k++;
        scanf("%d%d",&n,&m);
        int u,v,w;
        maxn=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=-1;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=map[v][u]=w;
        }
        Dijkstra(1);
        printf("Scenario #%d:
%d
",k,dis[n]);
        if(t) printf("
");
    }
    return 0;
}

6、POJ - 1860 Currency Exchange

题意：有多种汇币，汇币之间可以交换，这需要手续费，问s币的金额经过交换最终得到的s币金额数能否增加（货币的交换是可以重复多次的）。

思路：链式前向星存图+Bellman-Ford算法求是否有正环

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;

double x;
const double INF = 1e7+1.0;
const int maxv=210;
int n, m, s,tot;
double dis[maxv];

struct Edge
{
    int u,v;
    double w,c;
}edge[maxv];

void addege(int u,int v,double w,double c)
{
    edge[tot].u=u;
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].c=c;
    tot++;
}

int Bellman_Ford(int s)
{
    memset(dis, 0, sizeof(dis));
    dis[s]=x;
    for (int k = 1; k <= n ; k++)
        for (int i = 0; i < tot; i++){
            int u = edge[i].u, v = edge[i].v;
            double w = edge[i].w,c = edge[i].c;
            dis[v] =max(dis[v],(dis[u]-c)*w);
        }
    for(int i=0;i<tot;i++){
        int u = edge[i].u, v = edge[i].v;
        double w = edge[i].w,c = edge[i].c;
        if(dis[v]<(dis[u]-c)*w) return true;
    }
    return false;
}

int main()
{
    scanf("%d%d%d%lf",&n,&m,&s,&x);
    tot=0;
    while(m--){
        int a,b;
        double r1,r2,c1,c2;
        scanf("%d%d%lf%lf%lf%lf",&a,&b,&r1,&c1,&r2,&c2);
        addege(a,b,r1,c1);
        addege(b,a,r2,c2);
    }
    int p=Bellman_Ford(s);
    if(p) printf("YES
");
    else printf("NO
");
    return 0;
}