java经典算法Word下载.docx

java经典算法Word下载.docx

《java经典算法Word下载.docx》由会员分享，可在线阅读，更多相关《java经典算法Word下载.docx（161页珍藏版）》请在冰豆网上搜索。

hanoi（n,'

A'

'

B'

C'

return0;

}所需次数为：

2-1=184********709551615为5.05390248594782e+16年，也就是约5000世纪

2.AlgorithmGossip:

费式数列

Fibonacci为1200年代的欧洲数学家，在他的着作中曾经提到：

「若有一只免子每个月生一只小免

子，一个月后小免子也开始生产。

起初只有一只免子，一个月后就有两只免子，二个月后有三

只免子，三个月后有五只免子（小免子投入生产）......。

如果不太理解这个例子的话，举个图就知道了，注意新生的小免子需一个月成长期才会投入生

产，类似的道理也可以用于植物的生长，这就是Fibonacci数列，一般习惯称之为费氏数列，例

如以下：

1、1、2、3、5、8、13、21、34、55、89......

解法

依说明，我们可以将费氏数列定义为以下：

fn=fn-1+fn-2

fn=n

ifn>

1

ifn=0,1

stdlib.h>

#defineN20

intmain（void）{

intFib[N]={0};

inti;

Fib[0]=0;

Fib[1]=1;

for（i=2;

i<

N;

i++）

Fib[i]=Fib[i-1]+Fib[i-2];

for（i=0;

%d"

Fib[i]）;

\n"

}

3.巴斯卡三角形

#defineN12

longcombi（intn,intr）{

longp=1;

for（i=1;

=r;

p=p*（n-i+1）/i;

returnp;

voidpaint（）{

intn,r,t;

for（n=0;

n<

=N;

n++）{

for（r=0;

r<

=n;

r++）{

/*排版设定开始*/

if（r==0）{

=（N-n）;

}else{

}/*排版设定结束*/

%3d"

combi（n,r））;

4.AlgorithmGossip:

三色棋

三色旗的问题最早由E.W.Dijkstra所提出，他所使用的用语为DutchNationFlag（Dijkstra为荷兰

人），而多数的作者则使用Three-ColorFlag来称之。

假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您

希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上

进行这个动作，而且一次只能调换两个旗子。

在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来作辅助，问

题的解法很简单，您可以自己想像一下在移动旗子，从绳子开头进行，遇到蓝色往前移，遇到

白色留在中间，遇到红色往后移，如下所示：

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

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

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

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

注意B、W、R并不是三色旗的个数，它们只是一个移动的指标；

什幺时候移动结束呢？

一开始

时未处理的R指标会是等于旗子的总数，当R的索引数减至少于W的索引数时，表示接下来的旗

子就都是红色了，此时就可以结束移动，如下所示：

string.h>

#defineBLUE'

b'

#defineWHITE'

w'

#defineRED'

r'

#defineSWAP（x,y）{chartemp;

\

temp=color[x];

\

color[x]=color[y];

color[y]=temp;

}

intmain（）{

charcolor[]={'

'

\0'

};

intwFlag=0;

intbFlag=0;

intrFlag=strlen（color）-1;

strlen（color）;

%c"

color[i]）;

while（wFlag<

=rFlag）{

if（color[wFlag]==WHITE）

wFlag++;

elseif（color[wFlag]==BLUE）{

SWAP（bFlag,wFlag）;

bFlag++;

wFlag++;

rFlag&

&

color[rFlag]==RED）

rFlag--;

SWAP（rFlag,wFlag）;

5.AlgorithmGossip:

老鼠走迷官

（一）

说明老鼠走迷宫是递回求解的基本题型，我们在二维阵列中使用2表示迷宫墙壁，使用1来表

示老鼠的行走路径，试以程式求出由入口至出口的路径。

解法老鼠的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前

进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是

递回的基本题，请直接看程式应就可以理解。

intvisit（int,int）;

intmaze[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,2,2,2,2,2,2}};

intstartI=1,startJ=1;

//入口

intendI=5,endJ=5;

//出口

intsuccess=0;

inti,j;

显示迷宫：

7;

i++）{

for（j=0;

j<

j++）

if（maze[i][j]==2）

█"

else

if（visit（startI,startJ）==0）

\n没有找到出口！

\n显示路径：

j++）{

if（maze[i][j]==2）

elseif（maze[i][j]==1）

◇"

intvisit（inti,intj）{

maze[i][j]=1;

if（i==endI&

j==endJ）

success=1;

if（success!

=1&

maze[i][j+1]==0）visit（i,j+1）;

maze[i+1][j]==0）visit（i+1,j）;

maze[i][j-1]==0）visit（i,j-1）;

maze[i-1][j]==0）visit（i-1,j）;

=1）

maze[i][j]=0;

returnsuccess;

6.AlgorithmGossip:

老鼠走迷官

（二）

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

解法求所有路径看起来复杂但其实更简单，只要在老鼠走至出口时显示经过的路径，然后退

回上一格重新选择下一个位置继续递回就可以了，比求出单一路径还简单，我们的程式只要作

一点修改就可以了。

voidvisit（int,int）;

intmaze[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,2,2,2,2,2,2,2,2}};

intendI=7,endJ=7;

i++）{

visit（startI,startJ）;

voidvisit（inti,intj）{

intm,n;

j==endJ）{

for（m=0;

m<

9;

m++）{

n++）

if（maze[m][n]==2）

elseif（maze[m][n]==1）

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

7.AlgorithmGossip:

骑士走棋盘

说明骑士旅游（Knighttour）在十八世纪初倍受数学家与拼图迷的注意，它什么时候被提出

已不可考，骑士的走法为西洋棋的走法，骑士可以由任一个位置出发，它要如何走完[所有的位

置？

解法骑士的走法，基本上可以使用递回来解决，但是纯綷的递回在维度大时相当没有效率，

一个聪明的解法由J.C.Warnsdorff在1823年提出，简单的说，先将最难的位置走完，接下来的路

就宽广了，骑士所要走的下一步，「为下一步再选择时，所能走的步数最少的一步。

」，使用这个

方法，在不使用递回的情况下，可以有较高的机率找出走法（找不到走法的机会也是有的）。

intboard[8][8]={0};

intstartx,starty;

输入起始点：

%d%d"

startx,&

starty）;

if（travel（startx,starty））{

游历完成！

游历失败！

8;

j++）{

%2d"

board[i][j]）;

putchar（'

\n'

inttravel（intx,inty）{

//对应骑士可走的八个方向

intktmove1[8]={-2,-1,1,2,2,1,-1,-2};

intktmove2[8]={1,2,2,1,-1,-2,-2,-1};

//测试下一步的出路

intnexti[8]={0};

intnextj[8]={0};

//记录出路的个数

intexists[8]={0};

inti,j,k,m,l;

inttmpi,tmpj;

intcount,min,tmp;

i=x;

j=y;

board[i][j]=1;

for（m=2;

=64;

for（l=0;

l<

l++）

exists[l]=0;

l=0;

//试探八个方向

for（k=0;

k<

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）{

elseif（count==1）{

//只有一个可走的方向

//所以直接是最少出路的方向

min=0;

//找出下一个位置的出路数

count;

l++）{

tmpi=nexti[l]+ktmove1[k];

tmpj=nextj[l]+ktmove2[k];

0||

tmpi>

7）{

if（board[tmpi][tmpj]==0）

exists[l]++;

tmp=exists[0];

//从可走的方向中寻找最少出路的方向

for（l=1;

if（exists[l]<

tmp）{

tmp=exists[l];

min=l;

//走最少出路的方向

i=nexti[min];

j=nextj[min];

board[i][j]=m;

return1;

8.AlgorithmGossip:

八皇后

说明西洋棋中的皇后可以直线前进，吃掉遇到的所有棋子，如果棋盘上有八个皇后，则这八

个皇后如何相安无事的放置在棋盘上，1970年与1971年，E.W.Dijkstra与N.Wirth曾经用这个问

题来讲解程式设计之技巧。

解法关于棋盘的问题，都可以用递回求解，然而如何减少递回的次数？

在八个皇后的问题中，

不必要所有的格子都检查过，例如若某列检查过，该该列的其它格子就不用再检查了，这个方

法称为分支修剪。

#defineN8

intcolumn[N+1];

//同栏是否有皇后，1表示有

intrup[2*N+1];

//右上至左下是否有皇后

intlup[2*N+1];

//左上至右下是否有皇后

intqueen[N+1]={0};

intnum;

//解答编号

voidbacktrack（int）;

//递回求解

num=0;

column[i]=1;

=2*N;

rup[i]=lup[i]=1;

backtrack

（1）;

voidshowAnswer（）{

intx,y;

\n解答%d\n"

++num）;

for（y=1;

y<

y++）{

for（x=1;

x<

x++）{

if（queen[y]==x）{

Q"

."

voidbacktrack（inti）{

intj;

if（i>

N）{

showAnswer（）;

for（j=1;

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.AlgorithmGossip:

八枚银币

说明现有八枚银币abcdefgh，已知其中一枚是假币，其重量不同于真币，但不知是较轻或

较重，如何使用天平以最少的比较次数，决定出哪枚是假币，并得知假币比真币较轻或较重。

解法单就求假币的问题是不难，但问题限制使用最少的比较次数，所以我们不能以单纯的回

圈比较来求解，我们可以使用决策树（decisiontree），使用分析与树状图来协助求解。

一个简单

的状况是这样的，我们比较a+b+c与d+e+f，如果相等，则假币必是g或h，我们先比较g或h哪个

较重，如果g较重，再与a比较（a是真币），如果g等于a，则g为真币，则h为假币，由于h比g轻

而g是真币，则h假币的重量比真币轻。

time.h>

voidcompare（int[],int,int,int）;

voideightcoins（int[]）;

intcoins[8]={0};

srand（time（NULL））;

coins[i]=10;

\n输入假币重量（比10大或小）：

i）;

coins[rand（）%8]=i;

eightcoins（coins）;

\n\n列出所有钱币重量：

coins[i]）;

voidcompare（intcoins[],inti,intj,intk）{

if（coins[i]>

coins[k]）

\n假币%d较重"

i+1）;

\n假币%d较轻"

j+1）;

voideightco