L2-001 緊急救援 最短路+路徑打印

作為一個城市的應急救援隊伍的負責人，你有一張特殊的全國地圖。在地圖上顯示有多個分散的城市和一些連接城市的快速道路。每個城市的救援隊數量和每一條連接兩個城市的快速道路長度都標在地圖上。當其他城市有緊急求助電話給你的時候，你的任務是帶領你的救援隊盡快趕往事發地，同時，一路上召集盡可能多的救援隊。

輸入格式:

輸入第一行給出4個正整數N、M、S、D，其中N（2≤N≤500）是城市的個數，順便假設城市的編號為0 ~ (N?1)；M是快速道路的條數；S是出發地的城市編號；D是目的地的城市編號。

第二行給出N個正整數，其中第i個數是第i個城市的救援隊的數目，數字間以空格分隔。隨后的M行中，每行給出一條快速道路的信息，分別是：城市1、城市2、快速道路的長度，中間用空格分開，數字均為整數且不超過500。輸入保證救援可行且最優解唯一。

輸出格式:

第一行輸出最短路徑的條數和能夠召集的最多的救援隊數量。第二行輸出從S到D的路徑中經過的城市編號。數字間以空格分隔，輸出結尾不能有多余空格。

輸入樣例:

4 5 0 3 20 30 40 10 0 1 1 1 3 2 0 3 3 0 2 2 2 3 2

輸出樣例:

2 60 0 1 3

分析：

Dijkstra基礎應用，比模板單純求最短路的基礎上多了輸出路徑，路徑條數以及多權重（路徑相同時人數盡量大），路徑只要存每個節點的前驅，然后倒著遍歷一遍就行。其他就是一些小細節，看注釋。優先隊列默認為大頂堆priority_queue<PII>，這里需要改成小頂堆priority_queue<PII,vector<PII>,greater<PII> >

代碼：

#include<bits/stdc++.h> using namespace std; #define PII pair<int,int>const int INF = 0x3f3f3f3f; const int N = 510;//n個點m條邊從s到d int n,m,s,d; //分別為：鄰接矩陣存圖，是否訪問過，到起點的最短距離。 vector<PII> mp[N]; int vis[N], dis[N]; //分別為：到當前點最多召集幾個人，每個城市的人數，存路徑，到當前點幾條路。 int tot[510], city[510], path[510], road[510];void DJ(int s){//初始化 for(int i = 1 ; i <= n ; i ++ ) dis[i] = INF, vis[i] = false, path[s] = -1;tot[s] = city[s];dis[s] = 0;road[s] = 1;//小頂堆 priority_queue<PII, vector<PII>, greater<PII> > q; q.push({0, s}); while(q.size()){int t = q.top().second;q.pop();if(vis[t]) continue;vis[t] = true;for(int i = 0 ; i < mp[t].size() ; i ++ ){int j = mp[t][i].first, w = mp[t][i].second;if(dis[j] > dis[t]+w){ //松弛操作 //j從t這個點過來的路徑更短，前驅變為tpath[j] = t;//從t走過來，則可以召集的人數就是到t可召集的人數+j這個點的人數tot[j] = tot[t]+city[j];dis[j] = dis[t]+w;//到t有幾種走法，就到j有幾種road[j] = road[t];//由于j點最短距離被更新，需要壓入隊列q.push({dis[j], j});}else if(dis[j] == dis[t]+w){//有另外的走法使得最短路相同，更新方案數road[j] += road[t];//如果可以召集更多的人，更新方案if (tot[j] < tot[t] + city[j]) {tot[j] = tot[t] + city[j];path[j] = t;}}}} }void print(int d){ //路徑打印 int now = d;vector<int> v;while(now != -1){v.push_back(now);now = path[now];}for (int i = v.size()-1 ; i >= 0 ; i -- )printf("%d%c", v[i], i==0 ? '\n' : ' '); }int main(){cin>>n>>m>>s>>d;for(int i = 0 ; i < n ; i ++ ) cin>>city[i]; for(int i = 0 ; i < m ; i ++ ){int x, y, w;cin>>x>>y>>w;mp[x].push_back({y, w});mp[y].push_back({x, w});}DJ(s);cout<<road[d]<<" "<<tot[d]<<endl;print(d);return 0; }

L2-002 鏈表去重 模擬鏈表

給定一個帶整數鍵值的鏈表 L，你需要把其中絕對值重復的鍵值結點刪掉。即對每個鍵值 K，只有第一個絕對值等于 K 的結點被保留。同時，所有被刪除的結點須被保存在另一個鏈表上。例如給定 L 為 21→-15→-15→-7→15，你需要輸出去重后的鏈表 21→-15→-7，還有被刪除的鏈表 -15→15。

輸入格式：

輸入在第一行給出 L 的第一個結點的地址和一個正整數 N（≤105，為結點總數）。一個結點的地址是非負的 5 位整數，空地址 NULL 用 ?1 來表示。

隨后 N 行，每行按以下格式描述一個結點：

地址 鍵值 下一個結點

其中地址是該結點的地址，鍵值是絕對值不超過104的整數，下一個結點是下個結點的地址。

輸出格式：

首先輸出去重后的鏈表，然后輸出被刪除的鏈表。每個結點占一行，按輸入的格式輸出。

輸入樣例：

00100 5 99999 -7 87654 23854 -15 00000 87654 15 -1 00000 -15 99999 00100 21 23854

輸出樣例：

00100 21 23854 23854 -15 99999 99999 -7 -1 00000 -15 87654 87654 15 -1

分析：

數據量不大，可以直接用數組模擬鏈表，地址當做數組下標，考察基本的刪除操作和尾插法。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;struct node{int id,val,next,absval; }LNode[N]; bool cmp(node a,node b){return a.id<b.id; } pair<int,pair<int,int> > p; vector<pair<int,pair<int,int> > > com,del; int f[N];int main(){int ID,N,i;cin>>ID>>N;for(i=0;i<N;i++){cin>>LNode[i].id>>LNode[i].val>>LNode[i].next;LNode[i].absval=fabs(LNode[i].val);f[abs(LNode[i].val)]=0; //避免二分時重復計算 }sort(LNode,LNode+N,cmp);while(ID!=-1){ //用-1結束，別用N計數 int l=0,r=N-1; //二分查找下一節點 while(l<r){int mid=(l+r)/2;if(LNode[mid].id<ID) l=mid+1;else r=mid;}p.first=LNode[l].id;p.second.first=LNode[l].val;p.second.second=LNode[l].next;if(f[LNode[l].absval]==0){f[LNode[l].absval]=1;com.push_back(p);}elsedel.push_back(p);ID=LNode[l].next;}for(i=0;i<com.size();i++){if(i<com.size()-1)printf("%05d %d %05d\n",com[i].first,com[i].second.first,com[i+1].first);elseprintf("%05d %d -1\n",com[i].first,com[i].second.first);}for(i=0;i<del.size();i++){if(i<del.size()-1)printf("%05d %d %05d\n",del[i].first,del[i].second.first,del[i+1].first);elseprintf("%5d %d -1\n",del[i].first,del[i].second.first);}return 0; }

L2-003 月餅 貪心

月餅是中國人在中秋佳節時吃的一種傳統食品，不同地區有許多不同風味的月餅。現給定所有種類月餅的庫存量、總售價、以及市場的最大需求量，請你計算可以獲得的最大收益是多少。

注意：銷售時允許取出一部分庫存。樣例給出的情形是這樣的：假如我們有 3 種月餅，其庫存量分別為 18、15、10 萬噸，總售價分別為 75、72、45 億元。如果市場的最大需求量只有 20 萬噸，那么我們最大收益策略應該是賣出全部 15 萬噸第 2 種月餅、以及 5 萬噸第 3 種月餅，獲得 72 + 45/2 = 94.5（億元）。

輸入格式：

每個輸入包含一個測試用例。每個測試用例先給出一個不超過 1000 的正整數 N 表示月餅的種類數、以及不超過 500（以萬噸為單位）的正整數 D 表示市場最大需求量。隨后一行給出 N 個正數表示每種月餅的庫存量（以萬噸為單位）；最后一行給出 N 個正數表示每種月餅的總售價（以億元為單位）。數字間以空格分隔。

輸出格式：

對每組測試用例，在一行中輸出最大收益，以億元為單位并精確到小數點后 2 位。

輸入樣例：

3 20 18 15 10 75 72 45

輸出樣例：

94.50

分析：

按照單價排序，優先選擇單價最高的。庫存量和總售價不一定為整數

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;struct node{double num,price,dj; }Mooncake[N]; bool cmp(node a,node b){ return a.dj>b.dj; } int main(){int n,m,k=0,i;cin>>n>>m;for(i=0;i<n;i++) cin>>Mooncake[i].num;for(i=0;i<n;i++) cin>>Mooncake[i].price;for(i=0;i<n;i++) Mooncake[i].dj=Mooncake[i].price/Mooncake[i].num;sort(Mooncake,Mooncake+n,cmp);double ans=0;while(k<n){if(Mooncake[k].num<=m){m-=Mooncake[k].num;ans+=Mooncake[k].price;}else{ans+=Mooncake[k].dj*m;break;}k++;}printf("%.2lf\n",ans);return 0; }

L2-004 這是二叉搜索樹嗎？ 數據結構

一棵二叉搜索樹可被遞歸地定義為具有下列性質的二叉樹：對于任一結點，

• 其左子樹中所有結點的鍵值小于該結點的鍵值；
• 其右子樹中所有結點的鍵值大于等于該結點的鍵值；
• 其左右子樹都是二叉搜索樹。

所謂二叉搜索樹的“鏡像”，即將所有結點的左右子樹對換位置后所得到的樹。

給定一個整數鍵值序列，現請你編寫程序，判斷這是否是對一棵二叉搜索樹或其鏡像進行前序遍歷的結果。

輸入格式：

輸入的第一行給出正整數 N（≤1000）。隨后一行給出 N 個整數鍵值，其間以空格分隔。

輸出格式：

如果輸入序列是對一棵二叉搜索樹或其鏡像進行前序遍歷的結果，則首先在一行中輸出 YES ，然后在下一行輸出該樹后序遍歷的結果。數字間有 1 個空格，一行的首尾不得有多余空格。若答案是否，則輸出 NO。

輸入樣例 1：

7 8 6 5 7 10 8 11

輸出樣例 1：

YES 5 7 6 8 11 10 8

輸入樣例 2：

7 8 10 11 8 6 7 5

輸出樣例 2：

YES 11 8 10 7 5 6 8

輸入樣例 3：

7 8 6 8 5 10 9 11

輸出樣例 3：

NO

分析：

因為前序遍歷是根左右，所以在插入某個孩子節點時，它的父節點肯定已經被插入了，又由于搜索樹的限制關系（小的左邊，大的右邊），所以可以確定一棵唯一的二叉搜索樹，然后對其進行兩種不同的前序遍歷，再分別與題目所給的序列比較即可。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;struct node{node *l,*r;int data; }; typedef node* Tree; //s1為正常前序遍歷，s2為左右兒子顛倒的前序遍歷，s為輸入序列 vector<int> s1,s2,s,ans; int n,cnt,x; Tree build(Tree root,int x){if (root == NULL) {//到達最底部，創建新節點，并賦值root = new(node);root->l = root->r = NULL;root->data = x;}//x小于當前節點，說明x在root的左半邊，向左遞歸else if (x < root->data) root->l = build(root->l, x);else root->r = build(root->r, x);return root; } //正常前序遍歷 void pre1(Tree root) {if (root == NULL) return;s1.push_back(root->data);pre1(root->l);pre1(root->r); } //左右顛倒的前序 void pre2(Tree root) {if (root == NULL) return;s2.push_back(root->data);pre2(root->r);pre2(root->l); } //正常后序 void post1(Tree root) {if (root == NULL) return;post1(root->l);post1(root->r);ans.push_back(root->data); } //左右顛倒的后序 void post2(Tree root) {if (root == NULL) return;post2(root->r);post2(root->l);ans.push_back(root->data); } //比較兩個序列是否完全相同 bool judge(vector<int> a) {for (int i = 0; i < a.size(); i++) if (a[i] != s[i]) return 0;return 1; } int main(){cin >> n;for (int i = 0; i < n; i ++) cin >> x,s.push_back(x);Tree root=NULL;for (int i = 0; i < n; i ++)root = build(root, s[i]);pre1(root); pre2(root);if (judge(s1)) {//說明所給序列是二叉搜索樹的前序遍歷post1(root);puts("YES");for (int i = 0; i < n; i++)printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');}else if (judge(s2)) {//是鏡像的前序遍歷puts("YES");post2(root);for (int i = 0; i < n; i++)printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');}else //不是二叉搜索樹puts("NO");return 0; }

L2-005 集合相似度 STL

給定兩個整數集合，它們的相似度定義為：Nc/Nt×100%。其中Nc是兩個集合都有的不相等整數的個數，Nt是兩個集合一共有的不相等整數的個數。你的任務就是計算任意一對給定集合的相似度。

輸入格式：

輸入第一行給出一個正整數N（≤50），是集合的個數。隨后N行，每行對應一個集合。每個集合首先給出一個正整數M（≤104），是集合中元素的個數；然后跟M個[0,109]區間內的整數。

之后一行給出一個正整數K（≤2000），隨后K行，每行對應一對需要計算相似度的集合的編號（集合從1到N編號）。數字間以空格分隔。

輸出格式：

對每一對需要計算的集合，在一行中輸出它們的相似度，為保留小數點后2位的百分比數字。

輸入樣例：

3 3 99 87 101 4 87 101 5 87 7 99 101 18 5 135 18 99 2 1 2 1 3

輸出樣例：

50.00% 33.33%

分析：

最多50個集合，預處理出全部的組合，C50 2=49?25, 用set存放所有的集合，然后預處理的時候遍歷兩個set中較小的那個，在較大的中查找是否存在，將集合i和集合j共同擁有的數量存在both[i][j]中。Nc就是both[i][j]，Nt就是兩個集合size加起來再減掉both[i][j]。時間復雜度：25?49?10000?log(10000)=49000000。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;set<int> s[55];int main(){int n; cin>>n; int i,j,m,x;for(i=0;i<n;i++){cin>>m;for(j=0;j<m;j++){cin>>x;s[i].insert(x);}}int q; cin>>q;for(i=0;i<q;i++){int x,y;cin>>x>>y;x--,y--;int num1=0,num2=s[x].size()+s[y].size();for(set<int>::iterator i=s[x].begin();i!=s[x].end();i++){if(s[y].count(*i)!=0) num1++; //注意指針運算符 // cout<<*i<<endl; }printf("%.2lf%\n",num1*100.0/(num2-num1));}return 0; }

L2-006 樹的遍歷 數據結構

給定一棵二叉樹的后序遍歷和中序遍歷，請你輸出其層序遍歷的序列。這里假設鍵值都是互不相等的正整數。

輸入格式：

輸入第一行給出一個正整數N（≤30），是二叉樹中結點的個數。第二行給出其后序遍歷序列。第三行給出其中序遍歷序列。數字間以空格分隔。

輸出格式：

在一行中輸出該樹的層序遍歷的序列。數字間以1個空格分隔，行首尾不得有多余空格。

輸入樣例：

7 2 3 1 5 7 6 4 1 2 3 4 5 6 7

輸出樣例：

4 1 6 3 5 7 2

分析：

知道中序+后序或者前序，就能確定一棵唯一的二叉樹。所以此題知道后序+中序，可以建立二叉樹后層序遍歷。由于后序是左右根，所以最后面的節點就是根，然后在中序中找到這個根的位置，左邊就是左子樹的范圍，右邊就是右子樹的范圍，遞歸處理即可。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll; struct node{node *lson,*rson;int val; }; typedef node* Tree; vector<int> Mid_order, Post_order; int n,x,i,now; Tree build(int l,int r){ //中序和后序建樹 if(l>r) return NULL;Tree root = new(node);root -> val = Post_order[now];int mid = l;while(Post_order[now] != Mid_order[mid])mid++;now--;root -> rson = build(mid+1,r);root -> lson = build(l,mid-1);return root; }void print(Tree root){ //層序遍歷輸出 queue<Tree> q;q.push(root);int tot = 0;while(!q.empty()){Tree t = q.front();if(t->lson != NULL)q.push(t->lson);if(t->rson != NULL)q.push(t->rson);printf("%d",t->val);q.pop();tot++;if(tot<n)cout<<' ';else cout<<endl;} }int main(){cin>>n;for(i = 0 ; i < n ; i ++)cin>>x,Post_order.push_back(x);for(i = 0 ; i < n ; i ++)cin>>x,Mid_order.push_back(x);now = n - 1;print(build(0,n-1));return 0; }

L2-007 家庭房產 并查集

給定每個人的家庭成員和其自己名下的房產，請你統計出每個家庭的人口數、人均房產面積及房產套數。

輸入格式：

輸入第一行給出一個正整數N（≤1000），隨后N行，每行按下列格式給出一個人的房產：

編號 父 母 k 孩子1 ... 孩子k 房產套數 總面積

其中編號是每個人獨有的一個4位數的編號；父和母分別是該編號對應的這個人的父母的編號（如果已經過世，則顯示-1）；k（0≤k≤5）是該人的子女的個數；孩子i是其子女的編號。

輸出格式：

首先在第一行輸出家庭個數（所有有親屬關系的人都屬于同一個家庭）。隨后按下列格式輸出每個家庭的信息：

家庭成員的最小編號 家庭人口數 人均房產套數 人均房產面積

其中人均值要求保留小數點后3位。家庭信息首先按人均面積降序輸出，若有并列，則按成員編號的升序輸出。

輸入樣例：

10 6666 5551 5552 1 7777 1 100 1234 5678 9012 1 0002 2 300 8888 -1 -1 0 1 1000 2468 0001 0004 1 2222 1 500 7777 6666 -1 0 2 300 3721 -1 -1 1 2333 2 150 9012 -1 -1 3 1236 1235 1234 1 100 1235 5678 9012 0 1 50 2222 1236 2468 2 6661 6662 1 300 2333 -1 3721 3 6661 6662 6663 1 100

輸出樣例：

3 8888 1 1.000 1000.000 0001 15 0.600 100.000 5551 4 0.750 100.000

分析：

用并查集維護集合關系，由于要輸出最小編號，合并時將較大的合并給較小的點，由于編號一共最多到9999，記錄每個編號是否出現過，然后遍歷一遍，將每個編號所擁有的房產等信息貢獻給父節點。之后按照題目要求排序輸出即可。
坑：編號可能會有0000

代碼：

#include<bits/stdc++.h> using namespace std; #define PII pair<int,int> const int N = 1e4+10;struct node{//父節點//分別表示 編號，人口，房產數量，房產面積int id, kou, fang, mian;//分別表示 人均房產套數，人均房產面積double x1, x2;const bool operator < (const node &t) const {if(t.x2 == x2) return id < t.id;return x2 > t.x2;} }p[N];int n; int fa[N],vis[N],num[N],s[N];void init(int n) { for ( int i = 0 ; i < n ; i++ ) fa[i] = i; } //初始化 int find(int x) { return fa[x] == x ? x : fa[x] = find( fa[x] ); } //查找 路徑壓縮 void merge(int a,int b){ a = find(a), b = find(b); fa[max(a,b)] = min(a,b);} //家族最小值作為祖先 int main(){cin>>n;//初始化 init(N);while(n--){int id,fid,mid,k,ID;cin>>id>>fid>>mid>>k;vis[id]=1;//活人編號從0開始if(fid >= 0)merge(id,fid), vis[fid]=1;if(mid >= 0)merge(id,mid), vis[mid]=1;while(k--){int cid; cin>>cid;vis[cid] = 1;merge(id,cid);}cin>>num[id]>>s[id];}//將每個編號所擁有的房產等信息貢獻給父節點for(int i = 0 ; i < N ; i ++) {if(vis[i]) {int x = find(i);p[x].kou ++;p[x].fang += num[i];p[x].mian += s[i];}}vector<node> ans;for(int i = 0; i < N; i++) {if(vis[i] && find(i) == i) {p[i].id = i;p[i].x1 = p[i].fang * 1.0 / p[i].kou;p[i].x2 = p[i].mian * 1.0 / p[i].kou;ans.push_back(p[i]);}}sort(ans.begin(), ans.end());cout << ans.size() << endl;for(int i = 0; i < ans.size(); i++) printf("%04d %d %.3lf %.3lf\n",ans[i].id,ans[i].kou,ans[i].x1,ans[i].x2); return 0; }

L2-008 最長對稱子串 字符串

對給定的字符串，本題要求你輸出最長對稱子串的長度。例如，給定Is PAT&TAP symmetric?，最長對稱子串為s PAT&TAP s，于是你應該輸出11。

輸入格式：

輸入在一行中給出長度不超過1000的非空字符串。

輸出格式：

在一行中輸出最長對稱子串的長度。

輸入樣例：

Is PAT&TAP symmetric?

輸出樣例：

11

分析：

回文串問題，manacher模板題

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;string s,s_new; int p[N*2];void init(){ //初始化s_new+='$';s_new+='#';for(int i=0;i<s.size();i++){s_new+=s[i];s_new+='#';}s_new+='\0'; } void Manacher(){init();int mx=0,di,ans=0;for(int i=0;i<s_new.size();i++){p[i] = mx > i ? min(p[2 * di - i], mx - i) : 1;while(s_new[i-p[i]] == s_new[i+p[i]]) p[i]++;if(i+p[i] > mx){mx = i+p[i];di = i;ans = max(ans,p[i]);}}printf("%d\n",ans-1); } int main(){getline(cin,s);Manacher();return 0; }

L2-009 搶紅包 排序

沒有人沒搶過紅包吧…… 這里給出N個人之間互相發紅包、搶紅包的記錄，請你統計一下他們搶紅包的收獲。

輸入格式：

輸入第一行給出一個正整數N（≤104），即參與發紅包和搶紅包的總人數，則這些人從1到N編號。隨后N行，第i行給出編號為i的人發紅包的記錄，格式如下：

K**N1P1?NKP**K

其中K（0≤K≤20）是發出去的紅包個數，N**i是搶到紅包的人的編號，P**i（>0）是其搶到的紅包金額（以分為單位）。注意：對于同一個人發出的紅包，每人最多只能搶1次，不能重復搶。

輸出格式：

按照收入金額從高到低的遞減順序輸出每個人的編號和收入金額（以元為單位，輸出小數點后2位）。每個人的信息占一行，兩數字間有1個空格。如果收入金額有并列，則按搶到紅包的個數遞減輸出；如果還有并列，則按個人編號遞增輸出。

輸入樣例：

10 3 2 22 10 58 8 125 5 1 345 3 211 5 233 7 13 8 101 1 7 8800 2 1 1000 2 1000 2 4 250 10 320 6 5 11 9 22 8 33 7 44 10 55 4 2 1 3 8800 2 1 23 2 123 1 8 250 4 2 121 4 516 7 112 9 10

輸出樣例：

1 11.63 2 3.63 8 3.63 3 2.11 7 1.69 6 -1.67 9 -2.18 10 -3.26 5 -3.26 4 -12.32

分析：

就是細節題，題目讓你干什么就干什么。結構體中自定義排序規則

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;struct node{int id,money,num;const bool operator < (const node &t) const {if(t.money == money) return id > t.id;return money > t.money;} }peo[N];int main(){int n; cin>>n;for(int i = 1 ; i <= n ; i ++) peo[i].id = i;for(int i = 1 ; i <= n ; i ++){int k,sum=0; cin>>k;for(int j = 0 ; j < k ; j++){int x,m; cin>>x>>m;peo[x].money += m;sum += m;peo[x].num ++;}peo[i].money -= sum;}sort(peo+1, peo+1+n);for(int i = 1 ; i <= n ; i ++)printf("%d %.2lf\n", peo[i].id, peo[i].money*1.0/100);return 0; }

L2-010 排座位 dfs

布置宴席最微妙的事情，就是給前來參宴的各位賓客安排座位。無論如何，總不能把兩個死對頭排到同一張宴會桌旁！這個艱巨任務現在就交給你，對任何一對客人，請編寫程序告訴主人他們是否能被安排同席。

輸入格式：

輸入第一行給出3個正整數：N（≤100），即前來參宴的賓客總人數，則這些人從1到N編號；M為已知兩兩賓客之間的關系數；K為查詢的條數。隨后M行，每行給出一對賓客之間的關系，格式為：賓客1 賓客2 關系，其中關系為1表示是朋友，-1表示是死對頭。注意兩個人不可能既是朋友又是敵人。最后K行，每行給出一對需要查詢的賓客編號。

這里假設朋友的朋友也是朋友。但敵人的敵人并不一定就是朋友，朋友的敵人也不一定是敵人。只有單純直接的敵對關系才是絕對不能同席的。

輸出格式：

對每個查詢輸出一行結果：如果兩位賓客之間是朋友，且沒有敵對關系，則輸出No problem；如果他們之間并不是朋友，但也不敵對，則輸出OK；如果他們之間有敵對，然而也有共同的朋友，則輸出OK but...；如果他們之間只有敵對關系，則輸出No way。

輸入樣例：

7 8 4 5 6 1 2 7 -1 1 3 1 3 4 1 6 7 -1 1 2 1 1 4 1 2 3 -1 3 4 5 7 2 3 7 2

輸出樣例：

No problem OK OK but... No way

分析：

N≤100，說明可以直接建圖后進行dfs遍歷，只遍歷邊權為1的點，如果可以從a走到b，說明有共同朋友，再判斷mp[a][b]是否為-1即可。其他情況類似。

代碼：

#include <bits/stdc++.h> using namespace std; int n, m, k, a, b, c; int mp[111][111],vis[111];bool dfs(int now,int end) {if(now==end) return true;for(int i=1;i<=n;i++){if(mp[now][i]==1&&vis[i]==0){vis[now]=1;if(dfs(i,end)) return true;vis[now]=0;}}return false; }int main() {cin>>n>>m>>k;for (int i=0;i<m;i++) {cin>>a>>b>>c;mp[a][b]=mp[b][a]=c;}while (k--) {cin>>a>>b;for(int i=1;i<=n;i++) vis[i]=0;vis[a]=1;bool flag=dfs(a,b);if(flag && mp[a][b]!=-1) cout<<"No problem"<<endl;if(flag && mp[a][b]==-1) cout<<"OK but..."<<endl;if(!flag && mp[a][b]!=-1) cout<<"OK"<<endl;if(!flag && mp[a][b]==-1) cout<<"No way"<<endl;}return 0; }

L2-011 玩轉二叉樹 數據結構

給定一棵二叉樹的中序遍歷和前序遍歷，請你先將樹做個鏡面反轉，再輸出反轉后的層序遍歷的序列。所謂鏡面反轉，是指將所有非葉結點的左右孩子對換。這里假設鍵值都是互不相等的正整數。

輸入格式：

輸入第一行給出一個正整數N（≤30），是二叉樹中結點的個數。第二行給出其中序遍歷序列。第三行給出其前序遍歷序列。數字間以空格分隔。

輸出格式：

在一行中輸出該樹反轉后的層序遍歷的序列。數字間以1個空格分隔，行首尾不得有多余空格。

輸入樣例：

7 1 2 3 4 5 6 7 4 1 3 2 6 5 7

輸出樣例：

4 6 1 7 5 3 2

分析：

就是兩種遍歷方式求另外一種，PTA好喜歡這種題，鏡面翻轉其實就是在求層序的時候反著放入隊列就行。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;struct node{node *l,*r;int data; }; typedef node* Tree; int i,n,x,now=0; vector<int> pre_order,mid_order; Tree build(int l,int r){ //前序和中序建樹 if(l>r) return NULL;Tree root=new(node);root->data=pre_order[now];int mid=l;while(pre_order[now] != mid_order[mid]) mid++;now++;root->l = build(l, mid - 1);root->r = build(mid + 1, r);return root; } void printf(Tree root){ //層序輸出 queue<Tree> q;q.push(root);int tot=0;while(q.size()){Tree t=q.front();tot++;printf("%d%c",t->data,tot==n ? '\n' : ' ');q.pop();if(t->r!=NULL) q.push(t->r);if(t->l!=NULL) q.push(t->l); } } int main(){cin>>n;for(i=1;i<=n;i++) cin>>x,mid_order.push_back(x);for(i=1;i<=n;i++)cin>>x,pre_order.push_back(x);printf(build(0,n-1));return 0; }

L2-013 紅色警報 并查集

戰爭中保持各個城市間的連通性非常重要。本題要求你編寫一個報警程序，當失去一個城市導致國家被分裂為多個無法連通的區域時，就發出紅色警報。注意：若該國本來就不完全連通，是分裂的k個區域，而失去一個城市并不改變其他城市之間的連通性，則不要發出警報。

輸入格式：

輸入在第一行給出兩個整數N（0 < N ≤ 500）和M（≤ 5000），分別為城市個數（于是默認城市從0到N-1編號）和連接兩城市的通路條數。隨后M行，每行給出一條通路所連接的兩個城市的編號，其間以1個空格分隔。在城市信息之后給出被攻占的信息，即一個正整數K和隨后的K個被攻占的城市的編號。

注意：輸入保證給出的被攻占的城市編號都是合法的且無重復，但并不保證給出的通路沒有重復。

輸出格式：

對每個被攻占的城市，如果它會改變整個國家的連通性，則輸出Red Alert: City k is lost!，其中k是該城市的編號；否則只輸出City k is lost.即可。如果該國失去了最后一個城市，則增加一行輸出Game Over.。

輸入樣例：

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

輸出樣例：

City 1 is lost. City 2 is lost. Red Alert: City 0 is lost! City 4 is lost. City 3 is lost. Game Over.

分析：

每次刪去一個點，可以用一個數組記錄標記被刪去的點，每刪去一個點，對所有不包含被刪去點的邊求一次并查集，檢查有幾個集合，如果比之前多則說明有國家被分裂了，注意已經被消滅的城市不會算入一個集合。

代碼：

#include<bits/stdc++.h> using namespace std; typedef pair<int,int> PII; const int N=505;int n,m,k,x,y; int fa[N],vis[N]; vector<PII> v;void init(int n) { for ( int i = 0 ; i < n ; i++ ) fa[i] = i; } //初始化 int find(int x) { return fa[x] == x ? x : fa[x] = find( fa[x] ); } //查找 路徑壓縮 void merge(int a, int b) { a = find(a), b = find(b), fa[b] = a; } //合并 int fun(int x){init(n);vis[x]=0; //x城市被攻占for(int i=0;i<v.size();i++)if(vis[v[i].first]+vis[v[i].second]==2)merge(v[i].first,v[i].second);int res=0;for(int i=0;i<n;i++)if(vis[i]==1&&fa[i]==i)res++;return res; }int main(){cin>>n>>m;for(int i=1;i<=m;i++){cin>>x>>y;v.push_back({x,y});}cin>>k;for(int i=0;i<n;i++) vis[i]=1;int num=fun(n);while(k--){cin>>x;int t=fun(x);if(t>num) printf("Red Alert: City %d is lost!\n",x);else printf("City %d is lost.\n",x);if(t==0) printf("Game Over.\n");num=t;} }

L2-014 列車調度 STL

火車站的列車調度鐵軌的結構如下圖所示。

兩端分別是一條入口（Entrance）軌道和一條出口（Exit）軌道，它們之間有N條平行的軌道。每趟列車從入口可以選擇任意一條軌道進入，最后從出口離開。在圖中有9趟列車，在入口處按照{8，4，2，5，3，9，1，6，7}的順序排隊等待進入。如果要求它們必須按序號遞減的順序從出口離開，則至少需要多少條平行鐵軌用于調度？

輸入格式：

輸入第一行給出一個整數N (2 ≤ N ≤105)，下一行給出從1到N的整數序號的一個重排列。數字間以空格分隔。

輸出格式：

在一行中輸出可以將輸入的列車按序號遞減的順序調離所需要的最少的鐵軌條數。

輸入樣例：

9 8 4 2 5 3 9 1 6 7

輸出樣例：

4

分析：

可以這樣調度：先查看當前所有軌道的最左邊火車編號是否小于當前編號，插入到最小的比當前火車編號大的火車后，如果不存在則開辟新軌道。可知，軌道的最左端火車編號一定是隨軌道下標而遞增的，可以用二分查找快速找到那條軌道。當然，可以用set更為方便。

代碼：

#include<iostream> #include<set> using namespace std; int main() {int n; scanf("%d",&n);set<int>sc;for(int i=0;i<n;i++){int k; scanf("%d",&k);set<int>::iterator it=sc.lower_bound(k);if(it!=sc.end()){sc.erase(it);sc.insert(k);}elsesc.insert(k);}cout<<sc.size(); }

L2-015 互評成績 排序

學生互評作業的簡單規則是這樣定的：每個人的作業會被k個同學評審，得到k個成績。系統需要去掉一個最高分和一個最低分，將剩下的分數取平均，就得到這個學生的最后成績。本題就要求你編寫這個互評系統的算分模塊。

輸入格式：

輸入第一行給出3個正整數N（3 < N ≤104，學生總數）、k（3 ≤ k ≤ 10，每份作業的評審數）、M（≤ 20，需要輸出的學生數）。隨后N行，每行給出一份作業得到的k個評審成績（在區間[0, 100]內），其間以空格分隔。

輸出格式：

按非遞減順序輸出最后得分最高的M個成績，保留小數點后3位。分數間有1個空格，行首尾不得有多余空格。

輸入樣例：

6 5 3 88 90 85 99 60 67 60 80 76 70 90 93 96 99 99 78 65 77 70 72 88 88 88 88 88 55 55 55 55 55

輸出樣例：

87.667 88.000 96.000

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;int n,k,m,i,j,x; vector<int> vi; vector<double> vd;int main(){cin>>n>>k>>m;for(i = 1 ; i <= n ; i++){vi.clear();for(j = 0 ; j < k ; j ++)cin>>x,vi.push_back(x);sort(vi.begin(), vi.end());vi.erase(vi.begin());vi.erase(vi.end()-1);int sum = 0;for(j = 0 ; j < vi.size() ; j++) sum += vi[j];vd.push_back(sum*1.0/(k-2));}sort(vd.begin(), vd.end());for(i = vd.size() - m ; i < vd.size() ; i++)printf("%.3lf%c",vd[i],i==vd.size()-1?'\n':' ');return 0; }

L2-016 愿天下有情人都是失散多年的兄妹 dfs

呵呵。大家都知道五服以內不得通婚，即兩個人最近的共同祖先如果在五代以內（即本人、父母、祖父母、曾祖父母、高祖父母）則不可通婚。本題就請你幫助一對有情人判斷一下，他們究竟是否可以成婚？

輸入格式：

輸入第一行給出一個正整數（）N（2≤N≤104），隨后N行，每行按以下格式給出一個人的信息：

本人ID 性別 父親ID 母親ID
其中ID是5位數字，每人不同；性別M代表男性、F代表女性。如果某人的父親或母親已經不可考，則相應的ID位置上標記為-1。

接下來給出一個正整數K，隨后K行，每行給出一對有情人的ID，其間以空格分隔。

注意：題目保證兩個人是同輩，每人只有一個性別，并且血緣關系網中沒有亂倫或隔輩成婚的情況。

輸出格式：

對每一對有情人，判斷他們的關系是否可以通婚：如果兩人是同性，輸出Never Mind；如果是異性并且關系出了五服，輸出Yes；如果異性關系未出五服，輸出No。

輸入樣例：

24 00001 M 01111 -1 00002 F 02222 03333 00003 M 02222 03333 00004 F 04444 03333 00005 M 04444 05555 00006 F 04444 05555 00007 F 06666 07777 00008 M 06666 07777 00009 M 00001 00002 00010 M 00003 00006 00011 F 00005 00007 00012 F 00008 08888 00013 F 00009 00011 00014 M 00010 09999 00015 M 00010 09999 00016 M 10000 00012 00017 F -1 00012 00018 F 11000 00013 00019 F 11100 00018 00020 F 00015 11110 00021 M 11100 00020 00022 M 00016 -1 00023 M 10012 00017 00024 M 00022 10013 9 00021 00024 00019 00024 00011 00012 00022 00018 00001 00004 00013 00016 00017 00015 00019 00021 00010 00011

輸出樣例：

Never Mind Yes Never Mind No Yes No Yes No No

分析

先跑一遍dfs標記第一個人的所有五代內的長輩，然后再dfs一遍第二個人的所有五代內的長輩，檢查是否有重復。有個坑點就是：父母的性別都是已知的，但是可能不會告訴你父母的祖輩情況，所以要同時記錄父母的性別，否則父母性別默認初始值都是相同的了。還有個我自己的問題，直接在結構體內賦值的方式進行初始化，這樣是不可行的，正確方法是要么循環遍歷初始化，要么寫一個構造函數。

代碼

#include <bits/stdc++.h> #define LL long long using namespace std; const int maxn = 1e5+10; const int inf = 0x3f3f3f3f; const double PI = acos(-1.0); typedef pair<int,int> PII; struct node {int fa, ma, sex , flag;node() {flag = 0;fa = ma = -1;} }peo[maxn]; int f; int vis[maxn]; void dfs(int x, int ceng) {if(x == -1 || ceng > 5) return;vis[x] = 1;if (peo[x].flag == 0) return;dfs(peo[x].ma, ceng + 1);dfs(peo[x].fa,ceng+1); } void dfs2(int x, int ceng) {if(x == -1 || ceng > 5 || f == 1) return;if(vis[x] == 1) {f = 1;return;}if (peo[x].flag == 0) return;dfs2(peo[x].ma,ceng+1);dfs2(peo[x].fa,ceng+1); }int main(int argc, char const *argv[]) {int n;cin >> n;for(int i = 1; i <= n; i++) {string s;int id;cin >> id >> s;cin >> peo[id].fa >> peo[id].ma;peo[id].flag = 1;if(s[0] == 'M') peo[id].sex = 1;else peo[id].sex = 0;if(peo[id].fa != -1)peo[peo[id].fa].sex = 1;if(peo[id].ma != -1)peo[peo[id].ma].sex = 0;}int k;cin >> k;while(k--) {memset(vis, 0 ,sizeof vis);int x, y;cin >> x >> y;if(peo[x].sex == peo[y].sex) puts("Never Mind");else {f = 0;dfs(x,1);dfs2(y,1);if(f==0) puts("Yes");else puts("No");}}return 0; }

L2-017 人以群分 水題

社交網絡中我們給每個人定義了一個“活躍度”，現希望根據這個指標把人群分為兩大類，即外向型（outgoing，即活躍度高的）和內向型（introverted，即活躍度低的）。要求兩類人群的規模盡可能接近，而他們的總活躍度差距盡可能拉開。

輸入格式：

輸入第一行給出一個正整數N（2≤N≤105）。隨后一行給出N個正整數，分別是每個人的活躍度，其間以空格分隔。題目保證這些數字以及它們的和都不會超過231。

輸出格式：

按下列格式輸出：

Outgoing #: N1 Introverted #: N2 Diff = N3

其中N1是外向型人的個數；N2是內向型人的個數；N3是兩群人總活躍度之差的絕對值。

輸入樣例1：

10 23 8 10 99 46 2333 46 1 666 555

輸出樣例1：

Outgoing #: 5 Introverted #: 5 Diff = 3611

輸入樣例2：

13 110 79 218 69 3721 100 29 135 2 6 13 5188 85

輸出樣例2：

Outgoing #: 7 Introverted #: 6 Diff = 9359

分析：

要先保證人數平均再保證差值盡量大，那么就排序后平均分成兩份的差值會最大，如果人數為奇數，中間值分給外向的人群可以使得差值最大。

代碼：

#include<bits/stdc++.h> using namespace std;const int N=1e5+5; typedef long long ll;vector<int> v; int n,x,i,sum1,sum2;int main(){cin>>n;sum1=sum2=0;while(n--){cin>>x;v.push_back(x);}sort(v.begin(),v.end());for(i = 0 ; i < v.size()/2 ; i ++ ) sum1 += v[i];for(i = v.size()/2 ; i < v.size() ; i ++) sum2 += v[i];printf("Outgoing #: %d\n",v.size()-v.size()/2);printf("Introverted #: %d\n",v.size()/2);printf("Diff = %d\n",sum2-sum1);return 0; }

L2-018 多項式A除以B 模擬

這仍然是一道關于A/B的題，只不過A和B都換成了多項式。你需要計算兩個多項式相除的商Q和余R，其中R的階數必須小于B的階數。

輸入格式：

輸入分兩行，每行給出一個非零多項式，先給出A，再給出B。每行的格式如下：

N e[1] c[1] ... e[N] c[N]

其中N是該多項式非零項的個數，e[i]是第i個非零項的指數，c[i]是第i個非零項的系數。各項按照指數遞減的順序給出，保證所有指數是各不相同的非負整數，所有系數是非零整數，所有整數在整型范圍內。

輸出格式：

分兩行先后輸出商和余，輸出格式與輸入格式相同，輸出的系數保留小數點后1位。同行數字間以1個空格分隔，行首尾不得有多余空格。注意：零多項式是一個特殊多項式，對應輸出為0 0 0.0。但非零多項式不能輸出零系數（包括舍入后為0.0）的項。在樣例中，余多項式其實有常數項-1/27，但因其舍入后為0.0，故不輸出。

輸入樣例：

4 4 1 2 -3 1 -1 0 -1 3 2 3 1 -2 0 1

輸出樣例：

3 2 0.3 1 0.2 0 -1.0 1 1 -3.1

分析：

模擬手算多項式除法即可，注意細節

代碼：

#include<bits/stdc++.h> using namespace std;const int maxn=3e3+10; double c1[maxn],c2[maxn],c3[maxn];int nonNegativeNum(double c[],int st)//統計非負項個數 {int cnt=0;for(int i=st;i>=0;--i)if(abs(c[i])+0.05>=0.1)cnt++;return cnt; } void printPoly(double c[],int st) {printf("%d",nonNegativeNum(c,st));if(nonNegativeNum(c,st)==0)printf(" 0 0.0");for(int i=st;i>=0;--i)if(abs(c[i])+0.05>=0.1)printf(" %d %.1lf",i,c[i]); } int main() {int max1=-1,max2=-1;int m;scanf("%d",&m);for(int i=0;i<m;++i){int t;scanf("%d",&t);max1=max(max1,t);scanf("%lf",&c1[t]);}int n;scanf("%d",&n);for(int i=0;i<n;++i){int t;scanf("%d",&t);max2=max(max2,t);scanf("%lf",&c2[t]);}int t1=max1,t2=max2;while(t1>=t2){double x=c1[t1]/c2[t2];//最高次冪的商的系數 c3[t1-t2]=x;for(int i=t1,j=t2;j>=0;--j,--i)c1[i]-=c2[j]*x; while(abs(c1[t1])<1e-6)t1--;//如果該項是0，那么最高次冪降1； }printPoly(c3,max1-max2);puts("");printPoly(c1,t1);return 0; }

L2-019 悄悄關注 STL

新浪微博上有個“悄悄關注”，一個用戶悄悄關注的人，不出現在這個用戶的關注列表上，但系統會推送其悄悄關注的人發表的微博給該用戶。現在我們來做一回網絡偵探，根據某人的關注列表和其對其他用戶的點贊情況，扒出有可能被其悄悄關注的人。

輸入格式：

輸入首先在第一行給出某用戶的關注列表，格式如下：

人數N 用戶1 用戶2 …… 用戶N

其中N是不超過5000的正整數，每個用戶i（i=1, …, N）是被其關注的用戶的ID，是長度為4位的由數字和英文字母組成的字符串，各項間以空格分隔。

之后給出該用戶點贊的信息：首先給出一個不超過10000的正整數M，隨后M行，每行給出一個被其點贊的用戶ID和對該用戶的點贊次數（不超過1000），以空格分隔。注意：用戶ID是一個用戶的唯一身份標識。題目保證在關注列表中沒有重復用戶，在點贊信息中也沒有重復用戶。

輸出格式：

我們認為被該用戶點贊次數大于其點贊平均數、且不在其關注列表上的人，很可能是其悄悄關注的人。根據這個假設，請你按用戶ID字母序的升序輸出可能是其悄悄關注的人，每行1個ID。如果其實并沒有這樣的人，則輸出“Bing Mei You”。

輸入樣例1：

10 GAO3 Magi Zha1 Sen1 Quan FaMK LSum Eins FatM LLao 8 Magi 50 Pota 30 LLao 3 Ammy 48 Dave 15 GAO3 31 Zoro 1 Cath 60

輸出樣例1：

Ammy Cath Pota

輸入樣例2：

11 GAO3 Magi Zha1 Sen1 Quan FaMK LSum Eins FatM LLao Pota 7 Magi 50 Pota 30 LLao 48 Ammy 3 Dave 15 GAO3 31 Zoro 29

輸出樣例2：

Bing Mei You

分析：

map記錄一下哪些名字出現過，再用一個map記錄點贊情況并求出平均值，遍歷記錄點贊記錄的map，將滿足條件的名字放入vector，排序輸出。

代碼：

#include <bits/stdc++.h> #define LL long long using namespace std; const int maxn = 1e5+10; const int inf = 0x3f3f3f3f; const double PI = acos(-1.0); typedef pair<int,int> PII; map<string,int> zan; map<string,int> guan; int main(int argc, char const *argv[]) {int n;cin >> n;string s;for(int i = 0; i < n; i++) {cin >> s;guan[s] = 1;}int m, x;cin >> m;double sum = 0;for(int i = 0 ; i < m; i++){cin >> s >> x;sum += x;zan[s] = x;}sum = sum*1.0/m;vector<string> ans;for(auto it : zan) {if(guan[it.first] == 0 && sum < it.second) ans.push_back(it.first);}if(ans.size() == 0) puts("Bing Mei You");else {sort(ans.begin(), ans.end());for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;}return 0; }

L2-020 功夫傳人 dfs

一門武功能否傳承久遠并被發揚光大，是要看緣分的。一般來說，師傅傳授給徒弟的武功總要打個折扣，于是越往后傳，弟子們的功夫就越弱…… 直到某一支的某一代突然出現一個天分特別高的弟子（或者是吃到了靈丹、挖到了特別的秘笈），會將功夫的威力一下子放大N倍 —— 我們稱這種弟子為“得道者”。

這里我們來考察某一位祖師爺門下的徒子徒孫家譜：假設家譜中的每個人只有1位師傅（除了祖師爺沒有師傅）；每位師傅可以帶很多徒弟；并且假設輩分嚴格有序，即祖師爺這門武功的每個第i代傳人只能在第i-1代傳人中拜1個師傅。我們假設已知祖師爺的功力值為Z，每向下傳承一代，就會減弱r%，除非某一代弟子得道。現給出師門譜系關系，要求你算出所有得道者的功力總值。

輸入格式：

輸入在第一行給出3個正整數，分別是：N（≤105）——整個師門的總人數（于是每個人從0到N?1編號，祖師爺的編號為0）；Z——祖師爺的功力值（不一定是整數，但起碼是正數）；r ——每傳一代功夫所打的折扣百分比值（不超過100的正數）。接下來有N行，第i行（i=0,?,N?1）描述編號為i的人所傳的徒弟，格式為：

K**i ID[1] ID[2] ? ID[K**i]

其中K**i是徒弟的個數，后面跟的是各位徒弟的編號，數字間以空格間隔。K**i為零表示這是一位得道者，這時后面跟的一個數字表示其武功被放大的倍數。

輸出格式：

在一行中輸出所有得道者的功力總值，只保留其整數部分。題目保證輸入和正確的輸出都不超過1010。

輸入樣例：

10 18.0 1.00 3 2 3 5 1 9 1 4 1 7 0 7 2 6 1 1 8 0 9 0 4 0 3

輸出樣例：

404

分析：

由于每個徒弟嚴格只會跟一個高一輩的師傅，直接保存每個人的徒弟，然后dfs一遍就行，標記一下超級徒弟dfs的時候判斷一下就行，超級徒弟就是葉子節點。

代碼：

#include<bits/stdc++.h> using namespace std; #define PII pair<int,int>const int INF = 0x3f3f3f3f; const int N = 1e5+10;int n; int vis[N]; double z,r,sum; vector<int> v[N];void dfs(int x,double power){if(vis[x]){sum+=power*v[x][0];return ;}for(int i=0;i<v[x].size();i++)dfs(v[x][i],power*r); }int main(){cin>>n>>z>>r;r=(100.0-r)/100.0;for(int i=0;i<n;i++){int k,x; cin>>k;if(k==0) {cin>>x;vis[i]=1;v[i].push_back(x);}while(k--){cin>>x;v[i].push_back(x);}}dfs(0,z);cout<<(int)sum<<endl;return 0; }

總結

以上是生活随笔為你收集整理的团体程序设计天梯赛-练习集 （L2-001 - L2-020）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。