动态规划 01背包 最大子数组和 最小路径 斐波那契数列

动态规划是解决多决策问题的一种解决方案，而非一种算法。其中心思想在于，将原问题分解成多个子问题，通过子问题的求解，得到原问题的答案。

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;
}