作業部分：
A - 氪金帶東
題目
實驗室裏原先有一臺電腦(編號爲1)，最近氪金帶師咕咕東又爲實驗室購置了N-1臺電腦，編號爲2到N。每臺電腦都用網線連接到一臺先前安裝的電腦上。但是咕咕東擔心網速太慢，他希望知道第i臺電腦到其他電腦的最大網線長度，但是可憐的咕咕東在不久前剛剛遭受了宇宙射線的降智打擊，請你幫幫他。
提示: 樣例輸入對應這個圖，從這個圖中你可以看出，距離1號電腦最遠的電腦是4號電腦，他們之間的距離是3。 4號電腦與5號電腦都是距離2號電腦最遠的點，故其答案是2。5號電腦距離3號電腦最遠，故對於3號電腦來說它的答案是3。同樣的我們可以計算出4號電腦和5號電腦的答案是4.
樣例輸入輸出
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
解析
這是一道典型的圖的題。圖結構採用鏈式前向星描述。這道題我們可以類比樹的直徑問題，找一個點到其它點的最長距離，就是相當於求這個點到樹的直徑的兩個端點的距離。這個距離一定是最長的。（證明略）
實際上，針對這個問題，我們要求連續多個點到兩邊的最長路徑，需要經過多次遍歷，理論上可行，但是在時間複雜度上過高。所以我們換一種思路，先隨便取一個點，通過這個點找到樹的兩個端點，然後從這兩個端點遍歷求距離，每一個點，兩個端點遍歷時得到的距離中，較長的那一個就是我們要求的點。
代碼
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct edge{
int u, v, w, nxt;
}edges[20005];
int max1 = 0, max2 = 0, tot = 0;
int head[10005], vis[10005], dis[10005], vis1[10005], dis1[10005], vis2[10005], dis2[10005];
int v1 = 0, v2 = 0;
void init(int n){
memset(head, -1, sizeof(head));
memset(vis, 0, sizeof(vis));
memset(vis1, 0, sizeof(vis1));
memset(dis, 0, sizeof(dis));
memset(dis1, 0, sizeof(dis1));
memset(vis2, 0, sizeof(vis2));
memset(dis2, 0, sizeof(dis2));
}
void addedge(int u, int v, int w){
edges[tot].u = u;
edges[tot].v = v;
edges[tot].w = w;
edges[tot].nxt = head[u];
head[u] = tot;
tot++;
}
// 找出v1
void dfs(int u){
vis[u] = true;
for(int i = head[u] ; i != -1 ; i = edges[i].nxt)
{
if(!vis[edges[i].v])
{
vis[edges[i].v] = true;
dis[edges[i].v] = dis[u] + edges[i].w;
if(dis[edges[i].v] > max1)
{
max1 = dis[edges[i].v];
v1 = edges[i].v;
}
dfs(edges[i].v);
}
}
}
// 找出v2，順帶找到v1到各個點的距離（本來都是用上面的dfs找的，因爲不知道錯在哪裏就分開了）
void dfs2(int u){
vis2[u] = true;
for(int i = head[u] ; i != -1 ; i = edges[i].nxt)
{
if(!vis2[edges[i].v])
{
vis2[edges[i].v] = true;
dis2[edges[i].v] = dis2[u] + edges[i].w;
if(dis2[edges[i].v] > max2){
max2 = dis2[edges[i].v];
v2 = edges[i].v;
}
dfs2(edges[i].v);
}
}
}
// 找v2到各個點的距離
void dfs1(int u){
vis1[u] = true;
for(int i = head[u] ; i != -1 ; i = edges[i].nxt)
{
if(!vis1[edges[i].v])
{
vis1[edges[i].v] = true;
dis1[edges[i].v] = dis1[u] + edges[i].w;
dfs1(edges[i].v);
}
}
}
int main(){
int n;
while(cin >> n)
{
tot = 0;
max1 = 0, max2 = 0;
int a, b;
init(n);
for(int i = 2 ; i <= n ; i++)
{
scanf("%d %d", &a, &b);
addedge(i, a, b);
addedge(a, i, b);
}
dfs(1);
dfs2(v1);
dfs1(v2);
for(int i = 1 ; i <= n ; i++)
printf("%d\n", max(dis2[i], dis1[i]));
}
}
回顧
這道題出乎意料的錯了十幾次，而且我剛開始沒有發現錯在哪裏…
其實最開始的代碼只有兩個dfs的，只是後面爲了debug拆分開了，方便看看錯誤在哪裏。
一直沒有找出錯的原因，我就去找一個同學幫忙debug，他調了一會兒告訴我因爲是多組數據，tot每次開始前要清0，否則會因爲++太多次而超過剛開始定義的edgs空間（或者剛開始edges開到兩百萬也能過2333）。
感覺這樣錯比直接過學到的東西多，但是付出的時間代價太高…
（不過還有個不太理解的小問題，希望學長看到這兒能幫忙解決一下，就是上面說的這種tot太大超過edges定義範圍的情況，在C++編譯器報錯是RE（VA）非法訪問內存，這是正常的，可是在G++編譯器報的是TLE，有點兒不明白爲啥是超時…）
B - 戴好口罩！
題目
新型冠狀病毒肺炎（Corona Virus Disease 2019，COVID-19），簡稱“新冠肺炎”，是指2019新型冠狀病毒感染導致的肺炎。
如果一個感染者走入一個羣體，那麼這個羣體需要被隔離！
小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
解析
簡單的並查集問題。使每一組接觸過的同學擁有同一個parent（unit），最後通過find找到和find（感染者）相同的同學，利用路徑壓縮就能很快的得到答案。
代碼
#include<iostream>
#include<string>
using namespace std;
int par[40000], b[40000];
void init(int n){
for(int i = 0 ; i < n ; i++)
par[i] = i;
}
int find(int x){return par[x] == x ? x : par[x] = find(par[x]);}
bool unit(int x, int y){
x = find(x);
y = find(y);
if(x == y)
return false;
par[x] = y;
return true;
}
int main(){
int n, m;
while(true)
{
cin >> n >> m;
if(n == 0 && m == 0)
return 0;
init(n);
int ans = 0;
for(int i = 0 ; i < m ; i++)
{
int num;
cin >> num;
for(int j = 0 ; j < num ; j++)
cin >> b[j];
for(int j = 1 ; j < num ; j++)
unit(b[j - 1], b[j]);
}
for(int i = 0 ; i < n ; i++)
if(find(i) == find(0))
ans++;
cout << ans << 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值
Input
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
Output
9
解析
這道題在剛開始學長留時間讓我們自己想的時候，我感覺很迷茫，因爲除了最小生成樹，還有“黃之水天上來”，如果找不到合適的方法，處理起來會很複雜。
這樣想就陷入了思維誤區。如果沒有黃河之水天上來，這是一個非常普通的最小生成樹問題。可如果我們把黃河水（源頭）當成一個點，但是這個點可以和所有的點相連，距離就是MP值，這樣就變成了n + 1棵樹的最小生成樹問題。這樣就能輕鬆的解決這個問題。
這裏求最小生成樹用到的是kruskal算法，下面D題也用到了這種算法，在這裏簡述一下這種算法的思想：
kruskal算法是基於貪心思想的算法，每次選擇最短的邊，然後通過並查集的方式將其合併到一棵樹上，這樣直到所有的邊都有了歸宿，就能找到最小生成樹。
代碼
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int par[50005];
int tot = 0;
struct edge{
int u, v, w;
bool operator<(const edge &t) const {return w < t.w;}
}edges[150005];
void init(int n){
for(int i = 0 ; i <= n ; i++)
par[i] = i;
}
// 路徑壓縮
int find(int x){
return par[x] == x ? x : par[x] = find(par[x]);
}
bool unite(int x, int y){
x = find(x);
y = find(y);
if(x == y)
return false ;
par[x] = y ;
return true ;
}
int kruskal(int n){
int ans = 0;
sort(edges, edges + tot);
int cnt = 0;
for(int i = 0 ; i < tot ; i++)
{
if(unite(edges[i].u, edges[i].v))
{
ans += edges[i].w;
if(++cnt == n)
return ans;
}
}
return -1;
}
int main(){
int n;
cin >> n;
for (int i = 1 ; i <= n ; i++)
{
cin >> edges[tot].w;
edges[tot].u = 0;
edges[tot].v = i;
tot++;
}
for (int i = 1 ; i <= n ; i++)
for (int j = 1 ; j <= n ; j++)
{
cin >> edges[tot].w;
if (i != j)
{
edges[tot].u = i;
edges[tot].v = j;
tot++;
}
}
init(n);
cout << kruskal(n) << endl;
}
回顧
想明白了就很簡單。這道題給我一種啓發，就是圖的問題其實都很簡單，代碼實際上都可以套用一個模板。而圖題的難點在於圖的構建，當圖的構建正確了，剩下的就簡單了。所以遇到圖的題要多看，多想。
D - 數據中心
樣例輸入輸出
Input
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
Output
4
解析
無向圖！
邊權！
求解最優樹結構！
這道題歸根結底就是求最大邊權最小的生成樹。根據性質，最小生成樹一定是瓶頸生成樹，問題就轉化爲了求最小生成樹中耗時最大的邊的邊權。和上面C題類似，我們利用並查集，通過kruskal算法來求解，最終輸出最大邊權。
代碼
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int par[50005];
struct edge{
int u, v, w;
bool operator<(const edge &t) const {return w < t.w;}
}edges[100005];
void init(int n){
for(int i = 0 ; i <= n ; i++)
par[i] = i;
}
// 路徑壓縮
int find(int x){
return par[x] == x ? x : par[x] = find(par[x]);
}
bool unite(int x, int y){
x = find(x);
y = find(y);
if(x == y)
return false ;
par[x] = y ;
return true ;
}
int kruskal(int n, int m){
int ans = 0;
sort(edges + 1, edges + 1 + m) ;
int cnt = 0;
for(int i = 1 ; i <= m ; i++)
{
if(unite(edges[i].u, edges[i].v))
{
ans = max(ans, edges[i].w);
if(++cnt == n - 1)
break;
}
}
return cnt == n-1 ? ans : -1 ;
}
int main(){
int n, m, root;
cin >> n >> m >> root;
init(n);
for(int i = 1 ; i <= m; i++)
scanf("%d %d %d", &edges[i].u, &edges[i].v, &edges[i].w);
cout << kruskal(n, m) << endl;
return 0;
}
回顧
這道題相對來說比較簡單，在讀懂了學長貼在PPT上的代碼後，很容易的就能把這道題寫出來。這道題的代碼結構很適合作爲最小生成樹類型題目的模板記憶。
限時大模擬補題
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 種牌型的方案數（按牌型編號從小到大的順序）
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