这道题一看就是LCS，直接写个裸的，硬搜。TLE

void print(int r,int c,int n)
{
    if(dp[r][c]==0)
    {
        string ss=tp;
        ans[ss]=1;
        //sprintf(ansstr[cnt++],"%s\n",tp);
        return;
    }
    if(ph[r][c]==1)
        tp[n]=sa[r-1],print(r-1,c-1,n-1);
    else if(ph[r][c]==3)
        print(r,c-1,n),print(r-1,c,n);
    else
        while(1)
        {
            if(ph[r][c]==2)
                r--;
            else if(ph[r][c]==4)
                c--;
            if(ph[r][c]==1)
            {
                tp[n]=sa[r-1];
                print(r-1,c-1,n-1);
                return;
            }
            else if(ph[r][c]==3)
            {
                print(r,c-1,n);
                print(r-1,c,n);
                return;
            }
        }
}

于是看讨论里面说剪枝，我当时想到的是既然长度一致，那么拥有公共前缀的就可以不搜。同样TLE。因为当dp[i-1][j] 和dp[i][j-1]一样的时候都要二分深搜

接着搜解题报告。

1）首先按照常规的方法求出最长公共子序列的长度
也就是用O(MN)的那个动态规划，结果放在二维数组dp里
dp[i][j] = { 字串a的1~i部分与字串b的1~j部分的最长公共子序列的长度 }
2）求辅助数组
last1[i][j] = { 到下标i为止，字符j在字串a中最后一次出现的下标 }
last2[i][j] = { 到下标i为止，字符j在字串b中最后一次出现的下标 }
3）枚举最长公共字串的每一个字符
从最后一个字符开始枚举
比如说现在枚举最后一个字符是‘C‘的情况。
那么 ‘CDCD‘ 与 ‘FUCKC‘ 这两个字串。
一共有 (0, 2) (0, 4)  (2, 2)  (2. 4) 这四种可能。
很明显前三个是可以舍弃的，因为第四个优于前三个，为后续的枚举提供了更大的空间。
last数组正好是用来做这个的。
4）排序输出
代码里用了stl的set。

现在要分析这样为什么不会TLE。

这样不会有无用搜索，虽然看起来在每一层都有26个分支，但是但是有效的非常少t1=first[p1][i];，int t2=last[p2][i];，if(dp[t1][t2]==len)

当为i的时候已经表明两个相同的字符，还要刚好等于长度，这样必然不会成为之前的次完全二叉树。每一次函数调用都必然会是“有用的”

#include<stdio.h>
#include<set>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
set<string> set1;
int dp[100][100];
int first[100][26],last[100][26];
char ans[100];
string s1,s2;
int maxlen;

void dfs(int p1,int p2,int len)
{
    if(len<=0)
    {
        set1.insert(ans);
        return;
    }
    for(int i=0;i<26;i++)
    {
        int t1=first[p1][i];
        int t2=last[p2][i];
        if(dp[t1][t2]==len)//这句话是核心
        {
            ans[len-1]=i+'a';
            dfs(t1-1,t2-1,len-1);
        }
    }
}

int main()
{
    while(cin>>s1>>s2)
    {
        memset(dp,0,sizeof(dp));
        memset(first,0,sizeof(first));
        memset(last,0,sizeof(last));
        maxlen=0;
        for(int i=1;i<=s1.size();i++)
            for(int j=1;j<=s2.size();maxlen=max(maxlen,dp[i][j]),j++)
                if(s1[i-1]==s2[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        for(int i=1;i<=s1.size();i++)
        {
            for(int j=0;j<26;j++)
                first[i][j]=first[i-1][j];
            first[i][s1[i-1]-'a']=i;
        }
        for(int i=1;i<=s2.size();i++)
        {
            for(int j=0;j<26;j++)
                last[i][j]=last[i-1][j];
            last[i][s2[i-1]-'a']=i;
        }
        ans[maxlen]=0;set1.clear();
        dfs(s1.size(),s2.size(),maxlen);
        set<string>::iterator it;
        for(it=set1.begin();it!=set1.end();it++)
            cout<<*it<<endl;
    }
    return 0;
}

POJ 1934 Trip（LCS+枚举+输出所有路径）