[一道区间dp][String painter]

http://acm.hdu.edu.cn/showproblem.php?pid=2476

String painter

Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 6863    Accepted Submission(s): 3330

Problem Description

There are two strings A and B with equal length. Both strings are made up of lower case letters. Now you have a powerful string painter. With the help of the painter, you can change a segment of characters of a string to any other character you want. That is, after using the painter, the segment is made up of only one kind of character. Now your task is to change A to B using string painter. What’s the minimum number of operations?

 

Input

Input contains multiple cases. Each case consists of two lines:
The first line contains string A.
The second line contains string B.
The length of both strings will not be greater than 100.

 

Output

A single line contains one integer representing the answer.

Sample Input

zzzzzfzzzzz abcdefedcba abababababab cdcdcdcdcdcd

 

Sample Output

6 7

 题意：有两个字符串，A串和B串，每次可以对A串一个区间进行涂改，使该区间所有字母变成任意一种字母，求使A串变成B串需要的最少操作次数

题解：首先考虑一个简化的问题，把一个空串涂改成B串需要的操作数，显然可以通过最基本的区间dp进行解决，转移方程为if(B[i]==B[k])dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j])；else dp[i][j]=min(dp[i][j],min(dp[i][k]+dp[k+1][j],dp[i][k-1]+dp[k][j]))；然后考虑A串不是空串，那么如果A[i]==B[i]，则有ans[i]=ans[i-1],如果A[i]!=B[i]，那么ans[i]=min(ans[j]+dp[j][i])。

普通的循环迭代版本

#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout<<"["<<#x<<"]"<<" is "<<x<<endl;
char ch[105],ch2[105];
int dp[105][105],ans[105];
const int inf=1e8;
int main(){
    while(scanf("%s",ch+1)!=EOF){
        scanf("%s",ch2+1);
        int len=strlen(ch+1);
        for(int i=1;i<=len;i++){
            for(int j=1;j<=len;j++){
                if(i>j)dp[i][j]=0;
                else if(i==j)dp[i][j]=1;
                else dp[i][j]=inf;
            }
        }
        for(int i=2;i<=len;i++){
            for(int j=1;j+i-1<=len;j++){
                for(int k=j+1;k<=j+i-1;k++){
                    if(ch2[j]==ch2[k])dp[j][j+i-1]=min(dp[j][j+i-1],dp[j][k-1]+dp[k+1][j+i-1]);
                    else dp[j][j+i-1]=min(dp[j][j+i-1],min(dp[j][k]+dp[k+1][j+i-1],dp[j][k-1]+dp[k][j+i-1]));
                }
            }
        }
        for(int i=1;i<=len+1;i++){
            ans[i]=inf;
        }
        ans[1]=0;
        for(int i=1;i<=len;i++){
            if(ch[i]==ch2[i]){
                ans[i+1]=min(ans[i+1],ans[i]);
            }
            else{
                for(int j=1;j<=i;j++){
                    ans[i+1]=min(ans[i+1],ans[j]+dp[j][i]);
                }
            }
        }
        printf("%d
",ans[len+1]);
    }
    return 0;
}

记忆化搜索版本(注意由于sol(1,len)只能保证dp[1][len]被更新，而不能保证所有的dp[i][j]被遍历到，所以需要使用n^2次sol(i,j)保证所有dp[i][j]都被更新了而不再是初始值)

#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout<<"["<<#x<<"]"<<" is "<<x<<endl;
char ch[105],ch2[105];
int dp[105][105],ans[105];
const int inf=1e8;
int sol(int l,int r){
    if(dp[l][r]!=0x3f3f3f3f)return dp[l][r];
    if(l>r)return dp[l][r]=0;
    if(l==r)return dp[l][r]=1;
    for(int k=l+1;k<=r;k++){
        if(ch2[k]==ch2[l]){
            dp[l][r]=min(dp[l][r],sol(l+1,k)+sol(k+1,r));
        }
        else{
            dp[l][r]=min(dp[l][r],sol(l+1,r)+1);
        }
    }
    return dp[l][r];
}
int main(){
    while(scanf("%s",ch+1)!=EOF){
        scanf("%s",ch2+1);
        int len=strlen(ch+1);
        memset(dp,0x3f3f3f3f,sizeof(dp));
        for(int i=1;i<=len;i++){
            for(int j=i;j<=len;j++){
                sol(i,j);
            }
        }
       // sol(1,len);
        for(int i=1;i<=len+1;i++){
            ans[i]=0x3f3f3f3f;
        }
        ans[1]=0;
        for(int i=1;i<=len;i++){
            if(ch[i]==ch2[i]){
                ans[i+1]=min(ans[i+1],ans[i]);
            }
            else{
                for(int j=1;j<=i;j++){
                    ans[i+1]=min(ans[i+1],ans[j]+dp[j][i]);
                }
            }
        }
        printf("%d
",ans[len+1]);
    }
    return 0;
}