BZOJ1178 APIO2009 会议中心 贪心、倍增

传送门

---

只有第一问就比较水了

每一次贪心地选择当前可以选择的所有线段中右端点最短的，排序之后扫一遍即可。

考虑第二问。按照编号从小到大考虑每一条线段是否能够被加入。假设当前选了一个区间集合\(T\)，当前正在考虑第\(i\)个区间\((l_i,r_i)\)能否被加入。假如集合\(T\)中存在一个区间\((l_j,r_j)\)与\((l_i,r_i)\)有交，那么显然这个区间不能被放进去。

如果说不存在这样的区间，考虑集合\(T\)中区间\((l_i,r_i)\)的前驱\((l_p,r_p)\)和后继\((l_q,r_q)\)。那么\((l_i,r_i)\)能够被加入的充要条件是：\(f(r_p+1,l_i-1) + f(r_i+1 , l_q - 1) + 1 = f(r_p + 1 , l_q - 1)\)，其中\(f(i,j)\)表示只选择被包含于区间\([i,j]\)的区间，最多能够选择多少个区间。

显然我们不能每一次\(O(n)\)地计算\(f\)函数，考虑其他的方法。

在所有区间中，去掉包含了其他区间的区间。那么这些区间按照左端点排序后，左端点递增，右端点也递增。我们在这样的区间上贪心时，就可以对所有区间扫一遍，每一次能选即选。

注意到选中了某一个区间之后，下一次选中的区间是固定的，故考虑倍增优化。

设\(jmp_{i,j}\)表示从第\(i\)个区间开始向右选择，选择到的\(2^j\)个区间的编号，不难使用双指针预处理。

接下来考虑计算\(f(l,r)\)。通过二分查找找到左端点\(\geq l\)的最左端的区间\(x\)，那么如果\(r_x \leq r\)，\(x\)一定是会被选中的。而选中\(x\)之后接下来贪心选择的所有区间都可以通过倍增知道。那么倍增找到接下来选择的所有区间中右端点\(\leq r\)的最右段的区间并记录总共经过多少个区间即可。

对于区间集合\(T\)可以使用\(set\)维护。值得注意的是std::lower_bound在set等不支持随机访问的STL下复杂度不正确，请使用std::set::lower_bound。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cctype>
#include<algorithm>
#include<cstring>
#include<iomanip>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<vector>
#include<cmath>
#include<random>
//This code is written by Itst
using namespace std;

inline int read(){
    int a = 0;
    char c = getchar();
    while(!isdigit(c))
        c = getchar();
    while(isdigit(c)){
        a = a * 10 + c - 48;
        c = getchar();
    }
    return a;
}

const int MAXN = 2e5 + 3;
struct line{
    int l , r , ind;
    bool operator <(const line a)const{
        return l < a.l || l == a.l && r < a.r;
    }
}now[MAXN] , L[MAXN];
set < line > S;
set < line > :: iterator itS;
int N , cnt , cntL , jump[MAXN][21];

bool cmp(line a , line b){
    return a.ind < b.ind;
}

void init(){
    int minN = 1;
    sort(now + 1 , now + N + 1);
    for(int i = 1 ; i <= N ; ++i){
        if(now[minN].r < now[i].l){
            ++cnt;
            minN = i;
        }
        else
            if(now[minN].r > now[i].r)
                minN = i;
    }
    ++cnt;
    minN = 1e9;
    for(int i = N ; i ; --i)
        if(now[i].r < minN){
            minN = now[i].r;
            L[cntL++] = now[i];
        }
    reverse(L , L + cntL);
    int p = cntL - 1;
    for(int i = cntL - 1 ; i >= 0 ; --i){
        while(p > i && L[p].l > L[i].r)
            --p;
        jump[i][0] = p == cntL - 1 ? -1 : p + 1;
        for(int j = 1 ; j <= 19 ; ++j)
            jump[i][j] = jump[i][j - 1] == -1 ? -1 : jump[jump[i][j - 1]][j - 1];
    }
}

int query(int l , int r){
    int t = lower_bound(L , L + cntL , (line){l , 0}) - L;
    if(t == cntL || L[t].r > r)
        return 0;
    int sum = 0;
    for(int i = 19 ; i >= 0 ; --i)
        if(jump[t][i] != -1 && L[jump[t][i]].r <= r){
            sum += 1 << i;
            t = jump[t][i];
        }
    return sum + 1;
}

#define INF 2e9

int main(){
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
    freopen("out","w",stdout);
#endif
    N = read();
    for(int i = 1 ; i <= N ; ++i){
        now[i].l = read();
        now[i].r = read();
        now[i].ind = i;
    }
    init();
    printf("%d\n" , cnt);
    sort(now + 1 , now + N + 1 , cmp);
    for(int i = 1 ; i <= N && cnt ; ++i){
        int L , R;
        itS = S.lower_bound(now[i]);
        if(itS == S.end())
            R = INF;
        else
            if(itS->l > now[i].r)
                R = itS->l - 1;
            else
                continue;
        if(itS == S.begin())
            L = 0;
        else
            if((--itS)->r < now[i].l)
                L = itS->r + 1;
            else
                continue;
        if(query(L , now[i].l - 1) + query(now[i].r + 1 , R) + 1 == query(L , R)){
            printf("%d " , i);
            S.insert(now[i]);
            --cnt;
        }
    }
    return 0;
}