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

最新推荐文章于 2019-04-28 10:00:07 发布
最新推荐文章于 2019-04-28 10:00:07 发布
阅读量404 收藏
点赞数
分类专栏： 解题报告 文章标签： 解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_31818237/article/details/50609421
版权

城市平乱
时间限制：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 1005
int 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 1005
int 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 1005
int 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 1005
using 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;
}
zhishuang.rao
关注
专栏目录
nyoj--115 城市平乱（最短路径）
许少y
03-11 565
题解计算这n个点到Q的最短路径，取最小值。 Floyd 会TLE. 没优化的Dijkstra。#include <iostream> #include <cstdio> #include <vector> #include <cstring> #include <algorithm> using namespace std;const int maxn = 1005; const int inf
NYOJ - 115 - 城市平乱 ( 最短路 Dijkstra )
i逆天耗子
12-21 468
描述 南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。 他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。 现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。 现在已知在任意两个城市之间的路行军所需的时间，你作为南将军麾下最厉害的程序员，请你编写一个程序来告诉南将军第一个分队到达叛乱城市所需的
nyoj-115-城市平乱（dijkstra算法）
weixin_30924239的博客
04-27 105
题目链接 1 /* 2 Name:nyoj-115-城市平乱 3 Copyright: 4 Author: 5 Date: 2018/4/25 17:28:06 6 Description: 7 dijkstra模板题 8 枚举从部队所在的城市到叛乱城市取最小值 9 */ 10 #include ...
nyoj115城市平乱
Flyison的博客
09-11 440
南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。 他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。 现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。 现在已知在任意两个城市之间的路行军所需的时间，你作为南将军麾下最厉害的程序员，请你编写一个程序来告诉南将军第一个分队到达叛乱城市所需的时间。 int t,n; void
NYOJ-115-城市平乱（裸迪杰斯特拉）
Prim
05-02 1310
城市平乱 时间限制：1000 ms | 内存限制：65535 KB 难度：4 描述 南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。现在已知在任意两个城市之间的路行军所需的时间，你作为南将军麾下最厉害的程序员
NYOJ 115 城市平乱
倚世独殇
04-24 742
NYOJ 115 城市平乱
NYOj115-城市平乱-Dijkstra-
Fighting_Dream
12-06 663
城市平乱 时间限制：1000 ms  |  内存限制：65535 KB 难度：4 描述 南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。 他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。 现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。 现在已知在任意两个城市之间
nyoj 115 城市平乱 【BFS】
shengweisong
08-07 888
题意：中文题，不解释 策略：广搜。第一道广搜题，先从目标点开始，进队列，标记此节点已被找过，以对首为起始点再找与它相连（并且没有被标记的）的结点入队尾，删除队首，然后在以此时的队首为起始点，标记此节点已被找过， 找与它相邻的点（并且没有被标记的），删除队首，一直循环直至所有节点都被找完。 代码：#include #include #include #define MAXN 0x3f3f3f3f
NYOJ 115城市平乱 【dijkstra】
nuanxin_520的专栏
12-22 388
城市平乱 时间限制：1000 ms  |  内存限制：65535 KB 难度：4 描述 南将军统领着N个部队，这N个部队分别驻扎在N个不同的城市。 他在用这N个部队维护着M个城市的治安，这M个城市分别编号从1到M。 现在，小工军师告诉南将军，第K号城市发生了暴乱，南将军从各个部队都派遣了一个分队沿最近路去往暴乱城市平乱。 现在已知在任意两个城市之间
算法-矩形嵌套（NYOJ-16）（包含源程序）.rar
09-16
《算法-矩形嵌套（NYOJ-16）》是针对计算机科学中的一个典型问题进行探讨的资源包，其中包含了解决该问题的源程序。这个问题涉及到数据结构、图论以及算法设计等多个核心领域，是编程竞赛或算法学习中的常见题目。在...
nyoj--1058 部分和问题(dfs)
许少y
03-19 965
nyoj 1058题解dfs搜索。 注意剪枝。#include <iostream> #include <vector> #include <cstring> #include <algorithm> using namespace std;const int maxn = 25; int a[maxn], vis[maxn]; int n, k, flag;void dfs(int po
NYOJ - 38：布线问题
WINGREZ‘S BLOG
04-28 135
布线问题 来源：NYOJ 标签：最小生成树 参考资料： 相似题目： 题目 南阳理工学院要进行用电线路改造，现在校长要求设计师设计出一种布线方式，该布线方式需要满足以下条件： 1、把所有的楼都供上电。 2、所用电线花费最少 输入 第一行是一个整数n表示有n组测试数据。(n<5) 每组测试数据的第一行是两个整数v,e. v表示学校里楼的总个数(v<=500) 随后的e行里，每行有...
NYOJ - 5：Binary String Matching
WINGREZ‘S BLOG
08-25 310
NYOJ-5：Binary String Matching 来源：http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=5 标签：字符串，字符串匹配，KMP算法 参考资料： 相似题目： 题目 Given two strings A and B, whose alphabet consist only...
NYOJ - 70：阶乘因式分解（二）
WINGREZ‘S BLOG
09-21 472
NYOJ - 70：阶乘因式分解（二） 标签：算法、数论 参考资料：http://blog.csdn.net/wingrez/article/details/78054722（质因数分解式） 相似题目： NYOJ - 56：阶乘因式分解（一） 题目 给定两个数n，m,其中m是一个素数。将n（0<=n<=2^31）的阶乘分解质因数，求其中有多少个m。注：^
双向链表（非循环）排序
zhishuang.rao的博客
03-19 2930
双向链表的操作问题 Description 建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。） Input 第一行：双向表的长度； 第二行：链表中的数据元素。 Output 输出双向链表中的数据元素的值。 Sample Input 1 2 3 10 2 4 6 3 5 8 10 21 12 9Sample
【蓝桥杯题解】矩阵翻硬币
zhishuang.rao的博客
01-31 843
历届试题 矩阵翻硬币 时间限制：1.0s 内存限制：256.0MB 提交此题 问题描述 　　小明先把硬币摆成了一个 n 行 m 列的矩阵。　　随后，小明对每一个硬币分别进行一次 Q 操作。　　对第x行第y列的硬币进行 Q 操作的定义：将所有第 i*x 行，第 j*y 列的硬币进行翻转。　　其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。　　当小明对所有硬币都进行了一次 Q 操
[CCF]交通规则
zhishuang.rao的博客
12-08 651
201612-4 试题名称： 交通规划 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　G国国王来中国参观后，被中国的高速铁路深深的震撼，决定为自己的国家也建设一个高速铁路系统。 　　建设高速铁路投入非常大，为了节约建设成本，G国国王决定不新建铁路，而是将已有的铁路改造成高速铁路。现在，请你为G国国王提供一个方案，将现有的一部分铁路改造成高速铁路
【蓝桥杯题解】分糖果
zhishuang.rao的博客
01-31 613
历届试题 分糖果 时间限制：1.0s 内存限制：256.0MB 问题描述 　　有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏：　　每个小朋友都把自己的糖果分一半给左手边的孩子。　　一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。　　反复进行这个游戏，直到所有小朋友的糖果数都相同为止。　　你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少
归并求逆序数
zhishuang.rao的博客
02-04 514
#include <iostream> #include <algorithm> #include <vector> using namespace std; /* * 归并求逆序数 * 方法一：求出每个数的逆序对的个数num，对所有num求和后除以2得到逆序数 * 步骤：先求小区间中的每个数的num,再回溯合并两个小区间为一个大区间并更新大区间中每个数的num */ struct Node
筛选法----孪生素数问题
最新发布
08-13
- *2* *3* [NYOJ-26 孪生素数问题](https://blog.csdn.net/memoryofyck/article/details/52059096)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值