bzoj4383 [POI2015]Pustynia（线段树优化建图+差分约束）

Description

给定一个长度为n的正整数序列a，每个数都在1到10^9范围内，告诉你其中s个数，并给出m条信息，每条信息包含三个数l,r,k以及接下来k个正整数，表示a[l],a[l+1],…,a[r-1],a[r]里这k个数中的任意一个都比任意一个剩下的r-l+1-k个数大（严格大于，即没有等号）。

请任意构造出一组满足条件的方案，或者判断无解。

Input

第一行包含三个正整数n,s,m(1<=s<=n<=100000，1<=m<=200000)。

接下来s行，每行包含两个正整数p[i],di，表示已知a[p[i]]=d[i]，保证p[i]递增。

接下来m行，每行一开始为三个正整数l[i],r[i],ki，接下来k[i]个正整数x[1],x[2],…,x[k[i]](l[i]<=x[1]<x[2]<…<x[k[i]] <=r[i])，表示这k[i]个数中的任意一个都比任意一个剩下的r[i]-l[i]+1-k[i]个数大。Σk <= 300,000

Output

若无解，则输出NIE。

否则第一行输出TAK，第二行输出n个正整数，依次输出序列a中每个数。

Sample Input

5 2 2

2 7

5 3

1 4 2 2 3

4 5 1 4

Sample Output

TAK

6 7 1000000000 6 3


分析：
隐隐有一种差分约束的感觉
对于每一个约束条件暴力连边（就不细讲了），边数高达 $n^2=爆炸$

面对这种情况，我们可以考虑一下能不能减少一些没用的边（俗称边的合并）
由于给出的约束条件并没有很明确的限制，都是一堆大于另一堆这样模棱两可的条件
所以我们可以把给出的k个元素，如果有连续的一段，就可以视为一个点$a$
剩下的$r[i]-l[i]+1-k[i]$个元素，如果有连续的一段，同样视为一个点$b$
连边：$b-(1)->a$
（俗称线段树优化建图）
新建一个超级源点$S$，对于已知的点权$i$，连边：$S-(a_i)->i$
对于这个图拓扑排序一下，得到到达每个点的最大距离$dis$即为答案

如果对于一个已知点权的点，$dis>点权$，无解

tip

不知道bzoj犯什么病，网上以前可以AC的代码交上去变成WA。。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long

using namespace std;

const int M=4000010;
const int N=1000005;
int n,m,s,pos[N],st[N],tot=0,cnt=0,du[N],a[N];
struct node{
    int y,v,nxt;
};
node way[M];

void add(int u,int w,int z) {
    tot++;way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
    du[w]++;
} 

void build(int bh,int l,int r) {
    if (l==r) {
        pos[l]=bh;
        add(bh+4*n,bh,0);
        return;
    }
    int mid=(l+r)>>1;
    build(bh<<1,l,mid);
    build(bh<<1|1,mid+1,r);
    int lc=bh<<1,rc=bh<<1|1;
    add(lc,bh,0); add(rc,bh,0);
    add(bh+4*n,lc+4*n,0); add(bh+4*n,rc+4*n,0);
}

void change(int bh,int l,int r,int L,int R,int w) {
    if (l>=L&&r<=R) {
        add(bh,w,0);
        return;
    }
    int mid=(l+r)>>1;
    if (L<=mid) change(bh<<1,l,mid,L,R,w);
    if (R>mid) change(bh<<1|1,mid+1,r,L,R,w);
}

int q[N],tou=0,wei=0,f[N];

void TOP() {
    for (int i=1;i<=cnt;i++)
        if (du[i]==0) q[++wei]=i,f[i]=1;
    while (tou<wei) {
        int now=q[++tou];
        if (f[now]>a[now]&&a[now]) {
            printf("NIE\n"); return;
        } else f[now]=max(f[now],a[now]);          //相当于加了一条边 
        for (int i=st[now];i;i=way[i].nxt) {
            int y=way[i].y;
            du[y]--;
            f[y]=max(f[y],f[now]+way[i].v);
            if (du[y]==0) q[++wei]=y;
        }
    }
    bool ff=1;
    for (int i=1;i<=n;i++) 
        if (f[pos[i]]==0) {ff=0; break;}
    if (!ff) printf("NIE\n");
    else {
        printf("TAK\n");
        for (int i=1;i<=n;i++) printf("%d ",f[pos[i]]);
    }
}

int main() 
{
    scanf("%d%d%d",&n,&s,&m);
    build(1,1,n); 
    cnt=n<<3;
    for (int i=1;i<=s;i++) {
        int x,y; scanf("%d%d",&x,&y);
        a[pos[x]]=y;
    }
    int l,r,K,x;
    for (int i=1;i<=m;i++) {
        scanf("%d%d%d",&l,&r,&K); l--;
        ++cnt;                                //辅助结点 
        while (K--) {
            scanf("%d",&x); 
            add(cnt,pos[x]+4*n,1);
            if (l+1<x) change(1,1,n,l+1,x-1,cnt);
            l=x;
        }
        if (l<r) change(1,1,n,l+1,r,cnt);
    }   
    TOP();
    return 0;
}