五大经典算法之三动态递归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];
}




评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值