ACM程序设计算法讲解.doc

ACM程序设计算法讲解
目录
1.河内之塔 3
2.Algorithm Gossip: 费式数列 4
3.巴斯卡三角形 5
4.Algorithm Gossip: 三色棋 6
5.Algorithm Gossip: 老鼠走迷官（一） 8
6.Algorithm Gossip: 老鼠走迷官（二） 10
7.Algorithm Gossip: 骑士走棋盘 11
8.Algorithm Gossip: 八皇后 14
9.Algorithm Gossip: 八枚银币 16
10.Algorithm Gossip: 生命游戏 18
11.Algorithm Gossip: 字串核对 21
12.Algorithm Gossip: 双色、三色河内塔 23
13.Algorithm Gossip: 背包问题（Knapsack Problem） 27
14.Algorithm Gossip: 蒙地卡罗法求 PI 32
15.Algorithm Gossip: Eratosthenes筛选求质数 33
16.Algorithm Gossip: 超长整数运算（大数运算） 35
17.Algorithm Gossip: 长 PI 37
18.Algorithm Gossip: 最大公因数、最小公倍数、因式分解 40
19.Algorithm Gossip: 完美数 43
20.Algorithm Gossip: 阿姆斯壮数 46
21.Algorithm Gossip: 最大访客数 48
22.Algorithm Gossip: 中序式转后序式（前序式） 50
23.Algorithm Gossip: 后序式的运算 53
24.Algorithm Gossip: 洗扑克牌（乱数排列） 55
25.Algorithm Gossip: Craps赌博游戏 57
26.Algorithm Gossip: 约瑟夫问题（Josephus Problem） 59
27.Algorithm Gossip: 排列组合 61
28.Algorithm Gossip: 格雷码（Gray Code） 63
29.Algorithm Gossip: 产生可能的集合 65
30.Algorithm Gossip: m元素集合的n个元素子集 68
31.Algorithm Gossip: 数字拆解 70
32.Algorithm Gossip: 得分排行 73
33.Algorithm Gossip: 选择、插入、气泡排序 75
34.Algorithm Gossip: Shell 排序法 - 改良的插入排序 79
35.Algorithm Gossip: Shaker 排序法 - 改良的气泡排序 82
36.排序法 - 改良的选择排序 84
37.Algorithm Gossip: 快速排序法（一） 88
38.Algorithm Gossip: 快速排序法（二） 90
39.Algorithm Gossip: 快速排序法（三） 92
40.Algorithm Gossip: 合并排序法 95
41.Algorithm Gossip: 基数排序法 98
42.Algorithm Gossip: 循序搜寻法（使用卫兵） 100
43.Algorithm Gossip: 二分搜寻法（搜寻原则的代表） 102
44.Algorithm Gossip: 插补搜寻法 105
45.Algorithm Gossip 费氏搜寻法 108
46.Algorithm Gossip: 稀疏矩阵 112
47.Algorithm Gossip: 多维矩阵转一维矩阵 114
48.Algorithm Gossip: 上三角、下三角、对称矩阵 115
49.Algorithm Gossip: 奇数魔方阵 118
50.Algorithm Gossip: 4N 魔方阵 119
51.Algorithm Gossip: 2(2N+1) 魔方阵 121

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亿年左右。

#include

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: 费式数列
说明
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
#include

#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
#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
#include
#include

#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
#include

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;
}

6Algorithm Gossip: 老鼠走迷官（二）
说明由于迷宫的设计，老鼠走迷宫的入口至出口路径可能不只一条，如何求出所有的路径呢？
解法求所有路径看起来复杂但其实更简单，只要在老鼠走至出口时显示经过的路径，然后退回上一格重新选择下一个位置继续递回就可以了，比求出单一路径还简单，我们的程式只要作一点修改就可以了。
#include
#include

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

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;

// 试探八个方向
fork = 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
#include
#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[ij+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
#include
#include

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,