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

裸的迪杰斯特拉，直接求从Q到个驻军城市的最短路即可

代码

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1005;
const int INF=99999999;
int map[maxn][maxn];//邻接矩阵存图
int dis[maxn];//记录单源最短路距离
int vis[maxn];//已访问标记为1，初始化为0
int num[maxn];//第i个部队驻扎在num[i]城市
int N;//部队数量
int M;//城市数量
int P;//城市之间道路数量
int Q;//需要到达的城市编号
void dijstar(int point)//dis记录从point到各点最短路
{
    memset(vis,0,sizeof(vis));
    vis[point]=1;
    for(int i=1;i<=M;i++)
        dis[i]=map[point][i];
    for(int i=1;i<M;i++)
    {
        int minn=INF;
        int u;
        for(int j=1;j<=M;j++)
        {
            if(vis[j]==0&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
        if(minn==INF)
            break;
        vis[u]=1;
        for(int v=1;v<=M;v++)
        {
            if(map[u][v]<INF&&dis[v]>dis[u]+map[u][v])
                dis[v]=dis[u]+map[u][v];
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d",&N,&M,&P,&Q);
        for(int i=0; i<=M; i++)//初始化邻接矩阵
            for(int j=0; j<=M; j++)
                i==j?map[i][j]=0:map[i][j]=INF;
        for(int i=1; i<=N; i++) //部队驻扎的城市
            scanf("%d",&num[i]);
        int a,b,t;//临时接收数据
        while(P--)
        {
            scanf("%d%d%d",&a,&b,&t);
            if(map[a][b]>t)
                map[a][b]=map[b][a]=t;//无向图
        }
        int min_time=INF;//最短时间
        dijstar(Q);
        for(int i=1; i<=N; i++)//寻找最短时间
            min_time=min(min_time,dis[num[i]]);
        printf("%d\n",min_time);
    }
    return 0;
}

附上最优解，优先队列剪枝优化过的单源最短路

#include<iostream>
#include<climits>
#include<cstring>
#include<cstdio>
#include<vector>
#include<iterator>
#include<queue>
using namespace std;
const int MAX=1010;
int len[MAX];
bool visited[MAX];
int n,m,p,q,a,b,d;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > dq;
struct Node
{
    Node(int num,int dis):num(num),dis(dis){}
    int num,dis;
};
void Dijkstra(vector<vector<Node> >& g) //优先队列实现Dijkstra
{
    pair<int,int> tp;
    while(!dq.empty())
    {
        tp=dq.top();dq.pop();
        if(tp.second==q-1) return; //剪枝
        if(tp.first!=len[tp.second]) continue;
        visited[tp.second]=true;
        for(int j=0;j!=g[tp.second].size();++j)
            if(tp.first+g[tp.second][j].dis<len[g[tp.second][j].num])
            {
                len[g[tp.second][j].num]=tp.first+g[tp.second][j].dis;
                dq.push(make_pair(len[g[tp.second][j].num],g[tp.second][j].num));
            }
    }
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        while(!dq.empty()) dq.pop();
        cin>>n>>m>>p>>q;
        vector<vector<Node> > g(m);
        for(int i=0;i!=g.size();i++) len[i]=INT_MAX;
        for(int i=0;i!=n;i++)
        {
            cin>>a;
            len[a-1]=0;
            dq.push(make_pair(0,a-1));
        }
        for(int i=0;i!=p;++i)
        {
            scanf("%d%d%d",&a,&b,&d);
            g[a-1].push_back(Node(b-1,d));
            g[b-1].push_back(Node(a-1,d));
        }
        Dijkstra(g);
        cout<<len[q-1]<<endl;
        memset(len,0,sizeof(len));
        memset(visited,0,sizeof(visited));
    }

}