• C语言经典算法100例（三）

    1.河内之塔

    说明河内之塔(Towers of Hanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的，河内为越战时北越的首都，即现在的胡志明市；1883年法国数学家 Edouard Lucas曾提及这个故事，据说创世纪时Benares有一座波罗教塔，是由三支钻石棒（Pag）所支撑，开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘（Disc），并命令僧侣将所有的金盘从第一根石棒移至第三根石棒，且搬运过程中遵守大盘子在小盘子之下的原则，若每日仅搬一个盘子，则当盘子全数搬运完毕之时，此塔将毁损，而也就是世界末日来临之时。

    解法如果柱子标为ABC，要由A搬至C，在只有一个盘子时，就将它直接搬至C，当有两个盘子，就将B当作辅助柱。如果盘数超过2个，将第三个以下的盘子遮起来，就很简单了，每次处理两个盘子，也就是：A->B、A ->C、B->C这三个步骤，而被遮住的部份，其实就是进入程式的递回处理。事实上，若有n个盘子，则移动完毕所需之次数为2^n - 1，所以当盘数为64时，则所需次数为：264- 1 = 18446744073709551615为5.05390248594782e+16年，也就是约5000世纪，如果对这数字没什幺概念，就假设每秒钟搬一个盘子好了，也要约5850亿年左右。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">/************************************************************************/  
    2. /* 汉诺塔问题                                                           */  
    3. /************************************************************************/  
    4. void Hanoi(int n,char A,char B,char C)  
    5. {  
    6.     if(n == 1)  
    7.     {  
    8.         printf("Move sheet %d from %c to %c  ",n,A,C);  
    9.     }  
    10.     else  
    11.     {  
    12.         Hanoi(n-1,A,C,B);  
    13.         printf("Move sheet %d from %c to %c  ",n,A,B);  
    14.         Hanoi(n-1,B,A,C);  
    15.     }  
    16. }</span>  

    运行结果：

    2. 费式数列

    说明

    Fibonacci为1200年代的欧洲数学家，在他的着作中曾经提到：「若有一只免子每个月生一只小免子，一个月后小免子也开始生产。起初只有一只免子，一个月后就有两只免子，二个月后有三只免子，三个月后有五只免子（小免子投入生产）......。

    如果不太理解这个例子的话，举个图就知道了，注意新生的小免子需一个月成长期才会投入生产，类似的道理也可以用于植物的生长，这就是Fibonacci数列，一般习惯称之为费氏数列，例如以下： 1、1 、2、3、5、8、13、21、34、55、89......

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">/************************************************************************/  
    2. /* fibonacci数列                                                                  */  
    3. /************************************************************************/  
    4. void fibonacci()  
    5. {  
    6.     int Fib[N] = {0};  
    7.     int i = 0;  
    8.     Fib[0] = 0;  
    9.     Fib[1] = 1;  
    10.   
    11.     for(i = 2; i < N; i++)  
    12.         Fib[i] = Fib[i-1] + Fib[i-2];  
    13.       
    14.     for(i = 1; i < N; i++)  
    15.         printf("%d ",Fib[i]);  
    16.     printf(" ");  
    17. }</span>  

    3. 字串核对

    说明今日的一些高阶程式语言对于字串的处理支援越来越强大（例如Java、Perl等），不过字串搜寻本身仍是个值得探讨的课题，在这边以Boyer- Moore法来说明如何进行字串说明，这个方法快且原理简洁易懂。

    解法字串搜寻本身不难，使用暴力法也可以求解，但如何快速搜寻字串就不简单了，传统的字串搜寻是从关键字与字串的开头开始比对，例如Knuth-Morris-Pratt演算法字串搜寻，这个方法也不错，不过要花时间在公式计算上；Boyer-Moore字串核对改由关键字的后面开始核对字串，并制作前进表，如果比对不符合则依前进表中的值前进至下一个核对处，假设是p好了，然后比对字串中p-n+1至p的值是否与关键字相同。

    如果关键字中有重复出现的字元，则前进值就会有两个以上的值，此时则取前进值较小的值，如此就不会跳过可能的位置，例如texture这个关键字，t的前进值应该取后面的3而不是取前面的7。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2. #include <stdlib.h>   
    3. #include <string.h>   
    4.   
    5. void table(char*); // 建立前进表   
    6. int search(int, char*, char*); // 搜寻关键字   
    7. void substring(char*, char*, int, int); // 取出子字串   
    8.   
    9. int skip[256];   
    10.   
    11. int main(void) {   
    12. char str_input[80];   
    13. char str_key[80];   
    14. char tmp[80] = {''};   
    15. int m, n, p;   
    16. printf("请输入字串：");   
    17. gets(str_input);   
    18. printf("请输入搜寻关键字：");   
    19. gets(str_key);   
    20. m = strlen(str_input); // 计算字串长度   
    21. n = strlen(str_key);   
    22. table(str_key);   
    23. p = search(n-1, str_input, str_key);   
    24.   
    25. while(p != -1) {   
    26. substring(str_input, tmp, p, m);   
    27. printf("%s ", tmp);   
    28. p = search(p+n+1, str_input, str_key);   
    29. }   
    30.   
    31. printf(" ");   
    32. return 0;   
    33. }   
    34.   
    35. void table(char *key) {   
    36. int k, n;   
    37. n = strlen(key);   
    38. for(k = 0; k <= 255; k++)   
    39. skip[k] = n;   
    40. for(k = 0; k < n - 1; k++)   
    41. skip[key[k]] = n - k - 1;   
    42. }   
    43.   
    44. int search(int p, char* input, char* key) {   
    45. int i, m, n;   
    46. char tmp[80] = {''};   
    47. m = strlen(input);   
    48. n = strlen(key);   
    49.   
    50. while(p < m) {   
    51. substring(input, tmp, p-n+1, p);   
    52. if(!strcmp(tmp, key)) // 比较两字串是否相同   
    53. return p-n+1;   
    54. p += skip[input[p]];   
    55. }   
    56. return -1;   
    57. }   
    58.   
    59. void substring(char *text, char* tmp, int s, int e) {   
    60. int i, j;   
    61. for(i = s, j = 0; i <= e; i++, j++)   
    62.     mp[j] = text[i];   
    63. tmp[j] = '';   
    64. }  
    65. </span>  

     

    4.三色棋

    三色旗的问题最早由E.W.Dijkstra所提出，他所使用的用语为Dutch Nation Flag(Dijkstra为荷兰人)，而多数的作者则使用Three-ColorFlag来称之。

     

    假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。

    解法

    在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来作辅助，问题的解法很简单，您可以自己想像一下在移动旗子，从绳子开头进行，遇到蓝色往前移，遇到白色留在中间，遇到红色往后移，如下所示：

    只是要让移动次数最少的话，就要有些技巧：

    如果图中W所在的位置为白色，则W+1，表示未处理的部份移至至白色群组。

    如果W部份为蓝色，则B与W的元素对调，而B与W必须各+1，表示两个群组都多了一个元素。

    如果W所在的位置是红色，则将W与R交换，但R要减1，表示未处理的部份减1。

    注意B、W、R并不是三色旗的个数，它们只是一个移动的指标；什幺时候移动结束呢？一开始时未处理的R指标会是等于旗子的总数，当R的索引数减至少于W的索引数时，表示接下来的旗子就都是红色了，此时就可以结束移动，如下所示：

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2. #include <stdlib.h>   
    3. #include <string.h>   
    4.   
    5. #define BLUE 'b'   
    6. #define WHITE 'w'   
    7. #define RED 'r'   
    8.   
    9. #define SWAP(x, y) { char temp;   
    10.                      temp = color[x];   
    11.                      color[x] = color[y];   
    12.                      color[y] = temp; }  
    13.   
    14. int main() {  
    15.     char color[] = {'r', 'w', 'b', 'w', 'w',   
    16.                     'b', 'r', 'b', 'w', 'r', ''};   
    17.   
    18.     int wFlag = 0;  
    19.     int bFlag = 0;  
    20.     int rFlag = strlen(color) - 1;  
    21.     int i;   
    22.   
    23.     for(i = 0; i < strlen(color); i++)   
    24.         printf("%c ", color[i]);   
    25.     printf(" ");   
    26.   
    27.     while(wFlag <= rFlag) {  
    28.         if(color[wFlag] == WHITE)  
    29.             wFlag++;  
    30.         else if(color[wFlag] == BLUE) {  
    31.             SWAP(bFlag, wFlag);  
    32.             bFlag++; wFlag++;  
    33.         }   
    34.         else {   
    35.             while(wFlag < rFlag && color[rFlag] == RED)  
    36.               rFlag--;  
    37.             SWAP(rFlag, wFlag);  
    38.             rFlag--;  
    39.         }   
    40.     }   
    41.   
    42.     for(i = 0; i < strlen(color); i++)   
    43.         printf("%c ", color[i]);   
    44.     printf(" ");   
    45.   
    46.     return 0;   
    47. }   
    48. </span>  

    5. 老鼠走迷官（一）

    说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表示老鼠的行走路径，试以程式求出由入口至出口的路径。

    解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是递回的基本题，请直接看程式应就可以理解。

     

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>  
    2. #include <stdlib.h>   
    3.   
    4. int visit(int, int);   
    5.   
    6. int maze[7][7] = {{2, 2, 2, 2, 2, 2, 2},   
    7.                   {2, 0, 0, 0, 0, 0, 2},   
    8.                   {2, 0, 2, 0, 2, 0, 2},   
    9.                   {2, 0, 0, 2, 0, 2, 2},   
    10.                   {2, 2, 0, 2, 0, 2, 2},   
    11.                   {2, 0, 0, 0, 0, 0, 2},   
    12.                   {2, 2, 2, 2, 2, 2, 2}};   
    13.   
    14. int startI = 1, startJ = 1;  // 入口  
    15. int endI = 5, endJ = 5;  // 出口  
    16. int success = 0;  
    17.   
    18. int main(void) {   
    19.     int i, j;   
    20.   
    21.     printf("显示迷宫： ");   
    22.     for(i = 0; i < 7; i++) {   
    23.         for(j = 0; j < 7; j++)   
    24.             if(maze[i][j] == 2)   
    25.                 printf("█");   
    26.             else   
    27.                 printf("  ");   
    28.         printf(" ");   
    29.     }   
    30.   
    31.     if(visit(startI, startJ) == 0)  
    32.         printf(" 没有找到出口！ ");   
    33.     else {   
    34.         printf(" 显示路径： ");   
    35.         for(i = 0; i < 7; i++) {   
    36.             for(j = 0; j < 7; j++) {   
    37.                 if(maze[i][j] == 2)   
    38.                     printf("█");   
    39.                 else if(maze[i][j] == 1)   
    40.                     printf("◇");   
    41.                 else   
    42.                     printf("  ");   
    43.             }   
    44.             printf(" ");   
    45.         }   
    46.     }   
    47.   
    48.     return 0;   
    49. }   
    50.   
    51. int visit(int i, int j) {   
    52.     maze[i][j] = 1;   
    53.   
    54.     if(i == endI && j == endJ)  
    55.         success = 1;   
    56.   
    57.     if(success != 1 && maze[i][j+1] == 0) visit(i, j+1);   
    58.     if(success != 1 && maze[i+1][j] == 0) visit(i+1, j);   
    59.     if(success != 1 && maze[i][j-1] == 0) visit(i, j-1);   
    60.     if(success != 1 && maze[i-1][j] == 0) visit(i-1, j);   
    61.   
    62.     if(success != 1)   
    63.         maze[i][j] = 0;   
    64.       
    65.     return success;   
    66. }    
    67. </span>  

     

    6.老鼠走迷官（二）

    说明由于迷宫的设计，老鼠走迷宫的入口至出口路径可能不只一条，如何求出所有的路径呢？

    解法求所有路径看起来复杂但其实更简单，只要在老鼠走至出口时显示经过的路径，然后退回上一格重新选择下一个位置继续递回就可以了，比求出单一路径还简单，我们的程式只要作一点修改就可以了。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>  
    2. #include <stdlib.h>   
    3.   
    4. void visit(int, int);  
    5.   
    6. int maze[9][9] = {{2, 2, 2, 2, 2, 2, 2, 2, 2},  
    7.                   {2, 0, 0, 0, 0, 0, 0, 0, 2},  
    8.                   {2, 0, 2, 2, 0, 2, 2, 0, 2},  
    9.                   {2, 0, 2, 0, 0, 2, 0, 0, 2},  
    10.                   {2, 0, 2, 0, 2, 0, 2, 0, 2},  
    11.                   {2, 0, 0, 0, 0, 0, 2, 0, 2},  
    12.                   {2, 2, 0, 2, 2, 0, 2, 2, 2},  
    13.                   {2, 0, 0, 0, 0, 0, 0, 0, 2},  
    14.                   {2, 2, 2, 2, 2, 2, 2, 2, 2}};  
    15.   
    16. int startI = 1, startJ = 1;  // 入口  
    17. int endI = 7, endJ = 7;  // 出口  
    18.   
    19. int main(void) {   
    20.     int i, j;   
    21.   
    22.     printf("显示迷宫： ");   
    23.     for(i = 0; i < 7; i++) {   
    24.         for(j = 0; j < 7; j++)   
    25.             if(maze[i][j] == 2)   
    26.                 printf("█");   
    27.             else   
    28.                 printf("  ");   
    29.         printf(" ");   
    30.     }   
    31.   
    32.     visit(startI, startJ);  
    33.   
    34.     return 0;   
    35. }   
    36.   
    37. void visit(int i, int j) {  
    38.     int m, n;  
    39.   
    40.     maze[i][j] = 1;   
    41.   
    42.     if(i == endI && j == endJ) {  
    43.         printf(" 显示路径： ");  
    44.         for(m = 0; m < 9; m++) {  
    45.             for(n = 0; n < 9; n++)  
    46.                 if(maze[m][n] == 2)  
    47.                     printf("█");  
    48.                 else if(maze[m][n] == 1)  
    49.                     printf("◇");  
    50.                 else  
    51.                     printf("  ");  
    52.             printf(" ");  
    53.         }  
    54.     }  
    55.   
    56.     if(maze[i][j+1] == 0) visit(i, j+1);  
    57.     if(maze[i+1][j] == 0) visit(i+1, j);  
    58.     if(maze[i][j-1] == 0) visit(i, j-1);  
    59.     if(maze[i-1][j] == 0) visit(i-1, j);  
    60.   
    61.     maze[i][j] = 0;  
    62. }    
    63.   
    64. </span>  

    7. 骑士走棋盘

    说明骑士旅游（Knight tour）在十八世纪初倍受数学家与拼图迷的注意，它什么时候被提出已不可考，骑士的走法为西洋棋的走法，骑士可以由任一个位置出发，它要如何走完[所有的位置？

    解法骑士的走法，基本上可以使用递回来解决，但是纯綷的递回在维度大时相当没有效率，一个聪明的解法由J.C. Warnsdorff在1823年提出，简单的说，先将最难的位置走完，接下来的路就宽广了，骑士所要走的下一步，「为下一步再选择时，所能走的步数最少的一步。」，使用这个方法，在不使用递回的情况下，可以有较高的机率找出走法（找不到走法的机会也是有的）。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2.   
    3. int board[8][8] = {0};   
    4.   
    5.   
    6. int travel(int x, int y) {  
    7.     // 对应骑士可走的八个方向  
    8.     int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};  
    9.     int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};  
    10.   
    11.     // 测试下一步的出路  
    12.     int nexti[8] = {0};  
    13.     int nextj[8] = {0};  
    14.     // 记录出路的个数  
    15.     int exists[8] = {0};  
    16.     int i, j, k, m, l;  
    17.     int tmpi, tmpj;  
    18.     int count, min, tmp;  
    19.   
    20.     i = x;  
    21.     j = y;  
    22.     board[i][j] = 1;  
    23.   
    24.     for(m = 2; m <= 64; m++) {  
    25.         for(l = 0; l < 8; l++)   
    26.             exists[l] = 0;  
    27.   
    28.         l = 0;  
    29.   
    30.         // 试探八个方向  
    31.         for(k = 0; k < 8; k++) {  
    32.             tmpi = i + ktmove1[k];  
    33.             tmpj = j + ktmove2[k];  
    34.   
    35.             // 如果是边界了，不可走  
    36.             if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)  
    37.                 continue;  
    38.   
    39.             // 如果这个方向可走，记录下来  
    40.             if(board[tmpi][tmpj] == 0) {  
    41.                 nexti[l] = tmpi;  
    42.                 nextj[l] = tmpj;  
    43.                 // 可走的方向加一个  
    44.                 l++;  
    45.             }  
    46.         }  
    47.   
    48.         count = l;  
    49.         // 如果可走的方向为0个，返回  
    50.         if(count == 0) {  
    51.             return 0;  
    52.         }  
    53.         else if(count == 1) {  
    54.             // 只有一个可走的方向  
    55.             // 所以直接是最少出路的方向  
    56.             min = 0;  
    57.         }  
    58.         else {  
    59.             // 找出下一个位置的出路数  
    60.             for(l = 0; l < count; l++) {  
    61.                 for(k = 0; k < 8; k++) {  
    62.                     tmpi = nexti[l] + ktmove1[k];  
    63.                     tmpj = nextj[l] + ktmove2[k];  
    64.                     if(tmpi < 0 || tmpj < 0 ||   
    65.                        tmpi > 7 || tmpj > 7) {  
    66.                         continue;  
    67.                     }  
    68.                     if(board[tmpi][tmpj] == 0)  
    69.                         exists[l]++;  
    70.                 }  
    71.             }  
    72.             tmp = exists[0];  
    73.             min = 0;  
    74.             // 从可走的方向中寻找最少出路的方向  
    75.             for(l = 1; l < count; l++) {  
    76.                 if(exists[l] < tmp) {  
    77.                     tmp = exists[l];  
    78.                     min = l;  
    79.                 }  
    80.             }  
    81.         }  
    82.   
    83.         // 走最少出路的方向  
    84.         i = nexti[min];  
    85.         j = nextj[min];  
    86.         board[i][j] = m;  
    87.     }  
    88.   
    89.     return 1;  
    90. }   
    91. int main(void) {  
    92.     int startx, starty;  
    93.     int i, j;  
    94.     printf("输入起始点：");  
    95.     scanf("%d %d", &startx, &starty);  
    96.       
    97.     if(travel(startx, starty)) {  
    98.         printf("游历完成！ ");  
    99.     }  
    100.     else {  
    101.         printf("游历失败！ ");  
    102.     }  
    103.       
    104.     for(i = 0; i < 8; i++) {  
    105.         for(j = 0; j < 8; j++) {  
    106.             printf("%2d ", board[i][j]);  
    107.         }  
    108.         putchar(' ');  
    109.     }  
    110.     return 0;  
    111. } </span>  

    8.八皇后

    说明西洋棋中的皇后可以直线前进，吃掉遇到的所有棋子，如果棋盘上有八个皇后，则这八个皇后如何相安无事的放置在棋盘上，1970年与1971年， E.W.Dijkstra与N.Wirth曾经用这个问题来讲解程式设计之技巧。

    解法关于棋盘的问题，都可以用递回求解，然而如何减少递回的次数？在八个皇后的问题中，不必要所有的格子都检查过，例如若某列检查过，该该列的其它格子就不用再检查了，这个方法称为分支修剪。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2. #include <stdlib.h>   
    3. #define N 8   
    4.   
    5. int column[N+1]; // 同栏是否有皇后，1表示有   
    6. int rup[2*N+1]; // 右上至左下是否有皇后   
    7. int lup[2*N+1]; // 左上至右下是否有皇后   
    8. int queen[N+1] = {0};   
    9. int num; // 解答编号   
    10.   
    11. //void backtrack(int); // 递回求解   
    12.   
    13.   
    14.   
    15. void showAnswer() {  
    16.     int x, y;  
    17.     printf(" 解答 %d ", ++num);  
    18.     for(y = 1; y <= N; y++) {  
    19.         for(x = 1; x <= N; x++) {  
    20.             if(queen[y] == x) {  
    21.                 printf(" Q");  
    22.             }  
    23.             else {  
    24.                 printf(" .");  
    25.             }  
    26.         }  
    27.         printf(" ");  
    28.     }  
    29. }  
    30.   
    31. void backtrack(int i) {   
    32.     int j;  
    33.       
    34.     if(i > N) {   
    35.         showAnswer();  
    36.     }   
    37.     else {   
    38.         for(j = 1; j <= N; j++) {   
    39.             if(column[j] == 1 &&   
    40.                 rup[i+j] == 1 && lup[i-j+N] == 1) {   
    41.                 queen[i] = j;   
    42.                 // 设定为占用  
    43.                 column[j] = rup[i+j] = lup[i-j+N] = 0;   
    44.                 backtrack(i+1);   
    45.                 column[j] = rup[i+j] = lup[i-j+N] = 1;   
    46.             }   
    47.         }   
    48.     }   
    49. }   
    50. int main(void) {   
    51.     int i;   
    52.     num = 0;   
    53.       
    54.     for(i = 1; i <= N; i++)   
    55.         column[i] = 1;   
    56.       
    57.     for(i = 1; i <= 2*N; i++)   
    58.         rup[i] = lup[i] = 1;   
    59.       
    60.     backtrack(1);   
    61.       
    62.     return 0;   
    63. } </span>  

    9.八枚银币

    说明现有八枚银币a b c d e f g h，已知其中一枚是假币，其重量不同于真币，但不知是较轻或较重，如何使用天平以最少的比较次数，决定出哪枚是假币，并得知假币比真币较轻或较重。

    解法单就求假币的问题是不难，但问题限制使用最少的比较次数，所以我们不能以单纯的回圈比较来求解，我们可以使用决策树（decision tree），使用分析与树状图来协助求解。一个简单的状况是这样的，我们比较a+b+c与d+e+f ，如果相等，则假币必是g或h，我们先比较g或h哪个较重，如果g较重，再与a比较（a是真币），如果g等于a，则g为真币，则h为假币，由于h比g轻而 g是真币，则h假币的重量比真币轻。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2. #include <stdlib.h>   
    3. #include <time.h>   
    4.    
    5. void compare(int[], int, int, int);   
    6. void eightcoins(int[]);   
    7.    
    8. int main(void) {   
    9.     int coins[8] = {0};   
    10.     int i;   
    11.   
    12.     srand(time(NULL));   
    13.   
    14.     for(i = 0; i < 8; i++)   
    15.         coins[i] = 10;   
    16.   
    17.     printf(" 输入假币重量(比10大或小)：");   
    18.     scanf("%d", &i);   
    19.     coins[rand() % 8] = i;   
    20.   
    21.     eightcoins(coins);   
    22.   
    23.     printf(" 列出所有钱币重量：");   
    24.     for(i = 0; i < 8; i++)   
    25.         printf("%d ", coins[i]);   
    26.   
    27.     printf(" ");   
    28.   
    29.     return 0;   
    30. }   
    31.   
    32. void compare(int coins[], int i, int j, int k) {   
    33.     if(coins[i] > coins[k])   
    34.         printf(" 假币 %d 较重", i+1);   
    35.     else   
    36.         printf(" 假币 %d 较轻", j+1);   
    37. }   
    38.   
    39. void eightcoins(int coins[]) {   
    40.     if(coins[0]+coins[1]+coins[2] ==   
    41.        coins[3]+coins[4]+coins[5]) {   
    42.         if(coins[6] > coins[7])   
    43.             compare(coins, 6, 7, 0);   
    44.         else   
    45.             compare(coins, 7, 6, 0);   
    46.     }   
    47.     else if(coins[0]+coins[1]+coins[2] >   
    48.             coins[3]+coins[4]+coins[5]) {   
    49.         if(coins[0]+coins[3] == coins[1]+coins[4])   
    50.             compare(coins, 2, 5, 0);   
    51.         else if(coins[0]+coins[3] > coins[1]+coins[4])   
    52.             compare(coins, 0, 4, 1);   
    53.         if(coins[0]+coins[3] < coins[1]+coins[4])   
    54.             compare(coins, 1, 3, 0);   
    55.     }   
    56.     else if(coins[0]+coins[1]+coins[2] <  
    57.             coins[3]+coins[4]+coins[5]) {   
    58.         if(coins[0]+coins[3] == coins[1]+coins[4])   
    59.             compare(coins, 5, 2, 0);   
    60.         else if(coins[0]+coins[3] > coins[1]+coins[4])   
    61.             compare(coins, 3, 1, 0);   
    62.         if(coins[0]+coins[3] < coins[1]+coins[4])   
    63.             compare(coins, 4, 0, 1);   
    64.     }   
    65. }   
    66.   
    67. </span>  

    10.生命游戏

    说明生命游戏（game of life）为1970年由英国数学家J. H. Conway所提出，某一细胞的邻居包括上、下、左、右、左上、左下、右上与右下相邻之细胞，游戏规则如下：

    孤单死亡：如果细胞的邻居小于一个，则该细胞在下一次状态将死亡。

    拥挤死亡：如果细胞的邻居在四个以上，则该细胞在下一次状态将死亡。

    稳定：如果细胞的邻居为二个或三个，则下一次状态为稳定存活。

    复活：如果某位置原无细胞存活，而该位置的邻居为三个，则该位置将复活一细胞。

    解法生命游戏的规则可简化为以下，并使用CASE比对即可使用程式实作：

    邻居个数为0、1、4、5、6、7、8时，则该细胞下次状态为死亡。

    邻居个数为2时，则该细胞下次状态为复活。

    邻居个数为3时，则该细胞下次状态为稳定。

    [cpp] view plaincopy
    1. <span style="font-family:KaiTi_GB2312">#include <stdio.h>   
    2. #include <stdlib.h>   
    3. #include <ctype.h>   
    4.   
    5. #define MAXROW 10   
    6. #define MAXCOL 25   
    7. #define DEAD 0   
    8. #define ALIVE 1   
    9. int map[MAXROW][MAXCOL], newmap[MAXROW][MAXCOL];   
    10.   
    11. void init();   
    12. int neighbors(int, int);  
    13. void outputMap();  
    14. void copyMap();  
    15.   
    16. int main() {   
    17.    int row, col;   
    18.    char ans;   
    19.    init();  
    20.    while(1) {  
    21.       outputMap();  
    22.       for(row = 0; row < MAXROW; row++) {  
    23.          for(col = 0; col < MAXCOL; col++) {  
    24.             switch (neighbors(row, col)) {  
    25.                case 0:   
    26.                case 1:   
    27.                case 4:   
    28.                case 5:   
    29.                case 6:   
    30.                case 7:   
    31.                case 8:   
    32.                   newmap[row][col] = DEAD;   
    33.                   break;   
    34.                case 2:   
    35.                   newmap[row][col] = map[row][col];   
    36.                   break;   
    37.                case 3:   
    38.                   newmap[row][col] = ALIVE;   
    39.                   break;   
    40.             }   
    41.          }  
    42.       }  
    43.   
    44.       copyMap();  
    45.       printf(" Continue next Generation ? ");  
    46.       getchar();  
    47.       ans = toupper(getchar());  
    48.       if(ans != 'Y')    break;  
    49.    }  
    50.    return 0;   
    51. }   
    52.   
    53. void init() {  
    54.    int row, col;   
    55.       
    56.    for(row = 0; row < MAXROW; row++)   
    57.       for(col = 0; col < MAXCOL; col++)   
    58.          map[row][col] = DEAD;   
    59.   
    60.    puts("Game of life Program");   
    61.    puts("Enter x, y where x, y is living cell");  
    62.    printf("0 <= x <= %d, 0 <= y <= %d ",   
    63.                  MAXROW-1, MAXCOL-1);   
    64.    puts("Terminate with x, y = -1, -1");  
    65.   
    66.    while(1) {  
    67.       scanf("%d %d", &row, &col);   
    68.       if(0 <= row && row < MAXROW &&   
    69.          0 <= col && col < MAXCOL)  
    70.          map[row][col] = ALIVE;  
    71.       else if(row == -1 || col == -1)  
    72.          break;  
    73.       else   
    74.          printf("(x, y) exceeds map ranage!");   
    75.    }  
    76. }  
    77.   
    78. int neighbors(int row, int col) {  
    79.    int count = 0, c, r;   
    80.    for(r = row-1; r <= row+1; r++)   
    81.       for(c = col-1; c <= col+1; c++) {   
    82.          if(r < 0 || r >= MAXROW || c < 0 || c >= MAXCOL)   
    83.             continue;   
    84.          if(map[r][c] == ALIVE)   
    85.             count++;   
    86.       }   
    87.   
    88.    if(map[row][col] == ALIVE)   
    89.       count--;   
    90.    return count;   
    91. }   
    92.   
    93. void outputMap() {  
    94.    int row, col;   
    95.    printf(" %20cGame of life cell status ");   
    96.    for(row = 0; row < MAXROW; row++) {   
    97.       printf(" %20c", ' ');   
    98.       for(col = 0; col < MAXCOL; col++)   
    99.          if(map[row][col] == ALIVE)     putchar('#');   
    100.          else    putchar('-');   
    101.    }   
    102. }   
    103.   
    104. void copyMap() {  
    105.    int row, col;   
    106.    for(row = 0; row < MAXROW; row++)   
    107.       for(col = 0; col < MAXCOL; col++)   
    108.          map[row][col] = newmap[row][col];   
    109. }    
    110. </span> 
  • 相关阅读:
    dubbo-admin 2.0安装部署
    一文多发神器
    springboot整合druid踩坑记录
    thymeleaf中的重定向的绝对路径问题
    路径问题
    sp_executesql介绍和使用
    java.net.UnknownHostException: api.weixin.qq.com解决办法
    调用百度地图示例
    浅析分布式架构
    城乡医保用户角色未分配修改
  • 原文地址：https://www.cnblogs.com/didi520/p/4165597.html
Copyright © 2020-2023  润新知