动态规划算法作业

动态规划作业

（所有算法实现代码承诺为本人自己编写并且截图为实际有效截图）

作者：吴迪

参考资料：课件ppt,百度百科

算法分析3-1

设计一个O(n2)时间的算法，找出由n个数组成的序列的最长单调递增子序列。分析：考虑一个拥有n个元素的数列{a n}，欲找出其最长单调递增子序列，对于

前i-1个元素组成的单调递增序列，考虑第a i个元素，最长单调递增子序列是否应该包含这个元素？如果它在序列中不是单增的，并且能确定前面的元素都是必定选中的，那么肯定它不被选入单增序列；如果它是单增的，仍然需要考虑它后面可能出现多于一个元素的单增子序列都比它要小的情况。所以在这样的条件下，使用动态规划的方法，递归分析是合理的选择。

用数列{b i}来记录数列{a n}的最长单调递增子序列，0<=i

b[0]=1，b[i]=max{b[k]}+1 ,其中0<=k

设max表示子序列的最大长度，初始化赋值为0。从第一个元素a0开始选取,对于数组每个元素a i ,

b[0]=1;

for i=1…n {

k=0

for j=0 (i)

if(a[j]<=a[i]&&k

b[i]=k-1;

}

max=0

for i=1…n

{

if(b[i]>max) max=b[i];

}

算法复杂性为0(n2)。

算法分析3-4

考虑下面的整数线性规划问题

设计一个解此问题的动态规划算法，并分析算法的计算复杂性

分析；这题是01背包问题的变种,只不过同一种物品可以重复多次放入背包（无件数限制），即所谓完全背包问题。wi对应第i件物品重量，vi对应第i件物品价值。从每种物品的角度考虑，与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……等很多种。

状态转移方程：f[v]=max{f[v-k*c]+k*w}，其中0<=k*c<= v。

完全背包问题有一个很简单有效的优化：若两件物品i、j满足c<=c[j]且w>=w[j]，则将物品j去掉，不用考虑。由于有O(N*V)个状态需要求解，求解每个状态的时间则不是常数了，求解状态f[v]的时间是O(v/c)，，但是由于每件物品都可能取多件，总的复杂度就超过O(VN)了。

算法分析3-7

给定一个m×n的矩形网络，设其左上角为起点S。一辆汽车从起点S出发驶向右下角终点T。网格边上的数字表示距离。在若干个网格点处设置了障碍，表示该网格点不可到达。试设计一个算法，求出汽车从起点S出发到达终点T的一条行驶路程最短的路线。

分析：用一个集合R放置最短路径的所有网格点共m*n个。

点集合中的点有其对应坐标原点（0,0）的横纵坐标x,y属性。

用一个集合T记录所有边，边集合中的边有其边长和所连接的两点，

对于mXn的矩行网络，有横向边(m+1)*n条，纵向边m*(n+1)条，。将所有边放入T集合，然后遍历去掉所有直接链接不可达点的边。剩下的就是一张可达的网格图，对于起点S和终点T，从S开始，可以采用图论的Dijkstra算法更新S到每个点的距离d。（用距离记录集合M记录S到每个点的距离。）

d（u）=min(d(u),d(v k+1)+w(v k+1->u)). (u与v k+1相邻)

也可以直接将不可达点的连接边长设置为无穷大，然后代入Dijkstra算法。

算法实现题3-5

编辑距离问题

问题描述：

设A和B是两个字符串。要用最少的字符操作将字符串A转换为字符串B。这里所说的字符操作包括：

（1）删除一个字符；

（2）插入一个字符；

（3）将一个字符改为另一个字符

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

算法设计：对给定的字符串A和B，计算其编辑距离d(A,B).

数据输入：由文件input.txt提供输入数据。文件的第一行是字符串A，文件的第二行是字符串B。

结果输出：将编辑距离d(A,B)输出到output.txt的第1行

程序代码

#include

#include

using namespace std;

//Global variables

int **tab;

int m=0;

int n=0;

//function declare

void init();

void free();

int d(char * str1,char * str2);

int main()

{

char *A="sef";

char *B="asesfe";

//cout <

/* 文件输入处理部分，可以去掉这一部分直接只测A和B距离*/

/* 文件输出处理部分，可以去掉这一部分不输出文件*/

FILE *fp;

FILE *fp2;

char AF[100];

char BF[100];

const char*BP=BF;

if((fp=fopen("input.txt","r"))==NULL)

return 0;

if((fp2=fopen("output.txt","w"))==NULL)

return 0;

if(!fscanf(fp,"%s",AF)) cout<<"invalid file input!"<

while(fscanf(fp,"%s",BF)==1){

//cout <<"BF "<

cout <

fprintf(fp2,"%s和%s距离为%d\n",AF,BF,d(AF,BF));

memcpy(AF,BP,strlen(BF));

}

if(fclose(fp)!=0)

return 0; /**/

if(fclose(fp2)!=0)

return 0; /**/

system("pause");

return 0;

}

void init()

{

//cin >>m;

//cin >>n;

//malloc

tab = new int *[m];

for(int i=0;i

tab[i]= new int [n];

//init

for(int i=0;i

for(int j=0;j

tab[i][j]=0;

}

}

for(int i=0;i

tab[i][0]=i;

for(int j=0;j

tab[0][j]=j;

// return true;

}

void free()

{

for(int i=0;i

delete tab[i];

delete []tab;

}

int d(char * str1,char * str2)

{

m=strlen(str1);

n=strlen(str2);

//cout << m <

//cout << n <

if(m==0||n==0){

return m>n?m:n;

}

init();

int cost=0;

for(int i=1;i

for(int j=1;j

//计算替换操作的代价，如果两个字符相同，则替换代价为0，否则为1

if(str1[i]==str2[j])

cost=0;

else cost=1;

if(tab[i-1][j]

tab[i][j]=tab[i-1][j]+1;

else if(tab[i][j-1]+1

{

tab[i][j]=tab[i][j-1]+1;

}

else{

tab[i][j]=tab[i-1][j-1]+cost;

}

}

}

int result =tab[m-1][n-1];

free();

return result;

}

运行举例

input文件如下（为方便测试我采取的输入格式是连续的字符串，让它们依次与前一个字符串比较并输出结果）

01背包问题程序为ppt算法的实现1基本算法

/**

* author wd

* title 01背包（algorithm is from course ppt）* time 2011-5-1 15:41:09

*/

#include

using namespace std;

//global envirenment variables

int *w;

int *v;

int num=0;

bool *x;

typedef struct Point

{

int x;

int y;

}point;

//function

int m(int i,int j) //x[i] is 0 or 1

{

if(i>num-1) return 0;

if(j>=w[i]){

if(i==num-1) { return v[i];}

else{

int m1=m(i+1,j);

int m2=m(i+1,j-w[i])+v[i];

if(m1>m2){

return m1;

}

else{

return m2;

}

}

}

else if(j>0&&j

return m(i+1,j);

}

else if(j==0)

return 0;

else{

cout <<"error input! please check." << endl;

return 0;}

}

void init()

{

cout <<"input weight:"<

for(int i=0;i

{ cin>>w[i];

x[i]=0;

}

fflush(stdin);

cout <<"input value:"<

for(int i=0;i

{ cin>>v[i];}

}

int main(){

point a;

while(1){

int capacity,max_value=0;

cout <<"input the number of item(num) and capacity of package(capacity):"<< endl;

cin >> num;

cin >> capacity;

w=(int *)malloc(sizeof(int)*(num+1));

v=(int *)malloc(sizeof(int)*(num+1));

x = (bool *)malloc(sizeof(bool)*(num+1)); //sign if the object is selected

init();

int i=0;

max_value=m(i,capacity);

cout << "the highest total value is:" << max_value << endl;

free(w);

free(v);

free(x);

}

system("pause");

return 0;

}

运行截图

2改进算法

#include

#include

using namespace std;

//global variales

int *w;

int *v;

bool *x;

int num=0;

int capacity=0;

int max_value=0;

typedef struct Point

{

int x;

int y;

}point;

typedef vector vp;

void init();

void show_vp(vp p);

void combine_(vp &p,point key,vp &q); void union_(vp &p,vp &q,vp &r);

void show_result(vp r);

void free_();

int main()

{

vectorp;

vectorq;

vectorr;

int i;

point startp;

startp.x=0;startp.y=0;

point pi;

/* while(i>0){*/

p.push_back(startp);

/* i--;

}*/

init();

for(i=num-1;i>=0;i--){

pi.x=w[i];

pi.y=v[i];

combine_(p,pi,q); //make q

union_(p,q,r); //make next p

p=r;//可以拷贝赋值

}

show_result(r);

//cout << "the highest total value is:" << max_value << endl;

free_();

//so the last point's y value is what we want namely the best value

system("pause");

return 0;

}

void init()

{

cout <<"input the number of item(num) and capacity of package(capacity):"<< endl;

cin >> num;

cin >> capacity;

w=(int *)malloc(sizeof(int)*(num+1));

v=(int *)malloc(sizeof(int)*(num+1));

x = (bool *)malloc(sizeof(bool)*(num+1)); //sign if the object is selected

cout <<"input weight:"<

for(int i=0;i

{ cin>>w[i];

x[i]=0;

}

fflush(stdin);

cout <<"input value:"<

for(int i=0;i

{ cin>>v[i];}

}

void combine_(vp &p,point key,vp &q)

{

q.clear();

for(vp::iterator i=p.begin();i

{

//cout <<(*i).x<

point temp;

temp.x=(*i).x+key.x;

temp.y=(*i).y+key.y;

if(temp.x>capacity);

else

q.push_back(temp);

}

cout <<"q is now "<< endl;

show_vp(q);

}

void union_(vp &p,vp &q,vp &r){

r.clear();

vp::iterator i=p.begin();

vp::iterator j=q.begin();

while(i

{

point temp;

if(i>=p.end()){

while(j

temp.x=(*j).x;temp.y=(*j).y;

r.push_back(temp);

j++;

}

}

else if(j>=q.end()){

while(i

temp.x=(*i).x;temp.y=(*i).y;

r.push_back(temp);

i++;

}

}

else {

if((*i).x<(*j).x)

{

temp.x=(*i).x;temp.y=(*i).y;

r.push_back(temp);

i++;

}

else if((*i).x==(*j).x)

{

if((*i).y==(*j).y)

{

temp.x=(*i).x;temp.y=(*i).y;

r.push_back(temp);

}

else //x相等的统统跳过,记录一个就行

{

if((*i).y>(*j).y) {

temp.x=(*i).x;temp.y=(*i).y;

r.push_back(temp);

}

else

{

temp.x=(*j).x;temp.y=(*j).y;

r.push_back(temp);

}

}

i++;j++;

}

else

{

temp.x=(*j).x;temp.y=(*j).y;

r.push_back(temp);

j++;

}

}

}

//remove all (a,b)that a>=c but b

i=r.begin();

cout << "p is now "<

show_vp(r);

while((i+1)!=r.end()){

if((*i).y>(*(i+1)).y)

r.erase(i+1);

else i++;

}

}

void show_vp(vp p)

{

int c=0;

for(vp::iterator i=p.begin();i

{

cout <<++c<<" ("<<(*i).x<<",";

cout <<(*i).y<<" ) ";

}

cout << endl;

}

void show_result(vp r)

{

vp::iterator i;

i=r.end()-1;

cout<<"the highest total value is:"<<(*i).y<

void free_()

{

free(w);

free(v);

free(x);

}

运行截图