算法研究.docx

算法研究.docx

《算法研究.docx》由会员分享，可在线阅读，更多相关《算法研究.docx（73页珍藏版）》请在冰豆网上搜索。

算法研究

算法学习

（一）

作者：

佚名文章来源：

本站原创点击数：

3253更新时间：

2004-5-15

一、迭代法

迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。

设方程为f（x）=0，用

某种数学方法导出等价的形式x=g（x），然后按以下步骤执行：

（1）   选一个方程的近似根，赋给变量x0；

（2）   将x0的值保存于变量x1，然后计算g（x1），并将结果存于变量x0；

（3）   当x0与x1的差的绝对值还小于指定的精度要求时，重复步骤

（2）的计算。

若方程有根，并且用上述方法计算出来的近似根序列收敛，则按上述方法求得的x0就认

为是方程的根。

上述算法用C程序的形式表示为：

【算法】迭代法求方程的根

{   x0=初始近似根；

    do {

        x1=x0；

        x0=g（x1）；  /*按特定的方程计算新的近似根*/

        } while （ fabs（x0-x1）>Epsilon）；

    printf（“方程的近似根是%f\n”，x0）；

}

迭代算法也常用于求方程组的根，令

        X=（x0，x1，…，xn-1）

设方程组为：

        xi=gi（X）        （I=0，1，…，n-1）

则求方程组根的迭代算法可描述如下：

【算法】迭代法求方程组的根

    {   for （i=0;i

            x[i]=初始近似根;

        do {

            for （i=0;i

                y[i]=x[i];

            for （i=0;i

                x[i]=gi（X）;

            for （delta=0.0,i=0;i

                if （fabs（y[i]-x[i]）>delta）

    delta=fabs（y[i]-x[i]）；

            } while （delta>Epsilon）；

        for （i=0;i

            printf（“变量x[%d]的近似根是 %f”，I，x[i]）；

        printf（“\n”）；

    }

    具体使用迭代法求根时应注意以下两种可能发生的情况：

（1）   如果方程无解，算法求出的近似根序列就不会收敛，迭代过程会变成死循

环，因此在使用迭代算法前应先考察方程是否有解，并在程序中对迭代的次数给予限

制；

（2）   方程虽然有解，但迭代公式选择不当，或迭代的初始近似根选择不合理，也

会导致迭代失败。

二、穷举搜索法

    穷举搜索法是对可能是解的众多候选解按某种顺序进行逐一枚举和检验，并

从众找出那些符合要求的候选解作为问题的解。

【问题】    将A、B、C、D、E、F这六个变量排成如图所示的三角形，这六个变量分别取

[1，6]上的整数，且均不相同。

求使三角形三条边上的变量之和相等的全部解。

如图就

是一个解。

程序引入变量a、b、c、d、e、f，并让它们分别顺序取1至6的证书，在它们互不相同的

条件下，测试由它们排成的如图所示的三角形三条边上的变量之和是否相等，如相等即

为一种满足要求的排列，把它们输出。

当这些变量取尽所有的组合后，程序就可得到全

部可能的解。

细节见下面的程序。

【程序1】

# include 

void main（）

{   int a,b,c,d,e,f;

    for （a=1;a<=6;a++）

        for （b=1;b<=6;b++）      {

            if （b==a）       continue;

            for （c=1;c<=6;c++）      {

                if （c==a）||（c==b）   continue;

                for （d=1;d<=6;d++）      {

                    if （d==a）||（d==b）||

（d==c）  continue;

for （e=1;e<=6;e++）      {

    if （e==a）||（e==b）||（e==c）||（e==d）   continue;

f=21-（a+b+c+d+e）;

if （（a+b+c==c+d+e））&&（a+b+c==e+f+a））    {

printf（“%6d,a）;

    printf（“%4d%4d”,b,f）;

    printf（“%2d%4d%4d”,c,d,e）;

    scanf（“%*c”）;

}

                        }

                    }

                }

            }

        }

按穷举法编写的程序通常不能适应变化的情况。

如问题改成有9个变量排成三角形，每条

边有4个变量的情况，程序的循环重数就要相应改变。

    对一组数穷尽所有排列，还有更直接的方法。

将一个排列看作一个长整数，

则所有排列对应着一组整数。

将这组整数按从小到大的顺序排列排成一个整数，从对应

最小的整数开始。

按数列的递增顺序逐一列举每个排列对应的每个整数，这能更有效地

完成排列的穷举。

从一个排列找出对应数列的下一个排列可在当前排列的基础上作部分

调整来实现。

倘若当前排列为1，2，4，6，5，3，并令其对应的长整数为124653。

要寻

找比长整数124653更大的排列，可从该排列的最后一个数字顺序向前逐位考察，当发现

排列中的某个数字比它前一个数字大时，如本例中的6比它的前一位数字4大，这说明还

有对应更大整数的排列。

但为了顺序从小到大列举出所有的排列，不能立即调整得太

大，如本例中将数字6与数字4交换得到的排列126453就不是排列124653的下一个排列。

为了得到排列124653的下一个排列，应从已经考察过的那部分数字中选出比数字大，但

又是它们中最小的那一个数字，比如数字5，与数字4交换。

该数字也是从后向前考察过

程中第一个比4大的数字。

5与4交换后，得到排列125643。

在前面数字1，2，5固定的情

况下，还应选择对应最小整数的那个排列，为此还需将后面那部分数字的排列顺序颠

倒，如将数字6，4，3的排列顺序颠倒，得到排列1，2，5，3，4，6，这才是排列1，2，

4，6，5，3的下一个排列。

按以上想法编写的程序如下。

【程序2】

# include 

# define SIDE_N 3

# define LENGTH 3

# define VARIABLES  6

int A,B,C,D,E,F;

int *pt[]={&A,&B,&C,&D,&E,&F};

int *side[SIDE_N][LENGTH]={&A,&B,&C,&C,&D,&E,&E,&F,&A};

int side_total[SIDE_N];

main{}

{   int i,j,t,equal;

    for （j=0;j

        *pt[j]=j+1;

    while

（1）

    {   for （i=0;i

        {   for （t=j=0;j

                t+=*side[i][j];

            side_total[i]=t;

        }

        for （equal=1,i=0;equal&&i

            if （side_total[i]!

=side_total[i+1]

    equal=0;

        if （equal）

        {   for （i=1;i

                printf（“%4d”,*pt[i]）;

            printf（“\n”）;

            scanf（“%*c”）;

        }

        for （j=VARIABLES-1;j>0;j--）

            if （*pt[j]>*pt[j-1]）    break;

        if （j==0）   break;

        for （i=VARIABLES-1;i>=j;i--）

            if （*pt[i]>*pt[i-1]）    break;

        t=*pt[j-1];* pt[j-1] =* pt[i]; *pt[i]=t;

        for （i=VARIABLES-1;i>j;i--,j++）

        {   t=*pt[j]; *pt[j] =* pt[i]; *pt[i]=t;    }

    }

}

从上述问题解决的方法中，最重要的因素就是确定某种方法来确定所有的候选解。

下面

再用一个示例来加以说明。

【问题】    背包问题

问题描述：

有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择

方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。

设n个物品的重量和价值分别存储于数组w[ ]和v[ ]中，限制重量为tw。

考虑一个n元组

（x0，x1，…，xn-1），其中xi=0 表示第i个物品没有选取，而xi=1则表示第i个物品被

选取。

显然这个n元组等价于一个选择方案。

用枚举法解决背包问题，需要枚举所有的选

取方案，而根据上述方法，我们只要枚举所有的n元组，就可以得到问题的解。

显然，每个分量取值为0或1的n元组的个数共为2n个。

而每个n元组其实对应了一个长度

为n的二进制数，且这些二进制数的取值范围为0～2n-1。

因此，如果把0～2n-1分别转化

为相应的二进制数，则可以得到我们所需要的2n个n元组。

【算法】

maxv=0;

for （i=0;i<2n;i++）

{   B[0..n-1]=0;

    把i转化为二进制数，存储于数组B中;

    temp_w=0;

    temp_v=0;

    for （j=0;j

    {   if （B[j]==1）

        {   temp_w=temp_w+w[j];

            temp_v=temp_v+v[j];

        }

        if （（temp_w<=tw）&&（temp_v>maxv））

        {   maxv=temp_v;

            保存该B数组；

        }

    }

}

三、递推法

    递推法是利用问题本身所具有的一种递推关系求问题解的一种方法。

设要求

问题规模为N的解，当N=1时，解或为已知，或能非常方便地得到解。

能采用递推法构造

算法的问题有重要的递推性质，即当得到问题规模为i-1的解后，由问题的递推性质，能

从已求得的规模为1，2，…，i-1的一系列解，构造出问题规模为I的解。

这样，程序可

从i=0或i=1出发，重复地，由已知至i-1规模的解，通过递推，获得规模为i的解，直至

得到规模为N的解。

【问题】    阶乘计算

问题描述：

编写程序，对给定的n（n≦100），计算并输出k的阶乘k！

（k=1，2，…，

n）的全部有效数字。

由于要求的整数可能大大超出一般整数的位数，程序用一维数组存储长整数，存储长整

数数组的每个元素只存储长整数的一位数字。

如有m位成整数N用数组a[ ]存储：

    N=a[m]×10m-1+a[m-1]×10m-2+ … +a[2]×101+a[1]×100

并用a[0]存储长整数N的位数m，即a[0]=m。

按上述约定，数组的每个元素存储k的阶乘

k！

的一位数字，并从低位到高位依次存于数组的第二个元素、第三个元素……。

例如，

5！

=120，在数组中的存储形式为：

3   0   2   1   ……

首元素3表示长整数是一个3位数，接着是低位到高位依次是0、2、1，表示成整数120。

    计算阶乘k！

可采用对已求得的阶乘（k-1）！

连续累加k-1次后求得。

例如，已

知4！

=24，计算5！

，可对原来的24累加4次24后得到120。

细节见以下程序。

# include 

# include 

# define  MAXN  1000

void  pnext（int a[ ],int k）

{   int *b,m=a[0],i,j,r,carry;

    b=（int * ） malloc（sizeof（int）* （m+1））;

    for （ i=1;i<=m;i++）     b[i]=a[i];

    for （ j=1;j<=k;j++）

    {   for （ carry=0,i=1;i<=m;i++）

        {   r=（i

a[i]+b[i]:

a[i]）+carry;

            a[i]=r%10;

            carry=r/10;

        }

        if （carry）  a[++m]=carry;

    }

    free（b）;

    a[0]=m;

}

void  write（int *a,int k）

{   int i;

    printf（“%4d！

=”,k）;

    for （i=a[0];i>0;i--）

        printf（“%d”,a[i]）;

printf（“\n\n”）;

}

void main（）

{   int a[MAXN],n,k;

    printf（“Enter the number n:

  “）;

    scanf（“%d”,&n）;

    a[0]=1;

    a[1]=1;

    write（a,1）;

    for （k=2;k<=n;k++）

    {   pnext（a,k）;

        write（a,k）;

        getchar（）;

    }

}

四、递归

    递归是设计和描述算法的一种有力的工具，由于它在复杂算法的描述中被经

常采用，为此在进一步介绍其他算法设计方法之前先讨论它。

    能采用递归描述的算法通常有这样的特征：

为求解规模为N的问题，设法将它

分解成规模较小的问题，然后从这些小问题的解方便地构造出大问题的解，并且这些规

模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小

问题的解构造出规模较大问题的解。

特别地，当规模N=1时，能直接得解。

【问题】    编写计算斐波那契（Fibonacci）数列的第n项函数fib（n）。

    斐波那契数列为：

0、1、1、2、3、……，即：

        fib（0）=0;

        fib

（1）=1;

        fib（n）=fib（n-1）+fib（n-2）        （当n>1时）。

写成递归函数有：

int fib（int n）

{   if （n==0）       return  0;

    if （n==1）       return  1;

    if （n>1）        return  fib（n-1）+fib（n-2）;

}

    递归算法的执行过程分递推和回归两个阶段。

在递推阶段，把较复杂的问题

（规模为n）的求解推到比原问题简单一些的问题（规模小于n）的求解。

例如上例中，

求解fib（n），把它推到求解fib（n-1）和fib（n-2）。

也就是说，为计算fib（n），必须先计

算fib（n-1）和fib（n-2），而计算fib（n-1）和fib（n-2），又必须先计算fib（n-3）和fib（n-

4）。

依次类推，直至计算fib

（1）和fib（0），分别能立即得到结果1和0。

在递推阶段，必

须要有终止递归的情况。

例如在函数fib中，当n为1和0的情况。

    在回归阶段，当获得最简单情况的解后，逐级返回，依次得到稍复杂问题的

解，例如得到fib

（1）和fib（0）后，返回得到fib

（2）的结果，……，在得到了fib（n-1）和

fib（n-2）的结果后，返回得到fib（n）的结果。

    在编写递归函数时要注意，函数中的局部变量和参数知识局限于当前调用

层，当递推进入“简单问题”层时，原来层次上的参数和局部变量便被隐蔽起来。

在一

系列“简单问题”层，它们各有自己的参数和局部变量。

    由于递归引起一系列的函数调用，并且可能会有一系列的重复计算，递归算

法的执行效率相对较低。

当某个递归算法能较方便地转换成递推算法时，通常按递推算

法编写程序。

例如上例计算斐波那契数列的第n项的函数fib（n）应采用递推算法，即从斐

波那契数列的前两项出发，逐次由前两项计算出下一项，直至计算出要求的第n项。

【问题】    组合问题

问题描述：

找出从自然数1、2、……、n中任取r个数的所有组合。

例如n=5，r=3的所有

组合为：

（1）5、4、3        

（2）5、4、2

    （3）5、4、1

            （4）5、3、2        （5）5、3、1

        （6）5、2、1

            （7）4、3、2        （8）4、3、1

        （9）4、2、1

            （10）3、2、1

    分析所列的10个组合，可以采用这样的递归思想来考虑求组合函数的算法。

设函数为void  comb（int m,int k）为找出从自然数1、2、……、m中任取k个数的所有组

合。

当组合的第一个数字选定时，其后的数字是从余下的m-1个数中取k-1数的组合。

这

就将求m个数中取k个数的组合问题转化成求m-1个数中取k-1个数的组合问题。

设函数引

入工作数组a[ ]存放求出的组合的数字，约定函数将确定的k个数字组合的第一个数字放

在a[k]中，当一个组合求出后，才将a[ ]中的一个组合输出。

第一个数可以是m、m-1、

……、k，函数将确定组合的第一个数字放入数组后，有两种可能的选择，因还未去顶组

合的其余元素，继续递归去确定；或因已确定了组合的全部元素，输出这个组合。

细节

见以下程序中的函数comb。

【程序】

# include   

# define    MAXN    100

int a[MAXN];

void    comb（int m,int k）

{   int i,j;

    for （i=m;i>=k;i--）

    {   a[k]=i;

        if （k>1）

            comb（i-1,k-1）;

        else

        {   for （j=a[0];j>0;j--）

                printf（“%4d”,a[j]）;

            printf（“\n”）;

        }

    }

}

void main（）

{   a[0]=3;

    comb（5,3）;

}

【问题】    背包问题

问题描述：

有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择

方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。

设n件物品的重量分别为w0、w1、…、wn-1，物品的价值分别为v0、v1、…、vn-1。

采用

递归寻找物品的选择方案。

设前面已有了多种选择的方案，并保留了其中总价值最大的

方案于数组option[ ]，该方案的总价值存于变量maxv。

当前正在考察新方案，其物品选

择情况保存于数组cop[ ]。

假定当前方案已考虑了前i-1件物品，现在要考虑第i件物

品；当前方案已包含的物品的重量之和为tw；至此，若其余物品都选择是可能的话，本

方案能达到的总价值的期望值为tv。

算法引入tv是当一旦当前方案的总价值的期望值也

小于前面方案的总价值maxv时，继续考察当前方案变成无意义的工作，应终止当前方

案，立即去考察下一个方案。

因为当方案的总价值不比maxv大时，该方案不会被再考

察，这同时保证函数后找到的方案一定会比前面的方案更好。

对于第i件物品的选择考虑有两种可能：

（1）   考虑物品i被选择，这种可能性仅当包含它不会超过方案总重量限制时才是可

行的。

选中后，继续递归去考虑其余物品的选择。

（2）   考虑物品i不被选择，这种可能性仅当不包含物品i也有可能会找到价值更大

的方案的情况。

按以上思想写出递归算法如下：

try（物品i，当前选择已达到的重量和，本方案可能达到的总价值tv）

{   /*考虑物品i包含在当前方案中的可能性*/

    if（包含物品i是可以接受的）

    {   将物品i包含在当前方案中；

        if （i

            try（i+1,tw+物品i的重量,tv）;

        else

            /*又一个完整方案，因为它比前面的方案好，以它

作为最佳方案*/

以当前方案作为临时最佳方案保存;

            恢复物品i不包含状态；

        }

        /*考虑物品i不包含在当前方案中的可能性*/

        if （不包含物品i仅是可男考虑的）

            if （i

                try（i+1,tw,tv-物品i的价值）；

            else

                /*又一个完整方案，因它比前面的方案

好，以它作为最佳方案*/

以当前方案作为临时最佳方案保存;

    }

    为了理解上述算法，特举以下实例。

设有4件物品，它们的重量和价值见表：

物品    0   1   2   3

重量    5   3   2   1

价值    4   4   3   1

并设限制重量为7。

则按以上算法，下图表示找解过程。

由图知，一旦找到一个解，算法

就进一步找更好的佳。

如能判定某个查找分支不会找到更好的解，算法不会在该分支继

续查找，而是立即终止该分支，并去考察下一个分支。

按上述算法编写函数和程序如下：

【程序】

# include   

# define    N   100

double  limitW,totV,maxV;

int option[N],cop[N];

struct  {   double  weight;

            double  value;

        }a[N];

int n;

void find（int i,double tw,do