EOJ-2020“游族杯”Coronavirus Battle (CDQ分治、枚举优化)

标签：tmp   usb   owb   数组   空间复杂度   main   for   帮助   return   

题目链接：EOJ-2020“游族杯”C题 Coronavirus Battle

题意

有 \(n(1\leq n\leq 10^5)\) 个细胞，每个细胞各有一个三维坐标表示其位置，坐标由给定随机种子的伪随机数产生（随机数的范围是 unsigned long long）。病毒会对细胞进行多轮攻击，在第 \(k\) 轮攻击中，细胞 \(i\) 能够存活当且仅当存在细胞 \(j\) 满足 \(x_j\leq x_i \&\& y_j\leq y_i \&\& z_j\leq z_i \&\& (x_j<x_i || y_j<y_i||z_j<z_i)\) ，其中细胞 \(j\) 要满足病毒第 \(k-1\) 轮攻击后仍存活。求病毒攻击几轮之后能消灭所有细胞，和每个细胞各能存活几轮。

思路

解法一：枚举优化

首先容易想到三重循环的暴力解法，枚举轮数、枚举各个细胞 \(i\)，枚举各个细胞 \(j\) 判断 \(j\) 能否保护 \(i\) 。

由于坐标由随机数产生，所以细胞在坐标系上的分布是均匀的，可以发现最多攻击约 100 轮就能消灭所有细胞。但这样三重循环仍然很慢，考虑优化第二、三重循环的枚举：

1. 上一轮病毒攻击后已经被消灭的细胞对后面都没有作用了，直接剔除出去，不参与下一轮的枚举；
2. 对三维坐标的其中一个维度排序，比如对 \(x\) 轴的坐标从小到大排序，那么细胞 \(j\) 能够保护细胞 \(i\) 由于要满足 \(x_j\leq x_i\) ，可得 \(j<i\) ，所以第三重循环的上界为 \(i\) 即可（这里说的 \(i,j\) 是排序后的细胞新编号）。但即使第三重循环的上界为 \(i\) 仍然不够优秀，我们思考如果 \(j\) 能保护 \(i\) 并且 \(j\) 能在这一轮后存活，那么保护 \(j\) 的细胞 \(j_1\) 其实也能够保护 \(i\) ；如果 \(j_1\) 能存活，那么保护 \(j_1\) 的细胞 \(j_2\) 也能保护 \(i\) ...... 这样一重重套下去，最终肯定有一个在这一轮后不能存活的细胞 \(j_k\) 能够保护 \(i\) ，且 \(j_k<...<j_2<j_1<j<i\) 。所以第三重循环只要枚举在这一轮已死的细胞即可，不用枚举能存活的细胞。
3. 由于随机数的范围很大，所以基本不可能随机出相同的数字，所以 \(x_j\leq x_i \&\& y_j\leq y_i \&\& z_j\leq z_i \&\& (x_j<x_i || y_j<y_i||z_j<z_i)\) 也等价于 \(x_j<x_i \&\& y_j<y_i \&\& z_j<z_i\) 。因为这条逻辑表达式是放在最内层循环中，是程序中被执行次数最多的语句，所以这样改后能优化一些时间。

解法二 cdq分治

前置知识：cdq分治

观察到 \(x_j<x_i \&\& y_j<y_i \&\& z_j<z_i\) 这个形式和 三维偏序 问题十分相似，三维偏序问题就是 cdq 分治的典型问题。只是三维偏序问题求的是满足表达式的元素数量，而这道题并不是有多少个 \(j\) 能保护 \(i\) ，\(i\) 就能存活多少轮。我们用 \(j_k\to j_{k-1}\to...j_2\to j_1\) 来表示细胞 \(j_k\) 能保护 \(j_{k-1}\) ，\(j_{k-1}\) 能保护 \(j_{k-2}\) ...... \(j_2\) 能保护 \(j_1\) 这样一条保护链，那么 \(j_1\) 能够存活几轮就取决于这条链的长度。实际情况不是简单的链形关系，而是“有向图”形关系，如果说三维偏序问题各元素建模成“有向图”形关系后是求每个结点的前缀结点数量，那么这道题就是求每个结点的最长前缀链长度。这里只是形象化的理解，不是真要构建有向图来求解，这对于求解问题的时间空间复杂度并没有帮助。

从求数量变成求最长，cdq 分治中的树状数组维护前缀和就要变成维护前缀最大长度值。通常，cdq 分治都是先处理完 \([l,mid]\) 和 \([mid+1,r]\) ，再归并处理 \([l,r]\) ，在这道题中，\([l,r]\) 要在 \([mid+1,r]\) 之前处理。比如 \(1\to 2\to3\to 4\) ，先处理 \([1,2]\) ，能知道 \(2\) 有 \(1\to 2\) 这条长度为 2 的前缀链，再处理 \([3,4]\) ，能知道 \(4\) 有 \(3\to 4\) ，最后处理 \([1,4]\) ，只能知道 \(4\) 还有 \(1\to 2\to 4\) 这条长度为 3 的前缀链；如果先处理 \([1,4]\) ，就能更新 \(3\) 的前缀链长度为 3，再处理 \([3,4]\) ，能用 \(3\) 去更新 \(4\) 的前缀链长度为 4 。时间复杂度 \(O(nlog^2n)\) 。

代码实现

枚举优化：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 100010;
struct node {
    int id;
    unsigned long long x, y, z;
} cell[maxn];
int ans[maxn];
unsigned long long k1, k2;
unsigned long long CoronavirusBeats() {
    unsigned long long k3 = k1, k4 = k2;
    k1 = k4;
    k3 ^= k3 << 23;
    k2 = k3 ^ k4 ^ (k3 >> 17) ^ (k4 >> 26);
    return k2 + k4;
}
bool cmp(const node &a, const node &b) {
    if (a.x != b.x) return a.x < b.x;
    if (a.y != b.y) return a.y < b.y;
    return a.z < b.z;
}

int main() {
    int n;
    cin >> n >> k1 >> k2;
    for (int i = 0; i < n; i++) {
        cell[i].x = CoronavirusBeats();
        cell[i].y = CoronavirusBeats();
        cell[i].z = CoronavirusBeats();
        cell[i].id = i;
    }
    int lun;
    sort(cell, cell+ n, cmp);
    vector<int> sur; // 目前还存活的细胞
    for (int i = 0; i < n; i++) sur.push_back(i);
    for (lun = 1; sur.size() > 0; lun++) {  // 枚举每一轮
        vector<int> die, tmp_sur;  // die表示在这一轮被消灭的细胞
        die.push_back(sur[0]); // sur[0]是x坐标最小的细胞，肯定没被保护
        ans[cell[sur[0]].id] = lun - 1;
        for (int i = 1; i < sur.size(); i++) {
            int ii = sur[i];
            bool flag = false; // 细胞i能否在这一轮存活
            /* 由于按坐标排序了，如果细胞i能在这一轮存活，那么能保护i的所有细胞中
               肯定有这一轮已死的，逆否命题就是如果这一轮已死的所有细胞都不能保护i，
               那么i也不能存活 */
            for (int j : die) {
                if (cell[j].x < cell[ii].x || cell[j].y < cell[ii].y || cell[j].z < cell[ii].z) {
                    flag = true;
                    break;
                }
            }
            if (flag) tmp_sur.push_back(ii);
            else {
                ans[cell[ii].id] = lun - 1;
                die.push_back(ii);
            }
        }
        sur = tmp_sur;
    }
    printf("%d\n", lun - 1);
    for (int i = 0; i < n; i++) printf("%d%c", ans[i], " \n"[i==n]);

    return 0;
}

cdq分治：

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100010;
struct node {
    int id;
    unsigned long long x, y, z;
} cell[maxn], tmp_c[maxn];
int ans[maxn], tr[maxn], n;
unsigned long long tmp[maxn];
unsigned long long k1, k2;
unsigned long long CoronavirusBeats() {
    unsigned long long k3 = k1, k4 = k2;
    k1 = k4;
    k3 ^= k3 << 23;
    k2 = k3 ^ k4 ^ (k3 >> 17) ^ (k4 >> 26);
    return k2 + k4;
}
bool cmpx(const node &a, const node &b) {
    return a.x < b.x;
}
bool cmpy(const node &a, const node &b) {
    return a.y < b.y;
}
void change() { // 对z轴的值离散化
    for (int i = 0; i < n; i++) tmp[i] = cell[i].z;
    sort(tmp, tmp + n);
    for (int i = 0; i < n; i++) cell[i].z = lower_bound(tmp, tmp + n, cell[i].z) - tmp + 1;
}
int lowbit(int x) {
    return x & -x;
}
void update(int x, int val) {
    while (x <= n) tr[x] = max(tr[x], val), x += lowbit(x);
}
int query(int x) {
    int res = 0;
    while (x) res = max(res, tr[x]), x -= lowbit(x);
    return res;
}
void recover(int x) {
    while (x <= n) tr[x] = 0, x += lowbit(x);
}
void cdq_solve(int l, int r) {
    int mid = (l + r) >> 1;
    for (int i = l; i <= mid; i++) tmp_c[i] = cell[i];
    for (int i = mid + 1; i <= r; i++) tmp_c[i] = cell[i];
    sort(tmp_c + l, tmp_c + mid + 1, cmpy);
    sort(tmp_c + mid + 1, tmp_c + r + 1, cmpy);
    int j = l;
    for (int i = mid + 1; i <= r; i++) {
        for (; j <= mid && tmp_c[j].y < tmp_c[i].y; j++) {
            update(tmp_c[j].z, ans[tmp_c[j].id]);
        }
        ans[tmp_c[i].id] = max(ans[tmp_c[i].id], query(tmp_c[i].z) + 1);
    }
    int delj = j;
    for (int i = l; i < delj; i++) recover(tmp_c[i].z);
}
void cdq(int l, int r) {
    if (l == r) return ;
    int mid = (l + r) >> 1;
    cdq(l, mid);
    cdq_solve(l, r);
    cdq(mid + 1, r);
}

int main() {
    scanf("%d %llu %llu", &n, &k1, &k2);
    for (int i = 0; i < n; i++) {
        cell[i].x = CoronavirusBeats();
        cell[i].y = CoronavirusBeats();
        cell[i].z = CoronavirusBeats();
        cell[i].id = i;
        ans[i] = 1;
    }
    sort(cell, cell+ n, cmpx);
    change();
    cdq(0, n - 1);
    printf("%d\n", *max_element(ans, ans + n));
    for (int i = 0; i < n; i++) printf("%d%c", ans[i] - 1, " \n"[i==n-1]);

    return 0;
}

EOJ-2020“游族杯”Coronavirus Battle (CDQ分治、枚举优化)

标签：tmp   usb   owb   数组   空间复杂度   main   for   帮助   return   

原文地址：https://www.cnblogs.com/kangkang-/p/12950725.html