PKU2192 Zipper(DP+记忆化)

/*
 

Zipper
Time Limit: 1000MS        Memory Limit: 65536K
Total Submissions: 6751        Accepted: 2244

Description
Given three strings, you are to determine whether the third string can be formed by combining the characters in the first two strings. The first two strings can be mixed arbitrarily, but each must stay in its original order.

For example, consider forming "tcraete" from "cat" and "tree":

String A: cat
String B: tree
String C: tcraete

As you can see, we can form the third string by alternating characters from the two strings. As a second example, consider forming "catrtee" from "cat" and "tree":

String A: cat
String B: tree
String C: catrtee

Finally, notice that it is impossible to form "cttaree" from "cat" and "tree".

Input
The first line of input contains a single positive integer from 1 through 1000. It represents the number of data sets to follow. The processing for each data set is identical. The data sets appear on the following lines, one data set per line.

For each data set, the line of input consists of three strings, separated by a single space. All strings are composed of upper and lower case letters only. The length of the third string is always the sum of the lengths of the first two strings. The first two strings will have lengths between 1 and 200 characters, inclusive.

Output
For each data set, print:

Data set n: yes

if the third string can be formed from the first two, or

Data set n: no

if it cannot. Of course n should be replaced by the data set number. See the sample output below for an example.

Sample Input

3
cat tree tcraete
cat tree catrtee
cat tree cttaree

Sample Output

Data set 1: yes
Data set 2: yes
Data set 3: no

Source
Pacific Northwest 2004
*/

 

#include <iostream> #include <string.h> using namespace std; char s1[205],s2[205],s3[410]; int l1,l2,l3; int f[205][205]; int dp(int i,int j) { if(f[i][j]!= -1) { return f[i][j]; } if(i == l1 && j == l2) { return f[i][j] = 1; } if(i < l1 && s1[i] == s3[i + j]) { if(dp(i + 1,j)) { return f[i][j] = 1; } } if(j < l2 && s2[j] == s3[i + j]) { if(dp(i,j + 1)) { return f[i][j] = 1; } } return f[i][j] = 0; } int main(void) { int n,rst; cin>>n; for(int m = 1;m <= n;m++) { cin>>s1>>s2>>s3; l1 = strlen(s1); l2 = strlen(s2); l3 = l1 + l2; memset(f,-1,sizeof(f)); rst = dp(0,0); if(rst == 1) { cout<<"Data set "<<m<<": yes"<<endl; } else { cout<<"Data set "<<m<<": no"<<endl; } } return 0; }

整个就是从左向右，当出现某个位置S3即不和当前的S1[I]相等又不和当前的S2[J]相等的时候，我们就可以判断这个时候不对了，f[i][j] = 0,接着就往回推到之前的某个分支可以选择其他的地方再开始算（指的是这个意思：比如某个时候（分支）是选择i + 1,这下i + 1推到后来推出0了，那么一路f[i][j] = 0推回到这个分支这次选择j + 1，然后往下推），注意每次递归的时候我们先判断的是当前f[i][j]是不是已经算过了，就是这段代码：

    if(f[i][j]!= -1)
    {
    return f[i][j];
    }

因为当-1的时候是没算过的时候，当为其他值（不管1还是0）就是算过，算过就马上返回不要重复再算。