经典算法大全一

1.河内之塔........................................................................................................................................ 4
2.Algorithm Gossip: 费式数列........................................................................................................ 5
3. 巴斯卡三角形.............................................................................................................................. 6
4.Algorithm Gossip: 三色棋............................................................................................................ 7
5.Algorithm Gossip: 老鼠走迷官(一)........................................................................................ 9
6.Algorithm Gossip: 老鼠走迷官(二)...................................................................................... 11
7.Algorithm Gossip: 骑士走棋盘.................................................................................................. 13
8.Algorithm Gossip: 八皇后.......................................................................................................... 16
9.Algorithm Gossip: 八枚银币...................................................................................................... 18
10.Algorithm Gossip: 生命游戏.................................................................................................... 20
11.Algorithm Gossip: 字串核对.................................................................................................... 23
12.Algorithm Gossip: 双色、三色河内塔.................................................................................... 25
13.Algorithm Gossip: 背包问题(Knapsack Problem)............................................................. 29
14.Algorithm Gossip: 蒙地卡罗法求 PI...................................................................................... 34
15.Algorithm Gossip: Eratosthenes 筛选求质数............................................................................36
16.Algorithm Gossip: 超长整数运算(大数运算).................................................................... 37
17.Algorithm Gossip: 长 PI........................................................................................................... 39
18.Algorithm Gossip: 最大公因数、最小公倍数、因式分解.................................................... 43
19.Algorithm Gossip: 完美数........................................................................................................ 46
20.Algorithm Gossip: 阿姆斯壮数................................................................................................ 49
21.Algorithm Gossip: 最大访客数................................................................................................ 50
22.Algorithm Gossip: 中序式转后序式(前序式).................................................................... 52
23.Algorithm Gossip: 后序式的运算............................................................................................ 56
24.Algorithm Gossip: 洗扑克牌(乱数排列)............................................................................ 58
25.Algorithm Gossip: Craps 赌博游戏........................................................................................... 60
26.Algorithm Gossip: 约瑟夫问题(Josephus Problem)........................................................... 62
27.Algorithm Gossip: 排列组合.................................................................................................... 64
28.Algorithm Gossip: 格雷码(Gray Code)...............................................................................66
29.Algorithm Gossip: 产生可能的集合........................................................................................ 68
30.Algorithm Gossip: m 元素集合的 n 个元素子集..................................................................... 71
31.Algorithm Gossip: 数字拆解.................................................................................................... 73
32.Algorithm Gossip: 得分排行.................................................................................................... 76
33.Algorithm Gossip: 选择、插入、气泡排序............................................................................ 78
34.Algorithm Gossip: Shell 排序法 - 改良的插入排序............................................................. 82
35.Algorithm Gossip: Shaker 排序法 - 改良的气泡排序.......................................................... 85
36.排序法 - 改良的选择排序....................................................................................................... 87
37.Algorithm Gossip: 快速排序法(一).................................................................................... 92
38.Algorithm Gossip: 快速排序法(二).................................................................................... 94
39.Algorithm Gossip: 快速排序法(三).................................................................................... 96
40.Algorithm Gossip: 合并排序法................................................................................................ 99
41.Algorithm Gossip: 基数排序法.............................................................................................. 102
42.Algorithm Gossip: 循序搜寻法(使用卫兵)...................................................................... 104
43.Algorithm Gossip: 二分搜寻法(搜寻原则的代表).......................................................... 106
44.Algorithm Gossip: 插补搜寻法.............................................................................................. 109
45.Algorithm Gossip: 费氏搜寻法.............................................................................................. 112
46.Algorithm Gossip: 稀疏矩阵.................................................................................................. 116
47.Algorithm Gossip: 多维矩阵转一维矩阵.............................................................................. 118
48.Algorithm Gossip: 上三角、下三角、对称矩阵.................................................................. 120
49.Algorithm Gossip: 奇数魔方阵.............................................................................................. 122
50.Algorithm Gossip: 4N 魔方阵................................................................................................ 124
51.Algorithm Gossip: 2(2N+1) 魔方阵....................................................................................... 126
1.河内之塔
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时,则
                  64
所需次数为:2 - 1 = 18446744073709551615为5.05390248594782e+16年,也就是约5000世 纪 ,
如果对这数字没什幺概念,就假设每秒钟搬一个盘子好了,也要约5850亿年左右。
#include <stdio.h>
void hanoi(int n, char A, char B, char C) {
     if(n == 1) {
           printf("Move sheet %d from %c to %c\n", n, A, C);
     }
     else {
           hanoi(n-1, A, C, B);
           printf("Move sheet %d from %c to %c\n", n, A, C);
           hanoi(n-1, B, A, C);
     }
}
int main() {
     int n;
     printf("请输入盘数:");
     scanf("%d", &n);
     hanoi(n, 'A', 'B', 'C');
     return 0;
}
2.Algorithm Gossip: 费式数列
2.Algorithm
说明
Fibonacci为1200年代的欧洲数学家,在他的着作中曾经提到:「若有一只免子每个月生一只小免
子,一个月后小免子也开始生产。起初只有一只免子,一个月后就有两只免子,二个月后有三
只免子,三个月后有五只免子(小免子投入生产)......。
如果不太理解这个例子的话,举个图就知道了,注意新生的小免子需一个月成长期才会投入生
产,类似的道理也可以用于植物的生长,这就是Fibonacci数列,一般习惯称之为费氏数列,例
如以下: 1、1 、2、3、5、8、13、21、34、55、89......
解法
依说明,我们可以将费氏数列定义为以下:
fn = fn-1 + fn-2           if n > 1
fn = n                   if n = 0, 1
#include <stdio.h>
#include <stdlib.h>
#define N 20
int main(void) {
     int Fib[N] = {0};
     int i;
     Fib[0] = 0;
     Fib[1] = 1;
     for(i = 2; i < N; i++)
     Fib[i] = Fib[i-1] + Fib[i-2];
     for(i = 0; i < N; i++)
     printf("%d ", Fib[i]);
     printf("\n");
     return 0;
}
3. 巴斯卡三角形
#include <stdio.h>
#define N 12
long combi(int n, int r){
     int i;
     long p = 1;
     for(i = 1; i <= r; i++)
            p = p * (n-i+1) / i;
     return p;
}
void paint() {
     int n, r, t;
     for(n = 0; n <= N; n++) {
            for(r = 0; r <= n; r++) {
                  int i;/* 排版设定开始 */
                  if(r == 0) {
                         for(i = 0; i <= (N-n); i++)
                               printf(" ");
                  }else {
                         printf(" ");
                  } /* 排版设定结束 */
                  printf("%3d", combi(n, r));
          }
          printf("\n");
     }
}
4.Algorithm Gossip: 三色棋
说明
三色旗的问题最早由E.W.Dijkstra所提出,他所使用的用语为Dutch Nation Flag(Dijkstra为荷兰
人),而多数的作者则使用Three-Color Flag来称之。
假设有一条绳子,上面有红、白、蓝三种颜色的旗子,起初绳子上的旗子颜色并没有顺序,您
希望将之分类,并排列为蓝、白、红的顺序,要如何移动次数才会最少,注意您只能在绳子上
进行这个动作,而且一次只能调换两个旗子。
解法
在一条绳子上移动,在程式中也就意味只能使用一个阵列,而不使用其它的阵列来作辅助,问
题的解法很简单,您可以自己想像一下在移动旗子,从绳子开头进行,遇到蓝色往前移,遇到
白色留在中间,遇到红色往后移,如下所示:
只是要让移动次数最少的话,就要有些技巧:
  如果图中W所在的位置为白色,则W+1,表示未处理的部份移至至白色群组。
  如果W部份为蓝色,则B与W的元素对调,而B与W必须各+1,表示两个群组都多了一个元素。
  如果W所在的位置是红色,则将W与R交换,但R要减1,表示未处理的部份减1。
注意B、W、R并不是三色旗的个数,它们只是一个移动的指标;什幺时候移动结束呢?一开始
时未处理的R指标会是等于旗子的总数,当R的索引数减至少于W的索引数时,表示接下来的旗
子就都是红色了,此时就可以结束移动,如下所示:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BLUE 'b'
#define WHITE 'w'
#define RED 'r'
#define SWAP(x, y) { char temp; \
                               temp = color[x]; \
                               color[x] = color[y]; \
                               color[y] = temp; }
int main() {
     char color[] = {'r', 'w', 'b', 'w', 'w',
                             'b', 'r', 'b', 'w', 'r', '\0'};
     int wFlag = 0;
     int bFlag = 0;
     int rFlag = strlen(color) - 1;
     int i;
     for(i = 0; i < strlen(color); i++)
            printf("%c ", color[i]);
     printf("\n");
     while(wFlag <= rFlag) {
            if(color[wFlag] == WHITE)
                  wFlag++;
            else if(color[wFlag] == BLUE) {
                  SWAP(bFlag, wFlag);
                  bFlag++; wFlag++;
            }
            else {
                  while(wFlag < rFlag && color[rFlag] == RED)
                     rFlag--;
                  SWAP(rFlag, wFlag);
                  rFlag--;
            }
     }
     for(i = 0; i < strlen(color); i++)
            printf("%c ", color[i]);
     printf("\n");
     return 0;
}

5.Algorithm Gossip: 老鼠走迷官(一)
说明老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1来表
示老鼠的行走路径,试以程式求出由入口至出口的路径。
解法老鼠的走法有上、左、下、右四个方向,在每前进一格之后就选一个方向前进,无法前
进时退回选择下一个可前进方向,如此在阵列中依序测试四个方向,直到走到出口为止,这是
递回的基本题,请直接看程式应就可以理解。
#include <stdio.h>
#include <stdlib.h>
int visit(int, int);
int maze[7][7] = {{2, 2, 2, 2, 2, 2, 2},
                           {2, 0, 0, 0, 0, 0, 2},
                           {2, 0, 2, 0, 2, 0, 2},
                           {2, 0, 0, 2, 0, 2, 2},
                           {2, 2, 0, 2, 0, 2, 2},
                           {2, 0, 0, 0, 0, 0, 2},
                           {2, 2, 2, 2, 2, 2, 2}};
int startI = 1, startJ = 1; // 入口
int endI = 5, endJ = 5; // 出口
int success = 0;
int main(void) {
      int i, j;
      printf("显示迷宫:\n");
      for(i = 0; i < 7; i++) {
             for(j = 0; j < 7; j++)
                   if(maze[i][j] == 2)
                         printf("█");
                   else
                         printf("   ");
            printf("\n");
      }
      if(visit(startI, startJ) == 0)
            printf("\n没有找到出口!\n");
      else {
            printf("\n显示路径:\n");
            for(i = 0; i < 7; i++) {
                   for(j = 0; j < 7; j++) {
                         if(maze[i][j] == 2)
                               printf("█");
                         else if(maze[i][j] == 1)
                               printf("◇");
                         else
                               printf(" ");
                   }
                   printf("\n");
            }
      }
      return 0;
}
int visit(int i, int j) {
      maze[i][j] = 1;
      if(i == endI && j == endJ)
            success = 1;
      if(success != 1 && maze[i][j+1] == 0) visit(i, j+1);
      if(success != 1 && maze[i+1][j] == 0) visit(i+1, j);
      if(success != 1 && maze[i][j-1] == 0) visit(i, j-1);
      if(success != 1 && maze[i-1][j] == 0) visit(i-1, j);
      if(success != 1)
            maze[i][j] = 0;
      return success;
}
6.Algorithm Gossip: 老鼠走迷官(二)
说明由于迷宫的设计,                    老鼠走迷宫的入口至出口路径可能不只一条,      如何求出所有的路径呢?
解法求所有路径看起来复杂但其实更简单,只要在老鼠走至出口时显示经过的路径,然后退
回上一格重新选择下一个位置继续递回就可以了,比求出单一路径还简单,我们的程式只要作
一点修改就可以了。
#include <stdio.h>
#include <stdlib.h>
void visit(int, int);
int maze[9][9] = {{2, 2, 2, 2, 2, 2, 2, 2, 2},
                          {2, 0, 0, 0, 0, 0, 0, 0, 2},
                          {2, 0, 2, 2, 0, 2, 2, 0, 2},
                          {2, 0, 2, 0, 0, 2, 0, 0, 2},
                          {2, 0, 2, 0, 2, 0, 2, 0, 2},
                          {2, 0, 0, 0, 0, 0, 2, 0, 2},
                          {2, 2, 0, 2, 2, 0, 2, 2, 2},
                          {2, 0, 0, 0, 0, 0, 0, 0, 2},
                          {2, 2, 2, 2, 2, 2, 2, 2, 2}};
int startI = 1, startJ = 1; // 入口
int endI = 7, endJ = 7; // 出口
int main(void) {
      int i, j;
      printf("显示迷宫:\n");
      for(i = 0; i < 7; i++) {
           for(j = 0; j < 7; j++)
                 if(maze[i][j] == 2)
                        printf("█");
                 else
                        printf(" ");
           printf("\n");
     }
     visit(startI, startJ);
     return 0;
}
void visit(int i, int j) {
     int m, n;
     maze[i][j] = 1;
     if(i == endI && j == endJ) {
           printf("\n显示路径:\n");
           for(m = 0; m < 9; m++) {
                 for(n = 0; n < 9; n++)
                        if(maze[m][n] == 2)
                              printf("█");
                        else if(maze[m][n] == 1)
                              printf("◇");
                        else
                              printf(" ");
                 printf("\n");
           }
     }
     if(maze[i][j+1] == 0) visit(i, j+1);
     if(maze[i+1][j] == 0) visit(i+1, j);
     if(maze[i][j-1] == 0) visit(i, j-1);
     if(maze[i-1][j] == 0) visit(i-1, j);
     maze[i][j] = 0;
}
7.Algorithm Gossip: 骑士走棋盘
说明骑士旅游(Knight tour)在十八世纪初倍受数学家与拼图迷的注意,它什么时候被提出
已不可考,骑士的走法为西洋棋的走法,骑士可以由任一个位置出发,它要如何走完[所有的位
置?
解法骑士的走法,基本上可以使用递回来解决,但是纯綷的递回在维度大时相当没有效率,
一个聪明的解法由J.C. Warnsdorff在1823年提出,简单的说,先将最难的位置走完,接下来的路
就宽广了,骑士所要走的下一步,                      「为下一步再选择时,所能走的步数最少的一步。,使用这个
                                                          」
方法,在不使用递回的情况下,可以有较高的机率找出走法(找不到走法的机会也是有的)                      。
#include <stdio.h>
int board[8][8] = {0};
int main(void) {
     int startx, starty;
     int i, j;
     printf("输入起始点:");
     scanf("%d %d", &startx, &starty);
     if(travel(startx, starty)) {
            printf("游历完成!\n");
     }
     else {
            printf("游历失败!\n");
     }
     for(i = 0; i < 8; i++) {
            for(j = 0; j < 8; j++) {
                   printf("%2d ", board[i][j]);
             }
             putchar('\n');
      }
      return 0;
}
int travel(int x, int y) {
      // 对应骑士可走的八个方向
      int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
      int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};
      // 测试下一步的出路
      int nexti[8] = {0};
      int nextj[8] = {0};
      // 记录出路的个数
      int exists[8] = {0};
      int i, j, k, m, l;
      int tmpi, tmpj;
      int count, min, tmp;
      i = x;
      j = y;
      board[i][j] = 1;
      for(m = 2; m <= 64; m++) {
             for(l = 0; l < 8; l++)
                   exists[l] = 0;
             l = 0;
             // 试探八个方向
             for(k = 0; k < 8; k++) {
                   tmpi = i + ktmove1[k];
                   tmpj = j + ktmove2[k];
                   // 如果是边界了,不可走
                   if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)
                         continue;
                   // 如果这个方向可走,记录下来
      if(board[tmpi][tmpj] == 0) {
            nexti[l] = tmpi;
            nextj[l] = tmpj;
            // 可走的方向加一个
            l++;
      }
}
count = l;
// 如果可走的方向为0个,返回
if(count == 0) {
      return 0;
}
else if(count == 1) {
      // 只有一个可走的方向
      // 所以直接是最少出路的方向
      min = 0;
}
else {
      // 找出下一个位置的出路数
      for(l = 0; l < count; l++) {
            for(k = 0; k < 8; k++) {
                 tmpi = nexti[l] + ktmove1[k];
                 tmpj = nextj[l] + ktmove2[k];
                 if(tmpi < 0 || tmpj < 0 ||
                      tmpi > 7 || tmpj > 7) {
                        continue;
                 }
                 if(board[tmpi][tmpj] == 0)
                        exists[l]++;
            }
      }
      tmp = exists[0];
      min = 0;
      // 从可走的方向中寻找最少出路的方向
      for(l = 1; l < count; l++) {
            if(exists[l] < tmp) {
                 tmp = exists[l];
                 min = l;
            }
      }
             }
             // 走最少出路的方向
             i = nexti[min];
             j = nextj[min];
             board[i][j] = m;
      }
      return 1;
}
8.Algorithm Gossip: 八皇后
说明西洋棋中的皇后可以直线前进,吃掉遇到的所有棋子,如果棋盘上有八个皇后,则这八
个皇后如何相安无事的放置在棋盘上,1970年与1971年, E.W.Dijkstra与N.Wirth曾经用这个问
题来讲解程式设计之技巧。
解法关于棋盘的问题,都可以用递回求解,然而如何减少递回的次数?在八个皇后的问题中,
不必要所有的格子都检查过,例如若某列检查过,该该列的其它格子就不用再检查了,这个方
法称为分支修剪。
#include <stdio.h>
#include <stdlib.h>
#define N 8
int column[N+1]; // 同栏是否有皇后,1表示有
int rup[2*N+1]; // 右上至左下是否有皇后
int lup[2*N+1]; // 左上至右下是否有皇后
int queen[N+1] = {0};
int num; // 解答编号
void backtrack(int); // 递回求解
int main(void) {
      int i;
      num = 0;
     for(i = 1; i <= N; i++)
            column[i] = 1;
     for(i = 1; i <= 2*N; i++)
            rup[i] = lup[i] = 1;
     backtrack(1);
     return 0;
}
void showAnswer() {
     int x, y;
     printf("\n解答 %d\n", ++num);
     for(y = 1; y <= N; y++) {
            for(x = 1; x <= N; x++) {
                  if(queen[y] == x) {
                       printf(" Q");
                  }
                  else {
                       printf(" .");
                  }
            }
            printf("\n");
     }
}
void backtrack(int i) {
     int j;
     if(i > N) {
            showAnswer();
     }
     else {
            for(j = 1; j <= N; j++) {
                  if(column[j] == 1 &&
                         rup[i+j] == 1 && lup[i-j+N] == 1) {
                       queen[i] = j;
                       // 设定为占用
                       column[j] = rup[i+j] = lup[i-j+N] = 0;
                       backtrack(i+1);
                     column[j] = rup[i+j] = lup[i-j+N] = 1;
                }
            }
     }
}
9.Algorithm Gossip: 八枚银币
说明现有八枚银币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假币的重量比真币轻。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void compare(int[], int, int, int);
void eightcoins(int[]);
int main(void) {
     int coins[8] = {0};
     int i;
     srand(time(NULL));
     for(i = 0; i < 8; i++)
           coins[i] = 10;
     printf("\n输入假币重量(比10大或小):");
     scanf("%d", &i);
     coins[rand() % 8] = i;
     eightcoins(coins);
     printf("\n\n列出所有钱币重量:");
     for(i = 0; i < 8; i++)
           printf("%d ", coins[i]);
     printf("\n");
     return 0;
}
void compare(int coins[], int i, int j, int k) {
     if(coins[i] > coins[k])
           printf("\n假币 %d 较重", i+1);
     else
           printf("\n假币 %d 较轻", j+1);
}
void eightcoins(int coins[]) {
     if(coins[0]+coins[1]+coins[2] ==
         coins[3]+coins[4]+coins[5]) {
           if(coins[6] > coins[7])
                 compare(coins, 6, 7, 0);
           else
                 compare(coins, 7, 6, 0);
     }
     else if(coins[0]+coins[1]+coins[2] >
                 coins[3]+coins[4]+coins[5]) {
           if(coins[0]+coins[3] == coins[1]+coins[4])
                 compare(coins, 2, 5, 0);
           else if(coins[0]+coins[3] > coins[1]+coins[4])
                 compare(coins, 0, 4, 1);
           if(coins[0]+coins[3] < coins[1]+coins[4])
                 compare(coins, 1, 3, 0);
     }
     else if(coins[0]+coins[1]+coins[2] <
                 coins[3]+coins[4]+coins[5]) {
           if(coins[0]+coins[3] == coins[1]+coins[4])
                 compare(coins, 5, 2, 0);
           else if(coins[0]+coins[3] > coins[1]+coins[4])
                 compare(coins, 3, 1, 0);
           if(coins[0]+coins[3] < coins[1]+coins[4])
                 compare(coins, 4, 0, 1);
     }
}
10.Algorithm Gossip: 生命游戏
10.Algorithm
说明生命游戏(game of life)为1970年由英国数学家J. H. Conway所提出,某一细胞的邻居包
括上、下、左、右、左上、左下、右上与右下相邻之细胞,游戏规则如下:
  孤单死亡:如果细胞的邻居小于一个,则该细胞在下一次状态将死亡。
  拥挤死亡:如果细胞的邻居在四个以上,则该细胞在下一次状态将死亡。
  稳定:如果细胞的邻居为二个或三个,则下一次状态为稳定存活。
  复活:如果某位置原无细胞存活,而该位置的邻居为三个,则该位置将复活一细胞。
解法生命游戏的规则可简化为以下,并使用CASE比对即可使用程式实作:
  邻居个数为0、1、4、5、6、7、8时,则该细胞下次状态为死亡。
  邻居个数为2时,则该细胞下次状态为复活。
  邻居个数为3时,则该细胞下次状态为稳定。
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXROW 10
#define MAXCOL 25
#define DEAD 0
#define ALIVE 1
int map[MAXROW][MAXCOL], newmap[MAXROW][MAXCOL];
void init();
int neighbors(int, int);
void outputMap();
void copyMap();
int main() {
    int row, col;
    char ans;
    init();
    while(1) {
         outputMap();
         for(row = 0; row < MAXROW; row++) {
             for(col = 0; col < MAXCOL; col++) {
                 switch (neighbors(row, col)) {
                     case 0:
                     case 1:
                     case 4:
                     case 5:
                     case 6:
                     case 7:
                     case 8:
                         newmap[row][col] = DEAD;
                         break;
                     case 2:
                         newmap[row][col] = map[row][col];
                         break;
                     case 3:
                         newmap[row][col] = ALIVE;
                         break;
                 }
             }
         }
         copyMap();
         printf("\nContinue next Generation ? ");
         getchar();
         ans = toupper(getchar());
         if(ans != 'Y')    break;
    }
    return 0;
}
void init() {
    int row, col;
    for(row = 0; row < MAXROW; row++)
         for(col = 0; col < MAXCOL; col++)
             map[row][col] = DEAD;
    puts("Game of life Program");
    puts("Enter x, y where x, y is living cell");
    printf("0 <= x <= %d, 0 <= y <= %d\n",
                          MAXROW-1, MAXCOL-1);
    puts("Terminate with x, y = -1, -1");
    while(1) {
         scanf("%d %d", &row, &col);
         if(0 <= row && row < MAXROW &&
             0 <= col && col < MAXCOL)
             map[row][col] = ALIVE;
         else if(row == -1 || col == -1)
             break;
         else
             printf("(x, y) exceeds map ranage!");
    }
}
int neighbors(int row, int col) {
    int count = 0, c, r;
    for(r = row-1; r <= row+1; r++)
         for(c = col-1; c <= col+1; c++) {
             if(r < 0 || r >= MAXROW || c < 0 || c >= MAXCOL)
                  continue;
             if(map[r][c] == ALIVE)
                  count++;
         }
    if(map[row][col] == ALIVE)
         count--;
    return count;
}
void outputMap() {
   int row, col;
   printf("\n\n%20cGame of life cell status\n");
   for(row = 0; row < MAXROW; row++) {
        printf("\n%20c", ' ');
        for(col = 0; col < MAXCOL; col++)
            if(map[row][col] == ALIVE)      putchar('#');
            else       putchar('-');
   }
}
void copyMap() {
   int row, col;
   for(row = 0; row < MAXROW; row++)
        for(col = 0; col < MAXCOL; col++)
            map[row][col] = newmap[row][col];
}
11.Algorithm Gossip: 字串核对
说明今日的一些高阶程式语言对于字串的处理支援越来越强大(例如Java、Perl等 ) 过 字                           ,不
串搜寻本身仍是个值得探讨的课题,在这边以Boyer- Moore法来说明如何进行字串说明,这个
方法快且原理简洁易懂。
解法字串搜寻本身不难,使用暴力法也可以求解,但如何快速搜寻字串就不简单了,传统的
字串搜寻是从关键字与字串的开头开始比对,例如 Knuth-Morris-Pratt 演算法 字串搜寻,这个
方法也不错,不过要花时间在公式计算上;Boyer-Moore字串核对改由关键字的后面开始核对字
串,并制作前进表,如果比对不符合则依前进表中的值前进至下一个核对处,假设是p好了,然
后比对字串中p-n+1至p的值是否与关键字相同。
如果关键字中有重复出现的字元,则前进值就会有两个以上的值,此时则取前进值较小的值,
如此就不会跳过可能的位置,例如texture这个关键字,                              t的前进值应该取后面的3而不是取前面的
7。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void table(char*); // 建立前进表
int search(int, char*, char*); // 搜寻关键字
void substring(char*, char*, int, int); // 取出子字串
int skip[256];
int main(void) {
      char str_input[80];
      char str_key[80];
      char tmp[80] = {'\0'};
      int m, n, p;
      printf("请输入字串:");
      gets(str_input);
      printf("请输入搜寻关键字:");
      gets(str_key);
      m = strlen(str_input); // 计算字串长度
      n = strlen(str_key);
      table(str_key);
      p = search(n-1, str_input, str_key);
      while(p != -1) {
             substring(str_input, tmp, p, m);
             printf("%s\n", tmp);
             p = search(p+n+1, str_input, str_key);
}
      printf("\n");
      return 0;
}
void table(char *key) {
      int k, n;
      n = strlen(key);
      for(k = 0; k <= 255; k++)
      skip[k] = n;
      for(k = 0; k < n - 1; k++)
      skip[key[k]] = n - k - 1;
}
int search(int p, char* input, char* key) {
      int i, m, n;
     char tmp[80] = {'\0'};
     m = strlen(input);
     n = strlen(key);
     while(p < m) {
            substring(input, tmp, p-n+1, p);
            if(!strcmp(tmp, key)) // 比较两字串是否相同
                  return p-n+1;
            p += skip[input[p]];
     }
     return -1;
}
void substring(char *text, char* tmp, int s, int e) {
     int i, j;
     for(i = s, j = 0; i <= e; i++, j++)
     mp[j] = text[i];
     tmp[j] = '\0';
}
12.Algorithm Gossip: 双色、三色河内塔
说明双色河内塔与三色河内塔是由之前所介绍过的河内塔规则衍生而来,双色河内塔的目的
是将下图左上的圆环位置经移动成为右下的圆环位置:
而三色河内塔则是将下图左上的圆环经移动成为右上的圆环:
解法无论是双色河内塔或是三色河内塔,其解法观念与之前介绍过的河内塔是类似的,同样
也是使用递回来解,不过这次递回解法的目的不同,我们先来看只有两个盘的情况,这很简单,
只要将第一柱的黄色移动至第二柱,而接下来第一柱的蓝色移动至第三柱。
再来是四个盘的情况,首先必须用递回完成下图左上至右下的移动:
接下来最底层的就不用管它们了,因为它们已经就定位,只要再处理第一柱的上面两个盘子就
可以了。那么六个盘的情况呢?一样!首先必须用递回完成下图左上至右下的移动:
接下来最底层的就不用管它们了,因为它们已经就定位,只要再处理第一柱上面的四个盘子就
可以了,这又与之前只有四盘的情况相同,接下来您就知道该如何进行解题了,无论是八个盘、
十个盘以上等,都是用这个观念来解题。
那么三色河内塔呢?一样,直接来看九个盘的情况,首先必须完成下图的移动结果:
接下来最底两层的就不用管它们了,因为它们已经就定位,只要再处理第一柱上面的三个盘子
就可以了。
  双色河内塔 C 实作
#include <stdio.h>
void hanoi(int disks, char source, char temp, char target) {
     if (disks == 1) {
            printf("move disk from %c to %c\n", source, target);
            printf("move disk from %c to %c\n", source, target);
     } else {
            hanoi(disks-1, source, target, temp);
            hanoi(1, source, temp, target);
            hanoi(disks-1, temp, source, target);
     }
}
void hanoi2colors(int disks) {
     char source = 'A';
     char temp = 'B';
     char target = 'C';
     int i;
     for(i = disks / 2; i > 1; i--) {
            hanoi(i-1, source, temp, target);
            printf("move disk from %c to %c\n", source, temp);
            printf("move disk from %c to %c\n", source, temp);
            hanoi(i-1, target, temp, source);
            printf("move disk from %c to %c\n", temp, target);
     }
     printf("move disk from %c to %c\n", source, temp);
     printf("move disk from %c to %c\n", source, target);
}
int main() {
     int n;
     printf("请输入盘数:");
     scanf("%d", &n);
     hanoi2colors(n);
     return 0;
}
  三色河内塔 C 实作
#include <stdio.h>
void hanoi(int disks, char source, char temp, char target) {
     if (disks == 1) {
            printf("move disk from %c to %c\n", source, target);
            printf("move disk from %c to %c\n", source, target);
            printf("move disk from %c to %c\n", source, target);
     } else {
            hanoi(disks-1, source, target, temp);
            hanoi(1, source, temp, target);
            hanoi(disks-1, temp, source, target);
     }
}
void hanoi3colors(int disks) {
     char source = 'A';
     char temp = 'B';
     char target = 'C';
     int i;
     if(disks == 3) {
            printf("move disk from %c to %c\n", source, temp);
            printf("move disk from %c to %c\n", source, temp);
            printf("move disk from %c to %c\n", source, target);
            printf("move disk from %c to %c\n", temp, target);
            printf("move disk from %c to %c\n", temp, source);
            printf("move disk from %c to %c\n", target, temp);;
     }
     else {
            hanoi(disks/3-1, source, temp, target);
            printf("move disk from %c to %c\n", source, temp);
            printf("move disk from %c to %c\n", source, temp);
            printf("move disk from %c to %c\n", source, temp);
            hanoi(disks/3-1, target, temp, source);
            printf("move disk from %c to %c\n", temp, target);
            printf("move disk from %c to %c\n", temp, target);
            printf("move disk from %c to %c\n", temp, target);
           hanoi(disks/3-1, source, target, temp);
           printf("move disk from %c to %c\n", target, source);
           printf("move disk from %c to %c\n", target, source);
           hanoi(disks/3-1, temp, source, target);
           printf("move disk from %c to %c\n", source, temp);
           for (i = disks / 3 - 1; i > 0; i--) {
                 if (i>1) {
                       hanoi(i-1, target, source, temp);
                 }
                 printf("move disk from %c to %c\n",target, source);
                 printf("move disk from %c to %c\n",target, source);
                 if (i>1) {
                       hanoi(i-1, temp, source, target);
                 }
                 printf("move disk from %c to %c\n", source, temp);
           }
     }
}
int main() {
     int n;
     printf("请输入盘数:");
     scanf("%d", &n);
     hanoi3colors(n);
     return 0;
}
13.Algorithm Gossip: 背包问题(Knapsack Problem                   Knapsack Problem)
说明假设有一个背包的负重最多可达8公斤,而希望在背包中装入负重范围内可得之总价物
品,假设是水果好了,水果的编号、单价与重量如下所示:
                                          李子
                       0                                 4KG         NT$4500
                                          苹果
                       1                                 5KG         NT$5700
                                          橘子
                       2                                 2KG         NT$2250
                                          草莓
                       3                                 1KG         NT$1100
                       甜瓜
              4                  6KG       NT$6700
解法 背包问题是关于最佳化的问题,要解最佳化问题可以使用「动态规划」                    (Dynamic
            ,从空集合开始,每增加一个元素就先求出该阶段的最佳解,直到所有的元素加
programming)
入至集合中,最后得到的就是最佳解。
以背包问题为例,我们使用两个阵列value与item,value表示目前的最佳解所得之总价,item表
示最后一个放至背包的水果,假设有负重量 1~8的背包8个,并对每个背包求其最佳解。
逐步将水果放入背包中,并求该阶段的最佳解:
  放入李子
              背    1 2    3   4    5   6    7     8
              包
              负
              重
              valu 0 0    0   450  450 450  450   900
              e               0    0   0    0     0
              item - -    -   0    0   0    0     0
  放入苹果
              背    1 2    3   4    5   6    7     8
              包
              负
              重
                   0 0    0
              valu            450  570 570  570   900
              e               0    0   0    0     0
                   - -    -   0                   0
              item                 1   1    1
  放入橘子
              背    1 2    3   4    5   6    7     8
              包
              负
              重
                   0
              valu   225  225 450  570 675  795   900
              e      0    0   0    0   0    0     0
                   -          0                   0
              item   2    2        1   2    2
  放入草莓
                    背     1   2   3   4   5   6   7   8
                    包
                    负
                    重
                    valu  110 225 335 450 570 680 795 905
                    e     0   0   0   0   0   0   0   0
                                      0
                    item  3   2   3       1   3   2   3
   放入甜瓜
                    背     1   2   3   4   5   6   7   8
                    包
                    负
                    重
                    valu  110 225 335 450 570 680 795 905
                    e     0   0   0   0   0   0   0   0
                                      0
                    item  3   2   3       1   3   2   3
由最后一个表格,可以得知在背包负重8公斤时,最多可以装入9050元的水果,而最后一个装入
的 水果是3号,也就是草莓,装入了草莓,背包只能再放入7公斤(8-1)的水果,所以必须看
背包负重7公斤时的最佳解,最后一个放入的是2号,也就 是橘子,现在背包剩下负重量5公斤
(7-2)   ,所以看 负重5公斤的最佳解,最后放入的是1号,也就是苹果,此时背包负重量剩下0公
斤(5-5) 无 法 再放入水果,所以求出最佳解为放入草莓、橘子与苹果,而总价为9050元。
          ,
实作
   C
#include <stdio.h>
#include <stdlib.h>
                     // 重量限制
#define LIMIT 8
                     // 物品种类
#define N 5
                      // 最小重量
#define MIN 1
struct body {
     char name[20];
     int size;
     int price;
};
typedef struct body object;
int main(void) {
     int item[LIMIT+1] = {0};
     int value[LIMIT+1] = {0};
     int newvalue, i, s, p;
     object a[] = {{"李子", 4, 4500},
                         {"苹果", 5, 5700},
                         {"橘子", 2, 2250},
                         {"草莓", 1, 1100},
                         {"甜瓜", 6, 6700}};
     for(i = 0; i < N; i++) {
           for(s = a[i].size; s <= LIMIT; s++) {
                 p = s - a[i].size;
                 newvalue = value[p] + a[i].price;
                 if(newvalue > value[s]) {// 找到阶段最佳解
                      value[s] = newvalue;
                      item[s] = i;
                 }
           }
     }
     printf("物品\t价格\n");
     for(i = LIMIT; i >= MIN; i = i - a[item[i]].size) {
           printf("%s\t%d\n",
                         a[item[i]].name, a[item[i]].price);
     }
     printf("合计\t%d\n", value[LIMIT]);
     return 0;
}
  Java
class Fruit {
     private String name;
     private int size;
     private int price;
     public Fruit(String name, int size, int price) {
          this.name = name;
          this.size = size;
          this.price = price;
     }
     public String getName() {
          return name;
     }
     public int getPrice() {
          return price;
     }
     public int getSize() {
          return size;
     }
}
public class Knapsack {
     public static void main(String[] args) {
          final int MAX = 8;
          final int MIN = 1;
          int[] item = new int[MAX+1];
          int[] value = new int[MAX+1];
          Fruit fruits[] = {
                     new Fruit("李子", 4, 4500),
                     new Fruit("苹果", 5, 5700),
                     new Fruit("橘子", 2, 2250),
                     new Fruit("草莓", 1, 1100),
                     new Fruit("甜瓜", 6, 6700)};
          for(int i = 0; i < fruits.length; i++) {
                for(int s = fruits[i].getSize(); s <= MAX; s++) {
                     int p = s - fruits[i].getSize();
                     int newvalue = value[p] +
                                                fruits[i].getPrice();
                     if(newvalue > value[s]) {// 找到阶段最佳解
                            value[s] = newvalue;
                            item[s] = i;
                }
          }
     }
     System.out.println("物品\t价格");
     for(int i = MAX;
          i >= MIN;
          i = i - fruits[item[i]].getSize()) {
          System.out.println(fruits[item[i]].getName()+
                      "\t" + fruits[item[i]].getPrice());
     }
     System.out.println("合计\t" + value[MAX]);
   }
}
14.Algorithm Gossip: 蒙地卡罗法求 PI
说明蒙地卡罗为摩洛哥王国之首都,该国位于法国与义大利国境,以赌博闻名。蒙地卡罗的
基本原理为以乱数配合面积公式来进行解题,这种以机率来解题的方式带有赌博的意味,虽然
在精确度上有所疑虑,但其解题的思考方向却是个值得学习的方式。
解法蒙地卡罗的解法适用于与面积有关的题目,例如求PI值或椭圆面积,这边介绍如何求PI
值;假设有一个圆半径为1,所以四分之一圆面积就为PI,而包括此四分之一圆的正方形面积就
为1,如下图所示:
如果随意的在正方形中投射飞标(点)好了,则这些飞标(点)有些会落于四分之一圆内,假
设所投射的飞标(点)有n点,在圆内的飞标(点)有c点,则依比例来算,就会得到上图中最
后的公式。
至于如何判断所产生的点落于圆内,很简单,令乱数产生X与Y两个数值,如果X^2+Y^2等于1
就是落在圆内。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 50000
int main(void) {
     int i, sum = 0;
     double x, y;
     srand(time(NULL));
     for(i = 1; i < N; i++) {
            x = (double) rand() / RAND_MAX;
            y = (double) rand() / RAND_MAX;
            if((x * x + y * y) < 1)
                  sum++;
     }
     printf("PI = %f\n", (double) 4 * sum / N);
     return 0;
}
15.Algorithm Gossip: Eratosthenes 筛选求质数
说明除了自身之外,无法被其它整数整除的数称之为质数,要求质数很简单,但如何快速的
求出质数则一直是程式设计人员与数学家努力的课题,                      在这边介绍一个着名的 Eratosthenes求质
数方法。
解法首先知道这个问题可以使用回圈来求解,将一个指定的数除以所有小于它的数,若可以
整除就不是质数,然而如何减少回圈的检查次数?如何求出小于N的所有质数?
首先假设要检查的数是N好了,则事实上只要检查至N的开根号就可以了,道理很简单,假设
A*B = N,如果A大于N的开根号,则事实上在小于A之前的检查就可以先检查到B这个数可以整
除N。   不过在程式中使用开根号会精确度的问题,                   所以可以使用 i*i <= N进行检查,    且执行更快 。
再来假设有一个筛子存放1~N,例如:
2 3 4 5 6 7 8 9 10 11 12 13 14 15              16 17 18 19   20 21 ........ N
先将2的倍数筛去:
2 3 5 7 9 11 13 15        17 19 21 ........ N
再将3的倍数筛去:
2 3 5 7 11 13       17 19 ........ N
再来将5的倍数筛去,再来将7的质数筛去,再来将11的倍数筛去........,如此进行到最后留下的
数就都是质数,这就是Eratosthenes筛选方法(Eratosthenes Sieve Method)       。
检查的次数还可以再减少,事实上,只要检查6n+1与6n+5就可以了,也就是直接跳过2与3的倍
数,使得程式中的if的检查动作可以减少。
实作
  C
#include <stdio.h>
#include <stdlib.h>
#define N 1000
int main(void) {
     int i, j;
     int prime[N+1];
     for(i = 2; i <= N; i++)
            prime[i] = 1;
     for(i = 2; i*i <= N; i++) { // 这边可以改进
            if(prime[i] == 1) {
                  for(j = 2*i; j <= N; j++) {
                        if(j % i == 0)
                              prime[j] = 0;
                  }
            }
     }
     for(i = 2; i < N; i++) {
            if(prime[i] == 1) {
                  printf("%4d ", i);
                  if(i % 16 == 0)
                        printf("\n");
            }
     }
     printf("\n");
     return 0;
}
16.Algorithm Gossip: 超长整数运算(大数运算)
说明基于记忆体的有效运用,程式语言中规定了各种不同的资料型态,也因此变数所可以表
达的最大整数受到限制,例如123456789123456789这样的 整数就不可能储存在long变数中(例
如C/C++等)        ,我们称这为long数,这边翻为超长整数(避免与资料型态的长整数翻译混淆),或
俗称大数运算。
解法一个变数无法表示超长整数,则就使用多个变数,当然这使用阵列最为方便,假设程式
语言的最大资料型态可以储存至65535的数好了,为了计算方便及符合使用十进位制的习惯,让
每一个阵列元素可以储存四个位数,也就是0到9999的数,例如:
很多人问到如何计算像50!这样的问题,解法就是使用程式中的乘法函式,至于要算到多大,就
看需求了。
由于使用阵列来储存数值,关于数值在运算时的加减乘除等各种运算、位数的进位或借位就必
须自行定义,加、减、乘都是由低位数开始运算,而除法则是由高位数开始运算,这边直接提
供加减乘除运算的函式供作参考,以下的N为阵列长度。
void add(int *a, int *b, int *c) {
     int i, carry = 0;
     for(i = N - 1; i >= 0; i--) {
            c[i] = a[i] + b[i] + carry;
            if(c[i] < 10000)
                  carry = 0;
            else { // 进位
                  c[i] = c[i] - 10000;
                  carry = 1;
            }
     }
}
void sub(int *a, int *b, int *c) {
     int i, borrow = 0;
     for(i = N - 1; i >= 0; i--) {
            c[i] = a[i] - b[i] - borrow;
            if(c[i] >= 0)
                  borrow = 0;
            else { // 借位
                  c[i] = c[i] + 10000;
                  borrow = 1;
            }
     }
}
void mul(int *a, int b, int *c) { // b 为乘数
     int i, tmp, carry = 0;
     for(i = N - 1; i >=0; i--) {
            tmp = a[i] * b + carry;
            c[i] = tmp % 10000;
            carry = tmp / 10000;
     }
}
void div(int *a, int b, int *c) { // b 为除数
     int i, tmp, remain = 0;
     for(i = 0; i < N; i++) {
            tmp = a[i] + remain;
            c[i] = tmp / b;
            remain = (tmp % b) * 10000;
     }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值