LOJ#2134 小园丁与老司机

我的妈呀，这码农神题......

第一问是个DP，要记录方案。先把纵向的转移建图。发现可以按照y坐标来划分阶段，每一层vector存一下，用前后缀最大值来转移。

第二问考虑所有可能成为最优方案的边。从终点倒推可以保证每条边都能到起点，而从起点出发就不一定能保证。这些边拿去网络流建图，然后最小流。

注意第二问找边的时候，每一层的点其实可以视作两个，经过同层转移的和未经过的。这两者不可混为一谈。

最小流先跑S -> T然后t -> s退流的话，要用当前弧优化，否则会被最后一个数据卡成n²。

#include <bits/stdc++.h>

const int N = 50010, INF = 0x7f7f7f7f;

struct Node {
    int x, y, id;
    inline bool operator <(const Node &w) const {
        if(y != w.y) return y < w.y;
        return x < w.x;
    }
}node[N];

inline void read(int &x) {
    x = 0;
    char c = getchar();
    bool f = 0;
    while(c < '0' || c > '9') {
        if(c == '-') f = 1;
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = getchar();
    }
    if(f) x = (~x) + 1;
    return;
}

struct Edge {
    int nex, v;
}edge[N << 2]; int tp;

int n, X[N << 2], xx, bin[N << 2], e[N], fr1[N], fr2[N], fr_l[N], fr_r[N], large_l[N], large_r[N], f[N], ff[N];
bool visit[N], visit2[N];
std::vector<int> v[N << 2];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void out(int x, int flag) {
    if(!node[x].id) return;
    if(flag == 1) {
        out(fr1[x], 2);
    }
    else {
        out(fr2[x], 1);
        int y = fr2[x], u = node[y].y;
        if(y == x) {
            printf("%d ", node[x].id);
        }
        else if(node[y].x > node[x].x) {
            for(int i = 0; i < (int)(v[u].size()); i++) {
                if(node[v[u][i]].x >= node[y].x) {
                    printf("%d ", node[v[u][i]].id);
                }
            }
            for(int i = v[u].size() - 1; i >= 0; i--) {
                int temp = node[v[u][i]].x;
                if(temp < node[y].x && temp >= node[x].x) {
                    printf("%d ", node[v[u][i]].id);
                }
            }
        }
        else {
            for(int i = v[u].size() - 1; i >= 0; i--) {
                if(node[v[u][i]].x <= node[y].x) {
                    printf("%d ", node[v[u][i]].id);
                }
            }
            for(int i = 0; i < (int)(v[u].size()); i++) {
                int temp = node[v[u][i]].x;
                if(temp > node[y].x && temp <= node[x].x) {
                    printf("%d ", node[v[u][i]].id);
                }
            }
        }
    }
    return;
}

namespace fl {
    struct Edge {
        int nex, v, c;
        Edge(int Nex = 0, int V = 0, int C = 0) {
            nex = Nex;
            v = V;
            c = C;
        }
    }edge[1000010]; int tp = 1;
    int e[N], vis[N], in[N], d[N], vis2[N], cur[N];
    std::queue<int> Q;
    inline void add(int x, int y, int z) {
        edge[++tp] = Edge(e[x], y, z);
        e[x] = tp;
        edge[++tp] = Edge(e[y], x, 0);
        e[y] = tp;
        return;
    }
    inline void Add(int x, int y) {
        /// x -> y [1, INF]
        vis2[x] = vis2[y] = 1;
        add(x, y, N);
        in[y]++;
        in[x]--;
        return;
    }
    inline bool BFS(int s, int t) {
        static int Time = 0; Time++;
        vis[s] = Time;
        d[s] = 0;
        Q.push(s);
        while(!Q.empty()) {
            int x = Q.front();
            Q.pop();
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if(vis[y] != Time && edge[i].c) {
                    vis[y] = Time;
                    d[y] = d[x] + 1;
                    Q.push(y);
                }
            }
        }
        return vis[t] == Time;
    }
    int DFS(int x, int t, int maxF) {
        if(x == t) return maxF;
        int ans = 0;
        for(int i = cur[x] ? cur[x] : e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(!edge[i].c || d[y] != d[x] + 1) {
                continue;
            }
            int temp = DFS(y, t, std::min(maxF - ans, edge[i].c));
            if(!temp) d[y] = INF;
            ans += temp;
            edge[i].c -= temp;
            edge[i ^ 1].c += temp;
            if(ans == maxF) break;
            cur[x] = i;
        }
        return ans;
    }
    inline int dinic(int s, int t) {
        int ans = 0;
        while(BFS(s, t)) {
            memset(cur, 0, sizeof(cur));
            ans += DFS(s, t, INF);
        }
        return ans;
    }
    inline void solve() {
        int s = N - 5, t = N - 2, S = N - 3, T = N - 4;
        for(int i = 1; i <= n; i++) {
            if(!vis2[i]) continue;
            add(s, i, N);
            add(i, t, N);
        }
        int now = tp;
        add(t, s, INF);
        for(int i = 1; i <= n; i++) {
            if(in[i] > 0) {
                add(S, i, in[i]);
            }
            else if(in[i] < 0) {
                add(i, T, -in[i]);
            }
        }
        int ans;
        dinic(S, T);
        ans = edge[now + 2].c;
        for(int i = now + 1; i <= tp; i++) edge[i].c = 0;
        ans -= dinic(t, s);
        printf("%d
", ans);
        return;
    }
}

int main() {
    read(n);
    for(int i = 1; i <= n; i++) {
        read(node[i].x); read(node[i].y);
        node[i].id = i;
        X[++xx] = node[i].x;
        X[++xx] = node[i].y;
        X[++xx] = node[i].x + node[i].y;
        X[++xx] = node[i].x - node[i].y;
    }
    ++n; ++xx; /// the Node O
    std::sort(node + 1, node + n + 1);
    std::sort(X + 1, X + xx + 1);
    xx = std::unique(X + 1, X + xx + 1) - X - 1;
    for(int i = 1; i <= n; i++) {
        int temp = std::lower_bound(X + 1, X + xx + 1, node[i].x + node[i].y) - X;
        if(bin[temp]) {
            add(bin[temp], i);
        }
        bin[temp] = i;
    }
    memset(bin + 1, 0, xx * sizeof(int));
    for(int i = 1; i <= n; i++) {
        int temp = std::lower_bound(X + 1, X + xx + 1, node[i].x - node[i].y) - X;
        if(bin[temp]) {
            add(bin[temp], i);
        }
        bin[temp] = i;
    }
    memset(bin + 1, 0, xx * sizeof(int));
    for(int i = 1; i <= n; i++) {
        node[i].x = std::lower_bound(X + 1, X + xx + 1, node[i].x) - X;
        node[i].y = std::lower_bound(X + 1, X + xx + 1, node[i].y) - X;
    }
    for(int i = 1; i <= n; i++) {
        if(bin[node[i].x]) {
            add(bin[node[i].x], i);
        }
        bin[node[i].x] = i;
        v[node[i].y].push_back(i);
    }
    /// Build Graph 1 Over
    memset(f, ~0x3f, sizeof(f));
    f[1] = 0;
    for(int u = 1; u <= xx; u++) {
        if(!v[u].size()) continue;
        int len = v[u].size();
        for(int i = 0; i < len; i++) {
            int x = v[u][i];
            ff[x] = f[x];
            fr2[x] = x;
        }
        /// trans in row
        for(int i = 0; i < len; i++) {
            int x = v[u][i];
            if(i && f[x] < large_l[i - 1]) {
                large_l[i] = large_l[i - 1];
                fr_l[i] = fr_l[i - 1];
            }
            else {
                large_l[i] = f[x];
                fr_l[i] = x;
            }
        }
        for(int i = len - 1; i >= 0; i--) {
            int x = v[u][i];
            if(i < len - 1 && f[x] < large_r[i + 1]) {
                large_r[i] = large_r[i + 1];
                fr_r[i] = fr_r[i + 1];
            }
            else {
                large_r[i] = f[x];
                fr_r[i] = x;
            }
        }
        for(int i = 0; i < len; i++) {
            int x = v[u][i];
            if(i < len - 1 && f[x] < large_r[i + 1] + len - i - 1) {
                f[x] = large_r[i + 1] + len - i - 1;
                fr2[x] = fr_r[i + 1];
            }
            if(i && f[x] < large_l[i - 1] + i) {
                f[x] = large_l[i - 1] + i;
                fr2[x] = fr_l[i - 1];
            }
        }
        /// trans in cross / other
        for(int i = 0; i < len; i++) {
            int x = v[u][i];
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if(f[y] < f[x] + 1) {
                    f[y] = f[x] + 1;
                    fr1[y] = x;
                }
            }
        }
    }
    /// DP OVER
    int large_val = -INF, ans_pos = 0;
    for(int i = 1; i <= n; i++) {
        if(large_val < f[i]) {
            large_val = f[i];
            ans_pos = i;
        }
    }
    printf("%d
", large_val);
    out(ans_pos, 2);
    /// Out OVER
    for(int i = 1; i <= n; i++) {
        if(f[i] == large_val) visit2[i] = 1;
        if(ff[i] == large_val) visit[i] = 1;
    }
    for(int u = xx; u >= 1; u--) {
        if(!v[u].size()) continue;
        int len = v[u].size();
        /// build Flow Graph (this -> up)
        for(int i = 0; i < len; i++) {
            int x = v[u][i];
            for(int i = e[x]; i; i = edge[i].nex) {
                int y = edge[i].v;
                if(visit[y] && ff[y] == f[x] + 1) {
                    visit2[x] = 1;
                    fl::Add(x, y);
                }
            }
            if(visit2[x] && f[x] == ff[x]) {
                visit[x] = 1;
            }
        }
        /// Find Edge in row (update)
        for(int j = 0; j < len; j++) {
            int y = v[u][j];
            if(!visit2[y]) continue;
            for(int i = 0; i < len; i++) {
                int x = v[u][i];
                if(visit[x]) continue;
                /// x -> y
                if(node[x].x < node[y].x && f[y] == ff[x] + j) {
                    visit[x] = 1;
                }
                else if(node[y].x < node[x].x && f[y] == ff[x] + len - j - 1) {
                    visit[x] = 1;
                }
            }
        }
    }
    puts("");
    /// Build Flow Over
    fl::solve();
    return 0;
}

10k还行