程序设计思维与实践 Week6 作业及大模拟

A - 氪金带东
实验室里原先有一台电脑(编号为1)，最近氪金带师咕咕东又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。但是咕咕东担心网速太慢，他希望知道第i台电脑到其他电脑的最大网线长度，但是可怜的咕咕东在不久前刚刚遭受了宇宙射线的降智打击，请你帮帮他。

Input
输入文件包含多组测试数据。对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开。
Output
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N).
Sample Input
5
1 1
2 1
3 1
1 1
Sample Output
3
2
3
4
4

---

思路：树中最长路确定的两点中的一点是距离任意点的最远点。先随便找一点用dfs找到距离它的最远点leaf1，再对leaf1调用dfs，过程中记录到个点的距离，记录在数组dis1中。dfs函数需要一个last参数来确定该点是否是上一个点来避免重复。dis1中最远点是leaf2，对leaf2调用dfs，得到数组dis2，取dis1,dis2同一index中的最大值，就是答案。

---

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXM = 20000;
int head[MAXM], dis0[MAXM], dis1[MAXM], dis2[MAXM], tot, leaf, maxL;

struct Edge
{
	int u, v, w, next;
	Edge() {}
	Edge(int theU,int theV,int theW,int theNext)
		:u(theU),v(theV),w(theW),next(theNext)
	{
	}
}Edges[MAXM];

void addEdge(int u, int v, int w)
{
	Edges[++tot] = Edge(u, v, w, head[u]);
	head[u] = tot;
}

void dfs(int u,int last, int* dis)
{
	if (maxL < dis[u]) leaf = u;
	for (int i = head[u]; i != 0; i = Edges[i].next)
	{
		int v = Edges[i].v;
		if (last != v)
		{
			dis[v] = dis[u] + Edges[i].w;
			dfs(Edges[i].v, u, dis);
		}
	}
	return;
}
int main()
{
	int n, v, w;
	cin >> n;
	for (size_t i = 2; i <= n; i++)
	{
		cin >> v >> w;
		addEdge(i, v, w);
		addEdge(v, i, w);
	}
	dfs(1, -1, dis0);
	int leaf1 = leaf;
	maxL = 0;
	dfs(leaf1, -1, dis1);
	int leaf2 = leaf;
	dfs(leaf2, -1, dis2);
	for(int i = 1; i <= n; i++)
		cout << max(dis1[i],dis2[i]) << '\n';
}

---

B - 戴好口罩！

小A同学被确诊为新冠感染，并且没有戴口罩！！！！！！
需要尽快找到所有和小A同学直接或者间接接触过的同学，将他们隔离，防止更大范围的扩散。
众所周知，学生的交际可能是分小团体的，一位学生可能同时参与多个小团体内。

Input
多组数据，对于每组测试数据：
第一行为两个整数n和m（n = m = 0表示输入结束，不需要处理），n是学生的数量，m是学生群体的数量。0 < n <= 3e4 ， 0 <= m <= 5e2
学生编号为0~n-1
小A编号为0
随后，m行，每行有一个整数num即小团体人员数量。随后有num个整数代表这个小团体的学生。

Output
输出要隔离的人数，每组数据的答案输出占一行

Sample Input
100 4
2 1 2
5 10 13 11 12 14
2 0 1
2 99 2
200 2
1 5
5 1 2 3 4 5
1 0
0 0

Sample Output
4
1
1

---

思路：并查集，把同一个组的合并

#include <iostream>
#include<cstring>

using namespace std;

class fastUnionFind
{
public:
	fastUnionFind(int theN)
	{
		n = theN;
		par = new int[n];
		memset(par, -1, sizeof(int) * n);
	}
	~fastUnionFind()
	{
		delete[] par;
	}
	int find(int x)
	{
		while (par[x] >= 0)
			x = par[x];
		return x;
	}
	bool unite(int a,int b)
	{
		int x = find(a), y = find(b);
		if (x == y) return false;

		par[x] += par[y];
		par[y] = x;
		return true;
	}
	int tot()
	{
		int x = par[0];
		if (x < 0) return -x;
		while (par[x] >= 0)
			x = par[x];
		return -par[x];
	}
private:
	int* par;
	int n;
};
int main()
{
	int n, m;
	while (1)
	{
		cin >> n >> m;
		if (n == 0 && m == 0) return 0;
		fastUnionFind u(n);
		while (m--)
		{
			int k, a, b; cin >> k >> a;
			int l = k - 1;
			while (l--)
			{
				cin >> b;
				u.unite(a, b);
				a = b;
			}
		}
		cout << u.tot() << endl;
	}
}

---

C - 掌握魔法の东东 I
东东在老家农村无聊，想种田。农田有 n 块，编号从 1~n。种田要灌氵
众所周知东东是一个魔法师，他可以消耗一定的 MP 在一块田上施展魔法，使得黄河之水天上来。他也可以消耗一定的 MP 在两块田的渠上建立传送门，使得这块田引用那块有水的田的水。 (1<=n<=3e2)
黄河之水天上来的消耗是 Wi，i 是农田编号 (1<=Wi<=1e5)
建立传送门的消耗是 Pij，i、j 是农田编号 (1<= Pij <=1e5, Pij = Pji, Pii =0)
东东为所有的田灌氵的最小消耗

Input
第1行：一个数n
第2行到第n+1行：数wi
第n+2行到第2n+1行：矩阵即pij矩阵

Output
东东最小消耗的MP值

Example
Input
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
Output
9

---

思路：最小生成树问题，天上水也看做一个点就可以。将边从小到大排好，每次取最小的，若不与已经选的够成环，则加入集合。判断是否够成环用并查集，就是判断两点是否是同一集合。

#include <iostream>
#include <algorithm>

using namespace std;

constexpr int MAXM = 501000;
struct Edge
{
	int u, v, w;
}Edges[MAXM];
int tot;
class fastUnionFind
{
public:
	fastUnionFind(int theN)
	{
		n = theN;
		par = new int[n + 1];
		memset(par, -1, sizeof(int) * (n + 1));
	}
	~fastUnionFind()
	{
		delete[] par;
	}
	int find(int x)
	{
		while (par[x] >= 0)
			x = par[x];
		return x;
	}
	bool unite(int a,int b)
	{
		int x = find(a), y = find(b);
		if (x == y) return false;

		par[y] = x;
		return true;
	}

private:
	int* par;
	int n;
};
int main()
{
	int n, w;
	cin >> n;
	for (size_t i = 1; i <= n; i++)
	{
		cin >> w;
		Edge e; 
		e.u = 0, e.v = i, e.w = w;
		Edges[++tot] = e;
	}
	for (size_t i = 1; i <= n; i++)
	{
		for (size_t k = 1; k <= i; k++)
		{
			int x;
			cin >> x;
		}
		for (size_t j = i + 1; j <= n; j++)
		{
			cin >> w;
			Edge e;
			e.u = i, e.v = j, e.w = w;
			Edges[++tot] = e;
		}
	}

	sort(Edges + 1, Edges + 2 * n + 1, [](Edge l, Edge r) {
		return l.w < r.w;
	});
	fastUnionFind u(n);
	int index = 0;
	int length = 0;
	int cnt = 0;
	while (cnt < n)
	{
		Edge e = Edges[++index];
		if (u.find(e.u) != u.find(e.v))
		{
			length += e.w;
			u.unite(e.u, e.v);
			cnt++;
		}
	}
	cout << length;
}

---

D - 数据中心
Example
Input
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
Output
4

---

思路：最小生成树一定是瓶颈生成树，问题转化为找最小生成树的最大边，最小生成树算法同上题。另外这个题的并查集需要优化，不然会RE，优化方法是紧缩路径，让孩子与祖宗连接；合并采用重量规则，小树连在大树上。

#include <iostream>
#include <algorithm>

using namespace std;
constexpr int MAXM = 100005;
struct Edge
{
	int u, v, w;
}Edges[MAXM];
int ans;
class fastUnionFind
{
public:
	fastUnionFind(int theN)
	{
		n = theN;
		par = new int[n + 1];
		memset(par, -1, sizeof(int) * (n + 1));
	}
	~fastUnionFind()
	{
		delete[] par;
	}
	int find(int x)
	{
		int p = x;
		while (par[p] >= 0)
			p = par[p];
		int cur = x;
		while (par[cur] >= 0)
		{
			int temp = par[cur];
			par[cur] = p;
			cur = temp;
		}
		return p;
	}
	bool unite(int a, int b)
	{
		int x = find(a), y = find(b);
		if (x == y) return false;
		if (par[x] < par[y])
		{
			par[x] += par[y];
			par[y] = x;
		}
		else
		{
			par[y] += par[x];
			par[x] = y;
		}
		return true;
	}

private:
	int* par;
	int n;
};
int main()
{
	int n, m, root;
	cin >> n >> m >> root;
	for (size_t i = 0; i < m; i++)
	{
		cin >> Edges[i].u >> Edges[i].v >> Edges[i].w;
	}
	sort(Edges, Edges + m, [](Edge l, Edge r) {
		return l.w < r.w;
	});
	fastUnionFind u(n);
	int index = -1;
	int cnt = 0;
	while (cnt < n - 1)
	{
		if (index >= m - 1)
		{
			ans = -1;
			break;
		}
		Edge e = Edges[++index];
		if (u.find(e.u) != u.find(e.v))
		{
			ans = max(ans, Edges[index].w);
			u.unite(e.u, e.v);
			cnt++;
		}
	}
	cout << ans;
}

---

A - 掌握魔法の东东 II
东东有 A × B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A - 1）和一个花色（整数，记为b，范围区间是 0 到 B - 1。
扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。
“一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我们用“低序号优先”来匹配牌型，即这“一手牌”从上到下满足的第一个牌型规则就是它的“牌型编号”（一个整数，属于1到9）：

同花顺: 同时满足规则 2 和规则 3.
顺子 : 5张牌的大小形如 x, x + 1, x + 2, x + 3, x + 4
同花 : 5张牌都是相同花色的.
炸弹 : 5张牌其中有4张牌的大小相等.
三带二 : 5张牌其中有3张牌的大小相等，且另外2张牌的大小也相等.
两对: 5张牌其中有2张牌的大小相等，且另外3张牌中2张牌的大小相等.
三条: 5张牌其中有3张牌的大小相等.
一对: 5张牌其中有2张牌的大小相等.
要不起: 这手牌不满足上述的牌型中任意一个.
现在, 东东从A × B 张扑克牌中拿走了 2 张牌！分别是 (a1, b1) 和 (a2, b2). （其中a表示大小，b表示花色）
现在要从剩下的扑克牌中再随机拿出 3 张！组成一手牌！！
其实东东除了会打代码，他业余还是一个魔法师，现在他要预言他的未来的可能性，即他将拿到的“一手牌”的可能性，我们用一个“牌型编号（一个整数，属于1到9）”来表示这手牌的牌型，那么他的未来有 9 种可能，但每种可能的方案数不一样。
现在，东东的阿戈摩托之眼没了，你需要帮他算一算 9 种牌型中，每种牌型的方案数。
Input
第 1 行包含了整数 A 和 B (5 ≤ A ≤ 25, 1 ≤ B ≤ 4).

第 2 行包含了整数 a1, b1, a2, b2 (0 ≤ a1, a2 ≤ A - 1, 0 ≤ b1, b2 ≤ B - 1, (a1, b1) ≠ (a2, b2)).

Output
输出一行，这行有 9 个整数，每个整数代表了 9 种牌型的方案数（按牌型编号从小到大的顺序）

Examples
Input
5 2
1 0 3 1
Output
0 8 0 0 0 12 0 36 0
Input
25 4
0 0 24 3
Output
0 0 0 2 18 1656 644 36432 113344

---

思路：没想到直接暴力算法就行。我分类讨论了a1b1a2b2，然后计算概率，做成了概率题，其实可以更暴力，直接枚举就可以。

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

int a[10];
int A, B, a1, b1, a2, b2;

void judge()
{
	if (b1 == b2)
	{
		int d = abs(a1 - a2);
		if (d <= 4)
		{
			int l = min(a1, a2);
			int r = max(a1, a2);
			int ll = l >= (4 - d) ? (l - (4 - d)) : 0;
			int rr = r <= (A - 6 + d) ? (r + (4 - d)) : (A - 1);
			a[1] = rr - ll - 3;
			a[2] = pow(B, 3) * (rr - ll - 3) - a[1];
		}
		else
		{
			a[1] = 0;
		}
		a[3] = (A - 2) * (A - 3) * (A - 4) / 6 - a[1];
	}
	else
	{
		a[1] = a[3] = 0;
		int d = abs(a1 - a2);
		if (d <= 4)
		{
			int l = min(a1, a2);
			int r = max(a1, a2);
			int ll = l >= (4 - d) ? (l - (4 - d)) : 0;
			int rr = r <= (A - 6 + d) ? (r + (4 - d)) : (A - 1);
			a[2] = pow(B, 3) * (rr - ll - 3);
		}
		else a[2] = 0;
	}
	if (a1 == a2)
	{
		if (B >= 4) a[4] = A * B - 4;
		else a[4] = 0;
		if (B >= 3)
		{
			a[5] = (B - 2) * (A - 1) * B * (B - 1) / 2;
			a[7] = (B - 2) * ((A - 1) * B) * ((A - 2) * B);
		}
		else
		{
			a[5] = 0;
			a[7] = 0;
		}
		if (B >= 2)
		{
			a[6] = (A - 1) * B * (B - 1) / 2 * ((A - 2) * B);
			a[8] = (A - 1) * B * (A - 2) * B * (A - 3) * B;
		}
		else
		{
			a[6] = 0;
			a[8] = 0;
		}
	}
	else
	{
		if (B >= 4) a[4] = 2;
		else a[4] = 0;
		if (B >= 3)
		{
			a[5] = ((B - 1) * (B - 2) / 2 * (B - 1)) * 2;
			a[7] = 2 * ((B - 1) * (B - 2) / 2 * (A - 2) * B) + (A - 2) * B * (B - 1) * (B - 2) / 6;
		}
		else
		{
			a[5] = 0;
			a[7] = 0;
		}
		if (B >= 2)
		{
			a[6] = (B - 1) * (B - 1) * ((A - 2) * B) + (B - 1) * (A - 2) * B * (B - 1);
			a[8] = 2 * (B - 1) * (A - 2) * (A - 3) / 2 * pow(B, 2) + (A - 2) * B * (B - 1) / 2 * (A - 3) * B;
		}
		else
		{
			a[6] = 0;
			a[8] = 0;
		}
	}
	a[9] = (A * B - 2) * (A * B - 3) * (A * B - 4) / 6;
	for (int i = 1; i <= 8; i++)
		a[9] -= a[i];
}
int main()
{
	cin >> A >> B >> a1 >> b1 >> a2 >> b2;
	judge();
	for (int i = 1; i <= 9; i++) cout << a[i] << ' ';
}