[COCI2021-2022#1]题解

[COCI2021-2022#1]题解

T1

你可以设个数组$a$,$a_i$表示第$i$个人最后一次射击的时间，读入的同时更新$a$数组计算答案即可。

时间复杂度为$\mathcal{O}(n)$。

#include<bits/stdc++.h>
using namespace std;
int n,ans1=0,ans2=0;
vector<int> son[100+10];
int read()
{
    int s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        s=s*10+(ch-'0'),ch=getchar();
    return s*w;
}
int main()
{   
    n=read();
    for(int i=1;i<=n;++i)
    {
        int t=read(),a=read(),b=read();
        son[a].push_back(t);
    }
    for(int i=1;i<=8;++i)
    {
        int t=0,sum=0;
        for(auto it:son[i])
        {
            if(t==0)
                t=it;
            else
            {
                if(it-t<=10)
                {
                    sum+=50;
                    t=it;
                }
                else
                    t=it;
            }
            sum+=100;
        }
        if(i<=4)
            ans1+=sum;
        else
            ans2+=sum;
    }
    printf("%d %d",ans1,ans2);
    return 0;
}

T2

考虑记忆化搜索，设$f_{l,r,x}$表示拿到$l,r$区间时Alice拿到的红色石头的数量为$x$,$f_{1,n,0}$就为最终的答案，如果值为$1$就输出DA,反之则输出NE。那Bob拿到的红色石头数量就为$[1,l-1]\bigcup [r+1,n]$，Bob手中的红色石头数量可以用前缀和数组维护，当前是谁拿可以根据区间长度与$n$的奇偶性相比得知。如果是Alice拿，就尽量让自己赢，那转移方程就为$f[l][r][x]=max(dfs(l+1,r,x+a[l]),dfs(l,r-1,x+a[r]));$

。如果是Bob拿，就尽量让对方输，转移方程为

$f[l][r][x]=min(dfs(l+1,r,x),dfs(l,r-1,x))$

时间复杂度为$\mathcal{O}(n^3)$。

#include<bits/stdc++.h>
using namespace std;
int n,k,a[1000+10],sum1[1000+10],sum2[1000+10],f[350+10][350+10][180+10];
char s[1000+10];
int dfs(int l,int r,int x)
{
    int y=sum1[l-1]+sum2[r+1]-x;
    if(x==k)
        return 0;
    if(y==k)
        return 1;
    if(f[l][r][x]!=-1)
        return f[l][r][x];
    if(((r-l+1)&1)==(n&1))
        f[l][r][x]=max(dfs(l+1,r,x+a[l]),dfs(l,r-1,x+a[r]));
    else
        f[l][r][x]=min(dfs(l+1,r,x),dfs(l,r-1,x));
    return f[l][r][x];
}
int main()
{
    scanf("%d %d %s",&n,&k,s+1);
    sum1[0]=0;
    for(int i=1;i<=n;++i)
    {
        if(s[i]=='C')
            a[i]=1;
        sum1[i]=sum1[i-1]+a[i];
    }
    sum2[n+1]=0;
    for(int i=n;i>=1;--i)
        sum2[i]=sum2[i+1]+a[i];
    memset(f,-1,sizeof(f));
    if(dfs(1,n,0))
        printf("DA");
    else
        printf("NE");
    return 0;
}

T3、T4

挖个坑。

T5

我们可以画一个平面直角坐标系，将每个点用$(i,a_i)$表示，可以发现，每个上升子序列由$x,y$单调递增的若干个点对组成，于是我们考虑预处理出每个点在其构成的答案中的位置，也就是分层。推了几个小数据就可以发现，第$j$层集合由所有满足$LI{S}_i=j$的$i$组成。这里$LI{S}_i$可以用二分、树状数组或线段树算出来，分层后就可以用贪心构造。

时间复杂度为$\mathcal{O}(n\log n)$。

#include<bits/stdc++.h>
using namespace std;
int n,a[1000000+10],f[1000000+10],maxn=0,tot=INT_MAX,fans=0;
vector<int> son[1000000+10],s;
vector<vector<int> > ans;
struct tree
{
    int l,r,v;
}t[8000000+10];
int read()
{
    int s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        s=s*10+(ch-'0'),ch=getchar();
    return s*w;
}
void build(int root,int l,int r)
{
    t[root].l=l;
    t[root].r=r;
    if(l==r)
    {
        t[root].v=0;
        return ;
    }
    int mid=(l+r)>>1;
    build(root*2,l,mid);
    build(root*2+1,mid+1,r);
}
void add(int root,int l,int r,int pos,int val)
{
    if(l==r)
    {
        t[root].v=val;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        add(root*2,l,mid,pos,val);
    else
        add(root*2+1,mid+1,r,pos,val);
    t[root].v=max(t[root*2].v,t[root*2+1].v);
}
int ask(int root,int l,int r)
{
    if(t[root].l>=l&&t[root].r<=r)
        return t[root].v;
    if(t[root].r<l||t[root].l>r)
        return 0;
    int s=0;
    if(t[root*2].r>=l)
        s=max(s,ask(root*2,l,r));
    if(t[root*2+1].l<=r)
        s=max(s,ask(root*2+1,l,r));
    return s;
}
void work()
{
    while(1)
    {
        if(s.empty())
        {
            if(son[1].empty())
                break;
            else
                s.push_back(son[1].back()),son[1].pop_back();
        }
        else if(s.size()==maxn)
            ans.push_back(s),s.clear();
        else
        {
            int k=s.size()+1,now=s.back();
            while(!son[k].empty()&&now>son[k].back())
                son[k].pop_back();
            if(son[k].empty()||a[now]>a[son[k].back()])
                s.pop_back();
            else
                s.push_back(son[k].back()),son[k].pop_back();
        }
    }
}
int main()
{
    n=read();
    for(int i=1;i<=n;++i)
        a[i]=read();
    build(1,1,n);
    for(int i=1;i<=n;++i)
    {
        f[i]=ask(1,1,a[i]-1)+1;
        add(1,1,n,a[i],f[i]);
    }
    for(int i=1;i<=n;++i)
    {
        fans=max(fans,f[i]);
        son[f[i]].push_back(i);
        maxn=max(maxn,f[i]);
    }  
    for(int i=1;i<=maxn;++i)
        reverse(son[i].begin(),son[i].end());
    work(); 
    printf("%d %d\n",ans.size(),fans);
    int l=ans.size();
    for(int i=0;i<l;++i)
    {
        for(auto v:ans[i])
            printf("%d ",v);
        printf("\n");
    }
    return 0;   
}