题目
题解
当你看到标题说用网络流做A+B时,第一反应:这怕是个恶搞博客
但是这题不是A+B,是a+b!(区分大小写),你看了题面就会发现不对劲...
搞入正题,我们可以先把问题转化一下:
先把所有减去,若该点是白色,或该点以及前面的符合要求的点都是黑色时加上。
这时如果搞出一个点S表示白,T表示黑,把数组中每个点拍在图上,定义与S之间有边相连的点为白点,与T之间有边相连的点为黑色,
这题就可以转换成一个最小割问题。
从S连过来的边容量为,连向T的边容量为(注意方向),
然后这个要求一堆点为黑色的条件怎么处理呢?
可以建一个虚点(相应地,数组中的点对应图上的点为实点),有一条容量为的边连向T,因为根据要求,如果该边没被割,虚点顺利连向T,那么对应必须为黑点的若干个实点也必须有边连向T,所以可以从每个点建立一条容量为INF的边连向虚点。因为容量为极大值,这种边不可能包含在最小割中,也就无法被割。
至此我们跑一个最大流Dinic求出最小割,然后用边容量的总和(除了INF的边)减去它不久解决了?
然而这题范围很不友好,,按照上面的建图法,虽然点数是级别,但是边数;
空间也不友好,每个测试点只有48MB,只好小心翼翼地开int。。
所以我们考虑通过多建些虚点来减少边的数量,具体由很多种做法,光分块就不止一种。
我只介绍一种很稳妥的做法,建虚点主席树。
具体来说,把所有a、l、r的值离散化过后,对每个前缀(1≤j≤i)的所有建立权值线段树,线段树上的每个区间代表的是图中的一个虚点,
我们先定义这种虚点为区间虚点(为了方便,前面建立的有容量为的边连向T的虚点为条件虚点),那么树上区间(l,r)对应的区间虚点必须满足所有的 j 对应图上的实点直接或经其它区间虚点间接连INF边连向它。
这句话有点长,但是绝对能看懂。为了满足这个条件,只需要把左儿子和右儿子区间对应的虚点连向它,而满足条件的实点连向叶节点,
因为 和 是等效的,所以每次在树上找到()对应的若干个区间虚点,代替原本对应必须为黑点的若干个实点连向我们建立的条件虚点,由于最多对应有个区间,最多新建条边,
然后每棵树B我们用主席树动态开点建立,每次最多新建个点,条边,所以图上总点数不超过,总边数不超过(C、D为<10的常数),空间不会炸,Dinic也刚好跑得过。
代码
多加了几个没必要的优化,看得懂就行
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<climits>
#include<map>
#define ll long long
#define MAXN 400005 //边数点数大概是这个数量级
#define mst0(x) memset(x,0,sizeof(x))
#define INF 0x3f3f3f3f
using namespace std;
inline ll read(){
ll x=0;bool f=1;char s=getchar();
while((s<'0'||s>'9')&&s>0){if(s=='-')f^=1;s=getchar();}
while(s>='0'&&s<='9')x=(x<<1)+(x<<3)+s-'0',s=getchar();
return f?x:-x;
}
int n,IN,N;
int in[5005][6],SUM;
map<int,int>mp;
int root[MAXN],NN,XP,R;
int f[MAXN];
int d[MAXN],cur[MAXN];
struct edge{
int v,id;edge(){}
edge(int V,int I){v=V,id=I;}
};
vector<edge>G[MAXN];
queue<int>q;
bool ct[MAXN];
inline bool bfs(int S,int T){
for(int i=0,lm=min(XP,MAXN-5);i<=lm;i++)d[i]=-1;
q.push(S),d[S]=0;
while(!q.empty()){
int u=q.front();q.pop();
for(int i=0;i<G[u].size();i++){
int v=G[u][i].v,a=G[u][i].id;
if(ct[v]&&f[a]>0&&d[v]<0)d[v]=d[u]+1,q.push(v);
}
}
return d[T]>=0;
}
inline int dfs(int x,int lim,int T){
if(x==T)return lim;
int res=lim;
for(int i=cur[x];i<G[x].size()&&res>0;i++){
cur[x]=i; //当前弧优化
int v=G[x][i].v,a=G[x][i].id;
if(ct[v]&&f[a]>0&&d[v]==d[x]+1){
int ad=dfs(v,min(res,f[a]),T);
f[a]-=ad,f[a^1]+=ad,res-=ad;
}
}
if(lim==res)d[x]=-1; //吔屎优化
return lim-res;
}
inline int dinic(int S,int T){
int res=0;
while(bfs(S,T)){
for(int i=0,lm=min(XP,MAXN-5);i<=lm;i++)cur[i]=0;
while(int ad=dfs(S,INF,T))res+=ad;
}
return res;
}
inline void addedge(int u,int v,int w){
if(w<INF)SUM+=w;
f[IN]=w,f[IN^1]=0;
G[u].push_back(edge(v,IN));
G[v].push_back(edge(u,IN^1));
IN+=2;
}
struct itn{
int ls,rs,id;
}t[MAXN];
inline void add(int x,int y,int l,int r,int u){
if(y>0)addedge(t[y].id,t[x].id,INF); //把先前点y的信息通过连边转过来
if(l==r){addedge(u,t[x].id,INF);return;}
int mid=(l+r)>>1;
if(in[u][0]<=mid){
t[x].rs=t[y].rs,t[x].ls=++NN,t[t[x].ls].id=++XP;//另一儿子无需连边,因为先前点y的信息已经转过来了
add(t[x].ls,t[y].ls,l,mid,u);
addedge(t[t[x].ls].id,t[x].id,INF);
}
else{
t[x].ls=t[y].ls,t[x].rs=++NN,t[t[x].rs].id=++XP;
add(t[x].rs,t[y].rs,mid+1,r,u);
addedge(t[t[x].rs].id,t[x].id,INF);
}
}
inline void sch(int x,int l,int r,int a,int b,int p){
if(x==0)return;
if(l==a&&r==b){addedge(t[x].id,p,INF);return;}
int mid=(l+r)>>1;
if(a<=mid)sch(t[x].ls,l,mid,a,min(mid,b),p);
if(b>mid)sch(t[x].rs,mid+1,r,max(a,mid+1),b,p);
}
inline void DFS(int x){
if(ct[x])return;ct[x]=1;
for(int i=0;i<G[x].size();i++)
if(G[x][i].id&1)DFS(G[x][i].v);
}
int main()
{
n=read(),N=(n<<1)+1;
for(int i=1;i<=n;i++){
for(int j=0;j<6;j++)in[i][j]=read();
SUM-=in[i][5];
mp[in[i][0]]=1,mp[in[i][3]]=1,mp[in[i][4]]=1;
}
map<int,int>::iterator it;
for(it=mp.begin();it!=mp.end();it++)it->second=++R;
for(int i=1;i<=n;i++)
in[i][0]=mp[in[i][0]],in[i][3]=mp[in[i][3]],in[i][4]=mp[in[i][4]];
XP=N;
for(int i=1;i<=n;i++){
addedge(0,i,in[i][2]+in[i][5]);
if(i==1)addedge(i,N,in[i][1]+in[i][5]);
else addedge(i,N,in[i][1]),
addedge(n+i,N,in[i][5]),addedge(i,n+i,INF);
sch(root[i-1],1,R,in[i][3],in[i][4],n+i);
if(i<n){
root[i]=++NN,t[root[i]].id=++XP;
add(root[i],root[i-1],1,R,i);
}
}
DFS(N); //把最终无法通向T的点删去,免跑
printf("%d\n",SUM-dinic(0,N));
return 0;
}