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);

}