Luogu P9870 NOIp2023 双序列拓展 题解 [ 紫 ] [ 动态规划 ] [ 分治 ] [ adhoc ]

双序列拓展：很妙的特殊性质类 dp 题，由部分分引导向正解。

题意简化

你可以把序列 \(X\) 和序列 \(Y\) 中的每一个数复制若干倍并接到这个数后面，问能否构造出一种方案，使得两个序列长度相等且所有的 \(X_i>Y_i\) 或者 \(X_i<Y_i\)。有 \(60\) 次修改，每次修改都要输出答案。

观察

初看这题，只会打一个暴力匹配的暴搜。

然后忽然看到了这题的神秘性质，于是就把这条性质拆分成了两部分：

• \(x_1 < y_1\)
• \(x_n\) 是序列 \(X\) 唯一的一个最小值，\(y_m\) 是序列 \(Y\) 唯一的一个最大值。

第一条性质

我们观察每个数列的第一项有什么特别的，容易发现，无论后面的数怎么复制，两个数列的第一个数都一定是匹配上的。也就是说，\(x_1\) 与 \(y_1\) 的大小关系就决定了其他 \(x_i\) 与 \(y_i\) 的关系。

于是我们根据每个数列的第一个元素判断到底是 \(X_i>Y_i\) 还是 \(X_i<Y_i\) 就好了。

由此我们可以设计 dp：

\(dp_{i,j}\) 表示目前序列 \(X\) 匹配到第 \(i\) 个数，序列 \(Y\) 匹配到第 \(j\) 个数可不可行。

转移显然有三种：

\[dp_{i,j}=dp_{i-1,j} \bigvee dp_{i,j-1} \bigvee dp_{i-1,j-1}
\]

第二条性质

我们观察到这个方程很像方格取数，把他转化到方格上来。（这是本题思维难度最大的地方，要有抽象问题的能力）

一个方格 \((i,j)\) 能被走，当且仅当 \(x_i < y_j\)。（在 \(x_1<y_1\) 时）

这里借一张洛谷题解的图：

发现我们很快能标出所有能被走的点，并且对于第二条性质，如果这个序列要存在，第 \(n\) 个行和第 \(m\) 列的所有数都一定是红色的。这是有解的不充分必要条件。

为啥呢？因为第 \(n\) 个数是 \(X\) 里面的最小值，而如果连最小值都无法与 \(Y\) 中的某一个匹配，那么其他的自然也不可以了。这样就形成了一行或一列全为空的情况，显然是无法走过去的。最大值那个也同理。

那么接下来怎么求解呢？我们可以采用分支的思路，将 \(X\) 与 \(Y\) 的长度均减 \(1\)，递归求解即可。（这是因为后面的情况如果合法，那么右下角的部分一定能走到，因为剩下的部分有解的条件是一个存在长条，长条和原来的十字架组成新的十字架，就保证了一定能走到原来的那个更大的十字架里）

正解

下面肯定要往最大值最小值上面去想了。假设当前 \(X\) 的最小值在 \(i\)，\(Y\) 的最大值在 \(j\)，那么只有第 \(i\) 行和第 \(j\) 列全部是可以走的，当前局面才可能有解。

因为行列交叉形成一个十字架，所以我们递归求解左上部分与右下部份的答案即可，两者都能有解最终才有解。

如下图：

具体实现上，我们分别维护 \(X\) 的前缀、后缀最小值、最大值的位置和 \(Y\) 的前缀、后缀最小值、最大值的位置即可。一共要维护 \(8\) 个，递归进行求解即可。

因为每次分治最多只会修改一个数，那么每行每列总共一定不会超过 \(n+m\) 次被递归到，所以时间复杂度为 \(O(q(n+m))\)。

代码

参考了很多洛谷题解的细节与马蜂，确实是最好写、最直观的一种维护方式了。

#include <bits/stdc++.h>
#define fi first
#define se second
#define lc (p<<1)
#define rc ((p<<1)|1)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pi;
int n,m,a[500005],b[500005],pa[500005],va[500005],pb[500005],vb[500005];
struct node{
    int mx,mn;
}prea[500005],preb[500005],sufa[500005],sufb[500005];
void init()
{
    prea[1]={1,1};
    for(int i=2;i<=n;i++)
    {
        prea[i]=prea[i-1];
        if(a[prea[i].mx]<a[i])prea[i].mx=i;
        if(a[prea[i].mn]>a[i])prea[i].mn=i;
    }
    preb[1]={1,1};
    for(int i=2;i<=m;i++)
    {
        preb[i]=preb[i-1];
        if(b[preb[i].mx]<b[i])preb[i].mx=i;
        if(b[preb[i].mn]>b[i])preb[i].mn=i;
    }
    sufa[n]={n,n};
    for(int i=n-1;i>=1;i--)
    {
        sufa[i]=sufa[i+1];
        if(a[sufa[i].mx]<a[i])sufa[i].mx=i;
        if(a[sufa[i].mn]>a[i])sufa[i].mn=i;
    }
    sufb[m]={m,m};
    for(int i=m-1;i>=1;i--)
    {
        sufb[i]=sufb[i+1];
        if(b[sufb[i].mx]<b[i])sufb[i].mx=i;
        if(b[sufb[i].mn]>b[i])sufb[i].mn=i;
    }
}
bool checkl(int x,int y)
{
    if(x==1||y==1)return 1;
    node nx=prea[x-1],ny=preb[y-1];
    if(a[nx.mn]<b[ny.mn])return checkl(nx.mn,y);
    if(a[nx.mx]<b[ny.mx])return checkl(x,ny.mx);
    return 0;
}
bool checkr(int x,int y)
{
    if(x==n||y==m)return 1;
    node nx=sufa[x+1],ny=sufb[y+1];
    if(a[nx.mn]<b[ny.mn])return checkr(nx.mn,y);
    if(a[nx.mx]<b[ny.mx])return checkr(x,ny.mx);
    return 0;
}
void solve()
{
    bool swp=0;
    if(a[1]==b[1])
    {
        cout<<0;
        return;
    }
    if(a[1]>b[1])
    {
        swap(a,b);
        swap(n,m);
        swp=1;
    }
    init();
    node x=prea[n],y=preb[m];
    if(a[x.mn]>=b[y.mn]||a[x.mx]>=b[y.mx])
    {
        cout<<0;
        if(swp)
        {
            swap(a,b);
            swap(n,m);
        }
        return;
    }
    cout<<(checkl(x.mn,y.mx)&&checkr(x.mn,y.mx));
    if(swp)
    {
        swap(a,b);
        swap(n,m);
    }
}

int main()
{
    //freopen("expand.in","r",stdin);
    //freopen("expand.out","w",stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int c,q;
    cin>>c>>n>>m>>q;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=m;i++)cin>>b[i];
    solve();
    while(q--)
    {
        int kx,ky;
        cin>>kx>>ky;
        for(int i=1;i<=kx;i++)
        {
            cin>>pa[i]>>va[i];
            swap(a[pa[i]],va[i]);
        }
        for(int i=1;i<=ky;i++)
        {
            cin>>pb[i]>>vb[i];
            swap(b[pb[i]],vb[i]);
        }
        solve();
        for(int i=1;i<=kx;i++)
        {
            swap(a[pa[i]],va[i]);
        }
        for(int i=1;i<=ky;i++)
        {
            swap(b[pb[i]],vb[i]);
        }
    }
    return 0;
}