2017年省赛c组

最新推荐文章于 2021-11-23 20:18:53 发布

zx428621

最新推荐文章于 2021-11-23 20:18:53 发布

阅读量739

点赞数

分类专栏：蓝桥杯真题文章标签：算法

本文链接：https://blog.csdn.net/zx428621/article/details/108934493

版权

贪心算法组合优化背包问题资源分配调度

关键词由CSDN通过智能技术生成

蓝桥杯真题专栏收录该内容

24 篇文章 21 订阅

订阅专栏

A 贪吃蛇长度

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

小明在爷爷的私人收藏馆里找到一台老式电脑。居然没有图形界面，只能用控制台编程。

经过小明的一阵摸索，神奇地设计出了控制台上的贪食蛇游戏。

如上图，是游戏时画面截图。

其中，H表示蛇头，T表示蛇尾。#表示蛇的身体，@表示身体交叉重叠的地方。

你能说出现在的贪吃蛇长度是多少吗？

其实，只要数出#的数目算1，数出@的数目，算2，再加上头尾各算1就计算好了。

人工数一下？太累眼睛了，聪明的你为什么不让计算机帮忙呢？

本题的要求就是：请填写上图中贪食蛇的长度是多少？

注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

注意：cin.get()函数可以读取换行符。

参考代码(暴力解题)

#include<bits/stdc++.h>
using namespace std;
int main()
{
	char c;
	int count=0;
	while(cin.get(c))
	{
		if(c=='#')
			count++;
		if(c=='@')
			count=count+2; 
	}
	printf("%d",count+2);
	return 0;
}

B 兴趣小组

兴趣小组

为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组

（以下称A组，B组，C组）。

每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。

每个文件中存储的是学生的学号。

由于工作需要，我们现在想知道：

既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？

请你统计该数字并通过浏览器提交答案。

A.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,

B.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,

C.txt

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,

注意：可以直接读取，该代码直接复制粘贴了，因为有逗号隔开，可以直接给数组赋值。

参考代码(暴力解决)

#include<bits/stdc++.h>
using namespace std;
long long b[100000000]={0};
long long c[100000000]={0};
int main()
{
	long long A[200]={12894792, 92774113, 59529208, 22962224, 2991600, 83340521, 87365045, 
				40818286, 16400628, 39475245, 55933381, 76940287, 61366748, 95631228, 
				17102313, 50682833, 61562613, 87002524, 83062019, 51743442, 61977890, 
				32010762, 69680621, 87179571, 81761697, 32364296, 7833271, 36198035, 
				26588918, 84046668, 43059468, 73191775, 56794101, 454780, 11141030, 
				10008994, 35072237, 44945158, 53959980, 75758119, 18560273, 35801494, 
				42102550, 22496415, 3981786, 34593672, 13074905, 07733442, 42374678, 
				23452507, 98586743, 30771281, 17703080, 52123562, 5898131, 56698981, 
				90758589, 18238802, 18217979, 4511837, 75682969, 31135682, 55379006, 
				42224598, 98263070, 40228312, 28924663, 11580163, 25686441, 45944028, 
				96731602, 53675990, 3854194, 14858183, 16866794, 40677007, 73141512, 
				32317341, 56641725, 43123040, 15201174, 62389950, 72887083, 76860787, 
				61046319, 6923746, 17874548, 46028629, 10577743, 48747364, 5328780, 
				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, 9683688, 58218284, 46792829, 97221709, 45286643, 
				48158629, 57367208, 26903401, 76900414, 87927040, 9926730, 1508757, 
				15101101, 62491840, 43802529};
	long long B[300]={
		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, 3981786, 81541612, 07346443, 93154608, 19709455, 37446968, 
		17703080, 72378958, 66200696, 30610382, 89586343, 33152171, 67040930, 
		35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 1418023, 
		74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626, 
		01673442, 70548494, 13638168, 8163691, 11106566, 64375392, 40267902, 
		897705, 56447313, 54532235, 94738425, 66642634, 83219544, 40546096, 
		66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091, 
		8487641, 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, 9683688, 67082008, 71605255, 
		80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980, 
		48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892, 
		18926791, 40818286, 28936302, 11489524, 51031183, 73860337, 13241219, 
		9025448, 10718828, 76360986, 26031606, 76558053, 97726139, 46473415, 
		48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237, 
		8602486, 29815841, 56562216, 77684187, 81751704, 20160464, 50407962, 
		27786415, 19893526, 934129, 37759498, 52636463, 25666982, 43262852, 
		38393436, 2581136, 29323250, 56950657, 5898131, 95286262, 75574581, 
		54057961, 6703896, 90758589, 57782642, 34492535, 41919697, 6395464, 
		10993500, 81212949, 34017532, 69569396, 99009936, 57129610, 67401593, 
		71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544, 
		30433724, 53127345, 72887083, 25390873, 63711546, 6923746, 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, 5427896, 
		14444084, 36795868, 18079449, 59653393, 72942548, 06763077, 33895610, 
		94892653, 12085268, 65174140, 79567366, 23020126, 74290047, 13498869, 
		21696323, 27724594, 54941003, 38229841, 7050068};
	for(int i=0;i<250;i++)
		b[B[i]]=1;
	long long C[300]={13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555, 
				17102313, 47079425, 50682833, 74154313, 61562613, 93200452, 37103342, 
				18479435, 32502597, 36198035, 54210010, 73191775, 48358178, 85544503, 
				5996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041, 
				65899605, 56528700, 82671109, 61176034, 42374678, 51612628, 63329997, 
				56591652, 04552733, 12789324, 89586343, 51935014, 38611966, 43916409, 
				70996050, 98263070, 1418023, 65345049, 21734275, 76846198, 71506230, 
				833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325, 
				9386162, 95324041, 80688223, 67629139, 79552617, 76219736, 50368644, 
				45096021, 54972488, 63779011, 28862942, 73145521, 74078605, 66924991, 
				12806850, 02171001, 70896866, 73434467, 8487641, 44415025, 32500082, 
				84412833, 83896188, 52243759, 49191410, 38744339, 48079796, 44937032, 
				06267501, 81866886, 38575984, 25978688, 78974338, 41247821, 12356966, 
				64842303, 79127158, 2366944, 68000570, 12426275, 96409230, 705972, 
				8266503, 83820884, 8831807, 43273308, 23216105, 29196547, 95160161, 
				05553537, 52182214, 32641346, 91553427, 24436506, 77433749, 1979664, 
				52028151, 88985343, 1761499, 76203088, 63237368, 23405334, 59788467, 
				9683688, 67755443, 29946533, 12053603, 437479, 15200030, 45286643, 
				93537527, 82465821, 57367208, 53899751, 15354933, 97760830, 68933762, 
				80220545, 1892750, 39868288, 21524323, 69716610, 65083815, 78048499, 
				3227391, 83340521, 87365045, 71720254, 51031183, 89168555, 8503028, 
				37086236, 25103057, 87002524, 22808816, 80928090, 90741678, 15993372, 
				99117082, 49938176, 21755083, 86903426, 87830263, 53959980, 75758119, 
				59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608, 
				44882734, 90758589, 8075999, 66303819, 23480347, 11580163, 87080118, 
				18329165, 92514163, 89404632, 92377859, 3912329, 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, 9926730, 27724594, 95148523, 20503000, 64390907, 26006953, 
				98116293, 97457666, 29017396, 04634371, 70791589};
	for(int i=0;i<250;i++)
		c[C[i]]=1;
	int count=0;
	for(int i=0;i<150;i++)
	{
		//printf("%lld\n",A[i]);
		//printf("b[i]=%d,c[i]=%d\n",b[A[i]],c[A[i]]);
		if(b[A[i]]==1&&c[A[i]]==0)
			count++;
	}
	printf("%d\n",count); 
	return 0;
}

C 算式900

小明的作业本上有道思考题：

看下面的算式：

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

其中的小方块代表0_{9的数字，这10个方块刚好包含了0}9中的所有数字。

注意：0不能作为某个数字的首位。

小明经过几天的努力，终于做出了答案！如下：

(5012-4987)*36=900

用计算机搜索后，发现还有另外一个解，本题的任务就是：请你算出这另外的一个解。

我的代码（全排列解题）:

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int a[10]={0,1,2,3,4,5,6,7,8,9};
	do
	{
		int A=a[0]*1000+a[1]*100+a[2]*10+a[3];
		int B=a[4]*1000+a[5]*100+a[6]*10+a[7];
		int C=a[8]*10+a[9];
		if((A-B)*C==900)
		{
			printf("(%d-%d)*%d=900\n",A,B,C);
		}
	}while(next_permutation(a,a+10)); 
	return 0;
}

D 承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。

金属材料被严格地堆放成金字塔形。

	                             7 
	                            5 8 
	                           7 8 8 
	                          9 2 7 2 
	                         8 1 4 9 1 
	                        8 1 8 8 4 1 
	                       7 9 6 1 4 5 4 
	                      5 6 5 5 6 9 5 6 
	                     5 5 4 7 9 3 5 5 1 
	                    7 5 7 9 7 4 7 3 3 1 
	                   4 6 4 5 5 8 8 3 2 4 3 
	                  1 1 3 3 1 6 6 5 5 4 4 2 
	                 9 9 9 2 1 9 1 9 2 9 5 7 9 
	                4 3 3 7 7 9 3 6 1 3 8 8 3 7 
	               3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
	              8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
	             8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
	            2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 
	           7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 
	          9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 
	         5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 
	        6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 
	       2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 
	      7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 
	     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 
	    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 
	   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 
	  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 
	 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 
    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

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

参考代码:

#include<bits/stdc++.h>
using namespace std;
int main()
{
	double a[35][35];
	for(int i=0;i<29;i++)
		for(int j=0;j<=i;j++)
			scanf("%lf",&a[i][j]);	
	for(int i=0;i<30;i++)
	{
		for(int j=0;j<=i;j++)
		{
			a[i+1][j]=a[i+1][j]+a[i][j]/2.0;
			a[i+1][j+1]=a[i+1][j+1]+a[i][j]/2.0;
		}
	}
	double max=a[29][0],min=a[29][0];
	for(int i=0;i<30;i++)
	{
		if(a[29][i]>max)
			max=a[29][i];
		if(a[29][i]<min)
			min=a[29][i];
	}
	printf("%.0f\n",2086458231.0/min*max);// 该处注意成比例。
	return 0;
}

E 杨辉三角

杨辉三角也叫帕斯卡三角，在很多数量关系中可以看到，十分重要。

第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

直观地看，需要开辟一个二维数组，其实一维数组也可以胜任。

如下程序就是用一维数组“腾挪”的解法。

// 杨辉三角的第row行，第col列 
long long f(int row, int col){
	if(row<2) return 1;
	if(col==0) return 1;
	if(col==row) return 1;
	
	long long a[1024];
	a[0]=1;
	a[1]=1;	
	int p = 2;
	int q;
	
	while(p<=row){
		a[p] = 1;
		for( _________________ ) a[q] = a[q] + a[q-1]; //填空
		p++;
	}
	
	return a[col];
}

int main()
{
	printf("%d\n", f(6,2));
	printf("%d\n", f(6,3));
	printf("%lld\n", f(40,20));	
	return 0;
}

注意:

1.a[q]表示一行。

2.必须逆序。

完整代码

#include<bits/stdc++.h>
using namespace std;
long long f(int row, int col){
	if(row<2) return 1;
	if(col==0) return 1;
	if(col==row) return 1;
	
	long long a[1024];
	a[0]=1;
	a[1]=1;	
	int p = 2;
	int q;
	
	while(p<=row)
	{
		a[p] = 1;
		for( q=p-1;q>=1;q--) a[q] = a[q] + a[q-1]; //填空
		p++;
	}
	
	return a[col];
}

int main()
{
	printf("%d\n", f(6,2));
	printf("%d\n", f(6,3));
	printf("%lld\n", f(40,20));	
	return 0;
}

F 最大公共子串

刷题链接: link.

最大公共子串长度问题就是：

求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”，

可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

#include <stdio.h>
#include <string.h>

#define N 256
int f(const char* s1, const char* s2)
{
	int a[N][N];
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int i,j;
	
	memset(a,0,sizeof(int)*N*N);
	int max = 0;
	for(i=1; i<=len1; i++){
		for(j=1; j<=len2; j++){
			if(s1[i-1]==s2[j-1]) {
				a[i][j] = __________________________;  //填空
				if(a[i][j] > max) max = a[i][j];
			}
		}
	}
	
	return max;
}

完整代码:

#include <stdio.h>
#include <string.h>

#define N 256
int f(const char* s1, const char* s2)
{
	int a[N][N];
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int i,j;
	
	memset(a,0,sizeof(int)*N*N);
	int max = 0;
	for(i=1; i<=len1; i++)
	{
		for(j=1; j<=len2; j++)
		{
			if(s1[i-1]==s2[j-1]) 
			{
				a[i][j] = a[i-1][j-1]+1;  //填空
				if(a[i][j] > max) max = a[i][j];
			}
		}
	}

G Excel地址

Excel单元格的地址表示很有趣，它使用字母来表示列号。

比如，

A表示第1列，
B表示第2列，
Z表示第26列，
AA表示第27列，
AB表示第28列，
BA表示第53列，
....

当然Excel的最大列号是有限度的，所以转换起来不难。

如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。

例如，
输入：
26
则程序应该输出：
Z

再例如，
输入：
2054
则程序应该输出：
BZZ

参考代码:

#include<bits/stdc++.h>
using namespace std;
char a[100];
int main()
{
	int n;
	scanf("%d",&n);
	int t=n;
	int count=0;
	while(t>0)
	{
		a[count++]='A'+(t-1)%26;
		t=(t-(t-1)%26-1)/26;
	}
	for(int i=count-1;i>=0;i--)
		printf("%c",a[i]);
	return 0;
}

H 九宫幻方

刷题链接: link.

小明最近在教邻居家的小朋友小学奥数，而最近正好讲述到了三阶幻方这个部分，三阶幻方指的是将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

思路:（全排列）

我的代码：

#include<bits/stdc++.h>
using namespace std;
int main()
{
	//a为输入数组，temp为存储答案的数组，c为需要全排列数字的数组。 
	int a[10],temp[10],c[10];
	bool b[10]={false};
	int len=0,count=0;
	for(int i=0;i<9;i++)
	{
		scanf("%d",&a[i]);
		if(a[i]!=0)
			b[a[i]]=true;	
	}
	for(int i=1;i<10;i++)
		if(b[i]==false)
			c[len++]=i;
	sort(c,c+len);
	do
	{
		int L=0;
		for(int i=0;i<9;i++)
			if(b[a[i]]==0)
				a[i]=c[L++];
		int l1=a[0]+a[1]+a[2];
		int l2=a[3]+a[4]+a[5];
		int l3=a[6]+a[7]+a[8];
		int l4=a[0]+a[3]+a[6];
		int l5=a[1]+a[4]+a[7];
		int l6=a[2]+a[5]+a[8];
		int l7=a[0]+a[4]+a[8];
		int l8=a[2]+a[4]+a[6];
		if(l1==l2&&l2==l3&&l3==l4&&l4==l5&&l5==l6&&l6==l7&&l7==l8)
		{
			count++;
			if(count>=2)
			{
				printf("Too Many");
				return 0;
			}
			for(int i=0;i<9;i++)
				temp[i]=a[i];
		}
	}while(next_permutation(c,c+len));
	for(int i=0;i<9;i++)
	{
		if((i+1)%3==0)
			printf("%d\n",temp[i]);
		else
			printf("%d ",temp[i]);
	} 
	return 0;
}

思路（暴力枚举）

我的代码:

#include<bits/stdc++.h>
using namespace std;
int main()
{ 
	int b[9],temp,count=0;
	int a[8][9]={
	{4,9,2,3,5,7,8,1,6},
	{2,9,4,7,5,3,6,1,8},
	{8,1,6,3,5,7,4,9,2},
	{6,1,8,7,5,3,2,9,4},
	{4,3,8,9,5,1,2,7,6},
	{8,3,4,1,5,9,6,7,2},
	{2,7,6,9,5,1,4,3,8},
	{6,7,2,1,5,9,8,3,4}};
	for(int i=0;i<9;i++)
		scanf("%d",&b[i]);
	for(int i=0;i<8;i++)
	{
		int j;
		for(j=0;j<9;j++)
		{
			if(b[j]!=a[i][j]&&b[j]!=0)
				break;
		}
		if(j==9)
		{
			temp=i;
			count++;	
		}
		if(count>1)
		{
			printf("Too Many");
			return 0;
		}	
	}
	for(int i=0;i<9;i++)
	{
		if((i+1)%3==0)
			printf("%d\n",a[temp][i]);
		else
			printf("%d ",a[temp][i]);
	}
	return 0;
}

I 拉马车（该题暂时还不会做。。）

刷题链接: link.

小的时候，你玩过纸牌游戏吗？

有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。

其规则简述如下：

假设参加游戏的小朋友是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

思路:

参考代码:

#include <bits/stdc++.h>
using namespace std;
int main()
{
	return 0;
}

J 图形排版（该题暂时还不会做。。）

刷题链接: link.

小明需要在一篇文档中加入 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

思路:

参考代码:

#include <bits/stdc++.h>
using namespace std;
int main()
{
	return 0;
}

zx428621

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

2017年省赛c组

A 贪吃蛇长度

小明在爷爷的私人收藏馆里找到一台老式电脑。居然没有图形界面，只能用控制台编程。

经过小明的一阵摸索，神奇地设计出了控制台上的贪食蛇游戏。

如上图，是游戏时画面截图。

其中，H表示蛇头，T表示蛇尾。#表示蛇的身体，@表示身体交叉重叠的地方。

你能说出现在的贪吃蛇长度是多少吗？

其实，只要数出#的数目算1，数出@的数目，算2，再加上头尾各算1就计算好了。

人工数一下？太累眼睛了，聪明的你为什么不让计算机帮忙呢？

本题的要求就是： 请填写上图中贪食蛇的长度是多少？

注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

注意：cin.get()函数可以读取换行符。

参考代码(暴力解题)

B 兴趣小组

兴趣小组

为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组

（以下称A组，B组，C组）。

每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。

每个文件中存储的是学生的学号。

由于工作需要，我们现在想知道：

既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？

请你统计该数字并通过浏览器提交答案。

A.txt

B.txt

C.txt

注意：可以直接读取，该代码直接复制粘贴了，因为有逗号隔开，可以直接给数组赋值。

参考代码(暴力解决)

C 算式900

小明的作业本上有道思考题：

看下面的算式：

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

其中的小方块代表09的数字，这10个方块刚好包含了09中的所有数字。

注意：0不能作为某个数字的首位。

小明经过几天的努力，终于做出了答案！如下：

用计算机搜索后，发现还有另外一个解，本题的任务就是：请你算出这另外的一个解。

我的代码（全排列解题）:

D 承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。

金属材料被严格地堆放成金字塔形。

其中的数字代表金属块的重量（计量单位较大）。

最下一层的X代表30台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，

最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。

电子秤的计量单位很小，所以显示的数字很大。

工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

参考代码:

E 杨辉三角

杨辉三角也叫帕斯卡三角，在很多数量关系中可以看到，十分重要。

两边的元素都是1， 中间的元素是左上角的元素与右上角的元素和。

我们约定，行号，列号都从0计数。

所以： 第6行的第2个元素是15，第3个元素是20

直观地看，需要开辟一个二维数组，其实一维数组也可以胜任。

如下程序就是用一维数组“腾挪”的解法。

注意:

1.a[q]表示一行。

2.必须逆序。

完整代码

F 最大公共子串

最大公共子串长度问题就是：

求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”，

可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

完整代码:

G Excel地址

Excel单元格的地址表示很有趣，它使用字母来表示列号。

比如，

当然Excel的最大列号是有限度的，所以转换起来不难。

如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。

参考代码:

H 九宫幻方

小明最近在教邻居家的小朋友小学奥数，而最近正好讲述到了三阶幻方这个部分，三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中，使得每一行、每一列和每一条对角线的和都是相同的。

三阶幻方又被称作九宫格，在小学奥数里有一句非常有名的口诀：“二四为肩，六八为足，左三右七，戴九履一，五居其中”，通过这样的一句口诀就能够非常完美的构造出一个九宫格来。

而你呢，也被小明交付了同样的任务，但是不同的是，你需要写一个程序~

思路:（全排列）

本题的要求就是：请填写上图中贪食蛇的长度是多少？

其中的小方块代表0_{9的数字，这10个方块刚好包含了0}9中的所有数字。

两边的元素都是1，中间的元素是左上角的元素与右上角的元素和。

所以：第6行的第2个元素是15，第3个元素是20