bzoj4082

贪心+倍增

首先如果这个问题在序列上，好像可以按右端点排序，然后从起点开始向能到的最远的地方走。

但是环上不可以，因为随即一个起点可能不是最小的。

然后神思路来了：我们先将环展开倍增，再将区间按右端点排序，然后每个区间连向能达到最远的区间连边。因为每个区间只向外连一条边，而且最后一个区间没有后继，所以这是一颗树。（森林不可能吧，因为每个点都被覆盖了，那么每个区间都有后继，到达最后的区间时肯定有会归到最后一个区间）枚举每个区间，向上倍增，因为每个区间的祖先右端点都要大一些，所以只要倍增到自己左端点时就是答案。

#include<bits/stdc++.h>
using namespace std;
const int N = ;
struct cover {
    int x, y;
} a[N];
int n, len, ans =  << ;
int fa[N][], dep[N], mn[N];
bool cp(cover x, cover y)
{
    return x.y < y.y;
}
int query(int x, int limit)
{
    for(int i = ; i >= ; --i)
        if(fa[x][i] != - && a[fa[x][i]].y < limit)
            x = fa[x][i];
    return a[x].y >= limit ? x : fa[x][];
}
void getdep(int x)
{
    if(dep[x])
        return;
    if(fa[x][] == -)
    {
        dep[x] = ;
        return;
    }
    getdep(fa[x][]);
    dep[x] = dep[fa[x][]] + ;
}
int main()
{
    scanf("%d%d", &len, &n);
    for(int i = ; i <= n; ++i)
    {
        scanf("%d%d", &a[i].x, &a[i].y);
        if(a[i].y < a[i].x)
            a[i].y += len;
    }
    sort(a + , a + n + , cp);
    int j = ;
    memset(fa, -, sizeof(fa));
    memset(mn, 0x3f3f, sizeof(mn));
    for(int i = n; i; --i)
        mn[i] = min(mn[i + ], a[i].x);
    for(int i = ; i <= n; ++i)
    {
        while(a[i].y >= mn[j + ] -  && j < n)
            ++j;
        fa[i][] = j == i ? - : j;
    }
    for(int i = ; i <= n; ++i)
        getdep(i);
    for(int k = ; k <= ; ++k)
        for(int i = ; i <= n; ++i)
            if(fa[i][k - ] != -)
                fa[i][k] = fa[fa[i][k - ]][k - ];
    for(int i = ; i <= n; ++i)
    {
        int x = query(i, a[i].x + len - );
        if(x != -)
            ans = min(ans, dep[i] - dep[x] + );
    }
    if(ans !=  << )
        printf("%d\n", ans);
    else
        puts("impossible");
    return ;
}