五大经典算法之三动态递归DP

五大经典算法 动态递归DP

首先需要决定存储什么历史信息，以及用什么数据结构来存储。然后最重要的就是递推公式，最后需要考虑起始条件的值。

Leetcode 139. Word Break

要求一个非空字符串s,一个非空的字符串词典，判断s能够通过空格组成一个序列是词典里的多个单词：

例如s=”leetcode”

dict=[“leet”,”code”

]

因为“leetcode”可以改成“leet code”故返回1

使用DP，我们用dp[i]表示到字符串s的第i个元素为止能不能用字典里的词表示。假设已经知道dp[0,1,,,,i-1]的结果，要求dp[i]，其递推关系：

len取自[minlen,maxlen]，对于i从0到s.length，都有：

dp[i+len]=1 when dp[i]=1&&wordDict.fin(s.substr(i,len))

代码：

   
   
//word break
bool find_vector(vector<string> ss,string s){
int i= 0;
while(i<ss.size()){ if(s.compare(ss[i])== 0) return 1;i++;}
return 0;
}
bool wordBreak(string s,vector<string>& wordDict){
if(s.size()< 1) return 0;
vector< bool> dp(s.length()+ 1, false);
dp[ 0]= true;
int min_len=INT_MAX,max_len= 0;
for( int i= 0;i<wordDict.size();i++){ if(min_len>wordDict[i].size()){min_len=wordDict[i].size();}
if(max_len<wordDict[i].size()){ cout<< 1;max_len=wordDict[i].size();}
}
for( int i= 0;i<s.size();i++){
if(dp[i]){ for( int len=min_len;i+len<=s.size()&&len<=max_len;len++)
if(find_vector(wordDict,s.substr(i,len)))dp[i+len]= 1;
}
if(dp[s.length()]) return 1;
}
return dp[s.length()];
}
   
   

参考：Word Break

132. Palindrome Partitioning II
要求给定一个字符串，要求分成的若干字串都是回文，求最小分串次数。

本题采用动态规划法从后往前，引出dp数组，dp[i]表示s[0…i]的最小分割次数;

dp[i]初始化为i,每一个之间切一刀，这是最大值了;

若从0到i之间存在j,0<j<i，且有s[j…i]是回文，那么此时dp[i+1]=min(dp[i1+],dp[j]+1)

故递推公式：

dp[i+1]=min(dp[i1+],dp[j]+1)

   
   
vector < vector < bool> > getdict( string s){
vector< vector< bool> > res;
for( int i= 0;i<s.length();i++){
vector< bool> aa;
for( int j= 0;j<s.length();j++){aa.push_back( 0);};
res.push_back(aa);
}
if(s.size()< 1) return res;
for( int i=s.length() -1;i>= 0;i--)
for( int j=i;j<s.length();j++)
if(s[i]==s[j]&&((j-i< 2)||res[i+ 1][j -1]))res[i][j]= 1;

return res;
} //判断任意字串之间是不是回文
//palindrome Partitioning11
int minCut(string s){
int len= 0;
if(s.length()< 1) return len;
vector< vector< bool> >dict=getdict(s);
vector< int> dp(s.length()+ 1, 0);
dp[ 0]= 0;
for( int i= 0;i<s.size();i++){
{
dp[i+ 1]=i+ 1; //初始化
for( int j= 0;j<=i;j++)
if(dict[j][i])
dp[i+ 1]=min(dp[i+ 1],dp[j]+ 1);
}
}
return dp[s.size()] -1;
}
   
   

参考：132. Palindrome Partitioning II

44. Wildcard Matching

已知‘？’可以匹配任何一个字符

已知‘×’可以匹配0个或者多个任意字符

求两个字符串是否完全匹配。

类似上面的，这里引入动态规划，设dp[i][j]表示s的前i个字符与p的前j个字符的匹配情况，其递推公式：

dp[i][j]=dp[i][j-1]||dp[i-1,j] when p[j]==’*’,当此星号表示0个字符时，则主要看dp[i][j-1]，当星号代表字符时，则结果主要在于前面dp[i-1][j]

dp[i][j]=dp[i-1][j-1]&&(s[i]==p[j]||p[j]==’?’) when p[j]!=’*’

注意s的前i个字符与p的前j个字符的匹配情况，每次i+1的结果只依赖与i 与j,在程序中可以设置二重循环，则此时二维数组可以降为一维

dp[i+1]=dp[i]&&(p[j]==’?’||p[j]==s[i]) when p[j]!=’*’

当p[j]==’*’时，在次情形下，可以匹配任何情况，即只要遍历dp，发现dp[i]=1，则之后的结果肯定都是1

代码如下：

   
   
bool isMatch(string s,string p){
if(s.size()< 1&&p.size()< 1) return 1;
int slen=s.size(); int plen=p.size();
int i= 0;
int num= 0;
while(i<plen){ if(p[i]== '*')num++;i++;}
if(plen-num>slen) return 0;
vector< bool> dp(slen+ 1, false);
dp[ 0]= true;
for( int j= 0;j<plen;j++){
if(p[j]!= '*'){
for(i=slen;i>= 0;i--) //以为后面更新了dp[0]，故不能从i=0开始
dp[i+ 1]=dp[i]&&(p[j]==s[i]||p[j]== '?'); //此处体现i依赖与j
}
else {
i= 0;
while(i<=slen&&!dp[i])i++;
for(;i<=slen;i++)dp[i]= 1;
}
dp[ 0]=dp[ 0]&&(p[j]== '*'); //更新dp[0]，因为dp[0]表示s是空串，只有是星才匹配
}
return dp[slen];
}
   
   

摘自博文：五大经典算法之三动态递归DP