BZOJ4444 SCOI2015国旗计划 根据性质优化贪心

题目大意

现在给定一个大小为$M$的环，顺时针编号$1$~$M$，以及$N$个人，每个人有一个给定的属性$L_i, R_i$表示可以覆盖顺时针方向的$L_i$到$R_i$，现在要求选最少的人覆盖掉整个环（包括两个点之间的区间），问当第$i$个人必选时，至少选多少个人。

$M <= 10^9$
$N <= 10^5$

解题思路

首先最直观的思路就是把环拆开变成一条链，我们发现我们当起点确定是我们只需贪心的一直往能覆盖到的最有的地方覆盖就可以得到最小的答案。我们可以先离散化位置，然后设$F_i$表示区间左端点不超过$i$时右端点的最大值，这个可以线性的求出。那么现在已经我们可以$O（N^2）$的得出答案，那么怎么加速这个算法？

其实这$N$个答案的值相差不会超过1，因为不管怎样最优答案加上当前的这个人都是可行的。所以我们可以连$2N$t条$i$到$F_i$的边，这样我们就可以构出一颗树，第$i$个点的答案就是向上跳的第一个标号超过$M+i$的点（M是离散后的）。我们预处理出从第一个点跳的答案$L$，然后对于别的点就可以设$L-1$为下界，遍历一棵树是记录下到根有哪些点，那么查询的复杂度就是$O(N)$了。

程序

//YxuanwKeith
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 2e5 + 5;

struct Node {
    int Num, Bel, Ord;
    Node(int num, int bel, int ord) {Num = num, Bel = bel, Ord = ord;}
    Node() {}
};

Node Sort[MAXN * 2];
int N, M, Num, Least, top, L[MAXN], R[MAXN], F[MAXN * 4], Ans[MAXN * 4];
int tot, Last[MAXN * 4], Go[MAXN * 4], Next[MAXN * 4], D[MAXN * 4];  

void Max(int &Now, int Comp) {
    if (Comp > Now) Now = Comp;
}

bool Cmp(Node A, Node B) {
    return A.Num < B.Num;
}

void Link(int u, int v) {
    Next[++ tot] = Last[u], Last[u] = tot, Go[tot] = v;
}

void Prepare() {
    sort(Sort + 1, Sort + 1 + N * 2, Cmp);
    for (int i = 1; i <= N * 2; i ++) {
        if (Sort[i].Num != Sort[i - 1].Num) ++ Num; 
        if (Sort[i].Ord == 0) L[Sort[i].Bel] = Num; else
            R[Sort[i].Bel] = Num;
    }

    for (int i = 1; i <= N; i ++) {
        if (L[i] < R[i]) {
            Max(F[L[i]], R[i]);
            Max(F[L[i] + Num], R[i] + Num);
        } else {
            Max(F[1], R[i]);
            Max(F[L[i]], R[i] + Num);
            Max(F[L[i] + Num], Num + Num);
        }
    }
    for (int i = 1; i <= Num + Num; i ++) Max(F[i], F[i - 1]);

    for (int i = 1; i <= Num; i = F[i]) Least ++;
    Least -= 1;

    for (int i = 1; i < 2 * Num; i ++) Link(F[i], i);
}

void Dfs(int Now) {
    D[++ top] = Now;
    if (Now <= Num) 
        for (int i = Least; ; i ++) 
            if (D[top - i] >= Now + Num) {
                Ans[Now] = i;
                break;
            }

    for (int p = Last[Now]; p; p = Next[p]) 
        Dfs(Go[p]);
    top --;
}

void Solve() {
    Dfs(Num + Num);
    for (int i = 1; i <= N; i ++) printf("%d ", Ans[L[i]]);
}

int main() {
    scanf("%d%d", &N, &M);
    int Cnt = 0;
    for (int i = 1; i <= N; i ++) {
        scanf("%d%d", &L[i], &R[i]);
        Sort[++ Cnt] = Node(L[i], i, 0);
        Sort[++ Cnt] = Node(R[i], i, 1);
    }

    Prepare();
    Solve();
}