UOJ#77. A+B Problem [可持久化线段树优化建边 最小割]

UOJ#77. A+B Problem

题意：自己看

---

接触过线段树优化建图后思路不难想，细节要处理好




乱建图无果后想到最小割

白色和黑色只能选一个，割掉一个就行了

之前选白色必须额外割掉一个p[i]，i向i+n连p[i]，然后i+n向之前点连INF就行了

向一段区间连边？果断线段树优化

等等，还要满足\(l_i\le a_j \le r_i\)，权值建线段树，然后可持久化！

有一点细节没考虑好，就是之前的可能有x了这次a[i]=x，不需要重复把之前再连一遍，**只要新叶子到之前的叶子连INF就行了**


然后WA了一个小时，除了图上编号手残打错之外，一个主要的问题在于，可持久化线段树是动态开点，建树时父亲向孩子连边，不能在插入孩子的时候连边，有可能是之前的孩子，所以额外判断！！！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define fir first
#define sec second
#define lc t[x].l
#define rc t[x].r
#define mid ((l+r)>>1)
#define lson lc, l, mid
#define rson rc, mid+1, r
typedef long long ll;
const int N=2e5+5, M=1e6+5, INF=1e9;
inline ll read(){
    char c=getchar();ll x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

int n, s, t, tot, mp[N], m, n2, b, w, p, sum;
struct meow{int a, l, r;}a[N];
struct edge{int v, c, f, ne;}e[M];
int cnt=1, h[N];
inline void ins(int u, int v, int c) { //printf("ins %d %d %d\n",u,v,c);
	e[++cnt]=(edge){v, c, 0, h[u]}; h[u]=cnt;
	e[++cnt]=(edge){u, 0, 0, h[v]}; h[v]=cnt;
}
namespace Flow{
	int q[N], head, tail, vis[N], d[N], cur[N];
	bool bfs(int s, int t) {
		memset(vis, 0, sizeof(vis));
		head=tail=1;
		q[tail++]=s; d[s]=0; vis[s]=1;
		while(head!=tail) {
			int u=q[head++];
			for(int i=h[u];i;i=e[i].ne)
				if(!vis[e[i].v] && e[i].c>e[i].f) {
					vis[e[i].v]=1; d[e[i].v]=d[u]+1;
					q[tail++]=e[i].v;
					if(e[i].v==t) return true;
				}
		}
		return false;
	}
	int dfs(int u, int a, int t) {
		if(u==t || a==0) return a;
		int flow=0, f;
		for(int &i=cur[u];i;i=e[i].ne)
			if(d[e[i].v]==d[u]+1 && (f=dfs(e[i].v, min(a, e[i].c-e[i].f), t))>0) {
				flow+=f;
				e[i].f+=f;
				e[i^1].f-=f;
				a-=f;
				if(a==0) break;
			}
		if(a) d[u]=-1;
		return flow;
	}
	int dinic(int s, int t) {
		int flow=0;
		while(bfs(s, t)) {
			for(int i=0; i<=tot; i++) cur[i]=h[i];
			flow+=dfs(s, INF, t); //printf("flow %d\n",flow);
		}
		return flow;
	}
}using Flow::dinic;

namespace Chair{
	struct meow{int l, r;}t[N];
	int sz, root[N];
	void insert(int &x, int l, int r, int val, int id) {
		int last=x;
		t[++sz]=t[x]; x=sz;
		if(l==r) {
			if(last) ins(n2+x, n2+last, INF);
			ins(n2+x, id, INF);
			return;
		}
		if(val<=mid) insert(lson, val, id);
		else insert(rson, val, id);
		if(lc) ins(n2+x, n2+lc, INF);
		if(rc) ins(n2+x, n2+rc, INF);
	}
	void rabit(int x, int l, int r, int ql, int qr, int u) {
		if(!x) return;
		if(ql<=l && r<=qr) ins(u, n2+x, INF);
		else {
			if(ql<=mid) rabit(lson, ql, qr, u);
			if(mid<qr ) rabit(rson, ql, qr, u);
		}
	}
	void build() {
		for(int i=1; i<=n; i++) root[i]=root[i-1], insert(root[i], 1, m, a[i].a, i);
		for(int i=2; i<=n; i++) rabit(root[i-1], 1, m, a[i].l, a[i].r, i+n);
		tot=sz+n2+1;
	}
}using Chair::build;
int main() {
	freopen("in","r",stdin);
	n=read(); s=0; t=N-1;
	n2=n*2;
	for(int i=1; i<=n; i++) {
		mp[++m]=a[i].a=read(), b=read(), w=read(), mp[++m]=a[i].l=read(), mp[++m]=a[i].r=read(), p=read();
		ins(s, i, b); ins(i, t, w); ins(i, i+n, p); sum+=b+w;
	}
	sort(mp+1, mp+1+m); m=unique(mp+1, mp+1+m)-mp-1;
	for(int i=1; i<=n; i++) {
		a[i].a = lower_bound(mp+1, mp+1+m, a[i].a)-mp;
		a[i].l = lower_bound(mp+1, mp+1+m, a[i].l)-mp;
		a[i].r = lower_bound(mp+1, mp+1+m, a[i].r)-mp;
	//	printf("hi %d   %d %d %d\n",i,a[i].a,a[i].l,a[i].r);
	}
	build();
	int ans=dinic(s, t); //printf("sum %d %d\n",sum,ans);
	printf("%d",sum-ans);
}