算法实例

A. 什么叫"计算机算法"请举出5个计算机算法的例子.

准确的定义还是建议你上书上找，至于算法的例子，我大概说说好了，比如从1循环到指定的数（数的遍历），辗转相除法算最大公约数，从1加到100用的迭代算法，求某数的阶乘用的递归算法，求平方根的牛顿迭代法。。。。
总之就是能解决一类问题的固定的计算方法就是算法。

B. c语言中什么是算法有哪些描述算法的例子

1、有穷性（有限性）。任何一种提出的解题方法都是在有限的操作步骤内可以完成的。
如果在有限的操作步骤内完不成，得不到结果，这样的算法将无限的执行下去，永远不会停止。除非手动停止。例如操作系统就不具有有穷性，它可以一直运行。
2、一个算法应该具有以下七个重要的特征：
1）有穷性（finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止
2）确切性(definiteness)
算法的每一步骤必须有确切的定义；
3）输入项(input)
一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定出了初始条件；
4）输出项(output)
一个算法有一个或多个输出,以反映对输入数据加工后的结果.没有输出的算法是毫无意义的；
5）可行性(effectiveness)
算法中执行的任何计算步都是可以被分解为基本的可执行的操作步,即每个计算步都可以在有限时间内完成；
6）
高效性（high
efficiency）
执行速度快,占用资源少；
7）
健壮性（robustness）
健壮性又称鲁棒性，是指软件对于规范要求以外的输入情况的处理能力。所谓健壮的系统是指对于规范要求以外的输入能够判断出这个输入不符合规范要求，并能有合理的处理方式。

C. 关于简单算法举例问题

这个算法是求阶乘n!吧
用递归就好.
-------------------------------
上面是要求求1*2*3*4*5的值.
------------------------------
t表示结果,i表示乘到边了.
----------------------------
改进后的过程是这样的.

S1: 使t=1

S2: 使i=2

S3: 使t×i, 乘积仍然放在在变量t中，可表示为t×i→t
这时既是t×i=1*2=2, 结果记录在t中,所以t=2
S4: 使i的值+1，即i+1→i , 所以i=2+1=3

S5: 如果i≤5, 返回重新执行步骤S3以及其后的S4和S5；否则，算法结束。
这时,i=3,没小于5, 所以重复s3和s4,s5.

---------------第一次重复-------------------------
S3: 使t×i, 乘积仍然放在在变量t中，可表示为t×i→t
这时既是t×i=2*3=6, 结果记录在t中,所以t=6

S4: 使i的值+1，即i+1→i , 所以i=3+1=4

S5: 如果i≤5, 返回重新执行步骤S3以及其后的S4和S5；否则，算法结束。
这时,i=4,没小于5, 所以重复s3和s4,s5.
---------------第二次重复-------------------------
S3: 使t×i, 乘积仍然放在在变量t中，可表示为t×i→t
这时既是t×i=6*4=24, 结果记录在t中,所以t=24

S4: 使i的值+1，即i+1→i , 所以i=4+1=5

S5: 如果i≤5, 返回重新执行步骤S3以及其后的S4和S5；否则，算法结束。
这时,i=5,没小于5, 所以重复s3和s4,s5.
---------------第三次重复-------------------------
S3: 使t×i, 乘积仍然放在在变量t中，可表示为t×i→t
这时既是t×i=24*5=120 结果记录在t中,所以t=120

S4: 使i的值+1，即i+1→i , 所以i=5+1=6

S5: 如果i≤5, 返回重新执行步骤S3以及其后的S4和S5；否则，算法结束。
这时,i=6,大于5, 算法结束。

写成代码就是:
---------------------
n为由1开始相乘的数个数, t为要求的值
------------------
void function(const int n, long &t)
{
while(i<=n)
{
t = t*i;
i = i+1;
}
}
-------------------------
当求1*2*3*4*5*6时,
int n=6;
long value=0;
function(n,value);这样来调用

D. 什么是算法，都什么，举个例子，谢谢

根据我个人的理解：
算法就是解决问题的具体的方法和步骤，所以具有以下性质：

1、有穷性： 一个算法必须保证执行有限步之后结束（如果步骤无限，问题就无法解决）
2、确切性：步骤必须明确，说清楚做什么。
3、输入：即解决问题前我们所掌握的条件。
4、输出：输出即我们需要得到的答案。
5、可行性：逻辑不能错误，步骤必须有限，必须得到结果。

算法通俗的讲：就是解决问题的方法和步骤。在计算机发明之前便已经存在。只不过在计算机发明后，其应用变得更为广泛。通过简单的算法，利用电脑的计算速度，可以让问题变得简单。

譬如：计算 1×2×3×4。。。。×999999999×1000000000
如果人为计算，可想而知，即使你用N卡车的纸张都很难计算出来，即使算出来了，也很难保证其准确性。
如果用VB算法：
dim a as integer
a=1
For i =1 to 1000000000
a=a*i
next i
input a
就这样，简单的算法，通过计算机强大的计算能力，问题就解决了。
关于这段算法的解释：i每乘一次，其数值都会增大1，一直乘到1000000000，这样，就将从1到1000000000的每个数都乘了。而且每乘一次，就将结束赋给a,这样，a就代表了前面的相乘的所有结果，一直乘到1000000000。最后得到的a，就是我们想要的。

〓以下是网络复制过来的，如果你有足够耐心，可以参考一下。

算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
一个算法应该具有以下五个重要的特征：
1、有穷性： 一个算法必须保证执行有限步之后结束；
2、确切性： 算法的每一步骤必须有确切的定义；
3、输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定除了初始条件；
4、输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
5、可行性： 算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。
计算机科学家尼克劳斯-沃思曾着过一本着名的书《数据结构十算法= 程序》，可见算法在计算机科学界与计算机应用界的地位。
[编辑本段]算法的复杂度
同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。一个算法的评价主要从时间复杂度和空间复杂度来考虑。
时间复杂度
算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n 的函数f(n)，算法的时间复杂度也因此记做
T(n)=Ο(f(n))
因此，问题的规模n 越大，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度（Asymptotic Time Complexity）。
空间复杂度
算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。
详见网络词条"算法复杂度"
[编辑本段]算法设计与分析的基本方法
1.递推法
递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。它把问题分成若干步，找出相邻几步的关系，从而达到目的，此方法称为递推法。
2.递归
递归指的是一个过程：函数不断引用自身，直到引用的对象已知
3.穷举搜索法
穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并从众找出那些符合要求的候选解作为问题的解。
4.贪婪法
贪婪法是一种不追求最优解，只希望得到较为满意解的方法。贪婪法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪婪法不要回溯。
5.分治法
把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。
6.动态规划法
动态规划是一种在数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。动态规划的思想是多种算法的基础，被广泛应用于计算机科学和工程领域。
7.迭代法
迭代是数值分析中通过从一个初始估计出发寻找一系列近似解来解决问题（一般是解方程或者方程组）的过程，为实现这一过程所使用的方法统称为迭代法。
[编辑本段]算法分类
算法可大致分为基本算法、数据结构的算法、数论与代数算法、计算几何的算法、图论的算法、动态规划以及数值分析、加密算法、排序算法、检索算法、随机化算法、并行算法。
[编辑本段]举例
经典的算法有很多，如："欧几里德算法"。
[编辑本段]算法经典专着
目前市面上有许多论述算法的书籍，其中最着名的便是《计算机程序设计艺术》（The Art Of Computer Programming) 以及《算法导论》（Introction To Algorithms）。
[编辑本段]算法的历史
“算法”即算法的大陆中文名称出自《周髀算经》；而英文名称Algorithm 来自于9世纪波斯数学家al-Khwarizmi，因为al-Khwarizmi在数学上提出了算法这个概念。“算法”原为"algorism"，意思是阿拉伯数字的运算法则，在18世纪演变为"algorithm"。欧几里得算法被人们认为是史上第一个算法。 第一次编写程序是Ada Byron于1842年为巴贝奇分析机编写求解解伯努利方程的程序，因此Ada Byron被大多数人认为是世界上第一位程序员。因为查尔斯·巴贝奇(Charles Babbage)未能完成他的巴贝奇分析机，这个算法未能在巴贝奇分析机上执行。 因为"well-defined procere"缺少数学上精确的定义，19世纪和20世纪早期的数学家、逻辑学家在定义算法上出现了困难。20世纪的英国数学家图灵提出了着名的图灵论题，并提出一种假想的计算机的抽象模型，这个模型被称为图灵机。图灵机的出现解决了算法定义的难题，图灵的思想对算法的发展起到了重要作用的。

E. 实例计算分析

某高含硫气井，当地层压力降低到元素硫析出的饱和压力后，元素硫开始析出沉降，当产量较小的时候，元素硫会沉积硫堵，降低储层孔隙度及渗透率。分析元素硫沉积对储层各参数的影响，得到含硫饱和度随时间的变化关系，从而更好地指导含硫气藏科学合理的开发生产。

根据以上建立的数学模型，结合第4章对元素硫颗粒在孔隙介质中的受力运移分析，采用表5.1井的参数，进行了模拟计算分析。由于现场取样的困难性，对于元素硫溶解度的计算方面，本章还是采用常用的Roberts的溶解度计算公式（2.7）。将这些参数带入上式（5.13）进行分析求解。

图5.12 地层渗透率对含硫饱和度的影响

F. c语言问题： 什么是算法试从日常生活中找3个例子，描述它们的算法。 详细点，谢谢！

c语言中的算法是指：一系列解决问题的清晰指令，用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。通俗说就是解决问题的方法和步骤。

描述算法的例子：

1. 问题：从上海去到北京。

   其中的算法：做汽车、做飞机、或者徒步。

2. 问题：喝茶。

   其中的算法：先找到茶叶，再烧一壶开水，然后将茶叶放到杯子里，将开水倒入杯中，等茶叶泡好。

3. 问题：开车。

   其中的算法：首先要打开车门，驾驶员坐好，插上车钥匙，发动汽车。
   

G. C语言算法有哪些 并举例和分析

算法大全（C，C++）
一、 数论算法

1．求两数的最大公约数
function gcd(a,b:integer):integer;
begin
if b=0 then gcd:=a
else gcd:=gcd (b,a mod b);
end ;

2．求两数的最小公倍数
function lcm(a,b:integer):integer;
begin
if a<b then swap(a,b);
lcm:=a;
while lcm mod b>0 do inc(lcm,a);
end;

3．素数的求法
A.小范围内判断一个数是否为质数：
function prime (n: integer): Boolean;
var I: integer;
begin
for I:=2 to trunc(sqrt(n)) do
if n mod I=0 then begin
prime:=false; exit;
end;
prime:=true;
end;

B.判断longint范围内的数是否为素数（包含求50000以内的素数表）：
procere getprime;
var
i,j:longint;
p:array[1..50000] of boolean;
begin
fillchar(p,sizeof(p),true);
p[1]:=false;
i:=2;
while i<50000 do begin
if p[i] then begin
j:=i*2;
while j<50000 do begin
p[j]:=false;
inc(j,i);
end;
end;
inc(i);
end;
l:=0;
for i:=1 to 50000 do
if p[i] then begin
inc(l);pr[l]:=i;
end;
end;{getprime}

function prime(x:longint):integer;
var i:integer;
begin
prime:=false;
for i:=1 to l do
if pr[i]>=x then break
else if x mod pr[i]=0 then exit;
prime:=true;
end;{prime}

二、图论算法

1．最小生成树

A.Prim算法：

procere prim(v0:integer);
var
lowcost,closest:array[1..maxn] of integer;
i,j,k,min:integer;
begin
for i:=1 to n do begin
lowcost[i]:=cost[v0,i];
closest[i]:=v0;
end;
for i:=1 to n-1 do begin
{寻找离生成树最近的未加入顶点k}
min:=maxlongint;
for j:=1 to n do
if (lowcost[j]<min) and (lowcost[j]<>0) then begin
min:=lowcost[j];
k:=j;
end;
lowcost[k]:=0; {将顶点k加入生成树}
{生成树中增加一条新的边k到closest[k]}
{修正各点的lowcost和closest值}
for j:=1 to n do
if cost[k,j]<lwocost[j] then begin
lowcost[j]:=cost[k,j];
closest[j]:=k;
end;
end;
end;{prim}

B.Kruskal算法：(贪心)

按权值递增顺序删去图中的边，若不形成回路则将此边加入最小生成树。
function find(v:integer):integer; {返回顶点v所在的集合}
var i:integer;
begin
i:=1;
while (i<=n) and (not v in vset[i]) do inc(i);
if i<=n then find:=i else find:=0;
end;

procere kruskal;
var
tot,i,j:integer;
begin
for i:=1 to n do vset[i]:=[i];{初始化定义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条边的长度}
while p>0 do begin
i:=find(e[q].v1);j:=find(e[q].v2);
if i<>j then begin
inc(tot,e[q].len);
vset[i]:=vset[i]+vset[j];vset[j]:=[];
dec(p);
end;
inc(q);
end;
writeln(tot);
end;

2.最短路径

A.标号法求解单源点最短路径：
var
a:array[1..maxn,1..maxn] of integer;
b:array[1..maxn] of integer; {b[i]指顶点i到源点的最短路径}
mark:array[1..maxn] of boolean;

procere bhf;
var
best,best_j:integer;
begin
fillchar(mark,sizeof(mark),false);
mark[1]:=true; b[1]:=0;{1为源点}
repeat
best:=0;
for i:=1 to n do
If mark[i] then {对每一个已计算出最短路径的点}
for j:=1 to n do
if (not mark[j]) and (a[i,j]>0) then
if (best=0) or (b[i]+a[i,j]<best) then begin
best:=b[i]+a[i,j]; best_j:=j;
end;
if best>0 then begin
b[best_j]:=best；mark[best_j]:=true;
end;
until best=0;
end;{bhf}

B.Floyed算法求解所有顶点对之间的最短路径：
procere floyed;
begin
for I:=1 to n do
for j:=1 to n do
if a[I,j]>0 then p[I,j]:=I else p[I,j]:=0; {p[I,j]表示I到j的最短路径上j的前驱结点}
for k:=1 to n do {枚举中间结点}
for i:=1 to n do
for j:=1 to n do
if a[i,k]+a[j,k]<a[i,j] then begin
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] of integer;
b,pre:array[1..maxn] of integer; {pre[i]指最短路径上I的前驱结点}
mark:array[1..maxn] of boolean;
procere dijkstra(v0:integer);
begin
fillchar(mark,sizeof(mark),false);
for i:=1 to n do begin
d[i]:=a[v0,i];
if d[i]<>0 then pre[i]:=v0 else pre[i]:=0;
end;
mark[v0]:=true;
repeat {每循环一次加入一个离1集合最近的结点并调整其他结点的参数}
min:=maxint; u:=0; {u记录离1集合最近的结点}
for i:=1 to n do
if (not mark[i]) and (d[i]<min) then begin
u:=i; min:=d[i];
end;
if u<>0 then begin
mark[u]:=true;
for i:=1 to n do
if (not mark[i]) and (a[u,i]+d[u]<d[i]) then begin
d[i]:=a[u,i]+d[u];
pre[i]:=u;
end;
end;
until u=0;
end;

3.计算图的传递闭包

Procere Longlink;
Var
T:array[1..maxn,1..maxn] of boolean;
Begin
Fillchar(t,sizeof(t),false);
For k:=1 to n do
For I:=1 to n do
For j:=1 to n do T[I,j]:=t[I,j] or (t[I,k] and t[k,j]);
End;

4．无向图的连通分量

A.深度优先
procere dfs ( now,color: integer);
begin
for i:=1 to n do
if a[now,i] and c[i]=0 then begin {对结点I染色}
c[i]:=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由<j,k>表示，则Ee[I] = Ve[j];
d. 边活动最晚开始时间 El[I], 若边I由<j,k>表示，则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条边。
procere bellman-ford
begin
for I:=0 to n-1 do d[I]:=+infinitive;
d[0]:=0;
for I:=1 to n-1 do
for j:=1 to m do {枚举每一条边}
if d[x[j]]+t[j]<d[y[j]] then d[y[j]]:=d[x[j]]+t[j];
for I:=1 to m do
if d[x[j]]+t[j]<d[y[j]] then return false else return true;
end;

10．第n最短路径问题

*第二最短路径：每举最短路径上的每条边，每次删除一条，然后求新图的最短路径，取这些路径中最短的一条即为第二最短路径。
*同理，第n最短路径可在求解第n-1最短路径的基础上求解。

三、背包问题

*部分背包问题可有贪心法求解：计算Pi/Wi
数据结构：
w[i]:第i个背包的重量；
p[i]:第i个背包的价值；

1．0-1背包： 每个背包只能使用一次或有限次(可转化为一次)：

A.求最多可放入的重量。
NOIP2001 装箱问题
有一个箱子容量为v(正整数，o≤v≤20000)，同时有n个物品(o≤n≤30)，每个物品有一个体积 (正整数)。要求从 n 个物品中，任取若千个装入箱内，使箱子的剩余空间为最小。
l 搜索方法
procere search(k,v:integer); {搜索第k个物品，剩余空间为v}
var i,j:integer;
begin
if v<best then best:=v;
if v-(s[n]-s[k-1])>=best then exit; {s[n]为前n个物品的重量和}
if k<=n then begin
if v>w[k] then search(k+1,v-w[k]);
search(k+1,v);
end;
end;

l DP
F[I,j]为前i个物品中选择若干个放入使其体积正好为j的标志，为布尔型。
实现:将最优化问题转化为判定性问题
f [I, j] = f [ i-1, j-w[i] ] (w[I]<=j<=v) 边界：f[0,0]:=true.
For I:=1 to n do
For j:=w[I] to v do F[I,j]:=f[I-1,j-w[I]];
优化：当前状态只与前一阶段状态有关，可降至一维。
F[0]:=true;
For I:=1 to n do begin
F1:=f;
For j:=w[I] to v do
If f[j-w[I]] then f1[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:
Procere update;
var j,k:integer;
begin
c:=a;
for j:=0 to n do
if a[j]>0 then
if j+now<=n then inc(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.. j div w[I])

B.求可以放入的最大价值。
USACO 1.2 Score Inflation
进行一次竞赛，总时间T固定，有若干种可选择的题目，每种题目可选入的数量不限，每种题目有一个ti（解答此题所需的时间）和一个si（解答此题所得的分数），现要选择若干题目，使解这些题的总时间在T以内的前提下，所得的总分最大，求最大的得分。
*易想到：
f[i,j] = max { f [i- k*w[j], j-1] + k*p[j] } (0<=k<= i div w[j])
其中f[i,j]表示容量为i时取前j种背包所能达到的最大值。
*实现：
Begin
FillChar(f,SizeOf(f),0);
For i:=1 To M Do
For j:=1 To N Do
If i-problem[j].time>=0 Then
Begin
t:=problem[j].point+f[i-problem[j].time];
If t>f[i] Then f[i]:=t;
End;
Writeln(f[M]);
End.

C.求恰好装满的情况数。
Ahoi2001 Problem2
求自然数n本质不同的质数和的表达式的数目。
思路一，生成每个质数的系数的排列，在一一测试，这是通法。
procere try(dep:integer);
var i,j:integer;
begin
cal; {此过程计算当前系数的计算结果，now为结果}
if now>n then exit; {剪枝}
if dep=l+1 then begin {生成所有系数}
cal;
if now=n then inc(tot);
exit;
end;
for i:=0 to n div pr[dep] do begin
xs[dep]:=i;
try(dep+1);
xs[dep]:=0;
end;
end;

思路二，递归搜索效率较高
procere try(dep,rest:integer);
var i,j,x:integer;
begin
if (rest<=0) or (dep=l+1) then begin
if rest=0 then inc(tot);
exit;
end;
for i:=0 to rest div pr[dep] do
try(dep+1,rest-pr[dep]*i);
end;
{main: try(1,n); }

思路三：可使用动态规划求解
USACO1.2 money system
V个物品，背包容量为n，求放法总数。
转移方程：

Procere update;
var j,k:integer;
begin
c:=a;
for j:=0 to n do
if a[j]>0 then
for k:=1 to n div now do
if j+now*k<=n then inc(c[j+now*k],a[j]);
a:=c;
end;
{main}
begin
read(now); {读入第一个物品的重量}
i:=0; {a[i]为背包容量为i时的放法总数}
while i<=n do begin
a[i]:=1; inc(i,now); end; {定义第一个物品重的整数倍的重量a值为1，作为初值}
for i:=2 to v do
begin
read(now);
update; {动态更新}
end;
writeln(a[n]);

四、排序算法

A.快速排序：

procere qsort(l,r:integer);
var i,j,mid:integer;
begin
i:=l;j:=r; mid:=a[(l+r) div 2]; {将当前序列在中间位置的数定义为中间数}
repeat
while a[i]<mid do inc(i); {在左半部分寻找比中间数大的数}
while a[j]>mid do dec(j);{在右半部分寻找比中间数小的数}
if i<=j then begin {若找到一组与排序目标不一致的数对则交换它们}
swap(a[i],a[j]);
inc(i);dec(j); {继续找}
end;
until i>j;
if l<j then qsort(l,j); {若未到两个数的边界，则递归搜索左右区间}
if i<r then qsort(i,r);
end;{sort}

B.插入排序：

思路：当前a[1]..a[i-1]已排好序了，现要插入a[i]使a[1]..a[i]有序。
procere insert_sort;
var i,j:integer;
begin
for i:=2 to n do begin
a[0]:=a[i];
j:=i-1;
while a[0]<a[j] do begin
a[j+1]:=a[j];
j:=j-1;
end;
a[j+1]:=a[0];
end;
end;{inset_sort}

C.选择排序：
procere sort;
var i,j,k:integer;
begin
for i:=1 to n-1 do
for j:=i+1 to n do
if a[i]>a[j] then swap(a[i],a[j]);
end;

D. 冒泡排序
procere bubble_sort;
var i,j,k:integer;
begin
for i:=1 to n-1 do
for j:=n downto i+1 do
if a[j]<a[j-1] then swap( a[j],a[j-1]); {每次比较相邻元素的关系}
end;

E.堆排序：
procere sift(i,m:integer);{调整以i为根的子树成为堆,m为结点总数}
var k:integer;
begin
a[0]:=a[i]; k:=2*i;{在完全二叉树中结点i的左孩子为2*i,右孩子为2*i+1}
while k<=m do begin
if (k<m) and (a[k]<a[k+1]) then inc(k);{找出a[k]与a[k+1]中较大值}
if a[0]<a[k] then begin a[i]:=a[k];i:=k;k:=2*i; end
else k:=m+1;
end;
a[i]:=a[0]; {将根放在合适的位置}
end;

procere heapsort;
var
j:integer;
begin
for j:=n div 2 downto 1 do sift(j,n);
for j:=n downto 2 do begin
swap(a[1],a[j]);
sift(1,j-1);
end;

H. 二进制算法例子

很多啊，最简单的就是开、关了，凡是有两个相反、相对状态的就可以抽象为0和1了。

讲二进制应该类比十进制来讲。如10进制中，过了9就要进位了，2进制中，过了1就要进位了，高位就加1。和也是，如10进制的235，实际上是这样算出来的：
235 = 2* 10^2 + 3* 10^1 + 5*10^0 = 235
2进制也是如此：
101 = 1* 2^2 + 0*2^1 + 1*2^0 = 5
都是以这个进制的基数，进行每位的求和后得出。只要脑子还灵光的，都应该可以理解。

I. 什么是算法试从日常生活中找3个例子，描述它们的算法

算法就是解决问题的方法比如你要喝茶就要先找到茶叶，烧一壶开水，然后将茶叶放到杯子里，然后将开水倒入杯中，然后等一段时间再比如你要从a地到b地，中间可能有多种汽车换乘方案，是选速度最快的，还是选最省钱的，还是平衡的，制定换乘方案就是算法。

J. 实例计算

为了进一步阐述上述模型的使用方法，本节将使用松散沉积层包气带防污性能评价模型以某区域为例进行防污性能评价的计算演示。

假设该区域范围内污染物的初始浓度为100μg/L，将穿透整个包气带到达地下水面时污染物的浓度为初始浓度的1%，即1μg/L作为浓度限制，通过计算污染物需要多少时间才会达到该限制浓度，直接按照耗费的时间长短作为该地区防污性能的评价标准。

以某地区的10个典型包气带钻孔为例依次进行研究，系统的介绍该模型的计算及评价方法。首先，根据松散沉积物命名表将10个包气带钻孔进行细致划分，标明各层的厚度，然后按照忽略薄夹层，合并相似层的原则，对相对阻滞系数相同、渗透系数相同或细小的夹层进行厚度合并与概化，统一为一个整体层位便于下步计算。10个钻孔的概化结果见表7.5～表7.14。

表7.5 某包气带A钻孔剖面岩性表

注:由于两层亚粘土之间夹有的砂层很薄，因此将其直接归入亚粘土中，不另外计算其层位的相对阻滞系数。

表7.6 某包气带B钻孔剖面岩性表

续表

注:由于粉砂与细砂的相对阻滞系数相同，因此将两层合并，夹在亚粘土中的细砂层与粗砂层较亚粘土层薄，因此与上下亚粘土层合并为一个整体，夹层不再做单独计算。

表7.7 某包气带C钻孔剖面岩性表

注:由于粉细砂与粗砂的相对阻滞系数相同，因此将两层合并，不做单独计算。

表7.8 某包气带D钻孔剖面岩性表

注:由于粉细砂与含砾中细砂的相对阻滞系数相同，因此将两层合并，不做单独计算。

表7.9 某包气带E钻孔剖面岩性表

表7.10 某包气带F钻孔剖面岩性表

注:由于淤泥与粘土的相对阻滞系数相同，因此将两层合并，不做单独计算。

表7.11 某包气带G钻孔剖面岩性表

表7.12 某包气带H钻孔剖面岩性表

表7.13 某包气带I钻孔剖面岩性表

表7.14 某包气带J钻孔剖面岩性表

注:由于亚粘土与粉砂亚粘土互层的渗透系数相同，因此将两层合并，不做单独计算。

根据表7.5～表7.14的岩性概化结果可进行下步计算，A～J剖面的数据都在表7.5～表7.14中列出。按照7.3.2中给出的计算方法，先对A剖面进行计算，设定初始浓度100μg/L，限制浓度为初始浓度的1%，即1μg/L，垂向深度单元数为111，将表7.5中列出的各种介质的阻滞系数R_i'代入非均质包气带的公式(7.3)中，得y=60，即需要60个时间单元使得到达地下水面的污染物浓度达到1μg/L，接下来要计算的是走完一个单元的具体时间，根据表7.5中列出的渗透系数及公式:

T=t₁+t₂+t₃+…+t_n=L₁/K₁+L₂/K₂+L₃/K₃+…+L_n/K_n即

T_A=(4/0.5+11/0.1+8/1+53/0.1+6/20+29/0.1)/365=2.6年，那么污染物在A剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_A×T_A=60×2.6=156年。

按此步骤依次计算余下的9个钻孔，其中:

污染物在B剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_B×T_B=56×2.43=136年。

污染物在C剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_C×T_C=7×0.5=3.5年。

污染物在D剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_D×T_D=27×1.14=30.9年。

污染物在E剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_E×T_E=42×1.90=79.7年。

污染物在F剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_F×T_F=14×0.89=12.4年。

污染物在G剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_G×T_G=35×1.66=58年。

污染物在H剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_H×T_H=29×2.15=56年。

污染物在I剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_I×T_I=47×2.6=101年。

污染物在J剖面中累积浓度达到限制浓度所耗费的时间为:时间单元数y_J×T_J=13×0.77=10年。

通过计算发现，不同的剖面达到相同限制浓度所耗费的时间各有不同，计算结果见表7.15。

表7.15 10个包气带剖面防污性能评价结果

从表7.15中可以看出，同种污染物通过不同厚度、不同结构的包气带剖面所耗费的时间各有不同，且差异较大，污染物进入地下水的累积浓度达到1μg/L时所耗费的时间最少为10年，最多的可达到156年。据上节所述，包气带的厚度及结构对其防污性能都有着十分重要的影响，其中，包气带的厚度越厚，污染物进入地下水的途径就越长，去除污染物的容量就越大，地下水受到污染物威胁的可能性也就越弱;而包气带结构中阻滞能力较强的夹层有增强整个包气带防污性能的效力，夹层越厚，污染物到达地下水的浓度也越低，整个包气带的防污性能就越强。因此，下面就从该区域的包气带厚度及阻滞能力强的粘土、亚粘土层厚度出发，分析其对防污性能的影响及其影响的重要性。

图7.1 影响防污性能的因素分析图

图7.1分别绘制了剖面厚度及剖面中粘土、亚粘土厚度对防污性能的影响，从图7.1中可以看出，不管是整个剖面的厚度还是其中粘土、亚粘土层的厚度都与防污性能有着较好的正相关关系，拟合方程分别为y=0.497x+36.417，y=0.4965x+17.15，R²分别为0.8418和0.978。从拟合的相关系数不难发现，粘土、亚粘土层的厚度对包气带的防污性能影响高于整个包气带厚度所产生的影响，也就是包气带的结构对整个包气带的防污性能影响更为重要，且本研究建立的评价模型能很好地反映出结构差异造成的防污能力差异。粘土、亚粘土层的有机碳含量较高，且土壤质地较密集，孔隙度小，污染物通过该层所耗费的时间长，因此就有充足的时间在土壤中发生吸附作用，且含量较高的有机碳能吸附更多的污染物，进而降低污染物的浓度;而砂质土壤，它的孔隙度较大，污染物在该层的渗流速度较大，因此在该层停留的时间就越短，不能够很好地进行吸附反应，污染物的去除也不充分，致使污染物能较快地进入地下水，且进入地下水的浓度也较通过粘土层的高。由此可知，粘土、亚粘土是松散沉积层中防污性能最好的质地，其在包气带结构中占据的越多或者越靠近包气带的上部，阻滞污染物进入地下水的能力就越强，从而提高整个包气带介质的防污性能。总之，通过使用该评价模型计算结果可知，该松散沉积层内各包气带的防污性能由好至差的排序为:A＞B＞I＞E＞G＞H＞D＞F＞J＞C。

本章所讨论的松散沉积层细化包气带的评价体系仅仅是一种新思路的提出，在很多防污性能评价方法的研究中，研究者们都已认识到了包气带对地下水防污能力的影响，且在修正各种评价方法的时候都突出强调了包气带介质在地下水防污性能评价中的重要性。本研究建立的评价模型本着突出包气带介质重要性的前提，从结构上对包气带进行了更为细致的刻画，分析包气带结构的差异对地下水防污性能的贡献及影响。鉴于中国的地下水供水水源地大部分在松散沉积物区，故该评价方法主要是从松散沉积层的角度出发，地下水考虑的也仅是潜水含水层，根据这种思路构建的一套细化包气带的防污性能评价体系。实例计算是从以往的研究中选取了10 个较有代表性的钻孔资料，从钻孔的概化 ( 阻滞系数相同的层位可合并或将细小夹层与上下层位进行合并) 、参数的获取 ( 从给出的参数表中根据具体岩性名称查取各个层位的相对阻滞系数及渗透系数) 、计算 ( 根据所获取的参数计算污染物进入地下水所需的时间) 到最后的评价，对评价体系中的计算方法进行了一次有针对性及代表性的演示，遗憾的是，由于缺少实测资料而未能对该防污性能评价方法进行系统的验证。本研究提出的通过细化包气带的结构对地下水防污性能评价的方法虽然是一种尝试但还是有其实用价值的，它即能单独作为松散沉积层包气带结构的一种评价模式应用于其他的含水层评价中，也可作为某些防污性能评价方法的补充，尤其是评价污染物在包气带介质中垂向途径上的迁移。