9.29 csp-s模拟测试55 联+赛+题

T1 联

$n$最大到$1e18$，根本没法做，但$m$只有$1e5$，发现有很多区间是一起动的，或者根本没动，所以可以把区间离散化掉，然后线段树区间修改，对于第三种修改，只需要把它分解成一段一段相同的区间，再区间覆盖就可以。

在线段树中维护一个$cnt$，表示区间中$0$的个数，在询问的时候，只需要找到最左端$cnt！=0$的地方，在把离散化后的映射回来输出即可。

要注意的一点是，不仅要每个区间的左右端点，也要把区间右端点$+1$的地方也离散化，留下可能是$0$的位置，并且把$1$位置扔进去，不然可能会找不到答案，离散化后是$3×m$个点，数组要开够。。。

#include<iostream>
#include<cstdio>
#include<map>
#include<algorithm>
#define ll long long
using namespace std;
struct tree
{
    ll l,r,lz,cnt;//sz为区间0的个数
}t[];
struct node
{
    ll opt,l,r;
}q[];
ll n,m,tot,sum,cp[],pos[];
map<ll,ll>mp;
ll read()
{
    ll aa=,bb=;char cc=getchar();
    while(cc>''||cc<''){if(cc=='-') bb=-;cc=getchar();}
    while(cc>=''&&cc<=''){aa=(aa<<)+(aa<<)+(cc^'');cc=getchar();}
    return aa*bb;
}
void build(ll x,ll l,ll r)
{
    t[x].l=l;t[x].r=r;t[x].cnt=t[x].r-t[x].l+;
    if(l==r) return;
    ll mid=l+r>>;
    build(x<<,l,mid);
    build(x<<|,mid+,r);
}
void down(ll x)
{
    if(t[x].lz==){
        t[x<<].cnt=;t[x<<|].cnt=;
        t[x<<].lz=t[x].lz;t[x<<|].lz=t[x].lz;
        t[x].lz=;
    }
    else if(t[x].lz==){
        t[x<<].cnt=t[x<<].r-t[x<<].l+;t[x<<|].cnt=t[x<<|].r-t[x<<|].l+;
        t[x<<].lz=t[x].lz;t[x<<|].lz=t[x].lz;
        t[x].lz=;
    }
}
void update(ll x)
{
    t[x].cnt=t[x<<].cnt+t[x<<|].cnt;
}
void change(ll x,ll l,ll r,ll opt)//1:全改为1 2：全改为0 cnt：0的个数
{
    if(l<=t[x].l&&t[x].r<=r){
        if(opt==){
            t[x].lz=opt;
            t[x].cnt=;
            return;
        }
        if(opt==){
            t[x].lz=opt;
            t[x].cnt=t[x].r-t[x].l+;
            return;
        }
        if(opt==){
            if(t[x].cnt==){
                t[x].lz=;
                t[x].cnt=t[x].r-t[x].l+;
                return;
            }
            else if(t[x].cnt==t[x].r-t[x].l+){
                t[x].lz=;
                t[x].cnt=;
                return;
            }
        }
    }
    down(x);
    ll mid=t[x].l+t[x].r>>;
    if(l<=mid) change(x<<,l,r,opt);
    if(r>mid) change(x<<|,l,r,opt);
    update(x);
}
ll query(ll x)
{
    if(t[x].l==t[x].r||t[x].cnt==t[x].r-t[x].l+) return t[x].l;
    down(x);
    if(t[x<<].cnt) return query(x<<);
    else return query(x<<|);
}
int main()
{
    n=read();cp[++tot]=;
    for(int i=;i<=n;i++) q[i].opt=read(),q[i].l=read(),q[i].r=read(),cp[++tot]=q[i].l,cp[++tot]=q[i].r,cp[++tot]=q[i].r+;
    sort(cp+,cp+tot);
    for(int i=;i<=tot;i++) if(!mp[cp[i]]) mp[cp[i]]=++sum,pos[sum]=cp[i];
    for(int i=;i<=n;i++) q[i].l=mp[q[i].l],q[i].r=mp[q[i].r];
    build(,,sum);
    for(int i=;i<=n;i++){
        change(,q[i].l,q[i].r,q[i].opt);
        printf("%lld\n",pos[query()]);
    }
    return ;
}

联

T2 赛

把$n$个物品分成$4$类，甲乙都喜欢，只有甲喜欢，只有乙喜欢，甲乙都不喜欢，并按权值$sort$

枚举选$i$个甲乙都喜欢的，那么就要最小的$k-i$个甲喜欢的，最小的$k-i$个乙喜欢的，然后还不够的就从剩下的没选的里面选$m-k-k+i$个最小的，但显然会超时

把权值离散化，插到一棵权值线段树里，每次查询最小的$m-k-k+i$个元素的和

随着$i$的递推，新加入的点只有两个，但要注意边界问题，因为这个wa95了一晚上

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<set>
#include<map>
#define ll long long
using namespace std;
struct tree
{
    ll l,r,cnt,sum;
}t[];
ll n,m,k,x,y;
ll ans,a[],q0[],q1[],q2[],cp[],rt,tot,num,id[];
bool aa[],bb[];
vector<ll>ve[];
map<ll,ll>mp;
ll read()
{
    ll aa=,bb=;char cc=getchar();
    while(cc>''||cc<''){if(cc=='-') bb=-;cc=getchar();}
    while(cc>=''&&cc<=''){aa=(aa<<)+(aa<<)+(cc^'');cc=getchar();}
    return aa*bb;
}
void insert(ll &x,ll l,ll r,ll now)
{
    if(!x) x=++num;
    t[x].cnt++;t[x].sum+=id[now];
    if(l==r) return;
    ll mid=l+r>>;
    if(now<=mid) insert(t[x].l,l,mid,now);
    else insert(t[x].r,mid+,r,now);
}
ll query(ll x,ll l,ll r,ll cnt)
{
    if(t[x].cnt<=cnt) return t[x].sum;
    if(l==r) return l*cnt;
    ll mid=l+r>>,as=;
    as+=query(t[x].l,l,mid,cnt);
    if(t[t[x].l].cnt<cnt) as+=query(t[x].r,mid+,r,cnt-t[t[x].l].cnt);
    return as;
}
int main()
{
    //freopen("b19.in","r",stdin);
    n=read();m=read();k=read();ans=0x7ffffffffffff;
    for(int i=;i<=n;i++) a[i]=read(),cp[i]=a[i];
    x=read();
    for(int i=;i<=x;i++) aa[read()]=;
    y=read();
    for(int i=;i<=y;i++) bb[read()]=;
    if(x<k||y<k||k>m){
        puts("-1");
        return ;
    }
    sort(cp+,cp+n+);
    for(int i=;i<=n;i++) if(!mp[cp[i]]) mp[cp[i]]=++tot,id[tot]=cp[i];
    for(int i=;i<=n;i++){
        if(aa[i]&&bb[i]) ve[].push_back(a[i]);
        else if(aa[i]&&!bb[i]) ve[].push_back(a[i]);
        else if(!aa[i]&&bb[i]) ve[].push_back(a[i]);
        else if(!aa[i]&&!bb[i]) ve[].push_back(a[i]);
    }
    sort(ve[].begin(),ve[].end());
    sort(ve[].begin(),ve[].end());
    sort(ve[].begin(),ve[].end());
    for(int i=;i<ve[].size();i++) q0[i+]=q0[i]+ve[][i];
    for(int i=;i<ve[].size();i++) q1[i+]=q1[i]+ve[][i];
    for(int i=;i<ve[].size();i++) q2[i+]=q2[i]+ve[][i];
    for(int i=;i<ve[].size();i++) insert(rt,,n,mp[ve[][i]]);
    for(int i=k+;i<ve[].size();i++) insert(rt,,n,mp[ve[][i]]);
    for(int i=k+;i<ve[].size();i++) insert(rt,,n,mp[ve[][i]]);
    for(int i=;i<=min((ll)k,(ll)ve[].size());i++){
        if(k-i<ve[].size()) insert(rt,,n,mp[ve[][k-i]]);
        if(k-i<ve[].size()) insert(rt,,n,mp[ve[][k-i]]);
        if(m-k-k+i<||k-i>=ve[].size()||k-i>=ve[].size()) continue;
        ll as=q0[i]+q1[k-i]+q2[k-i];
        as+=query(rt,,n,m-k-k+i);
        ans=min(ans,as);
    }
    if(ans>=){
        puts("-1");
        return ;
    }
    printf("%lld\n",ans);
    return ;
}

赛

T3 题

$f[i]$表示$i$这个苹果是否可能剩下，$0$表示不可能，$1$可能剩下，初始全为$1$，$g[i][j]（bitset）$表示i这个苹果必须有，最终的状态，$1$表示状态已经确定，$0$表示不确定

枚举每个苹果，让他必须活下来，倒序枚举$m$个人，看最后一个人要吃的苹果，

如果$a$，$b$都不确定，那么他们还是都不确定，

如果$a$确定，那么$j$这个人就只能吃$b$，所以$b$也确定了

如果$b$确定，那么$j$这个人就只能吃$a$，所以$a$也确定了

如果$a$，$b$都已确定，那这个状态就推不回去了（后边的人把他确定了，但他在后边的人前边，所以一定是他先吃，状态一定不合法），所以i一定不会活下来

最后再枚举每个苹果，如果他可能剩下，再去找另一个可能剩下的苹果，看他们两个最终状态是不是交集为空（一个苹果只能被一个人吃），为空$ans++$

#include<iostream>
#include<cstdio>
#include<bitset>
using namespace std;
int n,m,ans,a[],b[];
bitset<>g[],as;
bool f[];
int read()
{
    int aa=,bb=;char cc=getchar();
    while(cc>''||cc<''){if(cc=='-') bb=-;cc=getchar();}
    while(cc>=''&&cc<=''){aa=(aa<<)+(aa<<)+(cc^'');cc=getchar();}
    return aa*bb;
}
int main()
{
    n=read();m=read();
    for(int i=;i<=m;i++) a[i]=read(),b[i]=read();
    for(int i=;i<=n;i++) f[i]=;
    for(int i=;i<=n;i++){
        g[i][i]=;
        for(int j=m;j>=;j--){
            if(g[i][a[j]]&&g[i][b[j]]){f[i]=;break;}
            else if(g[i][a[j]]&&!g[i][b[j]]) g[i][b[j]]=;
            else if(!g[i][a[j]]&&g[i][b[j]]) g[i][a[j]]=;
        }
    }
    for(int i=;i<=n;i++){
        if(f[i]){
            for(int j=i+;j<=n;j++){
                if(f[j]){
                    as=g[i]&g[j];
                    if(!as.count()) ans++;
                }
            }
        }
    }
    printf("%d\n",ans);
    return ;
}

题

不想联赛就退役就静下来好好想