2016级算法期末模拟练习赛-F.AlvinZH的青春记忆IV

Posted AlvinZH

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2016级算法期末模拟练习赛-F.AlvinZH的青春记忆IV相关的知识,希望对你有一定的参考价值。

1086 AlvinZH的青春记忆IV

思路

难题,动态规划。

这是一道很有意思的题,因为它不仅卡了时间,也卡了空间,而且卡的很妙很迷。

光是理解题意已经有点难度,简化题意:两串数字序列,相等的数字定义为可以交战,若 Ai==Bj,则 Ai 可与 Bj 交战,之后下一场 Aii、Bjj 交战的条件是:Aii==Bjj、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(n^4),空间复杂度:O(n^2)。可得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\n", 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[1~i-1]匹配,一定没有比与A[i]匹配更优。接下来需要去找一个递增的以B[j]结尾的LCIS,枚举dp[i-1][1~j-1]找最大值。为什么第一维是i-1,A[i]已经匹配,而取[1~i-2]显然没有比取i-1更优。

参考代码一:最浅显的翻译

根据上述dp定义可以直接翻译,得到最浅显的解决代码如下,依然超时,可得0.4分, TLE。

时间复杂度:O(n^3),空间复杂度:O(n^2)。

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(n^2),空间复杂度:O(n^2)。可得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\n", 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的力量一无所知!

以上是关于2016级算法期末模拟练习赛-F.AlvinZH的青春记忆IV的主要内容,如果未能解决你的问题,请参考以下文章

2016级算法期末模拟练习赛-C.AlvinZH的青春记忆II

2016级算法期末模拟练习赛-B.AlvinZH的青春记忆I

2016级算法期末模拟练习赛-E.AlvinZH的青春记忆III

2016级算法期末模拟练习赛-A.wuli51和京导的毕业旅行

2016级算法第四次上机-F.AlvinZH的最“长”公共子序列

《计算机网络》期末模拟考试练习+答案