动态规划练习

问题描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

1.定义数组
一只青蛙跳上3级需要3种跳法,跳上i级有dp[i]种跳法,所以数组就是dp[i] dp[0] dp[1]…,跳上一个i级台阶有dp[i]种跳法.第一步定义完成
2.找出数组元素间的关系式.
dp[n]会等于什么呢,青蛙可以一次跳一级,也可以跳2级,所以到达第n级台阶,一种是从n-1上来,另外是从n-2上来
,所以dpn=dp[n-1]+dp[n-2];
3.找出初始条件,n=1,n=2
dp[0]=0;dp[1]=1.dp[2]=2;

int getN(int n)
{
	if(n<=2)
	{
		return n;
	}
	int *dp=new int[n+1];
	dp[0]=0;
	dp[1]=1;
	dp[2]=2;
	for(int i=3;i<=n;i++)
	{
		dp[i]=dp[i-1]+dp[i-2];
	}
	return dp[n];//因为假如n=3,那我就返回dp[3],假如不多分配一个空间,那么会崩溃的
}

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
1.定义数组,目的是从左上角到右下角共有多少种路径,那我们就定义dp[i][j]的含义为,当机器人从左上角走到(i,j)这个位置时候,一共有dp[i][j]种路径.那么dp[m-1][n-1]就是我们要的答案了.因为数组元素index是0开头
2.找出关系数组元素间的表达式
到达最后一步,可以从左面往右走到达,或者从上面往下走到达,所以dp[i][j]=dp[i][j-1]
+dp[i-1][j];
3.找出初始值
dp[0][0…n-1[=1;一直往右走
dp[0…m-1][0]=1;一直往下走

//撸代码
int uniquePaths(int m,int n)
{
	if(m<=0||n<=0)
	{
		return 0;
	}
	int dp[][]=new int[m][n];
	for(int i=0;i<n;i++)
	{
		dp[0][n]=1;
	}
	for(int i=0;i<m;i++)
	{
		dp[m][0]=1;
	}
	for(int i=1;i<m;i++)
	{
		for(int j=1;j<n;j++)
		{
			dp[i][j]=dp[i][j-1]+dp[i-1][j];
		}
	}
	return dp[i-1][j-1];
}

问题描述

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。
1.定义数组的含义,我们定义dp[i][j]的含义为:从左上角走到(i,j)这个位置时候,最小的路径和为dp[i][j];那么dp[m-1][n-1]就是答案.
2.找出元素间的关系式
到达i,j 有2种方式到达,一种通过i,j-1到达,另外一种是通过i-1,j到达.这次不是计算所有可能的路径.而是计算哪个路径是最小的.那我们就要从这2个选一个最小的.显然有
dp[i][j]=min(dp[i][j-1],dp[i-1][j])+arr[i][j]
3.找出初始值
,数组索引还是不能为负数,所以我们还可以计算最上面一行,或者最左面一行的值.因此初始值如下
dp[0][j]=dp[0][j-1]+arr[0][j];
dp[i][0]=dp[i-1][0]+arr[i][0];

代码如下

int minSumPaths(int arr[][],int m,int n)
{
	if(m<0||n<0)
	return 0;
	int dp[][]=new int[m][n];
	for(int j=1;j<n;j++)
	{
		dp[0][j]=dp[0][j-1]+arr[0][j];
	}
	for(int i=1;i<m;i++)
	{
		dp[i][0]=dp[i-1][0]+arr[i][0];
	}
	for(int i=1;i<m;i++)
	{
		for(int j=1;j<n;j++)
		{
			dp[i][j]=min(dp[i-1][j],dp[i][j-1])+arr[i][j];
			
		}
	}
	return dp[m-1][n-1];
}

编辑距离
给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。
1.定义数组元素的含义:
求将word1转换为word2使用的最少操作数.那我们就定义dp[i][j]的含义为,当字符串word1的长度为i,word2的长度为j时候,将word1转换为word2所使用的最小操作次数dp[i][j];
2.找出数组元素的关系式:
大部分情况下,dp[i][j]都与dp[i-1][j] dp[i][j-1] dp[i-1][j-1]有关系.我们可以对word1有3种操作
1.插入一个字符
2.删除一个字符
3.替换一个字符
1)如果,i和j都是最末尾的,如果word1[i]和word[j]相等,那么不需要进行任何操作,显然有dp[i][j]=dp[i-1][j-1];
2)如果不相等,必须调整,调整的方法有3种,(1)如果把word[i]替换与Word2[j]相等,则dp[i][j]=dp[i-1][j-1]+1;
(2) 如果在Word1末尾处添加一个字符,则dp[i][j]=dp[i][j-1]+1;
(3)如果把字符串word1[1]删掉,dp[i][j]=dp[i-1][j]+1;

我们应该选择一种操作使得dp[i][j]最小,
dp[i][j]=min(dp[i-1][j-1],dp[i][j-1],dp[i-1][j])+1;
关系式就吐出来了.
3.找出初始值
非常容易计算dp[0][0…n] 和dp[0…m][0]的值.,第一个是word1是0字符串,只需要插入,第二个是Word2是0字符串,只需要删除.

代码:
	int minDistance(Istring word1,string word2)
	{
		int len1=word1.length();
		int len2=word2.length();
		int dp[][]=new int[len1+1][len2+1];//假如word1是4个,word2是3个,我需要最后求dp[4][3],那么就需要分配5行,4列,不能仅仅分配4行 3列,要不dp[4][3]会崩溃,
		for(int i=1;i<=len1;i++)
		{
				dp[i][0]=dp[i-1][0]+1;
		}
		for(int j=1;j<=len2;j++)
		{
				 dp[0][j]=dp[0][j-1]+1;
		}
	//通过公式推导出dp[len1][len2];
	 for(int i=1;i<=len1;i++)
	 {
	 		for(int j=1;j<=len2;j++)
	 		{
	 			if(word1[i-1]==word[j-1])
	 			{
	 				dp[i][j]=dp[i-1][j-1];
	 				
	 			}
	 			else
	 			{
	 				dp[i][j]=min(dp[i-1][j-1],dp[i][j-1],dp[i-1][j])+1;
	 			}
	 		}
	 }
	 return dp[len1][len2];
	 //所以最好求的是dp[4][3],分配的数组一定不是只是arr[4][3]
	 //和上面的机器人不一样,分配一个4行3列的值,求最短路径或者方法sum ,只需要到arr[3][2]这个元素,从左上角到3,2这个元素,也就是m-1,n-1
	}

上面几道题的优化:
第二题:dp矩阵
1 1 1 1

填充第二行
1 1 1 1
1 2 3 4
当填充第三行的时候,不需要第一行的值了.填充第n行的时候,只会用到n-1的值.
因此我们只需用一个一维的dp数组来保存一行的历史记录就行了.然后在计算的过程中,不断更新dp[]的值
int uniquePaths(int m,int n)
{
if(m<0||n<0)
return 0;
int *dp=new int[n];
for(int i=0;i<n;i++)
{
dp[i]=1;
}
//公式dp[i]=dpi+dpi-1
for(int i=1;i<m;j++)
{
dp[0]=1;
for(int j=1;j<n;j++)
{
dp[j]=dp[j-1]+dp[j];
}
}
return dp[n-1];
}

编辑距离:
int minDistance(string word1,string word2)
{
int n1=word1.length();
int n2=word2.length();
int *dp=new int [n2+1];
//初始化dp[0…n2]的值
for(int j=0;j<=n2;j++)
{
dp[j]=j;
}
for(int i=1;i<=n1;i++)
{
int temp=dp[0];
dp[0]=i;
for(int j=1;j<=n2;j++)
{
int pre=temp;
temp=dp[j];
if(word1[i-1]==word2[j-1])
{

	 		}
	 }
}

}