P3960 NOIP2017 提高组 列队

P3960 NOIP2017 提高组 列队 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

这个队伍的人数最多是全球人口的 15 倍。

慢慢开部分分。这题部分分给的相当足。

30 pts：1~6

$(n + m)q$ 暴力即可。

50 pts：7~10

其实 $(n + m)q$ 时间复杂度仍然可以通过，但空间复杂度 $nm$ 是不可过的。

遍历一遍所需的空间，时间复杂度就会和空间复杂度同阶，而这里时间复杂度却远低于空间复杂度，说明肯定有大量空间是赘余的。

观察到 $q \le 500$，最多只会删除 $500$ 个点，不难发现除了这 $500$ 个点所在的行和最后一列上的点以外，其它的点从始至终位置不变，更不可能出现在答案中。

因此只需要把这 $500$ 行上的点所在行数离散化后存入数组后再暴力即可。空间复杂度 $mq$。

80 pts：11~16

核心条件是 $x = 1$。容易发现只有第一行和最后一列上的点在变化，其他的点始终不动，不可能出现在答案中，直接忽略即可。

其实 $(1, 1), (1, 2), \cdots, (1, m), (2, m), \cdots (n, m)$ 就是一个支持取出第 $k$ 个元素并置于队尾的队列，只是从中间掰成了直角罢了。

每次取出第 $k$ 个元素，想到类似于约瑟夫问题的树状数组做法。

我们开辟出一个大小为 $n + m - 1 + q$ 的数组 $t$，前 $n + m - 1$ 个元素值为 $1$，代表这个土地有人；后 $q$ 个元素值为 $0$，代表这个空地无人。删除第 $k$ 个元素时，其实也就是找前缀和为 $k$ 的土地编号（代表这里以及前面恰好有 $k$ 个人），然后把这个位置的 $1$ 改成 $0$，代表这里的人没了。于是删除一个人后面的人是不用动位置的。然后把这个人丢在最后一个人后面那个空地上就行了，即把那个空地的 $0$ 改成 $1$。$t$ 使用树状数组加速即可。

和约瑟夫问题不同，这个题的空地编号不一定是队列中人的编号。开个和 $t$ 大小一样的数组记录空地编号对应的人的编号就可以了。

80 pts 代码

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2022-10-26 15:16:43 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2022-10-26 18:15:23
 */
#include <bits/stdc++.h>
#define int long long
inline int read() {
    int x = 0;
    bool flag = true;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            flag = false;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    if(flag)
        return x;
    return ~(x - 1);
}
inline int lowbit(int x) {
    return x & (-x);
}

const int maxn = (int)3e5 + 5;
const int maxm = (int)3e5 + 5;
const int maxq = (int)3e5 + 5;

int qx[maxq], qy[maxq];

int bit[maxn + maxm + maxq];
int no[maxn + maxm + maxq];

int li;
inline void del(int x) {
    for (; x <= li; x += lowbit(x))
        --bit[x];
}

inline int kth(int k) {
    int ans = 0, sum = 0;
    for (int i = 20; ~i; --i) {
        ans += (1 << i);
        if (ans > li || sum + bit[ans] >= k)
            ans -= (1 << i);
        else
            sum += bit[ans];
    }
    return ans + 1;
}

int ux[maxq];
int a[505][maxm];
int col[maxn];

signed main() {
    int n = read(), m = read(), q = read();

    bool pure = true;
    for (int i = 1; i <= q; ++i) {
        int x = read(), y = read();
        qx[i] = x;
        qy[i] = y;
        if (x != 1)
            pure = false;
    }

    if (pure) {
        li = n + m + q;
        for (int i = 1; i <= n + m + q; ++i)
            bit[i] = lowbit(i);
        
        int lst = m + n - 1;
        for (int i = 1; i <= m; ++i)
            no[i] = i;
        for (int i = 2; i <= n; ++i)
            no[m + i - 1] = m * i;
        
        for (int i = 1; i <= q; ++i) {
            int y = qy[i];
            int x = kth(y);

            printf("%lld\n", no[x]);
            del(x);
            no[++lst] = no[x]; 
        }
    } else {
        std :: copy(qx + 1, qx + q + 1, ux + 1);
        std :: sort(ux + 1, ux + q + 1);
        int *en = std :: unique(ux + 1, ux + q + 1);
        
        for (int i = 1; i <= q; ++i) {
            int x = qx[i];
            int dix = std :: lower_bound(ux + 1, en, qx[i]) - ux;
            for (int j = 1; j < m; ++j)
                a[dix][j] = (x - 1) * m + j;
        }

        for (int i = 1; i <= n; ++i)
            col[i] = i * m;
        
        for (int i = 1; i <= q; ++i) {
            int x = qx[i], y = qy[i];
            int dix = std :: lower_bound(ux + 1, en, qx[i]) - ux;
            
            if (y < m) {
                int num = a[dix][y];
                printf("%lld\n", num);

                for (int j = y; j < m - 1; ++j)
                    a[dix][j] = a[dix][j + 1];
                a[dix][m - 1] = col[x];

                for (int j = x; j < n; ++j)
                    col[j] = col[j + 1];
                col[n] = num;
            } else {
                int num = col[x];
                printf("%lld\n", num);

                for (int j = x; j < n; ++j)
                    col[j] = col[j + 1];
                col[n] = num;
            }
        }
    }

    return 0;
}

100pts：17~20

80pts 到 100pts 这一步的思维跨度远比 0pts 到 80pts 这步大。考场上请务必拿到 80 pts，非常可观。

不过据说 100pts 可以通过使用更高级的数据结构而少走思维弯路。

我们刚刚成功维护了一个数据结构（队列），满足：

• 找到第 $k$ 个元素并删除；
• 在结尾插入一个元素。

再仔细思考，我们会发现：这个矩阵的去除最后一个元素的每一行和最后一列，总共 $n + 1$ 个队列其实本质都是这样的一个数据结构。也就是我们可以把矩阵划分成这样：

一个红色的矩形就表示一个队列。

查询 $(x, y)$ 的时候，除非 $y = m$，否则都是第 $x$ 个横向队列和纵向队列之间配合完成操作。而 $y = m$ 时，只需要考虑纵向队列的操作。

具体配合是以下两段的对接：第 $x$ 个横向队列，和纵向队列从第 $x$ 个元素开始的一个后缀。

但是，由于空间限制，我们无法开 $n +1$ 个树状数组实现这个过程。

发现处在不同行数的元素的离队顺序，对于横向队列而言，是相互独立互不影响的（如果暂时不考虑和纵向队列对接），只有处在同一行的元素离队会因为处在同一行而互相影响。

因此想到将询问离线，按照所在行数分类。对于所有的横向队列，我们共用一个树状数组：先把第一行的所有信息在这个树状数组处理好，再把这个树状数组复原为初始状态（全为 $1$），再处理第二行的所有信息，再复原……

复原暴力显然是不行的。我们考虑在修改时，用一个 vector 记录把哪些元素从 $1$ 修改为 $0$ 了，那么复原时只需复原这些被修改的元素为 $1$ 即可。

但是有一点：不同行数元素离队顺序在对接前，对于横向队列不影响，但对接后，会影响纵向队列，也可能进而影响横向队列（因为纵向队列中的元素会跑到横向队列）。比如：$(2, 2)$ 先离队，$(1, 1)$ 后离队和 $(1, 1)$ 先离队，$(2, 2)$ 后离队两种情况是不同的。所以我们不能将询问离线排序之后，直接模拟对接这个过程。

询问离线排序了，还不能直接模拟对接。那么考虑先运用树状数组预处理信息，然后再运用这些信息，按照题目给出的离队顺序，模拟整个矩阵上的离队和对接。

显然同一行内的离队信息应该按照离队的时间顺序（即输入顺序）处理。

对于 $x$ 这一行，如果有一次离队操作 $(x, i)$，我们分两种情况讨论：

• $i = m$，事实上这次离队不在第 $x$ 个横向队列中，只在纵向队列中做出影响；我们作出特殊标记。
• $i < m$，说明这次离队在第 $x$ 个横向队列中。我们取出树状数组中第 $i$ 个元素（输出并删除）。在树状数组中，对应了前缀和为 $i$ 对应的那个土地编号 $j$。我们将 $j$ 记入这次离队的信息。

$j$ 的含义比较难用语言解释，可以先接着往下看，并配合 80pts 做法中的土地编号这一概念思考。

80 pts 中空地编号对应人编号的数组显然也是需要优化的。我们使用动态 vector，并且不存储 $j \le m$ 的情况（因为此时人编号可以根据 $(x - 1) \times m + j$ 直接算出）。这样，所有 vector 存储的多余的编号最多达到 $q$ 的量级，可以通过本题。

这两段有点难以理解（我自己都觉得），读不懂没关系，建议阅读代码！

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2022-10-27 16:07:43 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2022-10-27 17:09:25
 */
#include <bits/stdc++.h>
#define int long long
inline int read() {
    int x = 0;
    bool flag = true;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            flag = false;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    if(flag)
        return x;
    return ~(x - 1);
}
inline int lowbit(int x) {
    return x & (-x);
}

const int maxn = (int)3e5 + 5;
const int maxm = (int)3e5 + 5;
const int maxq = (int)3e5 + 5;

struct fenwick {
    int lim;
    int bit[maxn + maxm + maxq];

    inline void add(int x, int v) {
        for (; x <= lim; x += lowbit(x))
            bit[x] += v;
    }

    inline int kth(int k) {
        int ans = 0, sum = 0;
        for (int i = 20; ~i; --i) {
            ans += (1 << i);
            if (ans > lim || sum + bit[ans] >= k)
                ans -= (1 << i);
            else
                sum += bit[ans];
        }
        return ans + 1;
    }
} ve, ho;

typedef std :: pair <int, int> pii;

pii qts[maxq];
bool ism[maxq];
std :: vector <int> qt[maxn];
std :: vector <int> mdy;

std :: vector <int> veno[maxn];
std :: vector <int> homo;

// veno 类似于 80pts 做法中的 no 数组（但有改动），对横向队列而言
// homo 也类似于 no 数组，对竖向队列而言，有微改动（不多）

signed main() {
    int n = read(), m = read(), q = read();
    ve.lim = m + q;
    ho.lim = n + q;

    for (int i = 1; i <= ve.lim; ++i)
        ve.bit[i] = lowbit(i);
    for (int i = 1; i <= ho.lim; ++i)
        ho.bit[i] = lowbit(i);
    
    homo.push_back(0);
    for (int i = 1; i <= n; ++i)
        homo.push_back(i * m);
    
    for (int i = 1; i <= q; ++i) {
        int x = read(), y = read();
        if (y == m)
            ism[i] = true;
        qts[i] = std :: make_pair(x, y);
        qt[x].push_back(i);
    }

    for (int x = 1; x <= n; ++x) {
        for (auto id : qt[x]) {
            if (ism[id])
                continue;
            int y = qts[id].second;
            y = ve.kth(y);
            ve.add(y, -1);
            mdy.push_back(y);
            qts[id].second = y;
        }

        for (int y : mdy)
            ve.add(y, 1);
        mdy.clear();
    }

    for (int i = 1; i <= q; ++i) {
        int x = qts[i].first, y = qts[i].second;
        int num = 0;
        if (!ism[i]) {
            if (y < m)
                num = (x - 1) * m + y;
            else
                num = veno[x][y - m];
        }

        int coy = ho.kth(x);
        ho.add(coy, -1);

        int nw = homo[coy];
        
        if (ism[i])
            num = nw;
        else
            veno[x].push_back(nw);
        
        printf("%lld\n", num);
        homo.push_back(num);
    }

    return 0;
}