nyoj-115城市平乱-各种解法

城市平乱
时间限制：1000 ms | 内存限制：65535 KB
难度：4
描述
南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。

他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。

现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。

现在已知在任意两个城市之间的路行军所需的时间，你作为南将军麾下最厉害的程序员，请你编写一个程序来告诉南将军第一个分队到达叛乱城市所需的时间。

注意，两个城市之间可能不只一条路。

输入
第一行输入一个整数T，表示测试数据的组数。(T<20)
每组测试数据的第一行是四个整数N,M,P,Q(1<=N<=100,N<=M<=1000,M-1<=P<=100000)其中N表示部队数，M表示城市数，P表示城市之间的路的条数,Q表示发生暴乱的城市编号。
随后的一行是N个整数，表示部队所在城市的编号。
再之后的P行，每行有三个正整数，a,b,t(1<=a,b<=M,1<=t<=100)，表示a,b之间的路如果行军需要用时为t

数据保证暴乱的城市是可达的。
输出
对于每组测试数据，输出第一支部队到达叛乱城市时的时间。每组输出占一行
样例输入
1
3 8 9 8
1 2 3
1 2 1
2 3 2
1 4 2
2 5 3
3 6 2
4 7 1
5 7 3
5 8 2
6 8 2
样例输出
4
思路一：采用反向图，从目标点向起始点搜索最短路（时间）
解法一：普通dij邻接矩阵版

#include <stdio.h>#define inf 0x3f3f3f3f#define MAXN 1005int n;int mpt[MAXN][MAXN];int dis[MAXN];bool vis[MAXN];//标记是否访问过该点void dij(int s)//用距源点近的点松弛距源点远的点使其到源点的距离减小{    int i,j;    for(i=1;i<=n;i++)//初始化节点    {        dis[i]=mpt[s][i];//当初始化为inf时，下面的vis[s]==1必须去掉，否则导致松弛失败        vis[i]=0;    }    dis[s]=0;    vis[s]=1;//此步骤可去可不去    for(i=1;i<=n;i++)//最多松弛n次    {        int min=inf,t=0;        for(j=1;j<=n;j++)//找近的点            if(vis[j]==0&&dis[j]<min)                min=dis[t=j];        if(min==inf) break;//松弛完毕，退出        vis[t]=1;        for(j=1;j<=n;j++)//松弛远的点            if(vis[j]==0&&dis[j]>dis[t]+mpt[t][j])//加入vis[j]==0的判断条件是为了减少时间损耗，我们只能松弛距离源点更远的点                dis[j]=dis[t]+mpt[t][j];    }}int main(){    int i,j;    int t,M[110];    scanf("%d",&t);    while(t--)    {        int m,p,q;        while(scanf("%d%d%d%d",&m,&n,&p,&q)!=EOF)        {            for(i=0;i<m;i++)                scanf("%d",&M[i]);            memset(mpt,inf,sizeof(mpt));//图初始化            for(i=0;i<p;i++)            {                int x,y,z;                scanf("%d%d%d",&x,&y,&z);                if(mpt[x][y]>z)                    mpt[x][y]=mpt[y][x]=z;            }            dij(q);            int min=inf;            for(i=0;i<m;i++)            {                if(min>dis[M[i]])                    min=dis[M[i]];            }            printf("%d\n",min);        }    }    return 0;}

解法二：Bellman

#include <stdio.h>#define inf 0x3f3f3f3f#define MAXN 1005int n;int u[200005],v[200005],w[200005];int dis[MAXN];void bellman(int s,int m){    int i,j;    for(i=1;i<=n;i++)        dis[i]=inf;    dis[s]=0;    bool flag=0;    for(i=1;i<n;i++)//最多松弛n-1次    {        for(j=1;j<=2*m;j++)//每次松弛遍历所有边        {            if(dis[v[j]]>dis[u[j]]+w[j])//查看通过u[j],v[j]这条边是否能使dis[v[j]]减小            {                dis[v[j]]=dis[u[j]]+w[j];                flag=1;            }        }        if(!flag) break;//松弛失败，表示松弛结束，退出循环    }}int main(){    int i,j;    int t,M[110];    scanf("%d",&t);    while(t--)    {        int m,p,q;        while(scanf("%d%d%d%d",&m,&n,&p,&q)!=EOF)        {            for(i=0;i<m;i++)                scanf("%d",&M[i]);            for(i=1;i<=p;i++)            {                int x,y,z;                scanf("%d%d%d",&x,&y,&z);                u[i]=x;v[i]=y;w[i]=z;                u[i+p]=y;v[i+p]=x;w[i+p]=z;            }            bellman(q,p);            int min=inf;            for(i=0;i<m;i++)            {                if(min>dis[M[i]])                    min=dis[M[i]];            }            printf("%d\n",min);        }    }    return 0;}

解法三：SPFA邻接矩阵版

#include <stdio.h>#include <queue>#define inf 0x3f3f3f3f#define MAXN 1005int n;int mpt[MAXN][MAXN];int dis[MAXN];bool vis[MAXN];void dij(int s)//把距源点距离减小点放入队列，通过这些点可能使其出点距源点的距离减小{    int i,j;    for(i=1;i<=n;i++)//初始化节点    {        dis[i]=inf;//不能初始化为mpt[s][i],否则导致下面松弛失败        vis[i]=0;    }    dis[s]=0;    queue<int>q;    q.push(s);    vis[s]=1;//标记点是否在队列中    while(!q.empty())    {        int tx=q.front();        vis[tx]=0;//队首出队，标记还原        q.pop();        for(i=1;i<=n;i++)        {            if(mpt[tx][i]==inf)//不是该点出点，则继续判断下一个点                continue;            if(dis[i]>dis[tx]+mpt[tx][i])            {                dis[i]=dis[tx]+mpt[tx][i];                if(vis[i]==0)//松弛成功，判断其是否在队列中，没在则加入队列                {                    q.push(i);                    vis[i]=1;                }            }        }    }}int main(){    int i,j;    int t,M[110];    scanf("%d",&t);    while(t--)    {        int m,p,q;        while(scanf("%d%d%d%d",&m,&n,&p,&q)!=EOF)        {            for(i=0;i<m;i++)                scanf("%d",&M[i]);            memset(mpt,inf,sizeof(mpt));//图初始化            for(i=0;i<p;i++)            {                int x,y,z;                scanf("%d%d%d",&x,&y,&z);                if(mpt[x][y]>z)                {                    mpt[x][y]=z;                    mpt[y][x]=z;                }            }            dij(q);            int min=inf;            for(i=0;i<m;i++)            {                if(min>dis[M[i]])                    min=dis[M[i]];            }            printf("%d\n",min);        }    }    return 0;}

解法四：SPFA邻接表版（数组实现邻接表）

#include <stdio.h>#include <queue>using namespace std;#define inf 0x3f3f3f3f#define MAXN1 200005//最大边数#define MAXN2 1005//节点数int n,m;//n个顶点，m条边int u[MAXN1],v[MAXN1],w[MAXN1];int first[MAXN2];int next1[MAXN1];//first[i]存储节点i的第一条边的编号，next[i]存储编号为i的这条边的下一条边的编号（访问i这条边后，接下来访问next[i]这条边）int dis[MAXN2];bool vis[MAXN2];void spfa(int s)//把松弛成功的点放入队列，通过这些点可能使其邻接点距源点的距离减小{    int i,j;    for(i=1;i<=n;i++)//初始化节点    {        dis[i]=inf;//不能初始化为mpt[s][i],否则导致下面松弛失败        vis[i]=0;    }    dis[s]=0;    queue<int>q;    q.push(s);    vis[s]=1;//标记点在队列中    while(!q.empty())    {        int tx=q.front();        vis[tx]=0;//队首出队，标记还原        q.pop();        int k=first[tx];        while(k!=-1)        {            if(dis[v[k]]>dis[u[k]]+w[k])            {                dis[v[k]]=dis[u[k]]+w[k];                if(vis[v[k]]==0)//松弛成功，判断其是否在队列中，没在则加入队列                {                    q.push(v[k]);                    vis[v[k]]=1;                }            }            k=next1[k];        }    }}int main(){    int i,s,t,x,M[MAXN2];    scanf("%d",&t);    while(t--)    {        while(scanf("%d%d%d%d",&x,&n,&m,&s)!=EOF)        {            for(i=0;i<x;i++)                scanf("%d",&M[i]);            for(i=1;i<=n;i++)                first[i]=-1;            for(i=1;i<=m;i++)//邻接表存图（数组实现邻接表）            {                scanf("%d%d%d",&u[i],&v[i],&w[i]);                u[i+m]=v[i];v[i+m]=u[i];w[i+m]=w[i];//由于是无向图，把相反方向边的信息存在第i+m条边                next1[i]=first[u[i]];//next[i],first[u[i]]存储的都是以u[i]为起点的边的编号（不同）（next[i]不为负数）                first[u[i]]=i;//遍历边时，进行回访，先访问边i,再访问边next[i]                next1[i+m]=first[v[i]];//反方向边的信息存储                first[v[i]]=i+m;            }            spfa(s);            int min=inf;            for(i=0;i<x;i++)            {                if(min>dis[M[i]])                    min=dis[M[i]];            }            printf("%d\n",min);        }    }    return 0;}

思路二：构建超级源点，把起点集合连接到超级源点上，将起点与超级源点的集合的路径长度设为0，则我们只需要计算超级源点到终点的距离

#include <stdio.h>#include <algorithm>#define inf 0x3f3f3f3f#define MAXN 1005using namespace std;int n;int mpt[MAXN][MAXN];int dis[MAXN];int vis[MAXN];int dij(int s,int e){    int i,j;    memset(dis,inf,sizeof(dis));    memset(vis,0,sizeof(vis));    dis[s]=0;    for(i=0;i<=n;i++)    {        int min=inf,t=0;        for(j=0;j<=n;j++)            if(vis[j]==0&&dis[j]<min)                min=dis[t=j];        if(t==e) return dis[e];        vis[t]=1;        for(j=0;j<=n;j++)//松弛            if(vis[j]==0&&dis[j]>dis[t]+mpt[t][j])                dis[j]=dis[t]+mpt[t][j];    }}int main(){    int i,j,t;    scanf("%d",&t);    while(t--)    {        int m,p,q;        while(scanf("%d%d%d%d",&m,&n,&p,&q)!=EOF)        {            memset(mpt,inf,sizeof(mpt));//图初始化            for(i=0;i<m;i++)            {                int x;                scanf("%d",&x);                mpt[0][x]=0;            }            for(i=0;i<p;i++)            {                int x,y,z;                scanf("%d%d%d",&x,&y,&z);                if(mpt[x][y]>z)                    mpt[x][y]=mpt[y][x]=z;            }            int min=dij(0,q);            printf("%d\n",min);        }    }    return 0;}