CF1557D Ezzat and Grid

题意：给你个n行1e9列的01矩阵。i行和i+1行是相邻的当且仅当存在一列，这两行这一列的数都是1。问最少删掉多少行，才能使对于每个1<=i<m，i行和i+1行都相邻。m是删掉之后的总行数。输出方案。

解：首先发现，两个行能够相邻，一定是通过某个两者都是1的位置联系起来。

怎么做呢，想了一想想到了连边图论，然后马上发现边数是n²的，那没事了。再进一步，想到了DO。就设f[i]表示选了第i行，前面的全都相邻，要删掉的最少行数。那么转移就是对于这一行每个是1的地方，如果前面某一行这里也是1，那么可以从那一行转移来，转移方程是f[i]=min(f[j]+(i-j-1))，发现这个转移方程可以化成f[i]-i=min(f[j]-j)-1，于是我们考虑维护一个数据结构来转移，存f[i]-i的最小值。如果第i行这里是1，就把数据结构的这里改成f[i]-i，查询的时候查询这一行是1的地方的最小值，再-1就可以了。最终答案就是f[n+1]+n+1

记录方案就是DO经典套路，转移的同时记。可以把来源和最值一起扔到线段树里来存。然后我写的时候修改不是区间取min而是区间覆盖，因为我赛时想的是靠后的转移一定更优。赛后证了一下，是对于k<j这两个可行的转移，一定可以把j到k的中间这些行全都删了，也就是f[j]<=f[k]+(j-k-1)，也就是f[j]-j<=f[k]-k-1<f[k]-k，所以越靠后的转移越优。

值域是1e9来着所以要离散化一下。我之前动态开点结果MLE on 1

/**
 *  There is no end though there is a start in space. ---Infinity.
 *  It has own power, it ruins, and it goes though there is a start also in the star. ---Finite.
 *  Only the person who was wisdom can read the most foolish one from the history.
 *  The fish that lives in the sea doesn't know the world in the land.
 *  It also ruins and goes if they have wisdom.
 *  It is funnier that man exceeds the speed of light than fish start living in the land.
 *  It can be said that this is an final ultimatum from the god to the people who can fight.
 *  
 *  Steins;Gate
**/

#include <bits/stdc++.h>
typedef long long LL;
inline char gc() {
    return getchar();
    static char buf[100000], *p1 = buf, *p2 = buf;
    if(p1 == p2) {
        p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
    }
    return (p1 == p2) ? EOF : *p1++;
}

template <typename T>
inline void read(T& x) {
    x = 0;
    char c(gc());
    int f(1);
    while(c < '0' || c > '9') {
        if(c == '-') {
            f = -1;
        }
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = gc();
    }
    x *= f;
}

inline LL read() {
    LL x;
    read(x);
    return x;
}

const int N = 300010;

struct Node {
    int l, r;
};
struct Data {
    int val, id;
    Data(int V = 0, int I = 0)
        : val(V), id(I) {}
};
std::vector<Node> v[N];
int n, m, tot = 1, X[N * 2], top;
Data f[N];
Data Min[N * 8], tag[N * 8];
Data exmin(Data a, Data b) {
    if(!a.id)
        return b;
    if(!b.id)
        return a;
    if(a.val < b.val) {
        return a;
    }
    return b;
}
inline void pushdown(int o) {
    if(tag[o].id) {
        int ls = o << 1, rs = o << 1 | 1;
        tag[ls] = Min[ls] = tag[o];

        tag[rs] = Min[rs] = tag[o];

        tag[o] = Data(0, 0);
    }
}
inline void pushup(int o) {
    Min[o] = exmin(Min[o << 1], Min[o << 1 | 1]);
}
void change(int L, int R, int v, int id, int l, int r, int o) {
    if(L <= l && r <= R) {
        tag[o] = Min[o] = Data(v, id);
        return;
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    if(L <= mid) {
        change(L, R, v, id, l, mid, o << 1);
    }
    if(mid < R) {
        change(L, R, v, id, mid + 1, r, o << 1 | 1);
    }
    pushup(o);
}

Data getMin(int L, int R, int l, int r, int o) {
    if(L <= l && r <= R) {
        return Min[o];
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    Data ans(-1, 0);
    if(L <= mid) {
        ans = getMin(L, R, l, mid, o << 1);
    }
    if(mid < R) {
        ans = exmin(ans, getMin(L, R, mid + 1, r, o << 1 | 1));
    }
    return ans;
}

int main() {
    // printf("%d
", (sizeof(ls) + sizeof(rs) + sizeof(tag) + sizeof(Min) + sizeof(v)) / 1048576);

    read(n);
    read(m);
    for(int i = 1, x, l, r; i <= m; i++) {
        read(x);
        read(l);
        read(r);
        v[x].push_back(Node{l, r});
        X[++top] = l;
        X[++top] = r;
    }
    std::sort(X + 1, X + top + 1);
    top = std::unique(X + 1, X + top + 1) - X - 1;
    for(int i = 1; i <= n; i++) {
        for(int j = 0; j < v[i].size(); j++) {
            v[i][j].l = std::lower_bound(X + 1, X + top + 1, v[i][j].l) - X;
            v[i][j].r = std::lower_bound(X + 1, X + top + 1, v[i][j].r) - X;
        }
    }
    for(int i = 1; i <= n; i++) {
        for(Node node : v[i]) {
            int L = node.l, R = node.r;
            f[i] = exmin(f[i], getMin(L, R, 1, top, 1));
        }
        f[i].val--;
        for(Node node : v[i]) {
            int L = node.l, R = node.r;
            change(L, R, f[i].val, i, 1, top, 1);
        }
        // printf("f %d = %d from %d 
", i, f[i].val + i, f[i].id);
    }
    f[n + 1] = Min[1];
    f[n + 1].val--;
    printf("%d
", f[n + 1].val + n + 1);
    int p = n + 1;
    while(p) {
        int nexP = f[p].id;
        for(int i = nexP + 1; i < p; i++) {
            printf("%d ", i);
        }
        p = nexP;
    }

    return 0;
}