CF 1557 D. Ezzat and Grid

D. Ezzat and Grid

题目大意

给定一个\(n\times 10^9\)的01矩阵，要求去掉最少行，使得相邻两行有至少一列都是\(1\)。

输出去掉的最小行数和一种可行的去掉行的方案。

矩阵以给出每行\(1\)对应的列的形式给出。

解题思路

简单\(DP\)。

设\(dp[i]\)表示前\(i\)行，保留第\(i\)行，满足题目要求的去掉最小的行数。

则\(dp[i] = \min(dp[j] + i - j - 1)\)，其中第\(i\)行和第\(j\)行至少有一列都是\(1\)。

为方便期间，变换形式为\(dp[i] - i = \min(dp[j] - j) - 1\)容易猜测这个j是小于i的满足条件最大的

问题就在于如何维护可行的\(j\)。

换个角度，我们不考虑哪些\(j\)可行，而是考虑哪些\(j\)的某一列是\(1\)。

如果第\(i\)行的第\(k\)列为\(1\)，那么我们就在前面的行里，找到第\(k\)列同样为\(1\)的行，取他们的最大值。

维护辅助数组\(a[i]\)表示第\(i\)列为\(1\)的行的\(\min(dp[k] - k)\)

那么对于第\(i\)的某个连续的\(1\)区间\(l,r\)，我们就只要查询\(a[l..r]\)的最小值。

然后再将\(dp[i] - i\)的值更新到\(a\)数组即可。

区间赋值和区间查询，用线段树维护\(a\)数组。

需要先离散化列。

至于输出方案，记录转移的前继节点即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}

template <typename T, typename... rest>
void read(T &x, rest&... Rest) {
    read(x);
    read(Rest...);
}

template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}

const int N = 3e5 + 8;

class Segment{
#define lson root << 1
#define rson root << 1 | 1
    
    pair<int,int> minn[N << 3];
    pair<int,int> lazy[N << 3];
    public:

    void pushdown(int root){
        if (lazy[root] == make_pair(0, 0))
            return;
        minn[lson] = minn[rson] = lazy[lson] = lazy[rson] = lazy[root];
        lazy[root] = {0, 0};
    }

    void update(int root, int l, int r, int ll, int rr, pair<int,int> val){
        if (ll <= l && r <= rr){
            minn[root] = val;
            lazy[root] = val;
            return;
        }
        pushdown(root);
        int mid = (l + r) >> 1;
        if (ll <= mid)
            update(lson, l, mid, ll, rr, val);
        if (rr > mid)
            update(rson, mid + 1, r, ll, rr, val);
        minn[root] = min(minn[lson], minn[rson]);
    }

    pair<int,int> query(int root, int l, int r, int ll, int rr){
        if (ll <= l && r <= rr)
            return minn[root];
        pushdown(root);
        int mid = (l + r) >> 1;
        if (rr <= mid)
            return query(lson, l, mid, ll, rr);
        else if (ll > mid)
            return query(rson, mid + 1, r, ll, rr);
        else 
            return min(query(lson, l, mid, ll, rr), query(rson, mid + 1, r, ll, rr));
    }
}Seg;

int n, m;

vector<pair<int,int>> s[N];

map<int, int> rr;

int pre[N];

set<int> ss;

int main(void) {
    read(n, m);
    for(int a, l, r, i = 1; i <= m; ++ i){
        read(a, l, r);
        ss.insert(l);
        ss.insert(r);
        s[a].push_back({l, r});
    }
    int cnt = 1;
    for(auto i : ss)
        rr[i] = cnt++;
    int tot = ss.size();
    int ou = 1e9 + 7;
    int en = 0;
    for(int i = 1; i <= n; ++ i){
        int ans = -1;
        for(auto &j : s[i]){
            pair<int,int> re = Seg.query(1, 1, tot, rr[j.first], rr[j.second]);
            if (ans > re.first - 1){
                ans = re.first - 1;
                pre[i] = re.second;
            }
        }
        for(auto &j : s[i]){
            Seg.update(1, 1, tot, rr[j.first], rr[j.second], {ans, i});
        }
        if (ans + n < ou){
            en = i;
            ou = ans + n;
        }
    }
    write(ou, '\n'); 
    for(int i = n; i >= en + 1; -- i)
        write(i);
    for(int i = en; i != 0; i = pre[i]){
        for(int j = i - 1; j > pre[i]; -- j)
            write(j);
    }
    return 0;
}

---