动态规划+递归：给定两个序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}(1＜=n＜=1e3)，求所有最长公共子序列。

（1）思路分析

• 首先通过动态规划得到最长公共子序列的长度dp[n][m],同时用is[i][j]记录每个位置对应的状态，以便后续回溯路径。
• 然后递归回溯路径，当找到长度为最长公共子序列长度的路径时，将该路径加入到ans中。
• 最后，对ans中的路径进行去重然后输出，即可得到答案。

（2）代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
typedef long long ll;

const int N=5e3+10;

string a,b;
int n,m,maxn;
int dp[N][N];
int is[N][N];
vector<char>path;
vector<string>ans;

//	首先，通过init()函数初始化了两个字符串a和b，并将它们的长度分别存储在n和m中。
//  然后使用动态规划的思想，在二维数组dp中记录了每个位置对应的最长公共子序列的长度，
//  同时使用二维数组is记录了每个位置对应的状态，以便后续回溯路径。
void init()
{
	cin>>a>>b;
	n=a.size(); m=b.size();
	a=" "+a; b=" "+b;
	for(int i=0;i<=n;i++) dp[i][0]=0;
	for(int i=0;i<=m;i++) dp[0][i]=0;
}

//	LCS()函数实现了填表的过程，通过遍历字符串a和b的每个字符，根据当前字符是否相等来更新dp数组和is数组。
void LCS()
{
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(a[i]==b[j]){
				dp[i][j]=dp[i-1][j-1]+1;
				is[i][j]=0;
			}
			else{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
				if(dp[i-1][j]>dp[i][j-1]) 
					is[i][j]=1;
				else if(dp[i-1][j]<dp[i][j-1]) 
					is[i][j]=2;
				else 
					is[i][j]=3;
			}
		}
	}
	maxn=dp[n][m];
}

//	findPath()函数是一个递归函数，用于回溯路径，通过path数组记录当前找到的子序列。
//	当找到一条长度为最长公共子序列长度的路径时，将该路径加入到ans数组中。
void findPath(int x,int y,int cnt)
{
	if(is[x][y]==0) path.push_back(a[x]);
	if(cnt==maxn){
		string tem;
		for(auto i:path) tem+=i;
		reverse(tem.begin(),tem.end());
		ans.push_back(tem);
		path.pop_back();
		return ;
	}
	if(is[x][y]==0){
		if(x-1>=1&&y-1>=1){
			if(is[x-1][y-1]==0) findPath(x-1,y-1,cnt+1);
			else findPath(x-1,y-1,cnt);
		}
	}
	else if(is[x][y]==1){
		if(x-1>=1){
			if(is[x-1][y]==0) findPath(x-1,y,cnt+1);
			else findPath(x-1,y,cnt);
		}
	}
	else if(is[x][y]==2){
		if(y-1>=1){
			if(is[x][y-1]==0) findPath(x,y-1,cnt+1);
			else findPath(x,y-1,cnt);
		}
	}
	else if(is[x][y]==3){
		if(x-1>=1){
			if(is[x-1][y]==0) findPath(x-1,y,cnt+1);
			else findPath(x-1,y,cnt);
		}
		if(y-1>=1){
			if(is[x][y-1]==0) findPath(x,y-1,cnt+1);
			else findPath(x,y-1,cnt);
		}
	}
	if(is[x][y]==0) path.pop_back();
}

//	getLCS()函数遍历dp数组，找到所有最长公共子序列，并通过findPath()函数回溯路径。
void getLCS()
{
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(dp[i][j]!=maxn) continue;
			if(is[i][j]!=0) continue;
			path.clear();
			findPath(i,j,1);
		}
	}
}

//	最后，print()函数将找到的所有最长公共子序列输出，如果没有找到则输出"-1"。
//	在输出前，先对ans数组进行排序并去重，确保输出结果的顺序和唯一性。
void print()
{
	if(ans.empty()) cout<<"-1"<<endl;
	sort(ans.begin(),ans.end());
	ans.erase(unique(ans.begin(),ans.end()),ans.end());
	for(auto i:ans) cout<<i<<endl;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	init();
	LCS();
	getLCS();
	print();
	return 0;
}