ACM超级经典算法大集合资源-CSDN文库

需积分: 50 107 浏览量 2017-03-06 21:35:26 上传评论 4 收藏 1.72MB PDF 举报

资源推荐

资源详情

资源评论

超级经典算法大集合：

老掉牙

河内塔

费式数列

巴斯卡三角形

三色棋

老鼠走迷官（一）

老鼠走迷官（二）

骑士走棋盘

八个皇后

八枚银币

生命游戏

字串核对

双色、三色河内塔

背包问题（ Knapsack

Problem）

数、运算

蒙地卡罗法求 PI

Eratosthenes筛选求质数

超长整数运算（大数运算）

长 PI

最大公因数、最小公倍数、

因式分解

完美数

阿姆斯壮数

最大访客数

中序式转后序式（前序式）

后序式的运算

关于赌博

洗扑克牌（乱数排列）

Craps赌博游戏

约瑟夫问题（ Josephus

Problem）

集合问题

排列组合

格雷码（Gray Code）

产生可能的集合

m元素集合的n个元素子集

数字拆解

排序

得分排行

选择、插入、气泡排序

Shell 排序法 - 改良的插

入排序

Shaker 排序法 - 改良的

气泡排序

Heap 排序法 - 改良的选

择排序

快速排序法（一）

快速排序法（二）

快速排序法（三）

合并排序法

基数排序法

搜寻

循序搜寻法（使用卫兵）

二分搜寻法（搜寻原则的代

表）

插补搜寻法

费氏搜寻法

矩阵

稀疏矩阵

多维矩阵转一维矩阵

上三角、下三角、对称矩阵

奇数魔方阵

4N 魔方阵

2(2N+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时，则所需

次数为：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, A, C);

else {

hanoi(n-1, A, C, B);

printf("Move sheet %d from %c

to %c", 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 <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) -

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] ==

printf("█");

else

printf("

");

printf("\n");

}

if(visit(startI, startJ) ==

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;

剩余68页未读，继续阅读

评论收藏

内容反馈

程序猿三桥

粉丝: 17
资源: 19

ACM超级经典算法大集合

经典ACM算法合集

ACM51个经典算法大全

ACM常用算法(重要)

acm所有算法

ACM经典算法及例子

ACM算法集锦(实现代码)

ACM基本算法

ACM经典算法集锦

经典ACM算法

ACM 经典算法

ACM经典算法

ACM算法经典例题

ACM算法大全

ACM算法题100题-经典算法库

ACM的主要算法大全

ACM竞赛经典算法实现

ACM算法模板集史上最完整收藏版

ACM/ICPC算法大全(c语言)

ACM_算法模板集史上最完整收藏版223页全免费版.pdf

ACM算法模板 · 一些常用的算法模板-模板合集

ACM算法集合（涵盖各类算法题型+分析+源码）

经典ACM算法合集经典ACM算法合集

ACM算法集集合

acm各种算法的解析

ACM算法竞赛常用代码

最新资源