Codeforces Round #462

A.题目不难，但是如果想要用一些巧妙的方法去做的话….会变得很麻烦，要非常仔细地考虑各种可能。然而题目数据范围是如此的小，所以还不如暴力枚举所有的乘积，然后把最大的乘积所在的那一组数全部删掉，也就是第一个人应该删掉那个数。然后在剩下的数里找最大的数即可。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
using namespace std;
typedef long long ll;
//typedef pair<ll,ll>P;
int main()
{
    int n,m,i,j;//multimap<ll,ll>mp;
    cin>>n>>m;
    ll a[60],b[60];
    vector<ll>product[60];
    for(i=1;i<=n;i++)cin>>a[i];
    for(i=1;i<=m;i++)cin>>b[i];
    ll maxn=1LL<<63;int num;
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++){
        ll sum=a[i]*b[j];
        product[i].push_back(sum);
        if(sum>maxn){
            maxn=sum;num=i;
        }
    }
    product[num].clear();
    maxn=1LL<<63;
    for(i=1;i<=n;i++){
        for(auto a:product[i])
            maxn=max(maxn,a);
    }
    cout<<maxn<<endl;

    return 0;
}

B.这题就非常简单了，我们会发现其实只用4和8来凑就行，因此超过18*2=36的要求都是不行的。

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int k,i,j;
    cin>>k;
    if(k>36){
        cout<<-1<<endl;return 0;
    }
    i=k/2;
    if(k%2)cout<<4;
    while(i--)cout<<8;cout<<endl;

    return 0;
}

C.挺有意思的一道题。
很容易想到要预处理出1的前缀和pre[i]和2的后缀和suf[i]，因为我们其实是要找形如11*22*11*22的序列，这样我们把中间22*11的区间反转以后就能得到最长不下降子序列。
然后枚举区间，对于每个区间如果能求出最长递减序列的长度，那么就能更新答案了
这个用dp求
状态：
dp[i][j][0]表示i–j区间以2结尾的最长递减序列长度，很明显这个序列全为2，所以也就是i–j区间2的个数
dp[i][j][1]表示i–j区间以1结尾的最长递减序列长度

状态转移：
dp[i][j][0]=dp[i][j-1][0]+(a[j]==2)
dp[i][j][1]=max(dp[i][j-1][0],dp[i][j-1][1])+(a[j]==1)

O（n^2)的代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=2e3+5;
int a[N];
int pre[N];
int suf[N];
int dp[N][N][2];
int main(){
    //ios::sync_with_stdio(false);
    //cin.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)pre[i]=pre[i-1]+(a[i]==1);
    for(int i=n;i>=1;i--)suf[i]=suf[i+1]+(a[i]==2);
    int ans=0;
    for(int i=1;i<=n;i++){
        for(int j=i;j<=n;j++){
            dp[i][j][0]=dp[i][j-1][0]+(a[j]==2);
            dp[i][j][1]=max(dp[i][j-1][0],dp[i][j-1][1])+(a[j]==1);
            ans=max(ans,pre[i-1]+suf[j+1]+dp[i][j][0]);
            ans=max(ans,pre[i-1]+suf[j+1]+dp[i][j][1]);
        }
    }
    cout<<ans<<endl;
    return 0;
}

但是其实我们还有O（n）的做法；思路还是跟上面一样的，但是因为我们要找的其实是形如11*22*11*22的序列，我们认为这个序列是由4part组成的，我们令dp[i][j] (i = 1…n, j = 0..3) 为a[1……n]且包含前j part的最长序列长度，那么就可以o（n） dp解决。（Since the subsequence can be split into 4 parts (11…22…11…22…) , we can set dp[i][j](i = 1…n, j = 0..3) be the longest subsequence of a[1…i] with first j parts.）

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
int n,a[2005],dp[2005][4],b[5]={0,1,2,1,2};
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i < 5; i++)
        for (int j = 1; j <= n; j++)
            dp[j][i] = max(dp[j - 1][i] + (b[i] == a[j]), dp[j][i - 1]);
    printf("%d\n", dp[n][4]);

    return 0;
}