动态规划是解决多决策问题的一种解决方案,而非一种算法。其中心思想在于,将原问题分解成多个子问题,通过子问题的求解,得到原问题的答案。
01背包问题:
题目描述:有编号a,b,c,d,e的物件物品,他们的重量分别是2,2,6,5,4.他们的价值分别是6,3,5,4,6现在给到承重10的背包,如何将背包装入的物品具有最大价值总和.
表格从上到下,从左向右,c4表示当背包承重为4时,有物品a,b,c可装入时,背包最大价值。
背包转换方程::f[i,j]=Max{f[i-1,j-Wi]+Pi(j>=Wi),f[i-1,j]}
f[i,j] 表示在前i件物品中,选择若干件放在背包承重j的背包中以获得最大价值。
Pi 物品i的价值.
Wi物品i的重量
问题决策:为了使背包承重j的价值最大,物品i是否需要放进背包。
附代码:
#include "stdafx.h"
int max(int a,int b)
{
return a>b?a:b;
}
/*
0 1 背包
*/
int MaxValue()
{
int Weight[5]={2,2,6,5,4};//物品的重量数组
int Value[5]={6,3,5,4,6};//物品价值数组
int Total_Count = 5/*物品个数*/,
Total_w = 10 /*背包承重*/;
int f[5][10]={0};
for(int Cur_w =1;Cur_w <= Total_w;Cur_w++)//背包重量
{
for(int i=0;i<Total_Count;i++)//物品个数
{
{
//这里需要考虑Cur_w是否大于Weight
if(Cur_w >= Weight[i])
{
if(i==0)//第一件物品
{
f[i][Cur_w-1] = Value[i];
}
else
{
f[i][Cur_w-1] = max(f[i-1][Cur_w-1-Weight[i]]+Value[i],f[i-1][Cur_w-1]);
}
}
else//当前背包承重小于i物品的重量时
{
//同样考虑第一件物品的情况
if(i==0)
{
f[i][Cur_w-1] = 0;
}
else
{
f[i][Cur_w-1] = f[i-1][Cur_w-1];
}
}
}
}
}
return f[4][9];
}
最大子数组和。
问题描述:一个整数数组,一个非空的字数组,求它的最大和
设定dp[i]表示以a[i]结尾的最大字数组和
问题转化:dp[i] = max(dp[i-1]+a[i],a[i])
dp[i]取决于dp[i-1]+a[i]和a[i]的最大值。
代码:
/*
最大子数组
*/
#include<vector>
using namespace std;
int MaxSubarray(int a[],int n)
{
vector<int> dp(n);
dp[0] = a[0];
int maxSub =a[0];
for(int i=1;i<n;i++)
{
dp[i] = max(dp[i-1]+a[i],a[i]);
maxSub = max(dp[i],maxSub);//记录每一次的字数组和,并取到最大值
}
return maxSub;
}
最小路径: min(A->E)=min((A->B1)+min(B1->E),(A->B2)+min(B2->E))
同样,将A->E的最小路径问题转化为B1->E,B2->E的子问题,求出子问题后,再求解原始问题。
如下二维矩阵,表示从列A->E 到 行A->E的所有路径,除过有直接到E的几个节点外
其他均为0,优化期间path[i][10]表示经计算后i点到E的最小路径。所以
path[i][10]=min(path[i][j]+path[j][10],path[i][j+1]+path[j+1][10],...);
path[i][j]表示i行所有不为0的项。
/*
最短路径
*/
int path[11][11] =
//终点 A B1 B2 C1 C2 C3 C4 D1 D2 D3 E
/*起点*/
/*A*/{ 0, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0,
/*B1*/ 0, 0, 0, 1, 6, 3, 0, 0, 0, 0, 0,
/*B2*/ 0, 0, 0, 0, 0, 8, 4, 0, 0, 0, 0,
/*C1*/ 0, 0, 0, 0, 0, 0, 0, 5, 6, 0, 0,
/*C2*/ 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0,
/*C3*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0,
/*C4*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
/*D1*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
/*D2*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4,
/*D3*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
/*E*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int MinPath()
{
int i,j;
for(i=9;i>=0;i--)
{
vector<int> temp(11);
for(j=10;j>=0;j--)
{
//用当前行中,除最后一列的所有数字,加上path[j][10],取最小 ,赋给path[i][11];
if(path[i][j] > 0 && j!=10)//此处需要判断边界条件
{
temp[j] = path[j][10]+path[i][j];
}
}
vector<int>::iterator it =temp.begin();
int temp_minipath = 10000;//指定一个远大于所有路径之和的所有值
for(;it!=temp.end();it++)
{
if(*it!=0)
{
temp_minipath = temp_minipath < *it?temp_minipath:*it;
}
}
if(temp_minipath != 10000)
path[i][10] = temp_minipath;//求当前点到E的最小路径
}
return path[0][10];
}
/*
斐波那契数列
*/
斐波那契数列:动态规划的优化在于将所有计算过的选项用数组dp[n]保存起来,下次计算的时候,直接
运用,跳过指数级的重复计算过程。
int DpFiboArray(int n)
{
static vector<int> dp(n+1);
if(n==0 || n==1)
{
dp[n] = 1;
return dp[n];
}
else
{
if(dp[n-1] == 0)
dp[n-1] = DpFiboArray(n-1);
if(dp[n-2] == 0)
dp[n-2] = DpFiboArray(n-2);
dp[n] = dp[n-1]+dp[n-2];
}
return dp[n];
}
int FiboArray(int n)
{
if(n==0 || n==1)
return 1;
else
return FiboArray(n-1)+FiboArray(n-2);
}
int _tmain(int argc, _TCHAR* argv[])
{
// 01背包
int result = MaxValue();
//最大字数组
int a[10]={31,-41,59,26,-53,58,97,-93,-23,84};
int maxsub =MaxSubarray(a,10);
//最短路径
int minpath = MinPath();
//斐波那契数列
int FiboNum =DpFiboArray(20);
return 0;
}