基本代码.docx

基本代码.docx

《基本代码.docx》由会员分享，可在线阅读，更多相关《基本代码.docx（15页珍藏版）》请在冰豆网上搜索。

基本代码

一、数论算法

1．求两数的最大公约数

functiongcd（a,b:

integer）:

integer;

begin

ifb=0thengcd:

=a

   elsegcd:

=gcd（b,amodb）;

end;

2．求两数的最小公倍数

functionlcm（a,b:

integer）:

integer;

begin

ifa

lcm:

=a;

whilelcmmodb>0doinc（lcm,a）;

end;

3．素数的求法

A.小范围内判断一个数是否为质数：

functionprime（n:

integer）:

Boolean;

varI:

integer;

begin

   forI:

=2totrunc（sqrt（n））do

   ifnmodI=0thenbegin

     prime:

=false;exit;

   end;

     prime:

=true;

end;

B.判断longint范围内的数是否为素数（包含求50000以内的素数表）：

proceduregetprime;

   var

   i,j:

longint;

   p:

array[1..50000]ofboolean;

   begin

     fillchar（p,sizeof（p）,true）;

p[1]:

=false;

i:

=2;

whilei<50000dobegin

ifpthenbegin

   j:

=i*2;

   whilej<50000dobegin

   p[j]:

=false;

   inc（j,i）;

   end;

end;

inc（i）;

end;

l:

=0;

fori:

=1to50000do

ifpthenbegin

   inc（l）;pr[l]:

=i;

end;

end;{getprime}

functionprime（x:

longint）:

integer;

   vari:

integer;

   begin

     prime:

=false;

fori:

=1toldo

ifpr>=xthenbreak

   elseifxmodpr=0thenexit;

prime:

=true;

end;{prime}

二、图论算法

1．最小生成树

A.Prim算法：

procedureprim（v0:

integer）;

   var

     lowcost,closest:

array[1..maxn]ofinteger;

i,j,k,min:

integer;

   begin

     fori:

=1tondobegin

lowcost:

=cost[v0,i];

closest:

=v0;

end;

fori:

=1ton-1dobegin

{寻找离生成树最近的未加入顶点k}

min:

=maxlongint;

forj:

=1tondo

   if（lowcost[j]0）thenbegin

   min:

=lowcost[j];

   k:

=j;

   end;

lowcost[k]:

=0;{将顶点k加入生成树}

   {生成树中增加一条新的边k到closest[k]}

{修正各点的lowcost和closest值}

forj:

=1tondo

   ifcost[k,j]

   lowcost[j]:

=cost[k,j];

   closest[j]:

=k;

   end;

end;

end;{prim}

B.Kruskal算法：

（贪心）

按权值递增顺序删去图中的边，若不形成回路则将此边加入最小生成树。

functionfind（v:

integer）:

integer;{返回顶点v所在的集合}

vari:

integer;

begin

i:

=1;

while（i<=n）and（notvinvset）doinc（i）;

ifi<=nthenfind:

=ielsefind:

=0;

end;

procedurekruskal;

var

tot,i,j:

integer;

begin

fori:

=1tondovset:

=;{初始化定义n个集合，第I个集合包含一个元素I}

p:

=n-1;q:

=1;tot:

=0;{p为尚待加入的边数，q为边集指针}

sort;

{对所有边按权值递增排序，存于e[I]中，e[I].v1与e[I].v2为边I所连接的两个顶点的序号，e[I].len为第I条边的长度}

whilep>0dobegin

   i:

=find（e[q].v1）;j:

=find（e[q].v2）;

   ifi<>jthenbegin

   inc（tot,e[q].len）;

   vset:

=vset+vset[j];vset[j]:

=[];

   dec（p）;

   end;

   inc（q）;

end;

writeln（tot）;

end;

2.最短路径

A.标号法求解单源点最短路径：

var

   a:

array[1..maxn,1..maxn]ofinteger;

   b:

array[1..maxn]ofinteger;{b指顶点i到源点的最短路径}

   mark:

array[1..maxn]ofboolean;

procedurebhf;

   var

   best,best_j:

integer;

   begin

   fillchar（mark,sizeof（mark）,false）;

mark[1]:

=true;b[1]:

=0;{1为源点}

repeat

   best:

=0;

     fori:

=1tondo

     Ifmarkthen{对每一个已计算出最短路径的点}

     forj:

=1tondo

       if（notmark[j]）and（a[i,j]>0）then

       if（best=0）or（b+a[i,j]

       best:

=b+a[i,j];best_j:

=j;

     end;

   ifbest>0thenbegin

     b[best_j]:

=best；mark[best_j]:

=true;

   end;

   untilbest=0;

   end;{bhf}

B.Floyed算法求解所有顶点对之间的最短路径：

   procedurefloyed;

   begin

forI:

=1tondo

forj:

=1tondo

ifa[I,j]>0thenp[I,j]:

=Ielsep[I,j]:

=0;{p[I,j]表示I到j的最短路径上j的前驱结点}

fork:

=1tondo{枚举中间结点}

fori:

=1tondo

   forj:

=1tondo

     ifa[i,k]+a[j,k]

   a[i,j]:

=a[i,k]+a[k,j];

       p[I,j]:

=p[k,j];

   end;

   end;

c.Dijkstra算法：

var

   a:

array[1..maxn,1..maxn]ofinteger;

   b,pre:

array[1..maxn]ofinteger;{pre指最短路径上I的前驱结点}

   mark:

array[1..maxn]ofboolean;

proceduredijkstra（v0:

integer）;

begin

fillchar（mark,sizeof（mark）,false）;

fori:

=1tondobegin

   d:

=a[v0,i];

   ifd<>0thenpre:

=v0elsepre:

=0;

end;

mark[v0]:

=true;

repeat  {每循环一次加入一个离1集合最近的结点并调整其他结点的参数}

   min:

=maxint;u:

=0;{u记录离1集合最近的结点}

   fori:

=1tondo

   if（notmark）and（d

     u:

=i;min:

=d;

   end;

   ifu<>0thenbegin

   mark:

=true;

   fori:

=1tondo

     if（notmark）and（a[u,i]+d

     d:

=a[u,i]+d;

     pre:

=u;

   end;

   end;

untilu=0;

end;

3.计算图的传递闭包

ProcedureLonglink;

var

T:

array[1..maxn,1..maxn]ofboolean;

Begin

Fillchar（t,sizeof（t）,false）;

Fork:

=1tondo

ForI:

=1tondo

Forj:

=1tondoT[I,j]:

=t[I,j]or（t[I,k]andt[k,j]）;

End;

4．无向图的连通分量

A.深度优先

proceduredfs（now,color:

integer）;

begin

   fori:

=1tondo

   ifa[now,i]andc=0thenbegin{对结点I染色}

     c:

=color;

     dfs（I,color）;

   end;

end;

B宽度优先（种子染色法）

5．关键路径

几个定义：

顶点1为源点，n为汇点。

a.顶点事件最早发生时间Ve[j],Ve[j]=max{Ve[j]+w[I,j]},其中Ve

（1）=0;

b.顶点事件最晚发生时间Vl[j],Vl[j]=min{Vl[j]–w[I,j]},其中Vl（n）=Ve（n）;

c.边活动最早开始时间Ee[I],若边I由表示，则Ee[I]=Ve[j];

d.边活动最晚开始时间El[I],若边I由表示，则El[I]=Vl[k]–w[j,k];

若Ee[j]=El[j]，则活动j为关键活动，由关键活动组成的路径为关键路径。

求解方法：

a.从源点起topsort,判断是否有回路并计算Ve;

b.从汇点起topsort,求Vl;

c.算Ee和El;

6．拓扑排序

找入度为0的点，删去与其相连的所有边，不断重复这一过程。

例寻找一数列，其中任意连续p项之和为正，任意q项之和为负，若不存在则输出NO.

7.回路问题

Euler回路（DFS）

定义：

经过图的每条边仅一次的回路。

（充要条件：

图连同且无奇点）

Hamilton回路

定义：

经过图的每个顶点仅一次的回路。

一笔画

充要条件：

图连通且奇点个数为0个或2个。

9．判断图中是否有负权回路Bellman-ford算法

x[I],y[I],t[I]分别表示第I条边的起点，终点和权。

共n个结点和m条边。

procedurebellman-ford

begin

forI:

=0ton-1dod[I]:

=+infinitive;

d[0]:

=0;

forI:

=1ton-1do

forj:

=1tomdo{枚举每一条边}

ifd[x[j]]+t[j]

=d[x[j]]+t[j];

forI:

=1tomdo

ifd[x[j]]+t[j]

end;

10．第n最短路径问题

*第二最短路径：

每举最短路径上的每条边，每次删除一条，然后求新图的最短路径，取这些路径中最短的一条即为第二最短路径。

*同理，第n最短路径可在求解第n-1最短路径的基础上求解。

三、背包问题

*部分背包问题可有贪心法求解：

计算Pi/Wi

数据结构：

w:

第i个背包的重量；

p:

第i个背包的价值；

1．0-1背包：

每个背包只能使用一次或有限次（可转化为一次）：

A.求最多可放入的重量。

noiP2001装箱问题

有一个箱子容量为v（正整数，o≤v≤20000），同时有n个物品（o≤n≤30），每个物品有一个体积（正整数）。

要求从n个物品中，任取若千个装入箱内，使箱子的剩余空间为最小。

l搜索方法

proceduresearch（k,v:

integer）;{搜索第k个物品，剩余空间为v}

vari,j:

integer;

begin

   ifv

=v;

   ifv-（s[n]-s[k-1]）>=bestthenexit;{s[n]为前n个物品的重量和}

   ifk<=nthenbegin

   ifv>w[k]thensearch（k+1,v-w[k]）;

   search（k+1,v）;

   end;

end;

lDP

F[I,j]为前i个物品中选择若干个放入使其体积正好为j的标志，为布尔型。

实现:

将最优化问题转化为判定性问题

f[I,j]=f[i-1,j-w]（w[I]<=j<=v）    边界：

f[0,0]:

=true.

ForI:

=1tondo

Forj:

=w[I]tovdoF[I,j]:

=f[I-1,j-w[I]];

优化：

当前状态只与前一阶段状态有关，可降至一维。

F[0]:

=true;

ForI:

=1tondobegin

F1:

=f;

Forj:

=w[I]tovdo

Iff[j-w[I]]thenf1[j]:

=true;

F:

=f1;

End;

B.求可以放入的最大价值。

F[I,j]为容量为I时取前j个背包所能获得的最大价值。

F[i,j]=max{f[i–w[j],j-1]+p[j],f[i,j-1]}

c.求恰好装满的情况数。

DP:

Procedureupdate;

varj,k:

integer;

begin

c:

=a;

forj:

=0tondo

   ifa[j]>0then

     ifj+now<=ntheninc（c[j+now],a[j]）;

a:

=c;

end;

2．可重复背包

A求最多可放入的重量。

F[I,j]为前i个物品中选择若干个放入使其体积正好为j的标志，为布尔型。

状态转移方程为

f[I,j]=f[I-1,j–w[I]*k]（k=1..jdivw[I]）

B.求可以放入的最大价值。

USACO1.2ScoreInflation

进行一次竞赛，总时间T固定，有若干种可选择的题目，每种题目可选入的数量不限，每种题目有一个ti（解答此题所需的时间）和一个si（解答此题所得的分数），现要选择若干题目，使解这些题的总时间在T以内的前提下，所得的总分最大，求最大的得分。

*易想到：

   f[i,j]=max{f[i-k*w[j],j-1]+k*p[j]}（0<=k<=idivw[j]）

其中f[i,j]表示容量为i时取前j种背包所能达到的最大值。

*实现：

Begin

Fillchar（f,SizeOf（f）,0）;

Fori:

=1ToMDo

Forj:

=1ToNDo

Ifi-problem[j].time>=0Then

Begin

   t:

=problem[j].pOInt+f[i-problem[j].time];

   Ift>fThenf:

=t;

End;

Writeln（f[M]）;

End.

c.求恰好装满的情况数。

AhOI2001Problem2

求自然数n本质不同的质数和的表达式的数目。

思路一，生成每个质数的系数的排列，在一一测试，这是通法。

proceduretry（dep:

integer）;

vari,j:

integer;

begin

   cal;{此过程计算当前系数的计算结果，now为结果}

   ifnow>nthenexit;{剪枝}

   ifdep=l+1thenbegin{生成所有系数}

   cal;

   ifnow=ntheninc（tot）;

   exit;

   end;

   fori:

=0tondivpr[dep]dobegin

   xs[dep]:

=i;

   try（dep+1）;

   xs[dep]:

=0;

   end;

end;

思路二，递归搜索效率较高

proceduretry（dep,rest:

integer）;

vari,j,x:

integer;

begin

   if（rest<=0）or（dep=l+1）thenbegin

   ifrest=0theninc（tot）;

   exit;

   end;

   fori:

=0torestdivpr[dep]do

   try（dep+1,rest-pr[dep]*i）;

end;

{main:

try（1,n）;}

思路三：

可使用动态规划求解

USAcO1.2moneysystem

V个物品，背包容量为n，求放法总数。

转移方程：

Procedureupdate;

varj,k:

integer;

begin

c:

=a;

forj:

=0tondo

   ifa[j]>0then

   fork:

=1tondivnowdo

     ifj+now*k<=ntheninc（c[j+now*k],a[j]）;

a:

=c;

end;

{main}

begin

read（now）;{读入第一个物品的重量}

i:

=0;  {a为背包容量为i时的放法总数}

whilei<=ndobegin

a:

=1;inc（i,now）;end;{定义第一个物品重的整数倍的重量a值为1，作为初值}

fori:

=2tovdo

begin

read（now）;

update;{动态更新}

end;

writeln（a[n]）;

四、排序算法

1.快速排序：

procedureqsort（l,r:

integer）;

vari,j,mid:

integer;

begin

   i:

=l;j:

=r;mid:

=a[（l+r）div2];{将当前序列在中间位置的数定义为中间数}

repeat

   whilea

   whilea[j]>middodec（j）;{在右半部分寻找比中间数小的数}

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

   swap（a,a[j]）;

   inc（i）;dec（j）;{继续找}

   end;

untili>j;

ifl

ifi

end;{sort}

B.插入排序：

思路：

当前a[1]..a[i-1]已排好序了，现要插入a使a[1]..a有序。

procedureinsert_sort;

vari,j:

integer;

begin

fori:

=2tondobegin

   a[0]:

=a;

   j:

=i-1;

   whilea[0]

   a[j+1]:

=a[j];

j:

=j-1;

   end;

   a[j+1]:

=a[0];

end;

end;{inset_sort}

c.选择排序：

proceduresort;

vari,j,k:

integer;

begin

fori:

=1ton-1do

   forj:

=i+1tondo

     ifa>a[j]thenswap（a,a[j]）;

end;

D.冒泡排序

procedurebubble_sort;

vari,j,k:

integer;

begin

fori:

=1ton-1do

   forj:

=ndowntoi+1do

   ifa[j]

end;

E.堆排序：

proceduresift（i,m:

integer）;{调整以i为根的子树成为堆,m为结点总数}

vark:

integer;

begin

a[0]:

=a;k:

=2*i;{在完全二叉树中结点i的左孩子为2*i,右孩子为2*i+1}

whilek<=mdobegin

   if（k

ifa[0]

=a[k];i:

=k;k:

=2*i;end

elsek:

=m+1;

end;

a:

=a[0];{将根放在合适的位置}

end;

procedureheapsort;

var

j:

integer;

begin

forj:

=ndiv2downto1dosift（j,n）;

forj:

=ndownto2dobegin

   swap（a[1],a[j]）;

   sift（1,j-1）;

end;

end;

F.归并排序

{a为序列表，tmp为辅助数组}

proceduremerge（vara:

listtype;p,q,r:

integer）;

{将已排序好的子序列a[p..q]与a[q+1..r]合并为有序的tmp[p..r]}

varI,j,t:

integer;

tmp:

listtype;

begin

t:

=p;i:

=p;j:

=q+1;{t为tmp指针，I,j分别为左右子序列的指针