程序设计思维与实践 Week7 作业

最新推荐文章于 2020-06-30 14:11:44 发布

叭哒杏_vivila

最新推荐文章于 2020-06-30 14:11:44 发布

阅读量89

点赞数

分类专栏：程序设计

本文链接：https://blog.csdn.net/qq_44157558/article/details/105374538

版权

程序设计专栏收录该内容

28 篇文章 1 订阅

订阅专栏

A - TT 的魔法猫

众所周知，TT 有一只魔法猫。

这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？

魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过 B，且胜负关系具有传递性。即 A 胜过 B，B 胜过 C，则 A 也能胜过 C。

TT 不相信他的小猫咪什么比赛都能预测，因此他想知道有多少对选手的胜负无法预先得知，你能帮帮他吗？

Input
第一行给出数据组数。
每组数据第一行给出 N 和 M（N , M <= 500）。

接下来 M 行，每行给出 A B，表示 A 可以胜过 B。

Output
对于每一组数据，判断有多少场比赛的胜负不能预先得知。注意 (a, b) 与 (b, a) 等价，即每一个二元组只被计算一次。

Sample Input

3
3 3
1 2
1 3
2 3
3 2
1 2
2 3
4 2
1 2
3 4

Sample Output

0
0
4

思路
可以看作是一个有向图的问题，类似于来判断每个点可以到达的顶点。
比如说graph中，g[i][k]=1,代表i胜过k，g[k][j]=1代表k胜过j。
因为具有传递性，因此此时可以有g[i][j]=1,代表i胜过j。

据此可以采用Floyd的方法进行计算。由于Floyd是O(n^3)的复杂度，考虑进行简化：

如果g[i][k]=0，则所有以g[k][]的比赛都不能进行判断。
如果g[i][k]=1，g[k][j]=0，同样的i与j的胜负不能得到。

据此可以精简一些不必要的步骤。

计算结果时可以只扫描一个对角(比如说右上角)，对角线上的是自己与自己的比赛，可忽略。在扫描一个对角的同时要考虑与它沿对角线对称的地方(因为如果g[i][j]=0，g[j][i]=1时i与j的比赛是可以判断的。)

代码

#include<iostream>
using namespace std;


int N, M;//N数据个数，M对数
int Z;//组数
int result = 0;//结果
int g[510][510];//图

int main()
{
	cin >> Z;

	for (int z = 0; z < Z; z++)
	{
		cin >> N >> M;
		result = 0;
		memset(g, 0, sizeof(g));//初始化
		int a, b;
		for (int i = 0; i < M; i++)
		{
			cin >> a >> b;
			g[a][b] = 1;
		}
		//Floyed
		for (int k = 1; k <= N; k++)
		{
			for (int i = 1; i <= N; i++)
			{
				if (g[i][k] == 1)
				{
					for (int j = 1; j <= N; j++)
					{
						if (g[k][j] == 1)
						{
							g[i][j] = 1;
						}
					}
				}
			}
		}

		//统计结果
		for (int i = 1; i <= N; i++)
		{
			for (int j = i + 1; j <= N; j++)
			{
				if (g[i][j] == 0 && g[j][i] == 0)
				{
					result++;
				}
			}
		}
		cout << result << endl;

	}
}

B - TT 的旅行日记

众所周知，TT 有一只魔法猫。今天他在 B 站上开启了一次旅行直播，记录他与魔法猫在喵星旅游时的奇遇。 TT 从家里出发，准备乘坐猫猫快线前往喵星机场。猫猫快线分为经济线和商业线两种，它们的速度与价钱都不同。当然啦，商业线要比经济线贵，TT 平常只能坐经济线，但是今天 TT 的魔法猫变出了一张商业线车票，可以坐一站商业线。假设 TT 换乘的时间忽略不计，请你帮 TT 找到一条去喵星机场最快的线路，不然就要误机了！

输入
输入包含多组数据。

每组数据第一行为 3 个整数 N, S 和 E (2 ≤ N ≤ 500, 1 ≤ S, E ≤ 100)，即猫猫快线中的车站总数，起点和终点（即喵星机场所在站）编号。

下一行包含一个整数 M (1 ≤ M ≤ 1000)，即经济线的路段条数。

接下来有 M 行，每行 3 个整数 X, Y, Z (1 ≤ X, Y ≤ N, 1 ≤ Z ≤ 100)，表示 TT 可以乘坐经济线在车站 X 和车站 Y 之间往返，其中单程需要 Z 分钟。

下一行为商业线的路段条数 K (1 ≤ K ≤ 1000)。

接下来 K 行是商业线路段的描述，格式同经济线。

所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。

输出
对于每组数据，输出3行。

第一行按访问顺序给出 TT 经过的各个车站（包括起点和终点）。

第二行是 TT 换乘商业线的车站编号（如果没有使用商业线车票，输出"Ticket Not Used"，不含引号）。

第三行是 TT 前往喵星机场花费的总时间。

本题不忽略多余的空格和制表符，且每一组答案间要输出一个换行

输入样例

4 1 4
4
1 2 2
1 3 3
2 4 4
3 4 5
1
2 4 3

输出样例

1 2
4
2
5

思路
这道题使用的时Dijkstra算法。将路线看作是加权无向图。
因为题中会给出起点S和终点E，并且最多只走一条商业线。
因此可以先得到起点到每个点的最短距离dis1[]和终点到每个点的最短距离dis2[]。
同时记录路径上每个顶点的前一个顶点，以便后续输出路径。

枚举商业线，例如一条商业线的起点是u，终点时v，权值是w。
那么得到result=min{dis1[u]+dis2[v]+w,dis1[v]+dis2[u]+w}。并且每次更换result时记录商业线更换的站。

将这个最小值result和dis1[E]进行比较，如果result更小则使用这条商业线，否则不使用商业线。

注意：需要注意一下输出格式，因为每组答案之间需要多出一个空行，因此在循环的时候，除了第一组数据，其他组数据都要在一开始输出一个空行。

代码

#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;

/*B - TT 的旅行日记 */
struct Edge
{
	int to;
	int w;
	int next;
};

Edge edge[100010];
int N, S, E;
int M;
int K;
int result;//总时间
int head[100010];
int dis1[100010], dis2[100010];
int path1[100010], path2[100010];

int total;
bool vis[100010];


//添加一条边
void addEdge(int x, int y, int w)
{
	edge[++total].to = y;
	edge[total].w = w;
	edge[total].next = head[x];
	head[x] = total;
}

void dijkstra(int u, int dis[], int path[])
{
	//初始化
	memset(vis, false, sizeof(vis));

	for (int i = 1; i <= N; i++)
	{
		dis[i] = 1000000;
	}
	dis[u] = 0;

	for (int i = 1; i <= N; i++)
	{
		int theMin = 1000000;
		int temp = 0;
		for (int j = 1; j <= N; j++)
		{
			if (vis[j] == false && dis[j] < theMin)
			{
				theMin = dis[j];
				temp = j;
			}
			
		}
		vis[temp] = true;

		for (int j = head[temp];j; j = edge[j].next)
		{
			if (vis[edge[j].to] == false && dis[edge[j].to] > dis[temp] + edge[j].w)
			{
				dis[edge[j].to] = dis[temp] + edge[j].w;
				path[edge[j].to] = temp;//记录前驱节点
			}
		}
	}
}

int main()
{
	int f = 0;
	while (cin >> N >> S >> E)
	{
		if (f != 0)
		{
			cout << endl;
		}
		f = 1;
		//初始化
		memset(vis, false, sizeof(vis));
		memset(head, 0, sizeof(head));
		memset(path1, 0, sizeof(path1));
		memset(path2, 0, sizeof(path2));
		vector<int> path;
		total = 0;
		int tranfrom = 0, tranto = 0;//上午线起始站

		cin >> M;
		int x, y, z;
		for (int i = 0; i < M; i++)
		{
			cin >> x >> y >> z;
			addEdge(x, y, z);
			addEdge(y, x, z);
		}
		dijkstra(S, dis1, path1);
		dijkstra(E, dis2, path2);

		cin >> K;
		result = dis1[E];
		for (int i = 0; i < K; i++)
		{
			cin >> x >> y >> z;

			if (dis1[x] + dis2[y] + z < result)
			{
				result = dis1[x] + dis2[y] + z;
				tranfrom = x;
				tranto = y;
			}

			if (dis1[y] + dis2[x] + z < result)
			{
				result = dis1[y] + dis2[x] + z;
				tranfrom = y;
				tranto = x;
			}

		}


		if (tranfrom == 0)//不使用商务线
		{
			for (int t = E; t != S; t = path1[t])
			{
				path.push_back(t);
			}
			path.push_back(S);

			for (int t = (int)path.size() - 1; t >= 1; t--)
			{
				cout << path[t] << " ";
			}
			cout << path[0] << endl;
			cout << "Ticket Not Used" << endl;
			cout << result << endl;

		}
		else
		{
			for (int t = tranfrom; t != S; t = path1[t])
			{
				path.push_back(t);
			}
			path.push_back(S);

			for (int t = tranto; t != E; t = path2[t])
			{
				path.insert(path.begin(), t);
			}
			path.insert(path.begin(), E);

			for (int t = (int)path.size() - 1; t >= 1; t--)
			{
				cout << path[t] << " ";
			}
			cout << path[0] << endl;
			cout << tranfrom << endl;
			cout << result << endl;
		}


	}
}

C - TT 的美梦

这一晚，TT 做了个美梦！

在梦中，TT 的愿望成真了，他成为了喵星的统领！喵星上有 N 个商业城市，编号 1 ～ N，其中 1 号城市是 TT 所在的城市，即首都。

喵星上共有 M 条有向道路供商业城市相互往来。但是随着喵星商业的日渐繁荣，有些道路变得非常拥挤。正在 TT 为之苦恼之时，他的魔法小猫咪提出了一个解决方案！TT 欣然接受并针对该方案颁布了一项新的政策。

具体政策如下：对每一个商业城市标记一个正整数，表示其繁荣程度，当每一只喵沿道路从一个商业城市走到另一个商业城市时，TT 都会收取它们（目的地繁荣程度 - 出发地繁荣程度）^ 3 的税。

TT 打算测试一下这项政策是否合理，因此他想知道从首都出发，走到其他城市至少要交多少的税，如果总金额小于 3 或者无法到达请悄咪咪地打出 ‘?’。

Input
第一行输入 T，表明共有 T 组数据。（1 <= T <= 50）

对于每一组数据，第一行输入 N，表示点的个数。（1 <= N <= 200）

第二行输入 N 个整数，表示 1 ～ N 点的权值 a[i]。（0 <= a[i] <= 20）

第三行输入 M，表示有向道路的条数。（0 <= M <= 100000）

接下来 M 行，每行有两个整数 A B，表示存在一条 A 到 B 的有向道路。

接下来给出一个整数 Q，表示询问个数。（0 <= Q <= 100000）

每一次询问给出一个 P，表示求 1 号点到 P 号点的最少税费。

Output

每个询问输出一行，如果不可达或税费小于 3 则输出 ‘?’。

Sample Input

2
5
6 7 8 9 10
6
1 2
2 3
3 4
1 5
5 4
4 5
2
4
5
10
1 2 4 4 5 6 7 8 9 10
10
1 2
2 3
3 1
1 4
4 5
5 6
6 7
7 8
8 9
9 10
2
3 10

Sample Output

Case 1:
3
4
Case 2:
?
?

思路
同样可看作图的问题来解决。

因为每条路的权值为(终点-起点)^3，因此其权值有可能为负数。因此图中可能会出现负环。对于负环需要着重判断。

可以设一个bool型的数组，来记录一个顶点是否出现在负环中。

同时一旦检测到一个顶点在负环中，则dfs该顶点可以到达的其他顶点，这些顶点因为负环的原因也是不能到达的。

那么怎么判断一个顶点是否在负环中呢？
考虑图中顶点的个数是一定的，如果出现负环，则一定会在负环处循环，那么可以根据此时已经走过的顶点的个数来判断。如果个数>图中顶点数，那么就说明出现了负环。

反思

这里我出现了一个问题：
在进行for (int i = head[u];i; i = edge[i].next)这个循环的时候，我最开始采用的是for (int i = head[u];; i = edge[i].next)。

注意：我省略掉了第二个i的判断。因此出现了CE。

我这次刚开始写的时候，没注意这个判断条件，错误的认为它没有影响。将其省略了之后，如果接下来的edge[i].next不存在，这里这个循环就会出现错误。

代码

#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
#include<cmath>
using namespace std;
/*C - TT 的美梦 */
struct Edge
{
	int to;
	int w;
	int next;
};

Edge edge[100010];
int total;
int head[100010];
int T, N, M, Q, P;
int a[100010];
int dis[100010], cnt[100010];
bool vis[100010];
bool neg[100010];//标记是否为负环
queue<int>q;

//添加一条边
void addEdge(int x, int y, int w)
{
	edge[++total].to = y;
	edge[total].w = w;
	edge[total].next = head[x];
	head[x] = total;
}

void dfs(int u)
{
	neg[u] = true;
	for (int i = head[u];i; i = edge[i].next)
	{
		if (neg[edge[i].to] == false)//不是负环
		{
			dfs(edge[i].to);
		}
	}
}


void spfa(int u)
{
	//初始化
	for (int i = 1; i <= N; i++)
	{
		dis[i] = 1000000;
	}
	dis[u] = 0;
	vis[u] = true;
	while (!q.empty())//清空队列
	{
		q.pop();
	}

	q.push(u);

	while (!q.empty())
	{
		
		int v = q.front();
		q.pop();
		vis[v] = false;
		for (int i = head[v];i; i = edge[i].next)
		{
			
			if (dis[edge[i].to] > dis[v] + edge[i].w)
			{
				cnt[edge[i].to]++;
				dis[edge[i].to] = dis[v] + edge[i].w;
				if (cnt[edge[i].to] > N)
				{
					dfs(edge[i].to);
					continue;
				}
				if (vis[edge[i].to] == false)
				{
					q.push(edge[i].to);
					vis[edge[i].to] = true;
				}

			}
		}
	}


}




int main()
{
	cin >> T;
	for (int i = 0; i < T; i++)
	{
		//初始化
		total = 0;
		memset(head, 0, sizeof(head));
		memset(neg, false, sizeof(neg));
		memset(cnt, 0, sizeof(cnt));

		cin >> N;
		for (int j = 1; j <= N; j++)
		{
			cin >> a[j];
		}

		cin >> M;
		int A, B;
		for (int j = 0; j < M; j++)
		{
			cin >> A >> B;
			addEdge(A, B, pow(a[B] - a[A], 3));
		}

		spfa(1);
		cout << "Case " << i+1 << ":" << endl;
		cin >> Q;
		for (int j = 0; j < Q; j++)
		{
			cin >> P;
			if (dis[P] < 3 || neg[P] == true || dis[P] == 1000000)
			{
				cout << "?" << endl;
			}
			else
			{
				cout << dis[P] << endl;
			}
		}




	}
}

叭哒杏_vivila

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序设计思维与实践 Week7 作业

A - TT 的魔法猫众所周知，TT 有一只魔法猫。这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过 B，且胜负关系具有传递...
复制链接

扫一扫