算法设计与分析课程设计

成绩评定表

课程设计任务书

摘要

算法设计与分析，其实可以解释为一类优化问题，一般针对可以利用计算机解决的离散型问题的优化。主要目的就是为了解决某一问题而提出各种不同的解决方案，并且要针对具体的问题做细致的空间和时间复杂度分析。所有的算法中，应该尽量选取“好”的算法，这里所说的“好”，首先是正确的，其次是所选算法解决问题的效率要尽可能的高。计算机计算时间的长短以及所用空间的大小，跟算法有直接关系，用来衡量算法好坏的两个重要标准就是就是时间和空间复杂度，所以提出好的解决方案，其算法是重中之重。

动态规划算法是将待求解的问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。首先找出最优解的性质，并刻其结构特征，然后递归的定义最优值（写出动态规划方程）并且以自底向上的方式计算出最优值，最后根据计算最优值时得到的信息，构造一个最优解。

分支限界法类似于回溯法，也是在问题的解空间上搜索问题解的算法。一般情况下，分支限界法与回溯法的求解目标不同。回溯法的求解目标是找出解空间中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。分支限界法的搜索策略是，在扩展结点处，先生成其所有的儿子结点(分支)，然后再从当前的活结点表中选择下一扩展结点。为了有效地选择下一扩展结点，加速搜索的进程，在每一个活结点处，计算一个函数值(限界)，并根据函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解。这种方式称为分支限界法。人们已经用分支限界法解决了大量离散最优化的问题。

关键词：动态规划分支限界法编辑距离问题 0-1背包问题

目录

1.动态规划法解决编辑距离问题 (1)

1.1问题描述 (1)

1.2问题分仔 (1)

1.3算法设计 (2)

1.4算法实现 (3)

1.5结果分析 (5)

1.6复杂度分析 (5)

2.分支限界法解决0-1背包问题 (6)

2.1问题描述 (6)

2.2问题分析 (6)

2.3算法设计 (7)

2.4算法实现 (7)

2.5结果分析 (12)

2.6 复杂度分析 (12)

3.参考文献 (13)

1.动态规划法解决编辑距离问题

1.1问题描述

设A 和B 是2个字符串。要用最少的字符操作将A 转换为字符串B 。这里所说的字符操作包括：（1）删除一个字符；（2）插入一个字符：（3）将一个字符改为另一个字符。

将字符串A 变换为字符串B 所用的最少字符操作数称为字符串A 到B 的编辑距离，记为d(A,B)。试设计一个有效算法，对任给的2个字符串A 和B ，计算其编辑距离d （A,B ）。

1.2问题分仔

设所给的两个字符串为A[1:m]和B[1:n]，定义一个二维数组dp[i][j]表示状态，dp[i][j]= (A[1:i],B[1:j])表示字符串A[1:m]的子串A[1:i]变换到B[1:n]的子串B[1:j]的编辑距离，即子串A[1:i]至少要经过多少次操作（插入、删除、修改）可以变为B[1:j]。单字符a,b 间的编辑距离定义为

例如，字符串A:AGTAAGTAGGC 转换为

字符串B:AGTCTGACGC 。 操作一：A 串：A G T A A G T * A G G C B 串：A G T * C * T G A C G C

需要5步操作（2次删除，2次修改，1次删除） 操作二：A 串：A G T A A G T A G G C B 串：A G T C T G * A C G C 需要4次操作（3次修改，1次删除）

我们计算的编辑距离是变换的最小步数，所以要取其中的最小值。

考察从字符串A[1:i]到字符串B[1:j]的转换，有三种情况可以导致上面设计的状态发生转移：

()??

?≠==b

a b

a b a d ,1,0,

（1）可以删除字符A[i]需要1次操作。只将字符A[i]从A串中删除，对序列B[1:j]没有任何影响，此时问题的最优子结构形式为将A[1:i-1] 变为B[1:j] ，再加一步删除操作，可得dp[i][j] = dp[i-1][j] + 1。

（2）可以在A[i]后面插入一个字符ch（ch==B[j]）需要1次操作。在进行插入操作时，串A[1:i] 无任何变化，在A串i+1

位置上插入字符B[j],问题的最优子结构形式为将A[1:i]变

为B[1:j-1],再加一步插入操作，可得dp[i][j] = dp[i ][j-1] + 1。

（3）可以修改字符A[i]，使它变为B[j]，若A[i]=B[j]，修改

其实相当于用了0步；若A[i] != B[j]，修改相当于用了1步。

所以dp[i][j] = dp[i - 1][j - 1] + （A[i] == B[j] ? 0：1）。

最后的dp[i][j]就是选择上述3种状态转移中的最小值。

综上所述，状态转移方程dp[i][j]可归结为如下情况：

(1)当两个字符相同，即A[i]=B[j]时，

dp[i][j] = min{dp[i][j-1]+1, dp[i-1][j]+1, dp[i-1][j-1]}

(2)当两个字符不同，即A[i] != B[j]时，

dp[i][j] = min{dp[i][j-1]+1, dp[i-1][j]+1, dp[i-1][j-1]+1}

需要注意的是，要对dp[0][0:m]，dp[0:n][0]进行初始化。

*dp[0][i],就是说A串是一个空串，而B串是个长度为i的串，很显然A串变为B串就是插入i个字符，即dp[0][i]=i。

*dp[i][0] ，就是说A串是个长度为i的串，而B串是一个空串，很显然A串变为B串就是删除i个字符，即dp[i][0]=i。

1.3算法设计

数据输入：输入数据的第一行是一个正整数，表示一共有几组数据。每组数据两行，每行一个字符串。

*每个字符串长度不超过1000

结果输出：输出编辑距离。对于每组数据，请输出一个整数表示两个字符串的编辑距离。每个答案占一行。

1.4算法实现

#include

#include

#include

#define min(a,b) (a)>(b)?(b):(a)

#define N 1005

using namespace std;

intdp[N][N]; //dp[i][j]表示串s1的前i位变换到串s2的前j位的最小步数int DP(char *s1,char *s2)

{

inti,j,m=strlen(s1),n=strlen(s2),tem;

//初始化

for(i=0;i<=n;i++)

dp[0][i]=i; //从0个字符转换为i个字符，需要插入i次

for(i=0;i<=m;i++)

dp[i][0]=i; //从i个字符转换为0个字符，需要删除i次

//用动态规划方法计算编辑距离

for(i=1;i<=m;i++)

for(j=1;j<=n;j++) {

if(s1[i-1]==s2[j-1])

tem=dp[i-1][j-1]; //当两个字符相同时，替换操作代价为0 ，直接将dp[i-1][j-1] 转移过来

else

tem=dp[i-1][j-1]+1; //当s1[i-1]!=s2[j-1]时, 替换操作代价为1

tem=min(tem,dp[i][j-1]+1); //dp[i][j-1]+1为在s1的i+1位置上插入字符s2[j]

tem=min(tem,dp[i-1][j]+1); //dp[i-1][j]+1为在s1的i位置上删除字符s1[i]

dp[i][j]=tem; //dp[i][j]取3种状态的最小值

}

return dp[m][n]; //返回dp[m][n]

}

int main()

{

int c;

char s1[N],s2[N];

printf("输入一个整数：");

scanf("%d",&c);

getchar();

while(c--)

{

printf("\n输入两个字符串：\n");

gets(s1);

gets(s2);

printf("其编辑距离为：%d\n",DP(s1,s2));

}

return 0;

}

1.5结果分析

1.6复杂度分析

时间复杂度：总的时间复杂度为T(n*m+n+m)=O(m*n)

最坏的时间复杂度为O(n^2)

2.分支限界法解决0-1背包问题

2.1问题描述

给定n 种物品和一背包。物品i 的重量是wi ，其价值为vi ，背包容量为c 。问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大。在选择装入背包的物品时，对每种物品i 只有两种选择，即装入背包或不装入背包。不能将物品i 装入背包多次，也不能只装入部分的物品i 。因此，该问题称为0-1背包问题。

0-1背包问题的形式化描述是，给定c>0,Wi>0,Vi>0，1≤i ≤n ，要求找出一个n 元0-1向量（x1，x2，……xn ），Xi ∈{0,1},1≤i ≤n ，使得∑=n

1

i iXi W c ≤，而且∑=n

1

i i i X V 达到最大。因此

0-1背包问题是一个特殊的整数规划问题：

2.2问题分析

0-1背包问题是一类典型的离散型优化问题，问题的约束条件和要求都很简单。求解方案也比较多，本论文就几种典型的求解方案做简单的分析，但是主要实现的是利用分支限界法解决的方案。下面是几种典型算法的简单分析：

分支限界法：分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。

此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。从活结点表中选择下一扩展结点的不同方式导致不同的分支限界法：

∑=n

i i

i x v 1

max ???

??≤≤∈≤∑

=n i x C x w i n

i i i 1},1,0{1

队列式(FIFO)分支限界法：按照队列先进先出（FIFO）原则选取下一个节点为扩展节点。

优先队列式分支限界法：按照优先队列中规定的优先级选取优先级最高的节点成为当前扩展节点。

最大优先队列：使用最大堆，体现最大效益优先

最小优先队列：使用最小堆，体现最小费用优先

2.3算法设计

分支限界法的分析：已知有N个物品和一个可以容纳M重量的背包，每种物品I的重量为WEIGHT，一个只能全放入或者不放入，求解如何放入物品，可以使背包里的物品的总效益最大。对物品的选取与否构成一棵解树，左子树表示不装入，右表示装入，通过检索问题的解树得出最优解，并用结点上界杀死不符合要求的结点。

分支限界法的描述：首先，要对输入数据进行预处理，将各物品依其单位重量价值从大到小进行排列。在下面描述的优先队列分支限界法中，节点的优先级由已装袋的物品价值加上剩下的最大单位重量价值的物品装满剩余容量的价值和。算法首先检查当前扩展结点的左儿子结点的可行性。如果该左儿子结点是可行结点，则将它加入到子集树和活结点优先队列中。当前扩展结点的右儿子结点一定是可行结点，仅当右儿子结点满足上界约束时才将它加入子集树和活结点优先队列。当扩展到叶节点时为问题的最优值。

2.4算法实现

#include

#include

#include

#define MaxSize 100 //初始化队列长度为100 typedefstructQNode

{

float weight;

float value;

int ceng;

structQNode *parent;

boolleftChild;

}QNode,*qnode; //定义队列类型typedefstruct

{

qnode Q[MaxSize];

intfront,rear;

}SqQueue; //定义队列SqQueuesq;

float bestv=0; //最优解

int n=0; //实际物品数

float w[MaxSize]; //物品的重量

float v[MaxSize]; //物品的价值intbestx[MaxSize]; // 存放最优解qnodebestE;

void InitQueue(SqQueue&sq ) //队列初始化

{

sq.front=1;

sq.rear=1;

}

boolQueueEmpty(SqQueuesq) //队列判空

{

if(sq.front==sq.rear)

return true;

else

return false;

}

void EnQueue(SqQueue&sq,qnode b)//结点入队函数{

if(sq.front==(sq.rear+1)%MaxSize){

cout<<"队满，请修改队列初始大小!"<

exit(1); //队满出错，不再继续计算return ;

}

sq.Q[sq.rear]=b;

sq.rear=(sq.rear+1)%MaxSize;

}

qnodeDeQueue(SqQueue&sq)//出队

{

qnode e;

if(sq.front==sq.rear)

return 0;

e=sq.Q[sq.front];

sq.front=(sq.front+1)%MaxSize;

return e;

}

void EnQueue1(float wt,floatvt, int i ,

QNode *parent, boolleftchild)

{

qnode b;

if (i==n) //可行叶子结点

{

if (vt==bestv)

{

bestE=parent;

bestx[n]=(leftchild)?1:0;

}

return;

}

b=(qnode)malloc(sizeof(QNode)); //非叶子结点

b->weight=wt;

b->value=vt;

b->ceng=i;

b->parent=parent;

b->leftChild=leftchild;

EnQueue(sq,b);

}

void maxLoading(float w[],float v[],int c)

{

floatwt=0;

floatvt=0;

int i=1; //当前的扩展结点所在的层

float ew=0; //扩展节点所相应的当前载重量

float ev=0; //扩展结点所相应的价值

qnode e=NULL;

qnode t=NULL;

InitQueue(sq);

EnQueue(sq,t); //空标志进队列

while (!QueueEmpty(sq))

{

wt=ew+w[i];

vt=ev+v[i];

if (wt<= c)

{

if(vt>bestv)

bestv=vt;

EnQueue1(wt,vt,i,e,true); // 左儿子结点进队列}

EnQueue1(ew,ev,i,e,false); //右儿子总是可行；

e=DeQueue(sq); // 取下一扩展结点

if (e == NULL)

{

if (QueueEmpty(sq)) break;

EnQueue(sq,NULL); // 同层结点尾部标志

e=DeQueue(sq); // 取下一扩展结点

i++;

}

ew=e->weight; //更新当前扩展结点的值ev=e->value;

}

cout<<"最优价值为："<

cout<<"最优取值法："<

for( int j=n-1;j>0;j--) //构造最优解

{

bestx[j]=(bestE->leftChild?1:0);

bestE=bestE->parent;

}

for(int k=1;k<=n;k++)

{

if(bestx[k]==1)

cout<<"物品"<

cout<

}

void main()

{

int c;

floatewv[MaxSize];

cout<<"----------分支限界法求解0-1背包问题----------"<

cout<<"请输入物品的总数：";

cin>>n;

cout<<"请输入背包容量：";

cin>>c;

cout<<"请输入物品的价值与对应重量："<

for(int i=1;i<=n;++i){

cout<<"物品"<

cin>>ewv[i]>>w[i];

v[i]=ewv[i];

}

cout<

maxLoading(w, v, c);

}

2.5结果分析

2.6 复杂度分析

时间复杂度是O(2n);

3.参考文献

[1] 王晓东.算法设计与分析（第4版）.北京：清华大学出版社，2012

[2] 孟爱国.C语言程序设计.上海：复旦大学出版社,2010.02

[3] 严蔚敏，吴伟民. 数据结构(C语言版). 北京：清华大学出版社，2007

[4] 陈嫒.数据结构学习指导实验指导课程设计.北京：机械工业出版社，2008.01