Codeforces 1335E1 - Three Blocks Palindrome (easy version)

Posted 2021-03-01 stelayuri

题面

题意

给定一个长度为 n 的数列

定义要求的回文子数列满足下图条件

其中 x 与 y 可以为 0

即这个回文子数列可以是数字完全相同的一个子数列

也可以是只包含两种数字，且其中一种平均分布在另一种数字的两侧

求出最长的回文子数列长度

解题思路

在输入时往vector里记录下每个数字出现的位置

然后开始枚举位于两侧的数字的种类 i（ i = 1 ~ 26 ）

首先考虑这个回文子数列只包含一种数字，刚好根据枚举

直接将答案与枚举的字符数量取大（与枚举到的vector[i].size取大）

然后如果出现的次数少于2次，说明不能放在两侧，直接跳过这次枚举

否则，再对每一侧拥有多少个数字 i 进行枚举（ j = 1 ~ size/2 ）

然后根据贪心可以得知，假设枚举出数字 i 在每一侧出现 j 次的话

那就可以取原数列中最左边 j 个 i 和最右边 j 个 i 作为答案的原位置，再从左数第 j 个 i 的位置 +1 开始，以右数第 j 个 i 的位置 -1 结束，在这段区间内寻找出现最多次的数字 x 作为答案的中间部分，则这种情况的答案就是 j*2+x出现的次数

优化：

（如果用的是RMQ问题的 “静态查找区间内出现最多次数字的次数” 的话可以不需要看这里的优化）

可以发现，在我们枚举 j 的时候，可行的区间永远是连续的

以【 1 1 1 2 1 2 1 1 】，枚举数字 i = 1 时为例

图中绿色区域就是每一次我们需要找出现最多次数字时的区间

由图可以得知

如果 j 从小到大枚举，则我们查找的区间会在原来的基础上缩短，即上图从上往下

如果 j 从大到小枚举，则我们查找的区间会在原来的基础上延长，即上图从下往上

所以我们可以在每次枚举 j 时，记录下查找的区间内每种数字出现的个数

在 j 改变时，把两个状态中出现改变的两端区间处理下就可以直接转移

那么这里的时间复杂度就从 O( size/2 * n ) 降为了 O(n)

详见代码

主要部分代码实现

对于枚举 j 时的转移部分

因为状态转移时左右两端都会加上或者减少一段区间

以 j 从大到小枚举为例（代码也是从大到小）

需要先处理中间部分，然后再每次增加两段子区间

所以特殊处理下中间部分

假设当前枚举的数字 i 出现的次数为 cnt

则两端每端最多有 cnt/2 个数字 i ，以 cntt=cnt/2 记录

因为vector中下标从 0 开始

所以实际范围为 0 ~ cnt-1

如果cnt是偶数，则存在两个中位数，分别是 cntt-1 和 cntt ，最开始以这两个位置开始处理即可

而如果cnt是奇数，则中位数只存在一个，因为我们要保证两端的数字个数相同，所以最中间这个数字不能取，所以最开始处理的是 cntt-1 和 cntt+1

发现实际上按照两端数字相同的性质，可以直接采用 cntt-1 和 cnt-cntt 即可，不需要特殊判断奇偶

然后定义数组，寻找第 cntt-1 个数的位置 +1 到第 cnt-cntt 个数的位置 -1 这段范围内的各种数字出现的次数

因为两端个数为 cntt，则此时答案就是 最多次数mx+cntt*2

int num[30]={0},mx=0;
for(int j=v[i][cntt-1]+1;j<v[i][cnt-cntt];j++)
    num[ar[j]]++; //记录
for(int j=1;j<=26;j++)
    if(num[j]>mx)
        mx=num[j]; //寻找出现次数最大的
ans=max(ans,mx+cntt*2);

然后就可以通过状态转移了

j 从 cntt-1 开始向下枚举到 1

因为 j 代表的就是个数

所以每次增加的区间分别为 第 j-1 个数 到 第 j 个数 和 第 cnt-j-1 个数 到 第 cnt-j 个数

直接加入上面的num数组即可，不需要清零

最后的答案为 mx+j*2

for(int j=cntt-1;j>0;j--)
{
    for(int k=v[i][j-1]+1;k<v[i][j];k++)
        num[ar[k]]++;
    for(int k=v[i][cnt-j-1]+1;k<v[i][cnt-j];k++)
        num[ar[k]]++;
    for(int k=1;k<=26;k++)
        if(num[k]>mx)
            mx=num[k];
    ans=max(ans,mx+j*2);
}

完整程序

感觉是纯暴力加上个优化，结果跑得飞快

范围修改下可以直接过hard

(31ms/3000ms)

#include<bits/stdc++.h>
using namespace std;
int ar[2050];
vector<int> v[30];

void solve()
{
    int n,ans=0;
    cin>>n;
    for(int i=1;i<=26;i++)
        v[i].clear(); //多组数据注意清空
    for(int i=1;i<=n;i++)
    {
        cin>>ar[i];
        v[ar[i]].push_back(i); //记录每个数字出现的位置
    }
    for(int i=1;i<=26;i++) //枚举位于两侧的数字
    {
        int cnt=v[i].size(),cntt;
        ans=max(ans,cnt); //单种数字作为答案的情况

        if(cnt<=1)
            continue; //如果只出现了一次或没出现过，直接continue即可

        cntt=cnt/2; //位于某一侧的数字的最大数量

        int num[30]={0},mx=0;

        for(int j=v[i][cntt-1]+1;j<v[i][cnt-cntt];j++) //第一次每一侧的数量均为cntt，找的是第cntt-1个到第cnt-cntt个之间的位置
            num[ar[j]]++;
        for(int j=1;j<=26;j++)
            if(num[j]>mx)
                mx=num[j]; //寻找出现次数最多的次数
        ans=max(ans,mx+cntt*2); //记录答案

        for(int j=cntt-1;j>0;j--) //然后枚举每一侧的数量
        {
            for(int k=v[i][j-1]+1;k<v[i][j];k++) //左边的区间是从第j-1个到第j个
                num[ar[k]]++;
            for(int k=v[i][cnt-j-1]+1;k<v[i][cnt-j];k++) //右边的区间是从第cnt-j-1个到第cnt-j个
                num[ar[k]]++;
            for(int k=1;k<=26;k++)
                if(num[k]>mx)
                    mx=num[k]; //寻找出现次数最多的次数
            ans=max(ans,mx+j*2); //记录答案
        }
    }
    cout<<ans<<‘
‘;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int T;cin>>T;
    for(int t=1;t<=T;t++)
        solve();
    return 0;
}