信息学奥赛经典算法

一、排序算法

1.1选择算法

选择排序是一种简单而有效的排序算法，在问题规模不是很大的情况下就大胆的使用这个算法吧。

算法主过程如下：

PROCEDURE selectsort;

V AR

i,j,k,temp:integer;

BEGIN

FOR i:=1 to n-1 DO

BEGIN

k:=i;

FOR j:=i+1 to n DO

IF a[k]>a[j]

THEN k:=j;

IF k<>i

THEN BEGIN

temp:=a[k];

a[k]:=a[i];

a[i]:=temp;

END;

END;

END;

1.2快速排序

?快速排序是基于分治排序算法，在数据规模很大的情况下一般使用该算法。

算法主过程如下：

procedure qsort(L,R:longint);

var

i,j,mid,temp:longint;

begin

i:=L;

j:=R;

mid:=a[L+random(R-L+1)]; {随机选择一个数组中的数作为对比数}

repeat

while a[i]< mid do inc(i); {在左半部分寻找比中间数大的数}

while mid< a[j] do dec(j); {在右半部分寻找比中间数小的数}

if i< =j then {若找到一组与排序目标不一致的数对则交换它们}

begin

temp:=a[i];

a[i]):=a[j];

a[j]:=temp;

inc(i);dec(j); {继续找}

end;

until i >j;

if L< j then qsort(L,j); {若未到两个数的边界，则递归搜索左右区间}

if i< R then qsort(i,R);

end;

注意:主程序中必须加randomize语句。

二、高精度算法

1.2存储方法

由于待处理的数据超过了任何一种数据类型所能容纳的范围，因此必须采用数串形式输入，并将其转化为数组。该数组的每一个元素对应一个十进制数，由其下标顺序指明位序号。由于高精度运算可能使得数据长度发生变化，因此除要用整数数组存储数据外，还需要一个整数变量纪录整数数组的元素个数，即数据的实际长度。

type

numtype=array[1..255] of byte;

var

a:numtype;

la:byte;

s:string;

begin

readln(s);

la:=length(s);

for i:=1 to la do

a[la-i+1]:=ord(s[i])-ord('0');

end.

1.3加法运算

高精度加法运算

首先，确定a和b中的最大位数x，然后依照由低位至高位的顺序进行加法运算。在每一次运算中，a当前位加b当前位的和除以10，其整商即为进位，其余数即为和的当前位。在进行了x位的加法后，若最高位有进位(a[x+1]<>0)，则a的长度为x+1。

以下只列出关键程序：

type

numtype=array[1..255] of word;

var

a,b,s:numtype;

la,lb,ls:word;

procedure plus(var a:numtype;var la:word;b:numtype;lb:word); {利用过程实现}

var

i,x:word;

begin

if la>=lb

then x:=la

else x:=lb;

for i:=1 to x do

begin

a[i]:=a[i]+b[i];

a[i+1]:=a[i+1]+a[i] div 10;

a[i]:=a[i] mod 10;

end;

while a[x+1]<>0 do

x:=x+1;

la:=x; {最高位若有进位，则长度增加}

end;

1.4减法运算

高精度减法运算（a>b）

依照由低位至高位的顺序进行减法运算。在每一次位运算中，若出现不够减的情况，则向高位借位。在进行了la位的减法后，若最高位为零，则a的长度减1。

以下只列出关键程序：

type

numtype=array[1..255] of longint;

var

a,b:numtype;

la,lb:word;

procedure minus(var a:numtype;var la:word;b:numtype;);

var

i:word;

begin

for i:=1 to la do

begin

if a[i]

then begin

dec(a[i+1]);

a[i]:=a[i]+10;

end;

a[i]:=a[i]-b[i];

end;

while (a[la]=0) and (la>1) do

dec(la);

end;

? 版权所有桐乡市高级中学计算机组王建献2005- 2011

制作与维护：桐高计算机组王建献邮箱：omnislash2000@https://www.360docs.net/doc/3210604244.html,

建议使用：800*600分辨率，IE5.0以上版本浏览器

1.5乘法运算

高精度乘法运算

按照乘法规则，从a的第1位开始逐位与c（c为字节型）相乘。在第i位乘法运算中，a 的i位与c的乘积必须加上i-1位的进位，然后规整积的i-1位。

以下只列出关键程序：

type

numtype=array[1..1000] of word;

var

a:numtype;

la:word;

procedure multiply(var a:numtype;var la:word;c:word);

var

i:word;

begin

a[1]:=a[1]*c;

for i:=2 to la do

begin

a[i]:=a[i]*c;

a[i]:=a[i]+a[i-1] div 10;

a[i-1]:=a[i-1] mod 10;

end;

while a[la]>=10 do

begin

inc(la);

a[la]:=a[la-1] div 10;

a[la-1]:=a[la-1] mod 10;

end;

end;

1.6扩大进制数

扩大进制数改善高精度运算效率

用整数数组每一个元素表示一个十进制整数的方法存在的缺点是：如果十进制的位数很多，则对应的数组的长度会很长，并增加了高精度计算的时间。

如果用一个元素记录2位数字、3位数字或更多位数字，则数组的长度可以明显缩小，但是还要考虑数的取值范围问题，必须保证程序运行过程中不越界。在权衡了两方面的情况后得出：用一个longint记录4位数字是最佳的方案。那么这个数组就相当于一个10000进制的数，其中每一个元素都是10000进制下的一位数。

一、数据类型定义：

type

numtype=array[1..10000] of longint; {可以存储40000位十进制数}

var

a,n:numtype;

la,ln:byte;

s:ansistring; {任意长度的字符串类型}

二、整数数组的建立和输出

readln(s);

k:=length(s);

for i:=1 to k do

begin

j:=(k-i+4) div 4;

n[j]:=n[j]*10+ord(s[i])-48;

end;

ln:=(k+3) div 4;

当得出最后结果n后，必须按照次高位到最低位的顺序，将每一位元素由10000进制数转换成十进制数，即必须保证每个元素对应4位十进制数。例如n[i]=0015(0<=i<=ln-2)，对应的十进制数不能为15，否则会导致错误结果。可以按照如下方法输出n对应的十进制数：

write(n[ln]);

for i:=ln-1 downto 1 do

write(n[i] div 1000,(n[i] div 100) mod 10,(n[i] div 10) mod 10,n[i] mod 10);

三、基本运算

两个10000进制整数的加法和减法与前面的十进制运算方法类似，只是进制变成了10000

进制。

1、整数数组减1(n:=n-1,n为整数数组)

从n[1]出发寻找第一个非零的元素，由于接受了低位的借位，因此减1，其后缀全为9999。如果最高位为0，则n的长度减1。

j:=1;

while (n[j]=0) do inc(j); {寻找第一个非零的元素}

dec(n[j]); {该位接受低位的借位，因此减1}

for i:=1 to j-1 do

n[i]:=9999; {其后缀全为9999}

if (j=ln) and (n[j]=0) {如果最高位为0，则n的长度减1}

then dec(ln);

2、整数数组除以整数(a:=a div i,a为整数数组，i为整数)

按照从高位到低位的顺序，逐位相除，把余数乘进制后加到下一位继续相除。如果最高位为0，则a的长度减1。

l:=0;

for j:=la downto 1 do

begin

inc(a[j],l*10000);

l:=a[j] mod i;

a[j]:=a[j] div i;

end;

while a[la]=0 do dec(la);

3、两个整数数组相乘（a:=a*n，a和n为整数数组）

按照从高位到低位的顺序，将数组a的每一个元素与n相乘。

procedure multiply(a,b:numtype;la,lb:longint;var s:numtype;var ls:longint);

var

i,j:longint;

begin

for i:=1 to la do

for j:=1 to lb do

s[i+j-1]:=s[i+j-1]+a[i]*b[j];

for i:=1 to la+lb-1 do

begin

s[i+1]:=s[i+1]+s[i] div 10000;

s[i]:=s[i] mod 10000;

end;

if s[la+lb]=0

then ls:=la+lb-1

else ls:=la+lb;

end;

1.7习题与练习：

?习题与练习：

?习题与练习

?一、用高精度计算出s=1!+2!+3!+...+100!。

参考答案

?二、输入任意两个整数a,b(a,b均在长整型范围内),计算a/b的结果,保留100位

有效数字，最后一位要求四舍五入。

三、两个高精度数相乘。

参考答案

?四、2k进制数（digital.pas）(NIOP2006第四题)

【问题描述】设r是个2k进制数，并满足以下条件：

（1）r至少是个2位的2k进制数。

（2）作为2k进制数，除最后一位外，r的每一位严格小于它右边相邻的那一位。（3）将r转换为2进制数q后，则q的总位数不超过w。

在这里，正整数k（1≤k≤9）和w（k

问：满足上述条件的不同的r共有多少个？

我们再从另一角度作些解释：设S是长度为w 的01字符串（即字符串S由w个“0”或“1”组成），S对应于上述条件（3）中的q。将S从右起划分为若干个长度为k 的段，每段对应一位2k进制的数，如果S至少可分成2段，则S所对应的二进制数又可以转换为上述的2k进制数r。

例：设k=3，w=7。则r是个八进制数（23=8）。由于w=7，长度为7的01字符串按3位一段分，可分为3段（即1，3，3，左边第一段只有一个二进制位），则满足条件的八进制数有：

2位数：高位为1：6个（即12，13，14，15，16，17），高位为2：5个，…，高位为6：1个（即67）。共6+5+…+1=21个。

3位数：高位只能是1，第2位为2：5个（即123，124，125，126，127），第2位为3：4个，…，第2位为6：1个（即167）。共5+4+…+1=15个。

所以，满足要求的r共有36个。

【输入文件】

输入文件digital.in只有1行，为两个正整数，用一个空格隔开：

k W

【输出文件】

输出文件digital.out为1行，是一个正整数，为所求的计算结果，即满足条件的不同的r的个数（用十进制数表示），要求最高位不得为0，各数字之间不得插入数字以外的其他字符（例如空格、换行符、逗号等）。

（提示：作为结果的正整数可能很大，但不会超过200位）

【输入样例】

3 7

【输出样例】

36

?【题目分析】

考虑一个首位为r、位数为n且除最后一位每一位严格小于右边的2k进制数，它的种数等于从2k-(r+1)个自然数中选出n-1个升序排列。

而题目所求答案等于首位为1..2w mod k-1、位数为w/k+1且符合要求的2k进制数种数，加上首位任意、位数不超过w/k不低于2的且符合要求的2k进制数种数。(当w mod k=0时直接考虑后者即可)

因为k,W是指定的,则可以确定2k进制数r的最长位数是w div k +1，设d=w div k，则d位2k进制数组成的2位以上d位以下的升序排列数应该是:

这里还要比较d与的2k-1大小，必须保证d<=2k-1。

最后考虑首位的情况，显然首位的最大二进制位数是w mod k，则最大值m=2w mod k - 1，则首位不大于m，总位数是d+1位的升序排列数应是：

这里也要比较d与的2k-1大小，必须保证d<=2k-1-m。

两者相加即所求，因为最终的运算结果可能会很大，所以必须使用高精度运算。

【参考程序】

【NIOP满分程序】

答案一：program jiecheng;

type

numtype=array[1..255] of longint;

var

s,t:numtype;

ls,lt,i:longint;

procedure plus(var a:numtype;var la:longint;b:numtype;lb:longint);

var

i,x:byte;

begin

if la>=lb

then x:=la

else x:=lb;

for i:=1 to x do

begin

a[i]:=a[i]+b[i];

a[i+1]:=a[i+1]+a[i] div 10000;

a[i]:=a[i] mod 10000;

end;

while a[x+1]<>0 do

x:=x+1;

la:=x;

end;

procedure multiply(var a:numtype;var la:longint;c:longint);

var

i:longint;

begin

a[1]:=a[1]*c;

for i:=2 to la do

begin

a[i]:=a[i]*c;

a[i]:=a[i]+a[i-1] div 10000;

a[i-1]:=a[i-1] mod 10000;

end;

while a[la]>=10000 do

begin

a[la]:=a[la-1] div 10000;

a[la-1]:=a[la-1] mod 10000;

end;

end;

begin

lt:=1;

t[1]:=1;

ls:=0;

for i:=1 to 100 do

begin

multiply(t,lt,i);

plus(s,ls,t,lt);

end;

write(s[ls]);

for i:=ls-1 downto 1 do

write(s[i] div 1000,(s[i] div 100) mod 10,(s[i] div 10) mod 10,s[i] mod 10);

writeln;

writeln;

end.

答案二：

program multiplys;

type

numtype=array[1..1000] of int64;

var

a,b,s:numtype;

la,lb,ls,i:longint;

procedure inputa(var n:numtype;var ln:longint);

var

s:ansistring;

k,j:longint;

begin

readln(s);

k:=length(s);

for i:=1 to k do

begin

j:=(k-i+4) div 4;

n[j]:=n[j]*10+ord(s[i])-48;

end;

ln:=(k+3) div 4;

end;{input}

procedure outputa(n:numtype;ln:longint);

begin

for i:=ln-1 downto 1 do

write(n[i] div 1000,(n[i] div 100) mod 10,(n[i] div 10) mod 10,n[i] mod 10);

writeln;

end;

procedure multiply(a,b:numtype;la,lb:longint;var s:numtype;var

ls:longint);

var

i,j:longint;

begin

for i:=1 to la do

for j:=1 to lb do

s[i+j-1]:=s[i+j-1]+a[i]*b[j];

for i:=1 to la+lb-1 do

begin

s[i+1]:=s[i+1]+s[i] div 10000;

s[i]:=s[i] mod 10000;

end;

if s[la+lb]=0

then ls:=la+lb-1

else ls:=la+lb;

end;

begin

fillchar(a,sizeof(a),0);

fillchar(b,sizeof(b),0);

fillchar(s,sizeof(s),0);

inputa(a,la);

inputa(b,lb);

multiply(a,b,la,lb,s,ls);

writeln(ls);

outputa(s,ls);

readln;

end.

参考程序：

program digital1;

type

numtype=array[1..1000] of longint;

const

p:array[1..9] of longint=(2,4,8,16,32,64,128,256,512);

var

k,w,i,j,m,d,ls,lc:longint;

c,s:numtype;

procedure plus(var a:numtype;var la:longint;b:numtype;lb:longint);

var

i,x:longint;

begin

if la>=lb

then x:=la

else x:=lb;

for i:=1 to x do

begin

a[i]:=a[i]+b[i];

a[i+1]:=a[i+1]+a[i] div 10000;

a[i]:=a[i] mod 10000;

end;

while a[x+1]<>0 do

x:=x+1;

la:=x;

end;

procedure multiply(var a:numtype;var la:longint;c:longint); var

i:longint;

begin

a[1]:=a[1]*c;

for i:=2 to la do

begin

a[i]:=a[i]*c;

a[i]:=a[i]+a[i-1] div 10000;

a[i-1]:=a[i-1] mod 10000;

end;

while a[la]>=10000 do

begin

inc(la);

a[la]:=a[la-1] div 10000;

a[la-1]:=a[la-1] mod 10000;

end;

end;

procedure divice(var a:numtype;var la:longint;c:longint); var

l,j:longint;

begin

l:=0;

for j:=la downto 1 do

begin

inc(a[j],l*10000);

l:=a[j] mod c;

a[j]:=a[j] div c;

end;

while a[la]=0 do dec(la);

end;

procedure zuhe(m,n:longint;var c:numtype;var lc:longint); var

i:longint;

begin

fillchar(c, sizeof(c),0);

c[1]:=1;

lc:=1;

for i:=n downto n-m+1 do

multiply(c,lc,i);

for i:=m downto 2 do

divice(c,lc,i);

end;

begin

assign(input,'digital.in');

reset(input);

assign(output,'digital1.out');

rewrite(output);

readln(k,w);

fillchar(s,sizeof(s),0);

ls:=0;

d:=w div k;

if d>p[k]-1 then d:=p[k]-1;

for i:= 2 to d do

begin

zuhe(i,p[k]-1,c,lc);

plus(s,ls,c,lc);

end;

if w mod k<>0 then

begin

m:=p[w mod k]-1;

d:=w div k;

if m>p[k]-1-d then m:=p[k]-1-d;

for i:=1 to m do

begin

zuhe(d,p[k]-1-i,c,lc);

plus(s,ls,c,lc);

end;

end;

write(s[ls]);

for i:=ls-1 downto 1 do

write(s[i] div 1000,(s[i] div 100) mod 10,(s[i] div 10) mod 10,s[i] mod 10);

close(input);

close(output);

end.

NIOP:满分程序

const

inf='digital.in';

ouf='digital.out';

maxn=512;

pw:array[1..9]of longint=(2,4,8,16,32,64,128,256,512);

mol=1000000;

type

bignum=array[0..50]of longint;

var

k,w,n,i,p,j:longint;

f:array[boolean,0..maxn]of bignum;

ans:bignum;

procedure init;

begin

assign(input,inf);

reset(input);

readln(k,w);

n:=1;

for i:=1 to k do

n:=n*2;

close(input);

end;

procedure hiadd(var a,b:bignum);

var

i,j,n,tmp:longint;

ta:bignum;

begin

if a[0]

for i:=1 to a[0] do

a[i]:=a[i]+b[i];

for i:=1 to a[0] do

begin

tmp:=a[i] div mol; inc(a[i+1],tmp);

a[i]:=a[i] mod mol;

end;

if a[a[0]+1]>0 then inc(a[0]);

end;

procedure cal;

var

now,last:boolean;

change:boolean;

max:longint;

begin

p:=k;

now:=true; last:=false;

fillchar(f,sizeof(f),0);

for i:=0 to n do

begin

f[now,i][0]:=1; f[now,i][1]:=1; end;

dec(n);

if w>k*n then w:=k*n;

ans[0]:=1; ans[1]:=0;

repeat

now:=not now; last:=not last;

fillchar(f[now],sizeof(f[now]),0); change:=false;

inc(p,k);

if p>w then

begin

dec(p,k); max:=w-p; p:=w;

end

else max:=k;

hiadd(f[now,n-1],f[last,n]);

for i:=n-2 downto 0 do

begin

f[now,i]:=f[now,i+1];

hiadd(f[now,i],f[last,i+1]); end;

if p>2*k then hiadd(ans,f[now,0]); until p=w;

for i:=1 to pw[max]-1 do

hiadd(ans,f[now,i]);

assign(output,ouf);

rewrite(output);

n:=ans[0];

write(ans[n]);

for i:=n-1 downto 1 do

begin

max:=mol div 10;

while max<>0 do

begin

write(ans[i] div max mod 10);

max:=max div 10;

end;

end;

writeln;

close(output);

end;

begin

init;

cal;

end.

三、搜索算法

3.1 枚举算法：

枚举法(通常也称穷举法)是指在一个有穷的可能的解的集合中，枚举出集合中的每一个元素，用题目给定的约束条件去判断其是否符合条件，若满足条件，则该元素即为整个问题的解；否则就不是问题的解。

【枚举算法解题必须满足下列条件】

⑴可预先确定解元素的个数n，且问题的规模不是很大；

⑵对于每个解变量A1，A2，…An的可能值必须为一个连续的值域。

【枚举算法实现】

通常使用嵌套的FOR结构循环语句枚举每个变量的取值，在最里层的循环中判断是否满足给定的条件，若满足则输出一个解。

【枚举算法优化】

⑴减少枚举的变量。

在使用枚举法之前，先考虑一下解元素之间的关联，将那些能由已枚举解元素推算出来的变量直接用计算表达式代替。

⑵减少枚举变量的值域。

通过各枚举变量间的数学关系定义解元素的值域，在保证不遗漏的情况下越小越好。

⑶分解约束条件。

将拆分的约束条件嵌套在相应的循环体间，即尽可能根据约束条件减少变量个

3.2 深度优先算法

深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。在深度优先搜索中，对于最新发现的结点，如果它还有以此为起点而未搜过的边，就沿着边继续搜索下去。当结点v的所有边都已被探寻过，搜索将回溯到发现结点v有那条边的始结点。这一过程一直进行到已发现从源结点可达的所有结点为止。如果还存在未被发现的结点，则选择其中一个作为源结点并重复以上过程，整个过程反复进行直到所有结点都被发现为止。

深度优先搜索基本算法如下{递归算法}：

PROCEDURE dfs_try(i);

FOR i:=1 to maxr DO

BEGIN

IF 子结点 mr 符合条件 THEN

BEGIN

产生的子结点mr入栈；

IF 子结点mr是目标结点

THEN 输出

ELSE dfs_try(i+1);

栈顶元素出栈;

END;

END;

3.3 广度优先算法

宽度优先搜索算法（又称广度优先搜索算法）是最简单的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijksta单源最短路径算法和Prim最小生成树算法都采用了与宽度优先搜索类似的思想。

宽度优先搜索的核心思想是：从初始结点开始，应用算符生成第一层结点，检查目标结点是否在这些后继结点中，若没有，再用产生式规则将所有第一层的结点逐一扩展，得到第二层结点，并逐一检查第二层结点中是否包含目标结点。若没有，再用算符逐一扩展第二层所有结点……，如此依次扩展，直到发现目标结点为止。

宽度优先搜索基本算法如下：

list[1]:=source; {加入初始结点，list为待扩展结点的表}

head:=0; {队首指针}

foot:=1; {队尾指针}

REPEAT

head:=head+1;

FOR x:=1 to 规则数 DO

BEGIN

根据规则产生新结点nw;

IF not_appear(nw,list) THEN {若新结点队列中不存在，则加到队尾}

BEGIN

foot:=foot+1;

list[foot]:=nw;

list[foot].father:=head;

IF list[foot]=目标结点 THEN 输出；

END；

END；

UNTIL head>foot; {队列为空表明再无结点可扩展}

3.4 8数码问题

【八数码问题】

九宫格中有8个数码，其中只有一个空，规则是只能把一个数码移动到空的格子中，要求从一个初始状态移动到一个目标状态所要花费的最少步数。如下图

【算法分析】

解决此类问题的办法是宽度搜索，深度搜索耗时太大无法接受。当需要移动的步数很多时，

普通的宽度搜索仍旧无法满足需要，需要对其进行优化。

这个问题也可以推广到流行的拼图游戏。

【具体步骤】

一、确定问题规模（考虑搜索的时间代价）

二、确定产生式规则（如果规则太多，则时间代价会很大）

三、套用经典宽度搜索框架写程序

【参考样例】

【输入】8no.in

2 0 3

1 4 6

7 5 8

1 2 3

4 5 6

7 8 0

【输出】8no.out

5 {下面为移动步骤}

2 0 3

1 4 6

7 5 8

0 2 3

1 4 6

7 5 8

1 2 3

0 4 6

7 5 8