动态规划

1.基本思想

若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

tips:分治法的主要区别

关键在于分解出来的各个子问题的性质不同。分治法要求各个子问题是独立的(即不包含公共的子问题)，因此一旦递归地求出各个子问题的解后，便可自下而上地将子问题的解合并成原问题的解。如果各子问题是不独立的，那么分治法就要做许多不必要的工作，重复地解公共的子问题。动态规划与分治法的不同之处在于动态规划允许这些子问题不独立(即各子问题可包含公共的子问题)，它对每个子问题只解一次，并将结果保存起来，避免每次碰到时都要重复计算。

算法实现

(1)分析最优值的结构，刻画其结构特征；

(2)递归地定义最优值；

(3)按自底向上或自顶向下记忆化的方式计算最优

若干经典问题

1)0-1背包问题给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

该问题具有最优子结构


========>

//3d10-1 动态规划 背包问题
#include "stdafx.h"
#include <iostream>
using namespace std;

const int N = 4;

void Knapsack(int v[],int w[],int c,int n,int m[][10]);
void Traceback(int m[][10],int w[],int c,int n,int x[]);

int main()
{
int c=8;
int v[]={0,2,1,4,3},w[]={0,1,4,2,3};//下标从1开始
int x[N+1];
int m[10][10];

cout<<"待装物品重量分别为："<<endl;
for(int i=1; i<=N; i++)
{
cout<<w[i]<<" ";
}
cout<<endl;

cout<<"待装物品价值分别为："<<endl;
for(int i=1; i<=N; i++)
{
cout<<v[i]<<" ";
}
cout<<endl;

Knapsack(v,w,c,N,m);

cout<<"背包能装的最大价值为："<<m[1][c]<<endl;

Traceback(m,w,c,N,x);
cout<<"背包装下的物品编号为："<<endl;
for(int i=1; i<=N; i++)
{
if(x[i]==1)
{
cout<<i<<" ";
}
}
cout<<endl;

return 0;
}

void Knapsack(int v[],int w[],int c,int n,int m[][10])
{
int jMax = min(w
-1,c);//背包剩余容量上限 范围[0~w
-1]
for(int j=0; j<=jMax;j++)
{
m
[j]=0;
}

for(int j=w
; j<=c; j++)//限制范围[w
~c]
{
m
[j] = v
;
}

for(int i=n-1; i>1; i--)
{
jMax = min(w[i]-1,c);
for(int j=0; j<=jMax; j++)//背包不同剩余容量j<=jMax<c
{
m[i][j] = m[i+1][j];//没产生任何效益
}

for(int j=w[i]; j<=c; j++) //背包不同剩余容量j-wi >c
{
m[i][j] = max(m[i+1][j],m[i+1][j-w[i]]+v[i]);//效益值增长vi
}
}
m[1][c] = m[2][c];
if(c>=w[1])
{
m[1][c] = max(m[1][c],m[2][c-w[1]]+v[1]);
}
}

//x[]数组存储对应物品0-1向量,0不装入背包，1表示装入背包
void Traceback(int m[][10],int w[],int c,int n,int x[])
{
for(int i=1; i<n; i++)
{
if(m[i][c] == m[i+1][c])
{
x[i]=0;
}
else
{
x[i]=1;
c-=w[i];
}
}
x
=(m
[c])?1:0;
}