ACM经典算法超级大集合.docx
《ACM经典算法超级大集合.docx》由会员分享,可在线阅读,更多相关《ACM经典算法超级大集合.docx(142页珍藏版)》请在冰豆网上搜索。
ACM经典算法超级大集合
超
34.AlgorithmGossip:
Shell排序法-改良的插入排序
说明
插入排序法由未排序的后半部前端取出一个值,插入已排序前半部的适当位置,概念简单但速度不快。
排序要加快的基本原则之一,是让后一次的排序进行时,尽量利用前一次排序后的结果,以加快排序的速度,Shell排序法即是基于此一概念来改良插入排序法。
解法
Shell排序法最初是D.LShell于1959所提出,假设要排序的元素有n个,则每次进行插入排序时并不是所有的元素同时进行时,而是取一段间隔。
Shell首先将间隔设定为n/2,然后跳跃进行插入排序,再来将间隔n/4,跳跃进行排序动作,再来间隔设定为n/8、n/16,直到间隔为1之后的最后一次排序终止,由于上一次的排序动作都会将固定间隔内的元素排序好,所以当间隔越来越小时,某些元素位于正确位置的机率越高,因此最后几次的排序动作将可以大幅减低。
举个例子来说,假设有一未排序的数字如右:
8912659761812726198
数字的总数共有10个,所以第一次我们将间隔设定为10/2=5,此时我们对间隔为5的数字进行排序,如下所示:
集合问题
排列组合
格雷码(GrayCode)
产生可能的集合
m元素集合的n个元素子集
数字拆解
排序
得分排行
选择、插入、气泡排序
Shell排序法-改良的插入排序
Shaker排序法-改良的气泡排序
Heap排序法-改良的选择排序
快速排序法
(一)
快速排序法
(二)
快速排序法(三)
合并排序法
基数排序法
搜寻
循序搜寻法(使用卫兵)
二分搜寻法(搜寻原则的代表)
插补搜寻法
费氏搜寻法
矩阵
稀疏矩阵
多维矩阵转一维矩阵
上三角、下三角、对称矩阵
奇数魔方阵
4N魔方阵
2(2N+1)魔方阵
1.河内之塔
说明河内之塔(TowersofHanoi)是法国人M.Claus(Lucas)于1883年从泰国带至法国的,河内为越战时北越的首都,即现在的胡志明市;1883年法国数学家EdouardLucas曾提及这个故事,据说创世纪时Benares有一座波罗教塔,是由三支钻石棒(Pag)所支撑,开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘(Disc),并命令僧侣将所有的金盘从第一根石棒移至第三根石棒,且搬运过程中遵守大盘子在小盘子之下的原则,若每日仅搬一个盘子,则当盘子全数搬运完毕之时,此塔将毁损,而也就是世界末日来临之时。
解法如果柱子标为ABC,要由A搬至C,在只有一个盘子时,就将它直接搬至C,当有两个盘子,就将B当作辅助柱。
如果盘数超过2个,将第三个以下的盘子遮起来,就很简单了,每次处理两个盘子,也就是:
A->B、A->C、B->C这三个步骤,而被遮住的部份,其实就是进入程式的递回处理。
事实上,若有n个盘子,则移动完毕所需之次数为2^n-1,所以当盘数为64时,则所需次数为:
264-1=184********709551615为5.05390248594782e+16年,也就是约5000世纪,如果对这数字没什幺概念,就假设每秒钟搬一个盘子好了,也要约5850亿年左右。
#include
voidhanoi(intn,charA,charB,charC){
if(n==1)
printf("Movesheet%dfrom%cto%c\n",n,A,C);
else{
hanoi(n-1,A,C,B);
printf("Movesheet%dfrom%cto%c\n",n,A,C);
hanoi(n-1,B,A,C);
}
}
intmain(){
intn;
printf("请输入盘数:
");
scanf("%d",&n);
hanoi(n,'A','B','C');
return0;
}
2.AlgorithmGossip:
费式数列
说明
Fibonacci为1200年代的欧洲数学家,在他的着作中曾经提到:
「若有一只免子每个月生一只小免子,一个月后小免子也开始生产。
起初只有一只免子,一个月后就有两只免子,二个月后有三只免子,三个月后有五只免子(小免子投入生产)......。
如果不太理解这个例子的话,举个图就知道了,注意新生的小免子需一个月成长期才会投入生产,类似的道理也可以用于植物的生长,这就是Fibonacci数列,一般习惯称之为费氏数列,例如以下:
1、1、2、3、5、8、13、21、34、55、89......
解法
依说明,我们可以将费氏数列定义为以下:
fn=fn-1+fn-2 ifn>1
fn=n ifn=0,1
#include
#include
#defineN20
intmain(void){
intFib[N]={0};
inti;
Fib[0]=0;
Fib[1]=1;
for(i=2;iFib[i]=Fib[i-1]+Fib[i-2];
for(i=0;iprintf("%d",Fib[i]);
printf("\n");
return0;
}
3.巴斯卡三角形
#include
#defineN12
longcombi(intn,intr){
inti;
longp=1;
for(i=1;i<=r;i++)
p=p*(n-i+1)/i;
returnp;
}
voidpaint(){
intn,r,t;
for(n=0;n<=N;n++){
for(r=0;r<=n;r++){
inti;/*排版设定开始*/
if(r==0){
for(i=0;i<=(N-n);i++)
printf("");
}else{
printf("");
}/*排版设定结束*/
printf("%3d",combi(n,r));
}
printf("\n");
}
}
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的索引数时,表示接下来的旗子就都是红色了,此时就可以结束移动,如下所示:
#include
#include
#include
#defineBLUE'b'
#defineWHITE'w'
#defineRED'r'
#defineSWAP(x,y){chartemp;\
temp=color[x];\
color[x]=color[y];\
color[y]=temp;}
intmain(){
charcolor[]={'r','w','b','w','w',
'b','r','b','w','r','\0'};
intwFlag=0;
intbFlag=0;
intrFlag=strlen(color)-1;
inti;
for(i=0;iprintf("%c",color[i]);
printf("\n");
while(wFlag<=rFlag){
if(color[wFlag]==WHITE)
wFlag++;
elseif(color[wFlag]==BLUE){
SWAP(bFlag,wFlag);
bFlag++;wFlag++;
}
else{
while(wFlagrFlag--;
SWAP(rFlag,wFlag);
rFlag--;
}
}
for(i=0;iprintf("%c",color[i]);
printf("\n");
return0;
}
5.AlgorithmGossip:
老鼠走迷官
(一)
说明老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1来表示老鼠的行走路径,试以程式求出由入口至出口的路径。
解法老鼠的走法有上、左、下、右四个方向,在每前进一格之后就选一个方向前进,无法前进时退回选择下一个可前进方向,如此在阵列中依序测试四个方向,直到走到出口为止,这是递回的基本题,请直接看程式应就可以理解。
#include
#include
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,0,0,0,0,0,2},
{2,2,2,2,2,2,2}};
intstartI=1,startJ=1;//入口
intendI=5,endJ=5;//出口
intsuccess=0;
intmain(void){
inti,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("█");
elseif(maze[i][j]==1)
printf("◇");
else
printf("");
}
printf("\n");
}
}
return0;
}
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);
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;
returnsuccess;
}
6.AlgorithmGossip:
老鼠走迷官
(二)
说明由于迷宫的设计,老鼠走迷宫的入口至出口路径可能不只一条,如何求出所有的路径呢?
解法求所有路径看起来复杂但其实更简单,只要在老鼠走至出口时显示经过的路径,然后退回上一格重新选择下一个位置继续递回就可以了,比求出单一路径还简单,我们的程式只要作一点修改就可以了。
#include
#include
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,0,0,0,0,0,0,0,2},
{2,2,2,2,2,2,2,2,2}};
intstartI=1,startJ=1;//入口
intendI=7,endJ=7;//出口
intmain(void){
inti,j;
printf("显示迷宫:
\n");
for(i=0;i<7;i++){
for(j=0;j<7;j++)
if(maze[i][j]==2)printf("█");
elseprintf("");
printf("\n");
}
visit(startI,startJ);
return0;
}
voidvisit(inti,intj){
intm,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("█");
elseif(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.AlgorithmGossip:
骑士走棋盘
说明骑士旅游(Knighttour)在十八世纪初倍受数学家与拼图迷的注意,它什么时候被提出已不可考,骑士的走法为西洋棋的走法,骑士可以由任一个位置出发,它要如何走完[所有的位置?
解法骑士的走法,基本上可以使用递回来解决,但是纯綷的递回在维度大时相当没有效率,一个聪明的解法由J.C.Warnsdorff在1823年提出,简单的说,先将最难的位置走完,接下来的路就宽广了,骑士所要走的下一步,「为下一步再选择时,所能走的步数最少的一步。
」,使用这个方法,在不使用递回的情况下,可以有较高的机率找出走法(找不到走法的机会也是有的)。
#include
intboard[8][8]={0};
intmain(void){
intstartx,starty;
inti,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');
}
return0;
}
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;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){
return0;
}
elseif(count==1){
//只有一个可走的方向
//所以直接是最少出路的方向
min=0;
}
else{
//找出下一个位置的出路数
for(l=0;lfor(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;lif(exists[l]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曾经用这个问题来讲解程式设计之技巧。
解法关于棋盘的问题,都可以用递回求解,然而如何减少递回的次数?
在八个皇后的问题中,不必要所有的格子都检查过,例如若某列检查过,该该列的其它格子就不用再检查了,这个方法称为分支修剪。
#include
#include
#defineN8
intcolumn[N+1];//同栏是否有皇后,1表示有
intrup[2*N+1];//右上至左下是否有皇后
intlup[2*N+1];//左上至右下是否有皇后
intqueen[N+1]={0};
intnum;//解答编号
voidbacktrack(int);//递回求解
intmain(void){
inti;
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);
return0;
}
voidshowAnswer(){
intx,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");
}
}
voidbacktrack(inti){
intj;
if(i>N){
showAnswer();
}
else{
for(j=1;j<=N;j++){
if(column[j]==1&&
rup[i+j]==1&&