1086 AlvinZH的青春记忆IV
思路
难题，动态规划。
这是一道很有意思的题，因为它不仅卡了时间，也卡了空间，而且卡的很妙很迷。
光是理解题意已经有点难度，简化题意：两串数字序列，相等的数字定义为可以交战，若 AiBj，则 Ai 可与 Bj 交战，之后下一场 Aii、Bjj 交战的条件是：AiiBjj、ii＞i、jj＞j、Aii＞Ai、Bjj＞Bj 。
这是什么呢？最长公共子序列？最长递增子序列？都很像，其实是最长公共递增子序列！最长公共子序列与最长递增子序列的叠加，即LCS+LIS，称为 LCIS 问题。
如果你不知道怎么求LCS和LIS，请复习后继续往下看。
在开始讲TLE问题前，先讲一下MLE问题。可以发现题目中所给的 (n) 最大有1e4，如果你的(dp)数组是int的二维1e4数组，明显已经超过空间限制。
这里想一想 (dp) 数组的定义，它代表的是LCIS的大小，这个大小是不可能超过 (n) 和 (m) 的，所以dp[i][j]＜1e4，所以dp数组定义为 (short int)。
注意一个小问题：数学函数max(int,int)，比较大小前需要转成int。
方法一：最原始的方法——完全暴力
(dp[i][j])：A前i个元素和B前j个元素最长公共上升子序列。
四重for循环，外层两个判断LCS，内层两个判断LIS。TLE，不用说。
代码如下，时间复杂度：O(n4)，空间复杂度：O(n2)。可得0.4分，TLE。
int n, m, ans;
int A[10005];
int B[10005];
short int dp[10005][10005];//dp[i][j]：A前i个元素和B前j个元素最长公共上升子序列
ans = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(A[i] == B[j])
{
for(int k = 0; k < i; k++)
if(A[k] < A[i])
for(int l = 0;l < j; l++)
dp[i][j] = max((int)dp[i][j], (int)dp[k][l]+1);
}
ans = max(ans, (int)dp[i][j]);
}
}
printf("%d
", ans);
//完全暴力
//时间复杂度：O(n^4)
//空间复杂度：O(n^2)
方法二：推翻重来，重新定义DP数组
可以发现，上一种方法中DP数组定义实在是太普通了，我们可以对其加以限制。
(dp[i][j])：以A串的前i个整数与B串的前j个整数且以B[j]为结尾构成的LCIS的长度，即不强制选择A[i]且强制选择B[j]的长度。
状态转移方程：
- ①dp[i][j] = dp[i-1][j]。(A[i] != B[j])
- ②dp[i][j] = max(dp[i-1][k])+1 (A[i] == B[j]) (1 <= k <= j-1 && B[j] > B[k])
对于①，dp[i][j]定义可知：B[j]必须使用。但A[i] != B[j]，A[i]无贡献，可直接取dp[i-1][j]。
对于②：两数相等情况下为了最长，B[j]一定与A[i]匹配，若与之前某A[1i-1]匹配，一定没有比与A[i]匹配更优。接下来需要去找一个递增的以B[j]结尾的LCIS，枚举dp[i-1][1j-1]找最大值。为什么第一维是i-1，A[i]已经匹配，而取[1~i-2]显然没有比取i-1更优。
参考代码一：最浅显的翻译
根据上述dp定义可以直接翻译，得到最浅显的解决代码如下，依然超时，可得0.4分， TLE。
时间复杂度：O(n3)，空间复杂度：O(n2)。
int n, m, ans;
int A[10005];
int B[10005];
short int dp[10005][10005];//dp[i][j]：以A串的前i个整数与B串的前j个整数且以B[j]为结尾构成的LCIS的长度
ans = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(A[i] == B[j])
{
int maxx = 0;
for(int k = 1; k <= j-1; k++)//找到符合递增的最大长度
{
if(B[j] > B[k])//保证递增
maxx = max(maxx, (int)dp[i-1][k]);
}
dp[i][j] = maxx + 1;
}
else
dp[i][j] = dp[i-1][j];
}
}
for(int j = 1; j <= m; j++)
if(ans < dp[n][j]) ans = dp[n][j];
//时间复杂度：O(n^3)
//空间复杂度：O(n^2)
参考代码二：代码一的时间优化
时间优化：maxx可以在第二层循环直接求得，不需要第三层循环。如何求得？
首先明白maxx的定义：maxx=max(dp[i-1][k])，k=[1,j-1]。指的是符合递增条件下（B[k]＜B[j]），A[1~i-1]与B[1,j-1]形成的LCIS。
由于B[j]已经与A[i]匹配，要找的是B[j] > B[k]，即推出A[i] > B[k]。在第二层循环中直接判断即可更新maxx的值。
代码如下，时间复杂度：O(n2)，空间复杂度：O(n2)。可得0.6分，TLE。
int n, m, ans;
int A[10005];
int B[10005];
short int dp[10005][10005];//dp[i][j]：以A串的前i个整数与B串的前j个整数且以B[j]为结尾构成的LCIS的长度
ans = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++)
{
int maxx = 0;
for(int j = 1; j <= m; j++)
{
if(A[i] == B[j])
dp[i][j] = maxx+1;
else
dp[i][j] = dp[i-1][j];
if(A[i] > B[j])
maxx = max(maxx, (int)dp[i-1][j]);
}
}
for(int j = 1; j <= m; j++)
if(ans < dp[n][j]) ans = dp[n][j];
//时间复杂度：O(n^2)
//空间复杂度：O(n^2)
参考代码三：对代码二的空间优化
发现dp更新时只与上一状态有关，所以dp数组可以变成dp[2][10005]，位操作滚动更新，其他不变。
代码如下，时间复杂度：O(n^2)，空间复杂度：O(n)。可得1分，AC。终于可以AC了，但是，为什么呢？
莫名AC了，应该问问为什么。代码二与代码三对比，只是空间比小了，对于第二组数据，为什么一个1500ms直接T，而这个36ms刷的过去了呢？第二组数据有什么坑？
我直说：第二组数据中n很小，Ai和Bi很小，不过数据组数有点大。一个原因可以理解为初始化问题，第二个原因是堆空间分配问题，看你们计组学的如何了！
int n, m, ans;
int A[10005];
int B[10005];
short int dp[2][10005];
ans = 0;
memset(dp, 0, sizeof(dp));
int cur = 0;
for(int i = 1; i <= n; i++)
{
cur = cur^1;
int maxx = 0;
for(int j = 1; j <= m; j++)
{
if(A[i] == B[j])
dp[cur][j] = maxx+1;
else
dp[cur][j] = dp[cur^1][j];
if(A[i] > B[j])
maxx = max(maxx, (int)dp[cur^1][j]);
}
}
for(int j = 1; j <= m; j++)
if(ans < dp[cur][j]) ans = dp[cur][j];
printf("%d
", ans);
//时间复杂度：O(n^2)
//空间复杂度：O(n)
参考代码四：对代码三进一步优化
什么！！！还可以优化！
是的，其实既然可以位操作滚动优化，有可能可以像01背包一样直接变为一维数组。这里确实可以这样做。
dp数组的定义稍微有所改变，dp[i]表示以B[i]结尾的LCIS，A的范围是[1~n]。
代码如下，时间复杂度：O(n^2)，空间复杂度：O(n)。可得1分，AC。
int n, m, ans;
int A[10005];
int B[10005];
short int dp[10005];//dp[i]表示以B[i]结尾的LCIS，A的范围是[1~n]
ans = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++)
{
int maxx = 0;
for(int j = 1; j <= m; j++)
{
if(A[i] == B[j])
dp[j] = maxx+1;
if(A[i] > B[j])
maxx = max(maxx, (int)dp[j]);
}
}
for(int j = 1; j <= m; j++)
if(ans < dp[j]) ans = dp[j];
//时间复杂度：O(n^2)
//空间复杂度：O(n)
分析
不分析了，还分析个毛线！只能说，我们对DP的力量一无所知！