2017-第八屆藍橋杯大賽個人賽省賽（軟件類）真題 C大學C組

本文轉載自查看原文 2020-03-16 17:16 1018 藍橋杯

題目一覽：

1.貪吃蛇長度

+-------------------------------------------------+
|                                                 |
|    H######                      ####            |
|          #                      #  #            |
|          #                      #  #            |
|          #     ####             #  #            |
|          #     #  #             #  #            |
|          ######@###             #  #            |
|                #       ####     #  #            |
|                #       #  #     #  #            |
|            ####@#######@###     #  #            |
|            #   #       #        #  #            |
| T          #####       #        #  #   ##       |
| #                      #      ###  ### ##       |
| ################       #      #      ####       |
|                #       #      #         #       |
|   ##############       #######@##########       |
|   #                         ###                 |
|   ###########################                   |
+-------------------------------------------------+

小明在爺爺的私人收藏館里找到一台老式電腦。居然沒有圖形界面，只能用控制台編程。
經過小明的一陣摸索，神奇地設計出了控制台上的貪食蛇游戲。

如上圖，是游戲時畫面截圖。
其中，H表示蛇頭，T表示蛇尾。#表示蛇的身體，@表示身體交叉重疊的地方。
你能說出現在的貪吃蛇長度是多少嗎？

其實，只要數出#的數目算1，數出@的數目，算2，再加上頭尾各算1就計算好了。

人工數一下？太累眼睛了，聰明的你為什么不讓計算機幫忙呢？

本題的要求就是：請填寫上圖中貪食蛇的長度是多少？

注意：需要提交的是一個整數，不要添加任何多余內容（比如說明或注釋）

思路：讀取挨個判斷就好。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 char s[21][666];
 5 int Ans;
 6 
 7 int main() {
 8     for(int i=0; i<20; ++i) gets(s[i]);
 9     for(int i=0; i<20; ++i) {
10         for(int j=0; j<51; ++j) {
11             if(s[i][j] == '#') Ans ++;
12             else if(s[i][j] == '@') Ans += 2;
13         }
14     }
15     Ans += 2;
16     printf("%d", Ans);
17     return 0;
18 }

1.貪吃蛇長度

答案：190

2.興趣小組

為豐富同學們的業余文化生活，某高校學生會創辦了3個興趣小組
（以下稱A組，B組，C組）。
每個小組的學生名單分別在【A.txt】,【B.txt】和【C.txt】中。
每個文件中存儲的是學生的學號。

12894792, 92774113, 59529208, 22962224, 02991600, 83340521, 87365045, 
40818286, 16400628, 39475245, 55933381, 76940287, 61366748, 95631228, 
17102313, 50682833, 61562613, 87002524, 83062019, 51743442, 61977890, 
32010762, 69680621, 87179571, 81761697, 32364296, 07833271, 36198035, 
26588918, 84046668, 43059468, 73191775, 56794101, 00454780, 11141030, 
10008994, 35072237, 44945158, 53959980, 75758119, 18560273, 35801494, 
42102550, 22496415, 03981786, 34593672, 13074905, 07733442, 42374678, 
23452507, 98586743, 30771281, 17703080, 52123562, 05898131, 56698981, 
90758589, 18238802, 18217979, 04511837, 75682969, 31135682, 55379006, 
42224598, 98263070, 40228312, 28924663, 11580163, 25686441, 45944028, 
96731602, 53675990, 03854194, 14858183, 16866794, 40677007, 73141512, 
32317341, 56641725, 43123040, 15201174, 62389950, 72887083, 76860787, 
61046319, 06923746, 17874548, 46028629, 10577743, 48747364, 05328780, 
59855415, 60965266, 20592606, 14471207, 70896866, 46938647, 33575820, 
53426294, 56093931, 51326542, 94050481, 80114017, 33010503, 72971538, 
22407422, 17305672, 78974338, 93209260, 83461794, 41247821, 26118061, 
10657376, 42198057, 15338224, 50284714, 32232841, 26716521, 76048344, 
23676625, 62897700, 69296551, 59653393, 38704390, 48481614, 69782897, 
26850668, 37471053, 88720989, 51010849, 94951571, 60024611, 29808329, 
70377786, 13899299, 09683688, 58218284, 46792829, 97221709, 45286643, 
48158629, 57367208, 26903401, 76900414, 87927040, 09926730, 01508757, 
15101101, 62491840, 43802529,

A.txt

44894050, 34662733, 44141729, 92774113, 99208727, 91919833, 23727681, 
10003409, 55933381, 54443275, 13584702, 96523685, 50682833, 61562613, 
62380975, 20311684, 93200452, 23101945, 42192880, 28992561, 18460278, 
19186537, 58465301, 01111066, 62680429, 23721241, 20277631, 91708977, 
57514737, 03981786, 81541612, 07346443, 93154608, 19709455, 37446968, 
17703080, 72378958, 66200696, 30610382, 89586343, 33152171, 67040930, 
35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 01418023, 
74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626, 
01673442, 70548494, 13638168, 08163691, 11106566, 64375392, 40267902, 
00897705, 56447313, 54532235, 94738425, 66642634, 83219544, 40546096, 
66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091, 
08487641, 32500082, 84412833, 23311447, 38380409, 79957822, 72971538, 
69645784, 91863314, 73099909, 93209260, 83461794, 81378487, 30423273, 
22233715, 32232841, 26716521, 03511221, 29196547, 58263562, 56233305, 
52547525, 55812835, 87253244, 52484232, 80837360, 94098464, 52028151, 
53267501, 66381929, 84381316, 59788467, 09683688, 67082008, 71605255, 
80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980, 
48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892, 
18926791, 40818286, 28936302, 11489524, 51031183, 73860337, 13241219, 
09025448, 10718828, 76360986, 26031606, 76558053, 97726139, 46473415, 
48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237, 
08602486, 29815841, 56562216, 77684187, 81751704, 20160464, 50407962, 
27786415, 19893526, 00934129, 37759498, 52636463, 25666982, 43262852, 
38393436, 02581136, 29323250, 56950657, 05898131, 95286262, 75574581, 
54057961, 06703896, 90758589, 57782642, 34492535, 41919697, 06395464, 
10993500, 81212949, 34017532, 69569396, 99009936, 57129610, 67401593, 
71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544, 
30433724, 53127345, 72887083, 25390873, 63711546, 06923746, 27783723, 
33199575, 35929698, 16491251, 18276792, 62744775, 92096155, 06336570, 
56141974, 73007273, 31416832, 00171057, 64176982, 46938647, 58460388, 
69972026, 73724304, 27435484, 51568616, 15531822, 47788699, 11818851, 
41594694, 83561325, 43107163, 56965375, 10557343, 26118061, 74650126, 
90076467, 10657376, 49901436, 03425162, 61164599, 15797769, 05427896, 
14444084, 36795868, 18079449, 59653393, 72942548, 06763077, 33895610, 
94892653, 12085268, 65174140, 79567366, 23020126, 74290047, 13498869, 
21696323, 27724594, 54941003, 38229841, 07050068,

B.txt

13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555, 
17102313, 47079425, 50682833, 74154313, 61562613, 93200452, 37103342, 
18479435, 32502597, 36198035, 54210010, 73191775, 48358178, 85544503, 
05996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041, 
65899605, 56528700, 82671109, 61176034, 42374678, 51612628, 63329997, 
56591652, 04552733, 12789324, 89586343, 51935014, 38611966, 43916409, 
70996050, 98263070, 01418023, 65345049, 21734275, 76846198, 71506230, 
00833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325, 
09386162, 95324041, 80688223, 67629139, 79552617, 76219736, 50368644, 
45096021, 54972488, 63779011, 28862942, 73145521, 74078605, 66924991, 
12806850, 02171001, 70896866, 73434467, 08487641, 44415025, 32500082, 
84412833, 83896188, 52243759, 49191410, 38744339, 48079796, 44937032, 
06267501, 81866886, 38575984, 25978688, 78974338, 41247821, 12356966, 
64842303, 79127158, 02366944, 68000570, 12426275, 96409230, 00705972, 
08266503, 83820884, 08831807, 43273308, 23216105, 29196547, 95160161, 
05553537, 52182214, 32641346, 91553427, 24436506, 77433749, 01979664, 
52028151, 88985343, 01761499, 76203088, 63237368, 23405334, 59788467, 
09683688, 67755443, 29946533, 12053603, 00437479, 15200030, 45286643, 
93537527, 82465821, 57367208, 53899751, 15354933, 97760830, 68933762, 
80220545, 01892750, 39868288, 21524323, 69716610, 65083815, 78048499, 
03227391, 83340521, 87365045, 71720254, 51031183, 89168555, 08503028, 
37086236, 25103057, 87002524, 22808816, 80928090, 90741678, 15993372, 
99117082, 49938176, 21755083, 86903426, 87830263, 53959980, 75758119, 
59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608, 
44882734, 90758589, 08075999, 66303819, 23480347, 11580163, 87080118, 
18329165, 92514163, 89404632, 92377859, 03912329, 17499963, 59699979, 
79876366, 63894807, 37857001, 86003935, 90087123, 29433345, 80298948, 
61531153, 61046319, 37839841, 19421134, 48747364, 35196916, 62484573, 
59907079, 36845702, 21631642, 72739317, 26283700, 80114017, 76639390, 
29154110, 35159758, 47788699, 11818851, 56520669, 36396767, 36031167, 
83817428, 10657376, 90076467, 14676452, 11024560, 16327605, 76048344, 
14444084, 95452011, 99612346, 65172562, 84813675, 88618282, 38704390, 
27998014, 63859011, 33787505, 60024611, 16229880, 13899299, 35240335, 
29173227, 45036451, 66177893, 82658333, 43100730, 44520187, 74290047, 
85013538, 09926730, 27724594, 95148523, 20503000, 64390907, 26006953, 
98116293, 97457666, 29017396, 04634371, 70791589,

C.txt

由於工作需要，我們現在想知道：
既參加了A組，又參加了B組，但是沒有參加C組的同學一共有多少人？

請你統計該數字並通過瀏覽器提交答案。

注意：答案是一個整數，不要提交任何多余的內容。

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

笨笨有話說：
哇塞！數字好多啊！一眼望過去就能發現相同的，好像沒什么指望。
不過，可以排序啊，要是每個文件都是有序的，那就好多了。

歪歪有話說：
排什么序啊，這么幾行數字對計算機不是太輕松了嗎？
我看着需求怎么和中學學過的集合很像啊.....

思路：讀入三個小組的數據存放在三個數組里面，然后枚舉

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 int A[501], B[501], C[501];
 5 int Len1, Len2, Len3, Ans;
 6 
 7 int main() {
 8     // 讀入三個小組的數據，分別放到ABC三個數組內 
 9     int x;
10     freopen("A.txt", "r", stdin);
11     while(~scanf("%d, ", &x)) {
12         A[++Len1] = x;
13     }
14     fclose(stdin);
15     freopen("B.txt", "r", stdin);
16     while(~scanf("%d, ", &x)) {
17         B[++Len2] = x;
18     }
19     fclose(stdin);
20     freopen("C.txt", "r", stdin);
21     while(~scanf("%d, ", &x)) {
22         C[++Len3] = x;
23     }
24     fclose(stdin);
25     //printf("--------------------------\n");
26     int i, j, k;
27     for(i=1; i<=Len1; ++i) {
28         for(j=1; j<=Len2; ++j) {
29             int flag = 1; // 假設不在C組 
30             if(A[i] == B[j]) { // 參加A和B 
31                 for(k=1; k<=Len3; ++k) 
32                 if(A[i] == C[k]) { // C組有他，標記退出 
33                     flag = 0;
34                     break;
35                 }
36                 if(flag) Ans ++; // 不在C組 
37             }
38         }
39     }
40     printf("%d\n", Ans);
41     return 0;
42 }

2.興趣小組

答案：20

3.算式900

小明的作業本上有道思考題：

看下面的算式：

(□□□□-□□□□)*□□=900

其中的小方塊代表0~9的數字，這10個方塊剛好包含了0~9中的所有數字。
注意：0不能作為某個數字的首位。

小明經過幾天的努力，終於做出了答案！如下：
(5012-4987)*36=900

用計算機搜索后，發現還有另外一個解，本題的任務就是：請你算出這另外的一個解。

注意：提交的格式需要與示例嚴格一致；
括號及運算符號不要用中文輸入法；
整個算式中不能包含空格。

注意：機器評卷，不要填寫任何多余的內容，比如說明文字。

思路：其實是特殊一點的全排列問題，即第1、5、9位不能是0，可用dfs將十個空填好，然后判斷是否符合算式。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 int a[11];
 5 bool vis[11];
 6 
 7 void dfs(int pos) {
 8     if(pos > 10) { // 十個都搜完了  判斷是否滿足條件 
 9         int x = a[1]*1000 + a[2]*100 + a[3]*10 + a[4];
10         int y = a[5]*1000 + a[6]*100 + a[7]*10 + a[8];
11         int z = a[9]*10 + a[10];
12         int i;
13         //for(i=1; i<=10; ++i) printf("%d ", a[i]); printf("\n");
14         if((x - y)*z == 900) // 找到解 輸出 
15             printf("(%d-%d)*%d=900\n", x, y, z);
16     }
17     for(int i=0; i<=9; ++i) { // 開始嘗試將數填入第pos位
18         if(vis[i] == 0) {
19             if(i == 0) // 首位不能為零 
20                 if(pos==1 || pos==5 || pos==9) continue;
21             a[pos] = i; // 可以填入 將其填入 
22             vis[i] = true; // 標記已經使用 
23             dfs(pos+1); // 開始搜下一位 
24             a[pos] = -1; // 回溯 
25             vis[i] = false;
26         }
27     }
28 }
29 
30 int main() {
31     // 標記數字未使用 
32     for(int i=0; i<=9; ++i) vis[i] = false;
33     dfs(1); // 從第一位開始填入 
34     return 0;
35 }

3.算式900

答案：

(6048-5973)*12=900

4.承壓計算

X星球的高科技實驗室中整齊地堆放着某批珍貴金屬原料。

每塊金屬原料的外形、尺寸完全一致，但重量不同。
金屬材料被嚴格地堆放成金字塔形。

 1                              7 
 2                             5 8 
 3                            7 8 8 
 4                           9 2 7 2 
 5                          8 1 4 9 1 
 6                         8 1 8 8 4 1 
 7                        7 9 6 1 4 5 4 
 8                       5 6 5 5 6 9 5 6 
 9                      5 5 4 7 9 3 5 5 1 
10                     7 5 7 9 7 4 7 3 3 1 
11                    4 6 4 5 5 8 8 3 2 4 3 
12                   1 1 3 3 1 6 6 5 5 4 4 2 
13                  9 9 9 2 1 9 1 9 2 9 5 7 9 
14                 4 3 3 7 7 9 3 6 1 3 8 8 3 7 
15                3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
16               8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
17              8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
18             2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 
19            7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 
20           9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 
21          5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 
22         6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 
23        2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 
24       7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 
25      1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 
26     2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 
27    7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 
28   7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 
29  5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 
30 X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X

其中的數字代表金屬塊的重量（計量單位較大）。
最下一層的X代表30台極高精度的電子秤。

假設每塊原料的重量都十分精確地平均落在下方的兩個金屬塊上，
最后，所有的金屬塊的重量都嚴格精確地平分落在最底層的電子秤上。
電子秤的計量單位很小，所以顯示的數字很大。

工作人員發現，其中讀數最小的電子秤的示數為：2086458231

請你推算出：讀數最大的電子秤的示數為多少？

注意：需要提交的是一個整數，不要填寫任何多余的內容。

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

笨笨有話說：
不斷的除2，加到下面，除2,加到下面,.... 不會浮點精度溢出吧？
歪歪有話說：
怕除不開還不好辦，把每個數字擴大一定的倍數不就好了。

思路：歪歪告訴咱了。一共30層，其中第30層是秤。我們可以在讀入的時候，把每個數字都乘上536870912(2^29)(30也行，但最少要29，不然到最后幾行會出問題)，然后從上往下枚舉，將其重量平分，分給下面兩個。最后搜索一遍最后一層，也就是秤，找到最大、小值，然后用最小值除以2086458231得到一個倍數，再用最大值乘上倍數就得到了答案。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 const int Pow = 536870912;
 5 long long Map[31][31];
 6 long long Min = 9999035434, Max = -9999035434;
 7 
 8 int main() {
 9     //freopen("in.txt", "r", stdin);
10     //freopen("out.txt", "w", stdout);
11     for(int i=1; i<=29; ++i)
12         for(int j=1; j<=i; ++j) {
13             scanf("%lld", &Map[i][j]);
14             Map[i][j] *= Pow;
15         }
16     for(int i=1; i<=29; ++i) {
17         for(int j=1; j<=i; ++j) {
18             long long t = Map[i][j] / 2;
19             Map[i+1][j] += t;
20             Map[i+1][j+1] += t;
21         }
22     }
23     for(int j=1; j<=30; ++j) {
24         Max = Max>Map[30][j]? Max:Map[30][j];
25         Min = Min<Map[30][j]? Min:Map[30][j];
26     }
27     
28     long long temp = Min / 2086458231;
29     printf("%lld\n", Max/temp);
30     return 0;
31 }

4.承壓計算

答案：72665192664

5.楊輝三角

楊輝三角也叫帕斯卡三角，在很多數量關系中可以看到，十分重要。

第0行： 1
第1行： 1 1
第2行： 1 2 1
第3行： 1 3 3 1
第4行： 1 4 6 4 1
....

兩邊的元素都是1，中間的元素是左上角的元素與右上角的元素和。

我們約定，行號，列號都從0計數。
所以：第6行的第2個元素是15，第3個元素是20

直觀地看，需要開辟一個二維數組，其實一維數組也可以勝任。
如下程序就是用一維數組“騰挪”的解法。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 // 楊輝三角的第row行，第col列 
 5 long long f(int row, int col) {
 6     if(row<2) return 1;
 7     if(col==0) return 1;
 8     if(col==row) return 1;
 9 
10     long long a[1024];
11     a[0]=1;
12     a[1]=1;    
13     int p = 2;
14     int q;
15 
16     while(p<=row){
17         a[p] = 1;
18         for( _______ ) a[q] = a[q] + a[q-1]; //填空
19         p++;
20     }
21 
22     return a[col];
23 }
24 
25 int main() {
26     printf("%d\n", f(6,2));
27     printf("%d\n", f(6,3));
28     printf("%lld\n", f(40,20));    
29     return 0;
30 }

請仔細分析源碼，並完成划線部分缺少的代碼。
注意：只提交缺少的代碼，不要提交已有的代碼和符號。也不要提交說明性文字。

思路：仔細品一品10-20行。該程序的while從p=2開始，第11-12行的賦值，正是楊輝三角的第1行，所以可以推測出a數組是存放第p行的楊輝三角數。那么我們知道了第n行的數，怎么推出第n+1行呢。如下圖，我們假設從第2行推第3行，那么我們首先想的是正推，也就是q從0到p-1，那么推出(3,0)的1時，a數組是{1,2,1}，看起來還挺正常，推出(3,1)的3時，a數組是{1,3,1}，看起來也沒有毛病，但這時推(3,2)的3時，我們發現求出來的卻是4，因原本的1+2變成了1+3，這是為什么呢，因為我們把前面的數字給改變了，2被更新成了3，但是2的職責還沒有發揮完。每個數字都由他的頭上還有左上角更新來的，所以某個位置沒有被更新時，那么他的頭上和左上的數字就不能動，這時我們考慮倒推，也就是q從p-1到0，我們發現倒推更新時只會修改頭上的數字，而頭上的數字更新完自己之后就沒有用了，所以倒推是對的。

答案：

q=p-1; q>0; --q

6.最大公共子串

最大公共子串長度問題就是：
求兩個串的所有子串中能夠匹配上的最大長度是多少。

比如："abcdkkk" 和 "baabcdadabc"，
可以找到的最長的公共子串是"abcd",所以最大公共子串長度為4。

下面的程序是采用矩陣法進行求解的，這對串的規模不大的情況還是比較有效的解法。

請分析該解法的思路，並補全划線部分缺失的代碼。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 #define N 256
 5 
 6 int f(const char* s1, const char* s2) {
 7     int a[N][N];
 8     int len1 = strlen(s1);
 9     int len2 = strlen(s2);
10     int i,j;
11     
12     memset(a,0,sizeof(int)*N*N);
13     int max = 0;
14     for(i=1; i<=len1; i++){
15         for(j=1; j<=len2; j++){
16             if(s1[i-1]==s2[j-1]) {
17                 a[i][j] = ____________;  //填空
18                 if(a[i][j] > max) max = a[i][j];
19             }
20         }
21     }
22     return max;
23 }
24 
25 int main() {
26     printf("%d\n", f("abcdkkk", "baabcdadabc"));
27     return 0;
28 }

注意：只提交缺少的代碼，不要提交已有的代碼和符號。也不要提交說明性文字。

思路：很簡單的一道DP題，第16行判斷當前兩個字符是否相同，相同的話不就從前面轉移過來嘛。

答案：

a[i-1][j-1] + 1

7.Excel地址

Excel單元格的地址表示很有趣，它使用字母來表示列號。
比如，
A表示第1列，
B表示第2列，
Z表示第26列，
AA表示第27列，
AB表示第28列，
BA表示第53列，
....

當然Excel的最大列號是有限度的，所以轉換起來不難。
如果我們想把這種表示法一般化，可以把很大的數字轉換為很長的字母序列呢？

本題目既是要求對輸入的數字, 輸出其對應的Excel地址表示方式。

例如，
輸入：
26
則程序應該輸出：
Z

再例如，
輸入：
2054
則程序應該輸出：
BZZ

我們約定，輸入的整數范圍[1,2147483647]

資源約定：
峰值內存消耗（含虛擬機） < 256M
CPU消耗 < 1000ms

請嚴格按要求輸出，不要畫蛇添足地打印類似：“請您輸入...” 的多余內容。

注意：
main函數需要返回0;
只使用ANSI C/ANSI C++ 標准;
不要調用依賴於編譯環境或操作系統的特殊函數。
所有依賴的函數必須明確地在源文件中 #include <xxx>
不能通過工程設置而省略常用頭文件。

提交程序時，注意選擇所期望的語言類型和編譯器類型。

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

笨笨有話說：
這有點像進制關系，又不完全是。好像末2位是以1當26，末3位是以1當26*26

歪歪有話說：
要是從字母序列轉數字還好點，倒過來有點麻煩，不過計算機跑得快啊。

思路：首先我們能想到這就像是一個26進制數，那么我們就按照這個來寫：

1     scanf("%lld", &x);
2     while(x) {
3         y = x % 26;
4         x /= 26;
5         s[++len] = 'A' + y - 1;
6     }
7     while(len){
8         printf("%c", s[len--]);
9     }

測試的時候，輸入1，輸出"A"，輸入27，輸出"AA"。看起來似乎沒有什么問題，但當測試26時，發現問題了，輸出的不是"Z"，而是"A@"。問題出來了，這是為什么呢。這個和進制轉換還是有點區別的，因為我們的進制是逢26進一，而這個卻不太是這樣，因為26也是一個數，換成27進制也會出現問題，請大家自行思考。那么我們如何修改呢，我們發現當y為0時，應當輸出"Z"，那么我們特判一下y為0時將其修改為26。這時再測試26，輸出的是"AZ"，我們發現x沒有把這個"Z"去掉。那么我們再減去1就好了。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 int main() {
 5     long long x, y, len=0;
 6     char s[101];
 7     scanf("%lld", &x);
 8     while(x) {
 9         y = x % 26;
10         x /= 26;
11         if(!y) y = 26, x--;
12         s[++len] = 'A' + y - 1;
13     }
14     while(len){
15         printf("%c", s[len--]);
16     }
17     return 0;
18 }

7.Excel地址

8.九宮幻方

小明最近在教鄰居家的小朋友小學奧數，而最近正好講述到了三階幻方這個部分，三階幻方指的是將1~9不重復的填入一個3*3的矩陣當中，使得每一行、每一列和每一條對角線的和都是相同的。

三階幻方又被稱作九宮格，在小學奧數里有一句非常有名的口訣：“二四為肩，六八為足，左三右七，戴九履一，五居其中”，通過這樣的一句口訣就能夠非常完美的構造出一個九宮格來。
4 9 2
3 5 7
8 1 6

有意思的是，所有的三階幻方，都可以通過這樣一個九宮格進行若干鏡像和旋轉操作之后得到。現在小明准備將一個三階幻方（不一定是上圖中的那個）中的一些數抹掉，交給鄰居家的小朋友來進行還原，並且希望她能夠判斷出究竟是不是只有一個解。
而你呢，也被小明交付了同樣的任務，但是不同的是，你需要寫一個程序~

輸入格式：
輸入僅包含單組測試數據。
每組測試數據為一個3*3的矩陣，其中為0的部分表示被小明抹去的部分。
對於100%的數據，滿足給出的矩陣至少能還原出一組可行的三階幻方。

輸出格式：
如果僅能還原出一組可行的三階幻方，則將其輸出，否則輸出“Too Many”（不包含引號）。

樣例輸入
0 7 2
0 5 0
0 3 0

樣例輸出
6 7 2
1 5 9
8 3 4

資源約定：
峰值內存消耗（含虛擬機） < 256M
CPU消耗 < 1000ms

請嚴格按要求輸出，不要畫蛇添足地打印類似：“請您輸入...” 的多余內容。

提交程序時，注意選擇所期望的語言類型和編譯器類型。

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

笨笨有話說：
我最喜歡這類題目了。既然九宮幻方一共也沒有多少，我就不辭辛勞地一個一個寫出來好了。
也不能太過分，好歹用個數組。

思路：把3*3的拉成1*9的，讀入的時候對非0的位置、用過的數字進行標記。然后從第1個空開始填，填完之后去檢查是否每行、每列、對角線的三個數之和是15。是的話就記錄下來，計數器自增。剪枝：當計算器大於1時就不用再找了。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 int a[11], cnt;
 5 bool vis[11], book[11];
 6 int flag, b[11][11];
 7 
 8 void check() {
 9     int t[11];
10     for(int i=1; i<=10; ++i) t[i] = 0;
11     for(int j=0,i=1; i<=3; ++i,j+=2) {
12         t[1] += a[i];    // 123 第一行 
13         t[2] += a[i+3];    // 456 第二行 
14         t[3] += a[i+6];    // 789 第三行 
15         t[4] += a[i+j];    // 147 第一列 
16         t[5] += a[i+j+1];// 258 第二列 
17         t[6] += a[i+j+2];// 369 第三列 
18         t[7] += a[2*i+j-1];// 159
19         t[8] += a[j+3];    // 357
20     }
21     for(int i=1; i<=8; ++i) {
22         if(t[i] != 15)
23             return ;
24     }
25     // 滿足 復制到b里面 
26     flag ++;
27     for(int i=1; i<=9; ++i)
28         b[flag][i] = a[i];
29     return ;
30 }
31 
32 void dfs(int x) { // 第x個空 
33     if(flag > 1) return ;// 剪枝 有多個解了 
34     if(x > 9) {
35         check();
36         return ;
37     }
38     if(vis[x]) { // 該空有數字 
39         dfs(x+1);
40         return ;
41     }
42     for(int i=1; i<=9; ++i) {
43         if(!book[i]) {
44             a[x] = i;
45             book[i] = true;
46             dfs(x+1);
47             book[i] = false;
48         }
49     }
50 }
51 
52 void Print() {  
53     for(int i=1; i<=9; ++i) {
54         printf("%d ", b[1][i]);
55         if(!(i%3)) puts("");
56     }
57     
58 }
59 
60 int main() {
61     memset(vis, false, sizeof(vis));
62     memset(book, false, sizeof(book));
63     for(int i=1; i<=9; ++i) {
64         scanf("%d", &a[i]);
65         if(a[i]) {
66             vis[i] = true;// 非0的地方不用搜索 
67             book[a[i]] = true;
68         }
69     }
70     dfs(1);
71     if(flag == 1) Print(); // 一組解就打印 
72     else printf("Too Many");
73     return 0;
74 }

9.九宮幻方

9.拉馬車

小的時候，你玩過紙牌游戲嗎？
有一種叫做“拉馬車”的游戲，規則很簡單，卻很吸引小朋友。

其規則簡述如下：
假設參加游戲的小朋友是A和B，游戲開始的時候，他們得到的隨機的紙牌序列如下：
A方：[K, 8, X, K, A, 2, A, 9, 5, A]
B方：[2, 7, K, 5, J, 5, Q, 6, K, 4]

其中的X表示“10”，我們忽略了紙牌的花色。

從A方開始，A、B雙方輪流出牌。

當輪到某一方出牌時，他從自己的紙牌隊列的頭部拿走一張，放到桌上，並且壓在最上面一張紙牌上（如果有的話）。

此例中，游戲過程：
A出K，B出2，A出8，B出7，A出X，此時桌上的序列為：

K,2,8,7,X

當輪到B出牌時，他的牌K與桌上的紙牌序列中的K相同，則把包括K在內的以及兩個K之間的紙牌都贏回來，放入自己牌的隊尾。注意：為了操作方便，放入牌的順序是與桌上的順序相反的。
此時，A、B雙方的手里牌為：
A方：[K, A, 2, A, 9, 5, A]
B方：[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K]

贏牌的一方繼續出牌。也就是B接着出5，A出K，B出J，A出A，B出5，又贏牌了。
5,K,J,A,5
此時雙方手里牌：
A方：[2, A, 9, 5, A]
B方：[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5]

注意：更多的時候贏牌的一方並不能把桌上的牌都贏走，而是拿走相同牌點及其中間的部分。但無論如何，都是贏牌的一方繼續出牌，有的時候剛一出牌又贏了，也是允許的。

當某一方出掉手里最后一張牌，但無法從桌面上贏取牌時，游戲立即結束。

對於本例的初始手牌情況下，最后A會輸掉，而B最后的手里牌為：

9K2A62KAX58K57KJ5

本題的任務就是已知雙方初始牌序，計算游戲結束時，贏的一方手里的牌序。當游戲無法結束時，輸出-1。

輸入為2行，2個串，分別表示A、B雙方初始手里的牌序列。
輸出為1行，1個串，表示A先出牌，最后贏的一方手里的牌序。

例如，
輸入：
96J5A898QA
6278A7Q973

則程序應該輸出：
2J9A7QA6Q6889977

再比如，
輸入：
25663K6X7448
J88A5KJXX45A

則程序應該輸出：
6KAJ458KXAX885XJ645

我們約定，輸入的串的長度不超過30

資源約定：
峰值內存消耗（含虛擬機） < 256M
CPU消耗 < 1000ms

請嚴格按要求輸出，不要畫蛇添足地打印類似：“請您輸入...” 的多余內容。

提交程序時，注意選擇所期望的語言類型和編譯器類型。

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

笨笨有話說：
不斷刪除前邊的，又要后邊添加.... 如果用數組，需要開一個大點的，請佛祖保佑在游戲結束前，不會用到數組的邊緣。

歪歪有話說：
反正串也不長，不如每次操作都返回一個新的串。

默默有話說：
我一般都不吱聲，這是典型的隊列結構，動態數組最好，沒有？自己造一個唄！

思路：一道模擬題，就按照規則來一步一步實現。用STL中的queue會簡單一點，但本人太菜，用的數組。

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 bool draw;
 5 int cnt, Win;
 6 int A_s, A_e, B_s, B_e, len, who; 
 7 char A[20001], B[20001], Z[20001];
 8 
 9 void init() { // 讀入 初始化 
10     cin >> A;
11     A_s = 0, A_e = strlen(A)-1;
12     cin >> B;
13     B_s = 0, B_e = strlen(B)-1;
14     len = 0, who = 1, draw = false;
15     cnt = 0, Win = 0;
16 }
17 
18 void print() { // 輸出勝者手里的牌 
19     if(Win == 1) 
20         for(int i=A_s; i<=A_e; ++i)
21             printf("%c", A[i]);
22     if(Win == 2) 
23         for(int i=B_s; i<=B_e; ++i)
24             printf("%c", B[i]);
25 }
26 
27 bool check(char ch) { // 檢測出的牌桌面上有沒有 
28     for(int i=len; i>0; --i)
29         if(Z[i] == ch) return true;
30     return false;
31 }
32 
33 void work_A() { // A出牌 
34     if(check(A[A_s])) { // 桌上有，開始退牌 
35         char t = A[A_s++];
36         A[++A_e] = t;
37         while(Z[len] != t) A[++A_e] = Z[len--];
38         A[++A_e] = Z[len--];
39         who = -1;
40     }
41     else Z[++len] = A[A_s++]; // 沒有 放上去 
42     if(A_s > A_e) // 手里沒牌了 B贏了 
43         Win = 2;
44     return ;
45 }
46 
47 void work_B() { // 同上 
48     if(check(B[B_s])) {
49         char t = B[B_s++];
50         B[++B_e] = t;
51         while(Z[len] != t) B[++B_e] = Z[len--];
52         B[++B_e] = Z[len--];
53         who = -2;
54     }
55     else Z[++len] = B[B_s++];
56     if(B_s > B_e) 
57         Win = 1;
58     return ;
59 }
60 
61 void solve() {
62     if(who == 1) work_A();
63     else if(who == 2) work_B();
64     return ;
65 }
66 
67 int main() {
68     init();
69     while(!draw && !Win) {
70         solve();
71         if(cnt++ > 1000) draw = true; // 來來回回1q次，判定為平局 
72         if(who == 1) who = 2; // 當前是A出的牌 下次為B 
73         else if(who == 2) who = 1; // 當前是B出的牌 下次為A 
74         else if(who == -1) who = 1; // A贏牌了 還是A 
75         else if(who == -2) who = 2; // B贏牌了 還是B 
76     }
77     if(draw) cout << -1 << endl; // 平局 
78     else print(); // 非平局 輸出 
79     return 0;
80 }

9.拉馬車

10.圖形排版

小明需要在一篇文檔中加入 N 張圖片，其中第 i 張圖片的寬度是 Wi，高度是 Hi。
假設紙張的寬度是 M，小明使用的文檔編輯工具會用以下方式對圖片進行自動排版：

1. 該工具會按照圖片順序，在寬度 M 以內，將盡可能多的圖片排在一行。該行的高度是行內最高的圖片的高度。例如在 M=10 的紙張上依次打印 3x4, 2x2, 3x3 三張圖片，則效果如下圖所示，這一行高度為4。(分割線以上為列標尺，分割線以下為排版區域；數字組成的矩形為第x張圖片占用的版面)

2. 如果當前行剩余寬度大於0，並且小於下一張圖片，則下一張圖片會按比例縮放到寬度為當前行剩余寬度(高度向上取整)，然后放入當前行。例如再放入一張4x9的圖片，由於剩余寬度是2，這張圖片會被壓縮到2x5，再被放入第一行的末尾。此時該行高度為5：

3. 如果當前行剩余寬度為0，該工具會從下一行開始繼續對剩余的圖片進行排版，直到所有圖片都處理完畢。此時所有行的總高度和就是這 N 張圖片的排版高度。例如再放入11x1, 5x5, 3x4 的圖片后，效果如下圖所示，總高度為11：

現在由於排版高度過高，圖片的先后順序也不能改變，小明只好從 N 張圖片中選擇一張刪除掉以降低總高度。他希望剩余N-1張圖片按原順序的排版高度最低，你能求出最低高度是多少么？

輸入：
第一行包含兩個整數 M 和 N，分別表示紙張寬度和圖片的數量。
接下來 N 行，每行2個整數Wi, Hi，表示第 i 個圖大小為 Wi*Hi。

對於30%的數據，滿足1<=N<=1000
對於100%的數據，滿足1<=N<=100000，1<=M, Wi, Hi<=100

輸出：
一個整數，表示在刪除掉某一張圖片之后，排版高度最少能是多少。

樣例輸入：
4 3
2 2
2 3
2 2

樣例輸出：
2

另一個示例，
樣例輸入：
2 10
4 4
4 3
1 3
4 5
2 1
2 3
5 4
5 3
1 5
2 4

樣例輸出：
17

資源約定：
峰值內存消耗（含虛擬機） < 256M
CPU消耗 < 2000ms

請嚴格按要求輸出，不要畫蛇添足地打印類似：“請您輸入...” 的多余內容。

提交程序時，注意選擇所期望的語言類型和編譯器類型。

未完全理解，請參考：https://blog.csdn.net/weixin_40367307/article/details/88554037

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。