pat-1087【最短路径】

近期一次pat考试中的最后一题。事实上玩算法这东西就像打魔兽。不能光有思想上的高度,微操必须实打实。就这么个迪杰斯特拉算法。多少教科书上都讲烂了。

可是现场又有多少人是敲对的呢?不能光停留在理解上。必须能用自己的方式表达出来才算过关。

题目:

1087. All Roads Lead to Rome (30)

时间限制

200 ms

内存限制

32000 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

Indeed there are many different tourist routes from our city to Rome. You are supposed to find your clients the route with the least cost while gaining the most happiness.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers N (2<=N<=200), the number of cities, and K, the total number of routes between pairs of cities; followed by the name of the starting city. The next N-1 lines
each gives the name of a city and an integer that represents the happiness one can gain from that city, except the starting city. Then K lines follow, each describes a route between two cities in the format "City1 City2 Cost". Here the name of a city is a
string of 3 capital English letters, and the destination is always ROM which represents Rome.

Output Specification:

For each test case, we are supposed to find the route with the least cost. If such a route is not unique, the one with the maximum happiness will be recommended. If such a route is still not unique, then we output the one with the maximum average happiness
-- it is guaranteed by the judge that such a solution exists and is unique.

Hence in the first line of output, you must print 4 numbers: the number of different routes with the least cost, the cost, the happiness, and the average happiness (take the integer part only) of the recommended route. Then in the next line, you are supposed
to print the route in the format "City1->City2->...->ROM".

Sample Input:

6 7 HZH
ROM 100
PKN 40
GDN 55
PRS 95
BLN 80
ROM GDN 1
BLN ROM 1
HZH PKN 1
PRS ROM 2
BLN HZH 2
PKN GDN 1
HZH PRS 1

Sample Output:

3 3 195 97
HZH->PRS->ROM

----------------------------------------------------------------------------------------------------------------------------------------------------

题目的意思非常明白,给定图的点和边。起点。终点,求最短路径而且打印。假设有同样的情况,推断总的幸福指数。假设还是同样,推断平均幸福指数。

本题唯一的难点就在于统计同样路径的条数。

我们用数组存储到达每一个点的同样路径的条数。初始值都是1。

实际上就仅仅有两种情况,第一:这个点A被其它点B更新了,那么到达A的同样的最短路径条数就是B点的同样最短路径条数。

第二:起点到A点和B点的长度相等。那么A点的最短路径条数就是A本身的条数加上B点的条数。

// pat-1087.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include"algorithm"
#include"map"
#include"vector"
#include"string"
#include"iostream"
#include"stack"
using namespace std;

#define max 300
#define inf 2100000000//!!!
int dis[max][max]={0};
int n=0;
int visited[max]={0};
int father[max]={0};
int same[max]={0};
int happies[max]={0};
int finalhappies[max]={0};
int precnt[max]={0};
map<int,string> cityname;
map<string,int> citynum;
stack<string> ans;
void dijstrak(int s)
{
	same[0]=1;
	visited[s]=1;
	for(int i=0;i<n;i++)
	{
		 int min=inf;
		 int mark=-1;
	     for(int j=0;j<n;j++)
		 {//find min
		     if(visited[j]==0&&dis[s][j]<min)
			 {
			    min=dis[s][j];
			    mark=j;
			 }
		 }
		 if(mark==-1)
			 return ;
		 visited[mark]=1;//marked
		 for(int k=0;k<n;k++)
		 {//updata
			 if(visited[k]==1)
				 continue;
			 int raw=dis[s][k];
			 int another=dis[s][mark]+dis[mark][k];
		    if(raw>another)
			{   same[k]=same[mark];
		        dis[s][k]=dis[s][mark]+dis[mark][k];
				father[k]=mark;
				finalhappies[k]=finalhappies[mark]+happies[k];
				precnt[k]=precnt[mark]+1;
			}
			else if(raw==another)
			{
				same[k]+=same[mark];
				if(finalhappies[k]<finalhappies[mark]+happies[k])
				{
					father[k]=mark;
					finalhappies[k]=finalhappies[mark]+happies[k];
					precnt[k]=precnt[mark]+1;
				}
				else if(finalhappies[k]==finalhappies[mark]+happies[k])
				{
				   if(precnt[k]>(precnt[mark]+1))
				   {
					   father[k]=mark;
					   precnt[k]=precnt[mark]+1;
				   }
				}
			}

			}

		 }
	}

int main()
{
	for(int i=0;i<max;i++)
	    for(int j=0;j<max;j++){
			dis[i][j]=inf;
			dis[j][i]=inf;
			dis[i][i]=inf;
			dis[j][j]=inf;
	}
   int k=0;
   string s;
   cin>>n>>k>>s;
   cityname[0]=s;
   string citystr;
   int happy=0;
   for(int i=1;i<n;i++)
   {
	cin>>citystr>>happy;
	cityname[i]=citystr;
	citynum[citystr]=i;
	happies[i]=happy;
	finalhappies[i]=happy;
	precnt[i]=1;
	same[i]=1;
   }
   string city1,city2;
   int cost=0;
   for(int i=0;i<k;i++){
     cin>>city1>>city2>>cost;
	 int j=citynum[city1];
	 int b=citynum[city2];
	 dis[j][b]=cost;
	 dis[b][j]=cost;
   }

   dijstrak(0);   

   int romanum=citynum["ROM"];
   int index=romanum;
   string path;
   path+=s;//"HZH"
   ans.push("ROM");
   while(father[index]!=0)
   {
	 string pathcity=cityname[father[index]];
	 ans.push(pathcity);
	 index=father[index];
   }
   while(!ans.empty()){
	   path+="->";
	   path+=ans.top();
	   ans.pop();
   }
   cout<<same[romanum]<<" "<<dis[0][romanum]<<" "<<finalhappies[romanum]<<" "<<finalhappies[romanum]/precnt[romanum]<<endl;
   cout<<path<<endl;
  return 0;
}

提交的时候把预编译头

#include "stdafx.h"

去掉就可以。

时间: 2024-09-29 23:53:33

pat-1087【最短路径】的相关文章

[PAT]1087. All Roads Lead to Rome (30)

/************************************************************** 1087. All Roads Lead to Rome (30) 时间限制 200 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue Indeed there are many different tourist routes from our city to Rome. You are suppos

PAT 1087 All Roads Lead to Rome

1 #include <cstdio> 2 #include <climits> 3 #include <iostream> 4 #include <vector> 5 #include <string> 6 #include <queue> 7 #include <unordered_map> 8 #include <algorithm> 9 10 using namespace std; 11 12 typ

PAT 1087

又是最短路,陈越姥姥好像很喜欢最短路... 这道题之后还得再写一遍,最短路一定要熟悉 碰到一个坑,就是在加最短路的时候,不是++,而是要把前面的最短路加进来... 1 #include <vector> 2 #include <string> 3 #include <iostream> 4 #include <map> 5 #include <fstream> 6 7 //#define OJ 8 9 #ifdef OJ 10 #define f

PAT 1087 有多少不同的值

https://pintia.cn/problem-sets/994805260223102976/problems/1038429191091781632 当自然数 n 依次取 1.2.3.--.N 时,算式 ? 有多少个不同的值?(注:? 为取整函数,表示不超过 x 的最大自然数,即 x 的整数部分.) 输入格式: 输入给出一个正整数 N(2). 输出格式: 在一行中输出题面中算式取到的不同值的个数. 输入样例: 2017 输出样例: 1480 代码: #include <bits/stdc

PAT甲题题解-1111. Online Map (30)-PAT甲级真题(模板题,两次Dijkstra,同时记下最短路径)

题意:给了图,以及s和t,让你求s到t花费的最短路程.最短时间,以及输出对应的路径.   对于最短路程,如果路程一样,输出时间最少的. 对于最短时间,如果时间一样,输出节点数最少的.   如果最短路程和最短时间路径一样,合并输出一次即可. 纯粹就是练习dijkstra,没什么难的. 第一次dijkstra求最短路程,记录下每个节点的路程和时间. 第二次dijkstra求最短时间,记录下每个节点的时间和经过的节点数. pre数组用来存储前驱节点,保存路径 #include <iostream>

1087. All Roads Lead to Rome (30)【最短路】——PAT (Advanced Level) Practise

题目信息 1087. All Roads Lead to Rome (30) 时间限制200 ms 内存限制65536 kB 代码长度限制16000 B Indeed there are many different tourist routes from our city to Rome. You are supposed to find your clients the route with the least cost while gaining the most happiness. I

pat 乙级题目 1087

题目 1087 有多少不同的值 (20 分) 当自然数 n 依次取 1.2.3.--.N 时,算式 ?n/2?+?n/3?+?n/5? 有多少个不同的值?(注:?x? 为取整函数,表示不超过 x 的最大自然数,即 x 的整数部分.) 输入格式: 输入给出一个正整数 N(2≤N≤10?4??). 输出格式: 在一行中输出题面中算式取到的不同值的个数. 输入样例: 2017 输出样例: 1480 ----------------------------------------------我是华丽的分

PAT basic 1087

1087 有多少不同的值 (20 分) 当自然数 n 依次取 1.2.3.--.N 时,算式 ?n/2?+?n/3?+?n/5? 有多少个不同的值?(注:?x? 为取整函数,表示不超过 x 的最大自然数,即 x 的整数部分.) 输入格式: 输入给出一个正整数 N(2≤N≤10?4??). 输出格式: 在一行中输出题面中算式取到的不同值的个数. 输入样例: 2017 输出样例: 1480 这道题熟练使用STL,很容易做出来. 1 #include<iostream> 2 #include<

PAT (Advanced Level) 1087 All Roads Lead to Rome

题解   最短路径经典题型.套最短路的板子再加上额外的要求就可以了(说起来好简单).SPFA也行,Dijkstra也可以.这里我用的是SPFA.因为题目要求,将地名和其对应的数字用map映射一下,这样方便处理. same[i]代表到达地点 i 有几种路径: dist[i]代表从起点到地点 i 的最短距离: happy[i]代表从起点到地点 i 的幸福值: cnt[i]代表从起点到地点 i 需要经过几个城市: ans[i]代表从哪个地点到达了地点 i : 代码 #include<bits/stdc

PAT (Advanced Level) 1087. All Roads Lead to Rome (30)

暴力DFS. #include<cstdio> #include<cstring> #include<cmath> #include<vector> #include<map> #include<stack> #include<queue> #include<string> #include<iostream> #include<algorithm> using namespace st