CF1132.Educational Codeforces Round 61（简单题解）

A .Regular Bracket Sequence

题意：给定“((” ， “()” ，  “)(”，  “))”四种，问是否可以组成合法括号匹配

思路：设四种是ABCD，B可以不用管，而C在A或者D存在时可以不考虑，然后就是A=D。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
ll A,B,C,D,ans;
int main()
{
    scanf("%lld%lld%lld%lld",&A,&B,&C,&D);
    ans=B;
    if(A||D) ans+=C; ans+=2LL*min(A,D);
    if(ans==A+B+C+D) puts("");
    else puts("");
    return ;
}

B .Discounts

题意：给定N个物品，Q次询问，每次询问给定P，表示你可以选P个，最便宜的那个不用付款，问最少付款额。

思路：排序，贪心。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,w,v) for(int i=w;i<=v;i++)
using namespace std;
const int maxn=;
ll a[maxn],sum,ans;
int main()
{
    int N,M,x; scanf("%d",&N);
    rep(i,,N) scanf("%lld",&a[i]),sum+=a[i];
    sort(a+,a+N+);
    scanf("%d",&M);
    rep(i,,M) {
        scanf("%d",&x);
        printf("%lld ",sum-a[N+-x]);
    }
    return ;
}

C .Painting the Fence

题意：给定长度为N个点，M条线段，问选择M-2条，最多可以覆盖多少个点(N,M<5000)

思路：首先如果点被覆盖数大于2，不用考虑了，一定被覆盖。所以先求出被1个线段覆盖的，被2覆盖的，然后枚举不选的线段，前缀和更新答案即可。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,w,v) for(int i=w;i<=v;i++)
using namespace std;
const int maxn=;
int sum[maxn],num[][maxn],ans,tot; pair<int,int>s[maxn];
int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    rep(i,,M){
        scanf("%d%d",&s[i].first,&s[i].second);
        sum[s[i].first]++; sum[s[i].second+]--;
    }
    rep(i,,N) sum[i]+=sum[i-];
    rep(i,,N){
        if(sum[i]) tot++;
        num[][i]+=num[][i-];
        num[][i]+=num[][i-];
        if(sum[i]==) num[][i]++;
        if(sum[i]==) num[][i]++;
    }
    sort(s+,s+M+);
    rep(i,,M)
     rep(j,i+,M){
        if(s[j].first>s[i].second) ans=max(ans,tot-(num[][s[i].second]-num[][s[i].first-])-(num[][s[j].second]-num[][s[j].
            first-]));
        else if(s[j].second<=s[i].second)
         ans=max(ans,tot-(num[][s[j].first-]-num[][s[i].first-])-(num[][s[i].second]-num[][s[j].second])-(num[][s
            [j].second]-num[][s[j].first-]));
        else
         ans=max(ans,tot-(num[][s[j].first-]-num[][s[i].first-])-(num[][s[j].second]-num[][s[i].second])-(num
             [][s[i].second]-num[][s[j].first-]));
    }
    printf("%d\n",ans);
    return ;
}

D .Stressful Training

题意：有N台电脑，每台电脑初始电量a[]，每单位时间掉电b[]，现在给一个充电器，这个充电器同一单位时间只能给一个电脑充电，问每单位时间至少充多少，满足每台电脑都至少坚持K时间。

思路：二分X，二分之后这么写呢，是线性的呢。 求出每个人最晚的一些充电时间，然后总量不大于K，然后就是线性的向前摊平，如果同一时间个数大于1，则false。

这两个限制使得每次二分是线性的。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,w,v) for(int i=w;i<=v;i++)
using namespace std;
const int maxn=;
ll a[maxn],b[maxn],ans=-;int N,K,vis[maxn];
bool check(ll x)
{
    int cnt=; rep(i,,K) vis[i]=;
    rep(i,,N){
        ll L=a[i];
        while(L-b[i]*(K-)<){
            int t=L/b[i]+;
            if(L/b[i]+<=K) vis[L/b[i]+]++;
            cnt++; if(cnt==K) return false;
            L+=x;
        }
    }
    for(int i=K;i>;i--) {
        if(vis[i]) vis[i-]+=vis[i]-;
    }
    if(vis[]>) return false;
    return true;
}
int main()
{
    ll L=,R=1e18,Mid;
    scanf("%d%d",&N,&K);
    rep(i,,N) scanf("%lld",&a[i]);
    rep(i,,N) scanf("%lld",&b[i]);
    while(L<=R){
        Mid=(L+R)/;
        if(check(Mid)) R=Mid-,ans=Mid;
        else L=Mid+;
    }
    printf("%lld\n",ans);
    return ;
}

E .Knapsack

题意：给定8种物体的个数a[]，重量分别对应1到8，给定W，问选处的不超过W的最大重量。 (W<1e18，a<1e16）

思路：二进制拆分物体，然后暴力背包，可能会空间爆炸，用ans减去没用的一些空间就够了。

这样的话，物体要从大到小排序，这样才能保证map的空间，以及减枝效果。

（这是比较暴力的做法了，有更优美的解法

#include<bits/stdc++.h>
#define ll long long
using namespace std;
map<ll,bool>mp,tmp;
map<ll,bool>::iterator it;
const int maxn=;
ll ans,W,a[maxn],v[maxn],sum[maxn]; int tot,cnt;
int main()
{
    scanf("%lld",&W);
    for(int i=;i<=;i++){
        scanf("%lld",&a[i]);
        if(!a[i]) continue; cnt++; ll t=;
        ans=max(ans,min(W/i,a[i])*i);
        while(){
            tot++; v[tot]=min(t,a[i])*i;
            a[i]-=min(t,a[i]); t=t*;
            if(!a[i]) break;
        }
    }
    if(cnt==){
        printf("%lld\n",ans); return ;
    }
    sort(v+,v+tot+); reverse(v+,v+tot+);
    for(int i=tot;i>=;i--) sum[i]=sum[i+]+v[i];
    mp[]=true;
    for(int i=;i<=tot;i++){
        tmp.clear();
        for(it=mp.begin();it!=mp.end();it++){
            ll x=it->first;
            tmp[x]=true;
            if(x+v[i]<=W) tmp[x+v[i]]=true;
        }
        mp.clear();
        for(it=tmp.begin();it!=tmp.end();it++){
           if(it->first+sum[i+]<ans) continue;
           mp[it->first]=true;
           ans=max(it->first,ans);
        }
    }
    printf("%lld\n",ans);
    return ;
}

F .Clear the String

题意：给定长度为N的字符串，每次可以删去一段连续的相同字符，求最小删去次数。(N<500)

思路：区间DP，反过来就是“刷墙”这种题：每次可以刷一段，问最少刷的次数。 如果col[L]=col[R]，我们可以先刷[L,R]，然后去刷[L+1,R-1]；如果中间有相同的，还可以分子区间。所以是个需要枚举中间点的O(N^3)区间DP。（比赛的时候想N^2做，WA了。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,w,v) for(int i=w;i<=v;i++)
using namespace std;
const int maxn=;
int dp[maxn][maxn]; char a[maxn];
int main()
{
    int N,tot=; scanf("%d%s",&N,a+);
    rep(i,,N){
        if(a[i]!=a[i-]) a[++tot]=a[i];
    }
    N=tot;
    memset(dp,0x3f,sizeof(dp));
    rep(len,,N){
        rep(L,,N-len+){
            int R=L+len-;
            if(len==) dp[L][R]=;
            else if(len==) dp[L][R]=(a[L]==a[R]?:);
            else {
                dp[L][R]=len;
                if(a[L]==a[R]) dp[L][R]=min(dp[L+][R],dp[L][R-]);
                else{ dp[L][R]=min(dp[L+][R],dp[L][R-])+;
                   rep(k,L,R) dp[L][R]=min(dp[L][R],dp[L][k]+dp[k][R]-);
                }
            }
        }
    }
    printf("%d\n",dp[][N]);
    return ;
}