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
升级会员 