Codeforces Round 905 Div 1 (CF1887)

A1. Dances (Easy version)

把 \(a,b\) 序列都从小到大排序，\(a\) 贪心删大的，\(b\) 贪心删小的，二分答案并 \(O(n)\) \(\text{check}\)。

Code

const int N=1e5+5;
int T,n,m;
int a[N],b[N];
il bool check(int mid)
{
    for(int i=1,j=mid+1;i<=n-mid;i++,j++) if(a[i]>=b[j]) return 0;
    return 1;
}
int main()
{
    T=read();
    while(T--)
    {
        n=read(),m=read();
        a[1]=1;
        for(int i=2;i<=n;i++) a[i]=read();
        for(int i=1;i<=n;i++) b[i]=read();
        sort(a+1,a+n+1),sort(b+1,b+n+1);
        int l=0,r=n;
        while(l<r)
        {
            int mid=(l+r)>>1;
            if(check(mid)) r=mid;
            else l=mid+1;
        }
        printf("%d\n",l);
    }
    return 0;
}

A2. Dances (Hard Version)

日常给大家提供乐子。

Solution 1

现在的限制变成了 \(m\le 10^9\)，肯定不能一个一个求答案。但是发现我们只关心这个 \(a_1\) 和 \(a,b\) 中其余的每个元素的大小关系。也就是说我们只要枚举 \(4\times 10^5\) 种大小关系，对他们分别求解就可以得到所有答案了。

原来对一个给定序列求答案的时间复杂度是 \(O(n\log n)\)，考虑优化这个过程。

同样二分删掉的数量 \(mid\)，设 \(a_1=x\)，\(a\) 序列排序时不包含 \(a_1\)。

那么把 \(x\) 插进 \(a\) 的对应位置，需要判断的区间可以分成 \(3\) 段：\(a\) 序列中在 \(x\) 前的部分，\(x\) 的位置，\(a\) 序列中在 \(x\) 后的部分。

已经有两个 \(\log\) 了，需要 \(O(1)\) 地判断 \([a_l,a_r]\) 与 \([b_L,b_R]\) 对应起来是否合法。

设 \(lst_i\) 表示第一个比 \(b_i\) 小的位置与当前位置的差值。换句话说，取最大的 \(j\) 使 \(a_j<b_i\)，令 \(lst_i= j-i\)。那么 \([a_l,a_r]\) 与 \([b_L,b_R]\) 合法的判断条件就是 \(L-l\le \min\{lst_L,\dots,lst_R\}\)。使用 ST 表维护。

时间复杂度 \(O(n \log^2 n)\)。

我也不知道我怎么 5min 想到这个做法调了 1h 的，所以写出来给大家看看乐子。

Solution 2

发现答案只有两种，我们先把 \(a_{2,\dots,n}\) 跟 \(b\) 匹配。

现在加了一个数，要么以上匹配还是合法，要么变不合法了，那就把新加的那个删掉，答案增加 \(1\)。于是就做完了。

Code

#define int long long
const int N=2e5+5;
int T,n,m;
int a[N],b[N],d[N],L[N],tot;
int st[20][N];
il bool check(int l,int r,int L,int R)
{
    if(l>r) return 1;
    int len=__lg(R-L+1);
    int mn=min(st[len][L],st[len][R-(1<<len)+1]);
    if(mn<l-L) return 0;
    return 1;
}
il bool Check(int mid,int x)
{
    int pos=lower_bound(a+1,a+n,x)-a;
    if(pos>n-mid&&mid) return check(1,n-mid,mid+1,n);
    bool flag1=check(1,pos-1,mid+1,mid+pos-1);
    bool flag2=x<b[mid+pos];
    bool flag3=check(pos,n-mid-1,mid+pos+1,n);
    return flag1&&flag2&&flag3;
}
il int Solve(int x)
{
    int l=0,r=n;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(Check(mid,x)) r=mid;
        else l=mid+1;
    }
    return l;
}
void solve()
{
    tot=1;
    n=read(),m=read(); d[1]=m; d[++tot]=1;
    for(int i=1;i<n;i++) a[i]=read(),d[++tot]=a[i];
    for(int i=1;i<=n;i++) b[i]=read(),d[++tot]=b[i];
    sort(a+1,a+n),sort(b+1,b+n+1),sort(d+1,d+tot+1);
    for(int i=1;i<=n;i++)
    {
        L[i]=lower_bound(a+1,a+n,b[i])-a-1-i;
        // cerr<<"L[i] "<<i<<" "<<L[i]<<endl;
        st[0][i]=L[i];
    }
    for(int i=1;i<=__lg(n);i++)
        for(int j=1;j<=n-(1<<i)+1;j++) st[i][j]=min(st[i-1][j],st[i-1][j+(1<<i-1)]);
    int ans=0;
    for(int i=1;i<=tot;i++)
    {
        if(d[i]!=d[i-1]) ans+=Solve(d[i]);
        if(d[i]==m) break;
        if(i!=tot&&d[i+1]-d[i]>1) ans+=(d[i+1]-d[i]-1)*Solve(d[i]+1);
    }
    printf("%lld\n",ans);
}
signed main()
{
    int T=read();
    while(T--) solve();
}

---

B. Time Travel

因为时间和时间不好区分，我们不妨令 \(a_i\) 叫时间，\(i\) 叫日期。

设 \(dis_i\) 表示到达点 \(i\) 的最早日期。对每条边记录它所属的时间。

把每个 \(i\) 按 \(a_i\) 分组，就可以二分出在当前 \(dis_u\) 下 \(u\to v\) 这条边可通行的最早日期。

把这个当作边权跑 dijkstra 就行了，双 \(\log\) 但是跑得挺快。

Code

const int N=2e5+5,inf=1e9;
#define pii pair<int,int>
#define fi first
#define se second
int n,t,k,a[N];
map<pii,int> mp;
struct edge{int nxt,to,id;} e[N<<1];
int head[N],cnt=1;
il void add(int u,int v,int id) {e[++cnt]={head[u],v,id};head[u]=cnt;}
vector<int> tim[N],nxt[N];
int dis[N];
il int get(int nowt,int id)
{
    auto ans=upper_bound(nxt[id].begin(),nxt[id].end(),nowt);
    if(ans==nxt[id].end()) return inf;
    else return *ans;
}
int main()
{
    n=read(),t=read();
    for(int i=1;i<=t;i++)
    {
        int x=read();
        for(int j=1;j<=x;j++)
        {
            int u=read(),v=read();
            add(u,v,i),add(v,u,i);
        }
    }
    k=read();
    for(int i=1;i<=k;i++) a[i]=read(),nxt[a[i]].push_back(i);
    priority_queue<pii,vector<pii>,greater<pii> >q;
    for(int i=1;i<=n;i++) dis[i]=inf;
    dis[1]=0,q.push(pii(0,1));
    while(!q.empty())
    {
        int u=q.top().se,f=q.top().fi; q.pop();
        if(dis[u]!=f) continue;
        for(int i=head[u];i;i=e[i].nxt)
        {
            int v=e[i].to,id=e[i].id;
            int w=get(dis[u],id);
            if(dis[v]>w) dis[v]=w,q.push(pii(dis[v],v));
        }
    }
    if(dis[n]==inf) printf("-1\n");
    else printf("%d\n",dis[n]);
    return 0;
}

---

C. Minimum Array

被 A2 卡没时间了 /oh

Description

给一个长度为 \(n\) 的初始序列 \(a\) 和 \(q\) 次操作。每次操作形如给 \(a_l\sim a_r\) 的值加上 \(k\)。

依次进行这些操作，求过程中得到过字典序最小的序列。

$n,q\le 5\times 10^5,\ - 10^9\le a_i,k\le 10^9 $。

Solution 1

考虑依次进行每个操作，维护当前能使答案字典序最小的操作编号 \(ans\)。

只考虑从上一个 \(ans\) 到当前时刻的操作，设它们操作后形成的序列为 \(b\)。那么当前的实际序列就是 \([1,ans]\) 的实际序列与 \(b\) 数组对应位相加后的结果。

当前序列比 \([1,ans]\) 字典序更小的充要条件是 \(b\) 中第一个不为 \(0\) 的位置的值 \(<0\)，证明是显然的。每次修改后判断，满足这个条件就更新 \(ans\)，并清零 \(b\) 数组。

也就是说我们只需要一个数据结构支持区间加、求第一个不为 \(0\) 的位置、单点求值。

直接上线段树是可做的。不过发现第一个不为 \(0\) 的位置只能是某个 \(l_i\) 或 \(r_i+1\)，所以把这些点塞进 set 里暴力判断即可，区间加用树状数组维护。

Solution 2

看了下官方题解。

我们直接在差分数组上考虑这个问题，修改变成了单点，更新答案还是求第一个不为 \(0\) 的位置。这样就不用写树状数组了。

Code

#define int long long
const int N=5e5+5,inf=1e9;
int t,n,a[N];
struct node{int l,r,k;} q[N];
struct BIT
{
    int tr[N];
    il void modify(int x,int k) {for(;x<=n;x+=x&(-x)) tr[x]+=k;}
    il void add(int l,int r,int k) {modify(l,k),modify(r+1,-k);}
    il int query(int x) {int res=0;for(;x;x-=x&(-x)) res+=tr[x];return res;}
}tr;
int ans;
signed main()
{
    int T=read();
    while(T--)
    {
        n=read(); ans=0;
        for(int i=1;i<=n;i++) a[i]=read(),tr.tr[i]=0;
        t=read(); set<int> st;
        for(int i=1;i<=t;i++) q[i].l=read(),q[i].r=read(),q[i].k=read();
        for(int i=1;i<=t;i++)
        {
            tr.add(q[i].l,q[i].r,q[i].k);
            st.insert(q[i].l),st.insert(q[i].r+1);
            while(st.size()&&!tr.query(*st.begin())) st.erase(st.begin());
            if(!st.empty()&&tr.query(*st.begin())<0)
            {
                for(int j=i;j>ans;j--) tr.add(q[j].l,q[j].r,-q[j].k);
                ans=i,st.clear();
            }
        }
        for(int i=1;i<=n;i++) tr.tr[i]=0;
        for(int i=1;i<=n;i++) tr.modify(i,a[i]-a[i-1]);
        for(int i=1;i<=ans;i++) tr.add(q[i].l,q[i].r,q[i].k);
        for(int i=1;i<=n;i++) printf("%lld ",tr.query(i));
        printf("\n");
    }
}

---

D. Split

Description

定义一个序列是好的，当且仅当它存在某种划分成左右两部分的方案，使左半部分的最大值严格小于右半部分的最小值。

现给出长度为 \(n\) 的序列 \(a\)，保证 \(a\) 是一个 \(1\sim n\) 的排列。

\(q\) 次询问，每次询问 \(a\) 的子区间 \([l,r]\) 是否为好的序列。

\(n,q\le 3\times 10^5\)。

Solution

考虑对于一个确定的序列怎么搞。我们枚举一个值域分界点 \(i\)，把 \(\le i\) 的分在一边，\(>i\) 的分在另一边，判断它们是否恰好是原序列的某种划分。

然而这个东西没有单调性，从其它角度优化这个过程。

我们对于每个下标 \(i\)，不考虑具体的询问，而是考虑能使 \(a_i\) 成为合法的值域分界点的区间 \([l,r]\) 中 \(l,r\) 的范围。

首先，\(a_i\) 一定在左半部分，且是左半部分的最大值。那么令 \(x\) 为 \(i\) 向左找第一个 \(a_x>a_i\) 的位置。则左端点有限制 \(x< l\le i\)。

右半部分需满足全部值大于 \(a_i\)。那么令 \(y\) 为 \(i\) 右侧第一个 \(a_y>a_i\) 的位置，有限制 \(r\ge y\)。同时令 \(z\) 为 \(y\) 右侧第一个 \(a_z<a_i\) 的位置，有限制 \(y\le r < z\)。

把询问 \([l,r]\) 看作点的坐标，这是一个矩阵加单点查询问题，使用树状数组 + 扫描线维护。

Code

const int N=3e5+5;
int n,m,a[N],pos[N],ans[N],tot;
struct node {int tp,l,r,x,k,y,id;}q[N<<2];
set<int> ls,rs;
il bool cmp(node x,node y)
{
    if(x.x!=y.x) return x.x<y.x;
    else return x.tp<y.tp;
}
struct BIT
{
    int tr[N];
    il void modify(int x,int k) {for(;x<=n;x+=x&(-x)) tr[x]+=k;}
    il void add(int l,int r,int k) {modify(l,k),modify(r+1,-k);}
    il int query(int x) {int res=0;for(;x;x-=x&(-x)) res+=tr[x];return res;}
}tr;
int main()
{
    n=read();
    for(int i=1;i<=n;i++) a[i]=read(),pos[a[i]]=i,rs.insert(i);
    for(int I=1;I<=n;I++)
    {
        int i=pos[I];
        rs.erase(i);
        auto itx=rs.lower_bound(i),ity=rs.upper_bound(i);
        int x=(itx==rs.begin()||itx==rs.end())?0:*prev(itx);
        int y=(ity==rs.end())?n+1:*ity;
        auto itz=ls.upper_bound(y);
        int z=(itz==ls.end())?n+1:*itz;
        q[++tot]={1,x+1,i,y,1,0,0};
        q[++tot]={1,x+1,i,z,-1,0,0};
        ls.insert(i);
    }
    m=read();
    for(int i=1;i<=m;i++)
    {
        int l=read(),r=read();
        q[++tot]={2,0,0,r,0,l,i};
    }
    sort(q+1,q+tot+1,cmp);
    for(int i=1;i<=tot;i++)
    {
        if(q[i].tp==1) tr.add(q[i].l,q[i].r,q[i].k);
        else ans[q[i].id]=tr.query(q[i].y);
    }
    for(int i=1;i<=m;i++) printf(ans[i]?"Yes\n":"No\n");
    return 0;
}

---

E. Good Colorings

Description

Alice 和你玩游戏。有一个 \(n\times n\) 的网格，初始时没有颜色。Alice 在游戏开始前依次给其中 \(2n\) 个格子分别涂上了第 \(1\sim 2n\) 种颜色，并告诉你每个颜色的位置。

接下来的每次操作，你可以选择一个未涂色的格子，由 Alice 在 \(2n\) 种颜色中选择一个涂在该格子上，并告诉你该颜色。

如果在某次操作后方格图上存在四个不同颜色的点，且它们的位置形成一个平行于边线的矩形，则输出它们以获得胜利。

你至多进行 \(10\) 次操作，请构造一个获胜方案。交互库自适应，也就是说 Alice 的决策与你的选择有关。

\(T\le200,n\le 1000\)。

Solution

我们把网格图的行列分别看作点，把格子 \((x,y)\) 涂成颜色 \(c\)，看作行 \(x\) 向列 \(y\) 连一条边权为 \(c\) 的边。

那么这是一个左右各有 \(n\) 个点的二分图，我们要找的合法矩形就是长度为 \(4\) 且边权互不相同的环。

由于共有 \(2n\) 个点，已经连了 \(2n\) 条不相同的边，则已经连的边一定至少形成一个长度为偶数的环。考虑通过这个环构造答案。

设环上的点分别为 \(a_1,a_2,\dots,a_{2k}\)。每次我们考虑把这个环连一条边对半拆开：

因为整个环上边的颜色都不相同，所以不论新连的边是什么颜色，左右两个环都至少有一个满足环上边的颜色互不相同。选择满足该条件的一侧，重复上述操作，最终一定会得到一个大小为 \(4\) 的环。

由于每次令环长变为原来的一半，至多操作 \(O(\log 2n)-2\) 次。

Code

const int N=2005;
int T,n,f[N][N];
vector<int> e[N],a,b;
stack<int> q;
int in[N],flag,vis[N];
void dfs(int u,int lst)
{
    // cerr<<u<<" "<<lst<<" "<<q.size()<<endl;
    if(flag) return;
    vis[u]=1,in[u]=1,q.push(u);
    for(auto v:e[u]) if(v^lst)
    {
        if(flag) return;
        if(in[v])
        {
            // cerr<<"v "<<v<<" "<<u<<" "<<q.size()<<endl;
            assert(q.size());
            while(q.top()!=v) a.push_back(q.top()),q.pop();
            a.push_back(v),flag=1;return;
        }
        dfs(v,u);
    }
    in[u]=0;if(!q.empty()) q.pop();
}
il void clear()
{
    // cerr<<"qwq"<<n<<endl;
    a.clear(); flag=0;
    // cerr<<"?"<<" "<<q.size()<<endl;
    while(!q.empty()) q.pop();
    // cerr<<"?"<<endl;
    for(int i=1;i<=(n<<1);i++)
    {
        // cerr<<i<<endl;
        vis[i]=0,in[i]=0;
        for(auto v:e[i]) f[i][v]=0;
        e[i].clear();
    }
}
il int ask(int x,int y)
{
    if(x>y) swap(x,y);
    cout<<"? "<<x<<" "<<y-n<<endl;
    return read();
}
il void solve()
{
    n=read();
    for(int i=1;i<=(n<<1);i++)
    {
        int u=read(),v=read();
        e[u].push_back(v+n),e[v+n].push_back(u),f[u][v+n]=f[v+n][u]=i;
    }
    for(int i=1;i<=n;i++) if(!vis[i]) dfs(i,0);
    while(a.size()>4)
    {
        int sz=a.size()-1,mid=sz/4;
        assert(sz&1); int x=a[sz-mid],y=a[mid];
        int col=ask(x,y),fg=1;
        f[x][y]=f[y][x]=col,e[x].push_back(y),e[y].push_back(x);
        for(int i=mid;i<sz-mid;i++) if(f[a[i]][a[i+1]]==col) fg=0;
        b.clear();
        if(fg) for(int i=mid;i<=sz-mid;i++) b.push_back(a[i]);
        else {for(int i=0;i<=mid;i++) b.push_back(a[i]);for(int i=sz-mid;i<=sz;i++) b.push_back(a[i]);}
        swap(a,b);
    }
    assert(a.size()==4);
    sort(a.begin(),a.end());
    cout<<"! "<<a[0]<<" "<<a[1]<<" "<<a[2]-n<<" "<<a[3]-n<<endl;
    string s;cin>>s;
    if(s=="ERROR") exit(0);
}
int main()
{
    T=read();
    while(T--) solve(),clear();
    return 0;
}

---

F. Minimum Segments

不会。