动态规划总结

原创 2016年06月02日 10:59:28

经典问题:

一、最长上升子序列:

     问题描述如下: 
设L=<a1,a2,…,an>是n个不同的实数的序列,L的递增子序列是这样一个子序列Lin=<aK1,ak2,…,akm>,其中k1<k2<…<km且aK1<ak2<…<akm。求最大的m值。 这里采用的是逆向思维的方法,从最后一个开始想起,即先从A[N](A数组是存放数据的数组,下同)开始,则只有长度为1的子序列,到A[N-1]时就有两种情况,如果a[n-1] < a[n] 则存在长度为2的不下降子序列 a[n-1],a[n];如果a[n-1] > a[n] 则存在长度为1的不下降子序列a[n-1]或者a[n]。 
有了以上的思想,DP方程就呼之欲出了(这里是顺序推的,不是逆序的): DP[I]=MAX(1,DP[J]+1)  J=0,1,...,I-1 
但这样的想法实现起来是)O(n^2)的。本题还有更好的解法,就是O(n*logn)。

二、最长公共子序列:

给出两个字符串

a, b

,求它们的最长、连续的公共字串。

 

这很容易就想到以

DP[I][J]

表示

A

串匹配到

I

B

串匹配到

J

时的最大长度。

则:

 

0                              I==0 || J==0

 

DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]

 

          MAX

DP[I-1][J]

DP[I][J-1]

   

不是以上情况

 

 

但这样实现起来的空间复杂度为

O(n^2)

,而上面的方程只与第

I-1

行有关,所

以可以用两个一维数组来代替。

给出两个字符串

a, b

,求它们的最长、连续的公共字串。

 

这很容易就想到以

DP[I][J]

表示

A

串匹配到

I

B

串匹配到

J

时的最大长度。

则:

 

0                              I==0 || J==0

 

DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]

 

          MAX

DP[I-1][J]

DP[I][J-1]

   

不是以上情况

 

 

但这样实现起来的空间复杂度为

O(n^2)

,而上面的方程只与第

I-1

行有关,所

以可以用两个一维数组来代替。

给出两个字符串

a, b

,求它们的最长、连续的公共字串。

 

这很容易就想到以

DP[I][J]

表示

A

串匹配到

I

B

串匹配到

J

时的最大长度。

则:

 

0                              I==0 || J==0

 

DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]

 

          MAX

DP[I-1][J]

DP[I][J-1]

   

不是以上情况

 

 

但这样实现起来的空间复杂度为

O(n^2)

,而上面的方程只与第

I-1

行有关,所

以可以用两个一维数组来代替。

给出两个字符串

a, b

,求它们的最长、连续的公共字串。

 

这很容易就想到以

DP[I][J]

表示

A

串匹配到

I

B

串匹配到

J

时的最大长度。

则:

 

0                              I==0 || J==0

 

DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]

 

          MAX

DP[I-1][J]

DP[I][J-1]

   

不是以上情况

 

 

但这样实现起来的空间复杂度为

O(n^2)

,而上面的方程只与第

I-1

行有关,所

以可以用两个一维数组来代替。

给出两个字符串

a, b

,求它们的最长、连续的公共字串。

 

这很容易就想到以

DP[I][J]

表示

A

串匹配到

I

B

串匹配到

J

时的最大长度。

则:

 

0                              I==0 || J==0

 

DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]

 

          MAX

DP[I-1][J]

DP[I][J-1]

   

不是以上情况

 

 

但这样实现起来的空间复杂度为

O(n^2)

,而上面的方程只与第

I-1

行有关,所

以可以用两个一维数组来代替。

给出两个字符串a, b,求它们的最长、连续的公共字串。 
这很容易就想到以DP[I][J]表示A串匹配到I,B串匹配到J时的最大长度。则: 
0                              I==0 || J==0 
DP[I][J]=DP[I-1][J-1]+ 1                  A[I]==B[J]           MAX(DP[I-1][J],DP[I][J-1])   不是以上情况  
但这样实现起来的空间复杂度为O(n^2),而上面的方程只与第I-1行有关,所以可以用两个一维数组来代替。

三、o-1背包问题:

 有N件物品和一个容量为V的背包。第i件物品的大小是c[i],价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 
   用DP[I][J] 表示前I件物品放入一个容量为J的背包可以获得的最大价值。则   DP[I][J]= DP[I-1][J]                               ,J<C[I] 
MAX(DP[I-1][J],DP[I-1][J-C[I]]+W[I])  , J>=C[I]   
   这样实现的空间复杂度为O(VN),实际上可以优化到O(V)。以下是代码: const int MAXW=13000;    //最大重量 const int MAXN=3450;     //最大物品数量   
int c[MAXN];     //物品的存放要从下标1开始 int w[MAXN];     //物品的存放要从下标1开始 int dp[MAXW];   
//不需要将背包装满,则将DP数组全部初始化为0 
//要将背包装满,则初始化为DP[0]=0,DP[1]…DP[V]=-1(即非法状态) 

int Packet(int n,int v)

 {     

  int i,j; 
      memset(dp,0,sizeof(dp));    

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

 for(j=v;j>=c[i];--j)

 {  //这里是倒序,别弄错了             

  dp[j]=MAX(dp[j],dp[j-c[i]]+w[i]);   

        }     

      return dp[v];


四、完全背包问题:

有N种物品和一个容量为V的背包,每种物品都有无限件可用。第i种物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量,且价值总和最大。 
   很容易可以得到这种状态表示:用DP[I][J] 表示前I件物品放入一个容量为J的背包可以获得的最大价值。则 
  DP[I][J]=MAX(DP[I-1][J],DP[I-1][J-K*C[I]]+K*W[I]) 0<=K*C[I]<=J 这样的复杂度是O(V*Σ(V/c[i])) 
    有更好的做法,那就是利用01背包的优化原理。在优化的代码中,之所以第二重循环是倒序,
是为了防止重复拿,那么只要将其变为顺序即可以重复取。

五、多重背包问题:


有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用,每件费用是c[i],价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量,且价值总和最大。 
这题仍然可以用到上一题的思想,DP表示状态与上面的相同。方程为: DP[I][J]=MAX(DP[I-1][J],DP[I-1][J-K*C[I]]+K*W[I]) 
不同的是K的范围,0<=K<=N[I] && 0<=K*C[I]<=J 这样的复杂度为O(V*Σn[i])。

有更好的想法就是先用二进制来划分。将第i种物品分成若干件物品,其中每件物品有一个系数,这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为
1,2,4,...,2^(k-1),n[i]-2^k+1,且k是满足n[i]-2^k+1>0的最大整数。然后用01背包做,这样的复杂度为O(V*Σlog n[i])。

关键代码:

 const int SIZE=1001; int dp[SIZE]; 
int num[SIZE],c[SIZE],w[SIZE];  //num[i]是I物品的件数,C[I]是费用,W[I]是价值 int MultiPack(int n,int v) 

{  //存入参数,N是物品种类数,V是背包容量   

   int i,j,k; 

     memset(dp,0,sizeof(dp)); 
     for(i=1;i<=n;++i)

 { //存放物品的数组下标从1开始       

   if( c[i]*num[i]>=v )

 {              for(j=c[i];j<=v;++j) 


                 dp[j]=MAX(dp[j],dp[j-c[i]]+w[i]);              }   

      } 
         else {  //使用二进制划分              k=1; 
             while( k<num[i] )

 {                  for(j=v;j>=k*c[i];--j) 


                     dp[j]=MAX(dp[j],dp[j-k*c[i]]+k*w[i]);              

    }                  num[i]-=k;           

       k*=2;           

  } 
             for(j=v;j>=num[i]*c[i];--j)

 { 
                 dp[j]=MAX(dp[j],dp[j-num[i]*c[i]]+num[i]*w[i]);              }         

 }      


     return dp[v]; 


参考:http://wenku.baidu.com/link?url=phnoz8M9fnB6wQ5I4DuYkwOImljgy6n6YeLA0Kl20dKrvWZUEtKymDSQOOXMNABvkXYiH2AnV4VBWJ3DVuxRz8OWKgzczSSa97FiWuqvXFq

问题描述如下

:

 

L=<a1,a2,

,an>

n

个不同的实数的序列,

L

的递增子序列是这样一个子序

Lin=<aK1,ak2,

,akm>

,其中

k1<k2<

<km

aK1<ak2<

<akm

。求最大的

m

值。

 

这里采用的是逆向思维的方法,从最后一个开始想起,即先从

A[N]

A

数组是

存放数据的数组,下同)开始,则只有长度为

1

的子序列,到

A[N-1]

时就有两种情

况,

如果

a[n-1] 

a[n] 

则存在长度为

2

的不下降子序列

 a[n-1],a[n]

如果

a[n-1] 

a[n] 

则存在长度为

1

的不下降子序列

a[n-1]

或者

a[n]

 

有了以上的思想,

DP

方程就呼之欲出了(这里是顺序推的,不是逆序的):

 

DP[I]=MAX

1,DP[J]+1

  J=0,1,...,I-1

 

但这样的想法实现起来是)

O(n^2)

的。本题还有更好的解法,就是

O(n*logn)

利用了长升子序列的性质来优化,以下是优化版的代码:

 

//

最长不降子序

       

 

const int SIZE=500001;

 

int data[SIZE];

 

int dp[SIZE];

 

 

 

//

返回值是最长不降子序列的最大长度

,

复杂度

O(N*logN)

 

int LCS(int n) {            //N

DATA

数组的长度

,

下标从

1

开始

 

    int len(1),low,high,mid,i;

 

 

 

    dp[1]=data[1];    

 

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

 

       low=1;

 

       high=len;

问题描述如下

:

 

L=<a1,a2,

,an>

n

个不同的实数的序列,

L

的递增子序列是这样一个子序

Lin=<aK1,ak2,

,akm>

,其中

k1<k2<

<km

aK1<ak2<

<akm

。求最大的

m

值。

 

这里采用的是逆向思维的方法,从最后一个开始想起,即先从

A[N]

A

数组是

存放数据的数组,下同)开始,则只有长度为

1

的子序列,到

A[N-1]

时就有两种情

况,

如果

a[n-1] 

a[n] 

则存在长度为

2

的不下降子序列

 a[n-1],a[n]

如果

a[n-1] 

a[n] 

则存在长度为

1

的不下降子序列

a[n-1]

或者

a[n]

 

有了以上的思想,

DP

方程就呼之欲出了(这里是顺序推的,不是逆序的):

 

DP[I]=MAX

1,DP[J]+1

  J=0,1,...,I-1

 

但这样的想法实现起来是)

O(n^2)

的。本题还有更好的解法,就是

O(n*logn)

利用了长升子序列的性质来优化,以下是优化版的代码:

 

//

最长不降子序

       

 

const int SIZE=500001;

 

int data[SIZE];

 

int dp[SIZE];

 

 

 

//

返回值是最长不降子序列的最大长度

,

复杂度

O(N*logN)

 

int LCS(int n) {            //N

DATA

数组的长度

,

下标从

1

开始

 

    int len(1),low,high,mid,i;

 

 

 

    dp[1]=data[1];    

 

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

 

       low=1;

 

       high=len;

问题描述如下

:

 

L=<a1,a2,

,an>

n

个不同的实数的序列,

L

的递增子序列是这样一个子序

Lin=<aK1,ak2,

,akm>

,其中

k1<k2<

<km

aK1<ak2<

<akm

。求最大的

m

值。

 

这里采用的是逆向思维的方法,从最后一个开始想起,即先从

A[N]

A

数组是

存放数据的数组,下同)开始,则只有长度为

1

的子序列,到

A[N-1]

时就有两种情

况,

如果

a[n-1] 

a[n] 

则存在长度为

2

的不下降子序列

 a[n-1],a[n]

如果

a[n-1] 

a[n] 

则存在长度为

1

的不下降子序列

a[n-1]

或者

a[n]

 

有了以上的思想,

DP

方程就呼之欲出了(这里是顺序推的,不是逆序的):

 

DP[I]=MAX

1,DP[J]+1

  J=0,1,...,I-1

 

但这样的想法实现起来是)

O(n^2)

的。本题还有更好的解法,就是

O(n*logn)

利用了长升子序列的性质来优化,以下是优化版的代码:

 

//

最长不降子序

       

 

const int SIZE=500001;

 

int data[SIZE];

 

int dp[SIZE];

 

 

 

//

返回值是最长不降子序列的最大长度

,

复杂度

O(N*logN)

 

int LCS(int n) {            //N

DATA

数组的长度

,

下标从

1

开始

 

    int len(1),low,high,mid,i;

 

 

 

    dp[1]=data[1];    

 

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

 

       low=1;

 

       high=len;

版权声明:本文为博主原创文章,未经博主允许不得转载。

acm动态规划总结

  • 2012年03月05日 21:21
  • 388KB
  • 下载

数据结构动态规划算法总结

  • 2011年07月03日 19:51
  • 218KB
  • 下载

整数划分总结(动态规划)

先引入一个比较实际的问题:分苹果 题目 M个相同苹果放到N个相同篮子里有多少种放法,允许有篮子不放。 1...

动态规划总结-by Amber.doc

  • 2007年09月05日 18:39
  • 95KB
  • 下载

动态规划问题解题思路和总结

  • 2017年04月12日 14:45
  • 1021KB
  • 下载

动态规划的简要总结和四个经典问题的c++实现

本文给出了动态规划的简要定义、适用场景、算法实现。并给出了四种经典动态规划:钢条切割求最大收益问题、矩阵链相乘求最小乘法次数问题、最长公共子序列问题、求最小的搜索代价的最优二叉搜索树的c++代码实现。...

算法动态规划总结(基础篇)

  • 2012年01月01日 13:56
  • 474KB
  • 下载

动态规划总结

  • 2007年11月13日 11:41
  • 138KB
  • 下载

动态规划几个经典例子总结

1.了解动态规划     写的不是特别详细,凑合看吧,嘿嘿, 快要考试了,攒人品.... 动态规划的核心思想就是避免子问题重复计算,采用用空间换取时间的方法提高算法效率,比如用递归实现的斐波那契数...
  • ustcqi
  • ustcqi
  • 2013年01月03日 21:34
  • 1112

王道机试指南读后总结-6(动态规划等)

递推求解: N阶楼梯上楼问题。一次可走一阶或两阶,问有多少种上楼方式。 这同时也是裴波那契数列问题,当N>2时,走最后一次有两种情况,分从N-1到N和N-2到N,则F(N)=F(N-1)+F(N-2)...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:动态规划总结
举报原因:
原因补充:

(最多只允许输入30个字)