2012年蓝桥杯软件设计大赛河南省初赛试题和答案

一、微生物增殖

假设有两种微生物 X 和 Y

X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。    一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。

现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。

如果X=10，Y=90  呢？

本题的要求就是写出这两种初始条件下，60分钟后Y的数目。

题目的结果令你震惊吗？这不是简单的数字游戏！真实的生物圈有着同样脆弱的性质！也许因为你消灭的那只 Y 就是最终导致 Y 种群灭绝的最后一根稻草！

请忍住悲伤，把答案写在“解答.txt”中，不要写在这里！

View Code

 1 #include <cstdio>

 2 #include <iostream>

 3 

 4 using namespace std;

 5 

 6 /*

 7 思路：  把每分钟分成两个计数单位，这样更加容易计算

 8 输出结果：

 9     当 x = 10， y = 89时，60分钟后 x = 10485760，y = -979369984

10     当 x = 10， y = 90时，60分钟后 x = 10485760，y = 94371840

11 */

12 int main()

13 {

14     int x, y;

15     while(1)

16     {

17         printf("x = ");

18         scanf("%d", &x);

19         printf("y = ");

20         scanf("%d", &y);

21         for(int i = 1; i <= 120; ++i)

22         {

23             if(i & 1)//一个新出生的X，半分钟之后吃掉1个Y，并且，

24                y -= x;         //从此开始，每隔1分钟吃1个Y。

25             if(i % 6 == 0)  //X出生后每隔3分钟分裂一次（数目加倍）

26                 x <<= 1;

27             if(i % 4 == 0)  //Y出生后每隔2分钟分裂一次（数目加倍）

28                 y <<= 1;

29         }

30         printf("60分钟后x和y的数目分别是： %d %d\n", x, y);

31     }

32     return 0;

33 }

 

二、古堡算式

福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：

ABCDE * ? = EDCBA

他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”

华生：“我猜也是！”

于是，两人沉默了好久，还是没有算出合适的结果来。

请你利用计算机的优势，找到破解的答案。

把 ABCDE 所代表的数字写出来。

View Code

 1 #include <cstdio>

 2 #include <iostream>

 3 

 4 using namespace std;

 5 

 6 int main()

 7 {

 8     for(int i = 10000; i <= 99999; ++i)

 9     {

10         int t = i;

11         int a = t/10000;

12         t %= 10000;

13         int b = t/1000;

14         t %= 1000;

15         int c = t/100;

16         t %= 100;

17         int d = t/10;

18         int e = t%10;

19         int tmp = e * 10000 + d*1000 + c*100 + b*10 + a;

20         if(a==b || a==c || a==d || a==e || b==c || b==d || b==e || c==d || c==e || d==e)

21             continue;

22         for(int j = 1; j <= 9; ++j)

23         {

24             if(i * j == tmp)

25             {

26                 printf("ABCDE=%d\n", i);

27                 printf("?=%d\n", j);

28             }

29         }

30     }

31     system("pause");

32     return 0;

33 }

三、比酒量

    有一群海盗（不多于20人），在船上比拼酒量。过程如下：打开一瓶酒，所有在场的人平分喝下，有几个人倒下了。再打开一瓶酒平分，又有倒下的，再次重复...... 直到开了第4瓶酒，坐着的已经所剩无几，海盗船长也在其中。当第4瓶酒平分喝下后，大家都倒下了。

    等船长醒来，发现海盗船搁浅了。他在航海日志中写到：“......昨天，我正好喝了一瓶.......奉劝大家，开船不喝酒，喝酒别开船......”

    请你根据这些信息，推断开始有多少人，每一轮喝下来还剩多少人。

    如果有多个可能的答案，请列出所有答案，每个答案占一行。

    格式是：人数,人数,...

    例如,有一种可能是：20,5,4,2,0

View Code

 1 /*

 2 输出结果为：

 3     20 5 4 2 0

 4     18 9 3 2 0

 5     15 10 3 2 0

 6     12 6 4 2 0

 7 */

 8 #include <cstdio>

 9 #include <cmath>

10 #include <iostream>

11 

12 using namespace std;

13 

14 int main()

15 {

16     freopen("3-1.txt","w", stdout);

17     for(int i = 20; i > 0; --i)

18     {

19         for(int j = i-1; j > 0; --j)

20         {

21             for(int k = j-1; k > 0; --k)

22             {

23                 for(int p = k-1; p > 0; --p)

24                     if(fabs(1.0/i + 1.0/j + 1.0/k + 1.0/p - 1) < 1e-6)

25                         printf("%d %d %d %d 0\n", i, j, k, p);

26             }

27         }

28     }

29     system("pause");

30     return 0;

31 }

四、奇怪的比赛

    某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：

    每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。

    每位选手都有一个起步的分数为10分。

    某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？

    如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。例如：0010110011 就是可能的情况。

    你的任务是算出所有可能情况。每个答案占一行。

View Code

 1 /*

 2 输出答案为：

 3 0 0 1 0 1 1 0 0 1 1 

 4 0 1 1 1 0 1 0 0 0 0 

 5 1 0 1 1 0 1 0 0 0 0 

 6 */

 7 #include <cstdio>

 8 #include <cmath>

 9 #include <iostream>

10 

11 using namespace std;

12 int score;

13 int ans[11];

14 

15 void dp(int cur, int score)

16 {

17     if(cur == 11 && score == 100)

18     {

19         for(int i = 1; i <= 10; ++i)

20             printf("%d ", ans[i]);

21         printf("\n");

22         return ;    

23     }

24     if(cur >= 11)

25         return;

26 

27     score -= cur;

28     ans[cur] = 0;

29     dp(cur + 1, score);

30 

31 

32     score = (score + cur) << 1;

33     ans[cur] = 1;

34     dp(cur + 1, score);

35     

36 }

37 int main()

38 {

39     freopen("3-4.txt", "w", stdout);

40     score = 10;

41     dp(1, 10);

42     //system("pause");

43     return 0;

44 }

 

五、转方阵

    对一个方阵转置，就是把原来的行号变列号，原来的列号变行号

    例如，如下的方阵：

 1  2  3  4

 5  6  7  8

 9 10 11 12

13 14 15 16

    转置后变为：

 1  5  9 13

 2  6 10 14

 3  7 11 15

 4  8 12 16

    但，如果是对该方阵顺时针旋转（不是转置），却是如下结果：

13  9  5  1

14 10  6  2

15 11  7  3

16 12  8  4

    下面的代码实现的功能就是要把一个方阵顺时针旋转。

View Code

 1 #include <stdio.h>

 2 #include <malloc.h>

 3 

 4 /*

 5 就是将二维数组转化为一维数组

 6 根据 x[m][n] ----> y[n][rank-m-1],其中 m = i/rank,  n = i%rank

 7 */

 8 void rotate(int* x, int rank)

 9 {

10     int* y = (int*)malloc(rank * rank * sizeof(int));  // 填空

11     for(int i=0; i<rank * rank; i++)

12     {

13         y[(i%rank)*rank + rank-i/rank-1] = x[i];  // 填空

14     }

15     for(int i=0; i<rank*rank; i++)

16     {

17         x[i] = y[i];

18     }

19     free(y);

20 }

21 int main(int argc, char* argv[])

22 {

23     int x[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};

24     int rank = 4;

25     rotate(&x[0][0], rank);

26     for(int i=0; i<rank; i++)

27     {

28         for(int j=0; j<rank; j++)

29         {

30             printf("%4d", x[i][j]);

31         }

32         printf("\n");

33     }

34     system("pause");

35     return 0;

36 }

六、大数乘法

    对于32位字长的机器，大约超过20亿，用int类型就无法表示了，我们可以选择int64类型，但无论怎样扩展，固定的整数类型总是有表达的极限！如果对超级大整数进行精确运算呢？一个简单的办法是：仅仅使用现有类型，但是把大整数的运算化解为若干小整数的运算，即所谓：“分块法”。

    如图【1.jpg】表示了分块乘法的原理。可以把大数分成多段（此处为2段）小数，然后用小数的多次运算组合表示一个大数。可以根据int的承载能力规定小块的大小，比如要把int分成2段，则小块可取10000为上限值。注意，小块在进行纵向累加后，需要进行进位校正。

    以下代码示意了分块乘法的原理（乘数、被乘数都分为2段）。

View Code

 1 #include <stdio.h>

 2 #include <iostream>

 3 using namespace std;

 4 

 5 void bigmul(int x, int y, int r[])

 6 {

 7     int base = 10000;

 8     int x2 = x / base;

 9     int x1 = x % base;

10     int y2 = y / base;

11     int y1 = y % base;

12 

13     int n1 = x1 * y1;

14     int n2 = x1 * y2;

15     int n3 = x2 * y1;

16     int n4 = x2 * y2;

17 

18     r[3] = n1 % base;

19     r[2] = n1 / base + n2 % base + n3 % base;

20     r[1] = n3 / base + n2 / base + n4 % base; // 填空

21     r[0] = n4 / base;

22 

23     r[1] += r[2] / base;  // 填空

24     r[2] = r[2] % base;

25     r[0] += r[1] / base;

26     r[1] = r[1] % base;

27 }

28 int main(int argc, char* argv[])

29 {

30     int x[] = {0,0,0,0};

31     bigmul(87654321, 12345678, x);

32     printf("%d%d%d%d\n", x[0],x[1],x[2],x[3]);

33     system("pause");

34     return 0;

35 }

七、放棋子

    今有 6 x 6 的棋盘格。其中某些格子已经预先放好了棋子。现在要再放上去一些，使得：每行每列都正好有3颗棋子。我们希望推算出所有可能的放法。下面的代码就实现了这个功能。

    初始数组中，“1”表示放有棋子，“0”表示空白。

View Code

 1 #include <cstdio>

 2 #include <iostream>

 3 

 4 using namespace std;

 5 

 6 int N = 0;

 7 bool CheckStoneNum(int x[][6])

 8 {

 9     for(int k=0; k<6; k++)

10     {

11         int NumRow = 0;

12         int NumCol = 0;

13         for(int i=0; i<6; i++)

14         {

15             if(x[k][i]) NumRow++;

16             if(x[i][k]) NumCol++;

17         }

18         if(NumRow != 3 || NumCol != 3)// 填空

19             return false;

20     }

21     return true;

22 }

23 int GetRowStoneNum(int x[][6], int r)

24 {

25     int sum = 0;

26     for(int i=0; i<6; i++)     if(x[r][i]) sum++;

27     return sum;

28 }

29 int GetColStoneNum(int x[][6], int c)

30 {

31     int sum = 0;

32     for(int i=0; i<6; i++)     if(x[i][c]) sum++;

33     return sum;

34 }

35 void show(int x[][6])

36 {

37     for(int i=0; i<6; i++)

38     {

39         for(int j=0; j<6; j++) printf("%2d", x[i][j]);

40         printf("\n");

41     }

42     printf("\n");

43 }

44 void f(int x[][6], int r, int c);

45 void GoNext(int x[][6],  int r,  int c)

46 {

47     if(c<6)

48         f(x, r, c+1);   // 填空

49     else

50         f(x, r+1, 0);

51 }

52 void f(int x[][6], int r, int c)

53 {

54     if(r==6)

55     {

56         if(CheckStoneNum(x))

57         {

58             N++;

59             show(x);

60         }

61         return;

62     }

63     if(x[r][c])  // 填空------已经放有了棋子

64     {

65         GoNext(x,r,c);

66         return;

67     }

68     int rr = GetRowStoneNum(x,r);

69     int cc = GetColStoneNum(x,c);

70     if(cc>=3)  // 本列已满

71         GoNext(x,r,c);

72     else if(rr>=3)  // 本行已满

73         f(x, r+1, 0);

74     else

75     {

76         x[r][c] = 1;

77         GoNext(x,r,c);

78         x[r][c] = 0;

79         if(!(3-rr >= 6-c || 3-cc >= 6-r))  // 本行或本列严重缺子，则本格不能空着！

80             GoNext(x,r,c);

81     }

82 }

83 int main(int argc, char* argv[])

84 {

85     int x[6][6] = {

86         {1,0,0,0,0,0},

87         {0,0,1,0,1,0},

88         {0,0,1,1,0,1},

89         {0,1,0,0,1,0},

90         {0,0,0,1,0,0},

91         {1,0,1,0,0,1}

92     };

93     f(x, 0, 0);

94     printf("%d\n", N);

95     system("pause");

96     return 0;

97 }

八、密码发生器

    在对银行账户等重要权限设置密码的时候，我们常常遇到这样的烦恼：如果为了好记用生日吧，容易被破解，不安全；如果设置不好记的密码，又担心自己也会忘记；如果写在纸上，担心纸张被别人发现或弄丢了...

    这个程序的任务就是把一串拼音字母转换为6位数字（密码）。我们可以使用任何好记的拼音串(比如名字，王喜明，就写：wangximing)作为输入，程序输出6位数字。

    变换的过程如下：

    第一步. 把字符串6个一组折叠起来，比如wangximing则变为：

    wangxi

    ming

    第二步. 把所有垂直在同一个位置的字符的ascii码值相加，得出6个数字，如上面的例子，则得出：

    228 202 220 206 120 105

    第三步. 再把每个数字“缩位”处理：就是把每个位的数字相加，得出的数字如果不是一位数字，就再缩位，直到变成一位数字为止。例如: 228 => 2+2+8=12 => 1+2=3

    上面的数字缩位后变为：344836, 这就是程序最终的输出结果！

    要求程序从标准输入接收数据，在标准输出上输出结果。

    输入格式为：第一行是一个整数n（<100），表示下边有多少输入行，接下来是n行字符串，就是等待变换的字符串。

    输出格式为：n行变换后的6位密码。

    例如，输入：

5

zhangfeng

wangximing

jiujingfazi

woaibeijingtiananmen

haohaoxuexi

    则输出：

772243

344836

297332

716652

875843

    注意：

    请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！   

    在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

    请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。   

    相关的工程文件不要拷入。   

    源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。   

    允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。

View Code

 1 #include <cstdio>

 2 #include <iostream>

 3 

 4 using namespace std;

 5 

 6 char s1[100];

 7 int s2[100][6];

 8 int ans[100];

 9 

10 int change(int num)

11 {

12     int tmp = 0;

13     if(num < 10)

14         return num;

15     while(num)

16     {

17         tmp += num%10;

18         num /= 10;

19     }

20     return change(tmp);

21 }

22 

23 int main()

24 {

25     int T;

26     scanf("%d", &T);

27     while(T--)

28     {

29         memset(s2, 0, sizeof(s2));

30         memset(ans, 0, sizeof(ans));

31         scanf("%s", s1);

32         int len = strlen(s1);

33         for(int i =0, j = 0; i < len; ++i)

34             s2[i/6][i%6] = s1[i];

35         for(int i = 0; i < 6; ++i)

36         {

37             for(int j = 0; j <= len/6; ++j)

38                 ans[i] += s2[j][i];

39         }

40         for(int i = 0; i < 6; ++i)

41             printf("%d", change(ans[i]));

42         printf("\n");

43     }

44     return 0;

45 }

九、夺冠概率

    足球比赛具有一定程度的偶然性，弱队也有战胜强队的可能。

    假设有甲、乙、丙、丁四个球队。根据他们过去比赛的成绩，得出每个队与另一个队对阵时取胜的概率表:

    甲  乙  丙  丁  

甲   -  0.1 0.3 0.5

乙 0.9  -   0.7 0.4

丙 0.7  0.3 -   0.2

丁 0.5  0.6 0.8 -

    数据含义：甲对乙的取胜概率为0.1，丙对乙的胜率为0.3，...

    现在要举行一次锦标赛。双方抽签，分两个组比，获胜的两个队再争夺冠军。（参见【1.jpg】）

请你进行10万次模拟，计算出甲队夺冠的概率。

 

    注意：

    请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！   

    在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

    请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。   

    相关的工程文件不要拷入。   

    源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。   

    允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。

解析：

　　这道题没读懂到底模拟你什么意思，是让随机产生10万个分组然后计算甲胜的概率？？？

其实可以用公式推导出概率公式的

十、取球游戏

    今盒子里有n个小球，A、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。

    我们约定：   

    每个人从盒子中取出的球的数目必须是：1，3，7或者8个。

    轮到某一方取球时不能弃权！

    A先取球，然后双方交替取球，直到取完。

    被迫拿到最后一个球的一方为负方（输方）

    请编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？

    程序运行时，从标准输入获得数据，其格式如下：

    先是一个整数n(n<100)，表示接下来有n个整数。然后是n个整数，每个占一行（整数<10000），表示初始球数。

    程序则输出n行，表示A的输赢情况（输为0，赢为1）。

    例如，用户输入：

４

１

２

10

18

 

    则程序应该输出：

0

1

1

0

 

    注意：

    请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

    在评卷时使用的输入数据与试卷中给出的实例数据可能是不同的。

    请把所有函数写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

    相关的工程文件不要拷入。   

    源代码中不能能使用诸如绘图、Win32API、中断调用、硬件操作或与操作系统相关的API。   

    允许使用STL类库，但不能使用MFC或ATL等非ANSI c++标准的类库。例如，不能使用CString类型（属于MFC类库）。

 代码一： 不知道这种思路对不对

View Code

 1 #include <cstdio>

 2 #include <iostream>

 3 

 4 using namespace std;

 5 

 6 int a[10005];

 7 

 8 // a[i] = 1 表示先手必赢， a[i] = 0表示输

 9 void fun()

10 {

11     for(int i = 1; i <= 10000; ++i)

12     {

13         if(a[i] == 0)

14         {

15             a[i+1] = 1;

16             a[i+3] = 1;

17             a[i+7] = 1;

18             a[i+8] = 1;

19         }

20     }

21 }

22 

23 int main()

24 {

25     int n, num;

26     memset(a, 0, sizeof(a));

27     fun();

28     scanf("%d", &n);

29     while(n--)

30     {

31         scanf("%d", &num);

32         printf("%d\n", a[num]);

33     }

34     return 0;

35 }

代码二：  网上找的，没看太懂

View Code

 1 #include <cstdio>

 2 #include <cstring>

 3 const int nMax=10010;

 4 int g[nMax];

 5 int p[]={1,3,7,8};

 6 int sg(int a)

 7 {

 8     if(g[a]!=-1) return g[a];

 9     int is[5];

10     memset(is,0,sizeof(is));

11     for(int i=0;i<4 && p[i]<a;i++)

12         is[sg(a-p[i])]=1;

13     int i=0;

14     for(;i<4;i++)

15         if(!is[i])

16             break;

17     return g[a]=i;

18 }

19 int main()

20 {

21     freopen("f://data.in","r",stdin);

22     int n;

23     scanf("%d",&n);

24     memset(g,-1,sizeof(g));

25     g[1]=0;

26     while(n--)

27     {

28         int a;

29         scanf("%d",&a);

30         printf("%d\n",sg(a)==0?0:1);

31     }

32     return 0;

33 }

 代码三：网上找的

View Code

 1 #include <stdio.h> 

 2 #include <string.h> 

 3 int a[10001];  

 4 int b[4] = {1, 3, 7, 8}; 

 5 int main()  

 6 { 

 7     int i,n, j;  

 8     freopen("2.out", "w", stdout); 

 9     memset(a,0, sizeof a);//初始化判定数组为0     

10     a[0]=1;//说明对方取完了最后一堆，那么自己胜利 

11     for(i=1;i<=10000;i++)  

12         for(j=0; j<4; j++)if(i-b[j]>=0) 

13         { 

14             if(a[i-b[j]]==0)//有取法能致使对方输，那么自己就要赢 

15             { 

16                 a[i]=1; 

17                 break; 

18             } 

19         } 

20     for(int k=0; k<=20; k++) 

21     printf("%d:%d\n", k, a[k]); 

22         scanf("%d",&n);  

23         while(n--)  

24         { 

25             scanf("%d",&i);  

26             printf("%d\n", a[i]);//直接输出即可，不需要存储下来统一输出，PS:ACM里都是这样处理的。 

27         } 

28     return 0; 

29 } 

30   

31 /*算出部分结果如下： 

32 石头个数：胜利情况 

33 0:1 

34 1:0 

35 2:1 

36 3:0 

37 4:1 

38 5:0 

39 6:1 

40 7:0 

41 8:1 

42 9:1 

43 10:1 

44 11:1 

45 12:1 

46 13:1 

47 14:1 

48 15:1 

49 16:0 

50 17:1 

51 18:0 

52 19:1 

53 20:0 

 

 一些比赛模拟题摘录：

某游戏规则中，甲乙双方每个回合的战斗总是有一方胜利，一方失败。游戏规定：失败的一方要把自己的体力值的1/4加给胜利的一方。例如：如果双方体力值当前都是4，则经过一轮战斗后，双方的体力值会变为：5，3。

现在已知：双方开始时的体力值甲：1000，乙：2000。

假设战斗中，甲乙获胜的概率都是50%

求解：双方经过4个回合的战斗，体力值之差小于1000的理论概率。

代码一： 因为概率都是0.5，所以不用过多考虑概率问题。

View Code

 1 #include <cstdio>

 2 #include <cmath>

 3 #include <iostream>

 4 

 5 using namespace std;

 6 

 7 double a, b;

 8 int cnt, sum;

 9 

10 void fight(double na, double nb, int cur)

11 {

12     if(cur == 4)

13     {

14         if(fabs(na - nb) < 1000)

15             ++cnt;

16         ++sum;

17         return;

18     }

19     fight(a * 0.75, b += 0.25*a, cur+1);

20     fight(a += b*0.25, b*0.75, cur+1);

21 }

22 

23 int main()

24 {

25     a = 1000;

26     b = 2000;

27     cnt = sum = 0;

28     fight(a, b, 0);

29     printf("sum = %d\ncnt = %d\n", sum, cnt);

30     printf("%.1lf%%", 100.0*cnt/sum);

31     return 0;

32 }

代码二： 函数中加入概率计算：

View Code

 1 #include<stdio.h>

 2 #include<math.h>

 3 #define N 4

 4 double p=0.5;//p表示甲赢的概率是0.5

 5 

 6 double fun(double x, double y, int cur, double k) {

 7     double sum=0;

 8     if(cur==N) {

 9         if(fabs(x-y)<1000)

10             sum+=k;

11         return sum;

12     }

13     sum+=fun(x-x/4,y+x/4,cur+1,k*(1-p));//甲输掉比赛

14     sum+=fun(x+y/4,y-y/4,cur+1,k*p);

15     return sum;

16 }

17 int main() {

18     printf("%lf\n",fun(1000,2000,0,1));

19     return 0;

20 }