[BZOJ 3681]Ariettad

终于是打完了 CH 上的数据结构专场了……

不过看样子还有一套 5555

传送门: http://ch.ezoj.tk/contest/CH%20Round%20%2351%20-%20Shinrein%E7%A5%AD%20%231

直接连边会 TLE。但是，连出去的点都是一个连续点集……

——于是我们机智的用了 “可合并线段树”（好，） 以空间换取时间

在网络流的图中塞一棵可持久化线段树进去，这样区间连边时就只会连 O(logn) 的边了

智商++，而且这道题让我重新认识了线段树的合并，真是受益匪浅~

不过——

我恨卡内存！！！

 #include <cstdio>
 #include <cstring>
 #include <vector>
 const int inf=0x7FFFFFFF;
 const int sizeOfSegmemt=;
 const int sizeOfEdge=;
 const int sizeOfPoint=;
 const int sizeOfNote=;
 
 int n, m;
 int P[sizeOfNote], H[sizeOfNote];
 std::vector<int> son[sizeOfPoint];
 inline int min(int, int);
 inline int getint();
 inline void putint(int);
 
 struct seg {int p; seg * l, * r;};
 seg memory_seg[sizeOfSegmemt], * port_seg=memory_seg;
 seg * t[sizeOfPoint];
 inline seg * newseg();
 void insert(seg *& , int, int, int, int);
 seg * merge(seg * , seg * );
 void query(seg * , int, int, int, int, int);
 void dfs(int);
 
 int S, T;
 int V, E;
 struct edge {int point, flow; edge * next, * pair;};
 edge memory_edge[sizeOfEdge], * port_edge=memory_edge;
 edge * e[sizeOfPoint];
 int h[sizeOfPoint], gap[sizeOfPoint];
 inline edge * newedge(int, int, edge * );
 inline void link(int, int, int);
 int head, tail, queue[sizeOfPoint];
 inline bool bfs();
 edge * r[sizeOfPoint], * p[sizeOfPoint];
 int aug[sizeOfPoint];
 inline int isap();
 
 int main()
 {
     int D, L, R, M;
 
     n=getint(), m=getint();
     S=; T=n+; V=n+;
     for (int i=;i<=n;i++)
     {
         P[i]=getint();
         son[P[i]].push_back(i);
     }
     for (int i=;i<=n;i++)
         H[i]=getint();
 
     dfs();
 
     for (int i=;i<=m;i++)
     {
         L=getint(), R=getint(), D=getint(), M=getint();
         link(S, ++V, M);
         query(t[D], , n, L, R, V);
     }
 
     putint(isap());
 
     return ;
 }
 inline int min(int x, int y)
 {
     return x<y?x:y;
 }
 inline int getint()
 {
     register int num=;
     register char ch;
     do ch=getchar(); while (ch<'' || ch>'');
     do num=num*+ch-'', ch=getchar(); while (ch>='' && ch<='');
     return num;
 }
 inline void putint(int num)
 {
     char stack[];
     register int top=;
     if (num==) stack[top=]='';
     for ( ;num;num/=) stack[++top]=num%+'';
     for ( ;top;top--) putchar(stack[top]);
     putchar('\n');
 }
 inline edge * newedge(int point, int flow, edge * next)
 {
     edge * ret=port_edge++;
     ret->point=point; ret->flow=flow; ret->next=next;
     return ret;
 }
 inline void link(int u, int v, int f)
 {
     e[u]=newedge(v, f, e[u]); e[v]=newedge(u, , e[v]);
     e[u]->pair=e[v]; e[v]->pair=e[u];
 }
 inline bool bfs()
 {
     memset(h, 0xFF, sizeof(h)); h[T]=;
     head=tail=;
     for (queue[tail++]=T;head<tail;head++)
     {
         int u=queue[head];
         gap[h[u]]++;
         for (edge * i=e[u];i;i=i->next) if (h[i->point]==-)
         {
             h[i->point]=h[u]+;
             queue[tail++]=i->point;
         }
     }
     return h[S]>-;
 }
 inline int isap()
 {
     int flow=;
     int hmin=;
 
     if (!bfs()) return ;
 
     memcpy(r, e, sizeof(e));
     memset(p, , sizeof(p));
     aug[S]=inf;
     for (int u=S;h[S]<V; )
     {
         if (u==T)
         {
             flow+=aug[T];
             for (edge * i=p[T];i;i=p[i->point])
                 i->pair->flow-=aug[T], i->flow+=aug[T], aug[i->point]-=aug[T];
             for (edge * i=p[T];i;i=p[i->point]) if (aug[i->point])
             {
                 u=i->point;
                 break;
             }
         }
 
         edge *& i=r[u];
         for ( ;i && (!i->flow || h[i->point]+!=h[u]);i=i->next);
         if (i)
         {
             p[i->point]=i->pair; aug[i->point]=min(aug[u], i->flow);
             u=i->point;
         }
         else
         {
             if (!--gap[h[u]]) break;
             hmin=V;
             for (edge * j=e[u];j;j=j->next) if (j->flow && h[j->point]+<hmin)
             {
                 r[u]=j;
                 hmin=h[j->point]+;
             }
             ++gap[h[u]=hmin];
             u=u==S?S:p[u]->point;
         }
     }
 
     return flow;
 }
 
 inline seg * newseg()
 {
     seg * ret=port_seg++;
     ret->p=++V; ret->l=ret->r=NULL;
     return ret;
 }
 void insert(seg *& t, int l, int r, int p, int v)
 {
     if (!t) t=newseg();
     if (l==r) link(t->p, v, inf);
     else
     {
         int m=(l+r)>>;
         if (p<=m) insert(t->l, l, m, p, v), link(t->p, t->l->p, inf);
         else insert(t->r, m+, r, p, v), link(t->p, t->r->p, inf);
     }
 }
 seg * merge(seg * x, seg * y)
 {
     if (!x) return y;
     if (!y) return x;
     seg * t=newseg();
     bool leaf=true;
     if ((t->l=merge(x->l, y->l))) link(t->p, t->l->p, inf), leaf=false;
     if ((t->r=merge(x->r, y->r))) link(t->p, t->r->p, inf), leaf=false;
     if (leaf) link(t->p, x->p, inf), link(t->p, y->p, inf);
     return t;
 }
 void query(seg * t, int l, int r, int ql, int qr, int p)
 {
     if (!t) return ;
     if (l==ql && r==qr) link(p, t->p, inf);
     else
     {
         int m=(l+r)>>;
         if (qr<=m) query(t->l, l, m, ql, qr, p);
         else if (ql>=m+) query(t->r, m+, r, ql, qr, p);
         else query(t->l, l, m, ql, m, p), query(t->r, m+, r, m+, qr, p);
     }
 }
 void dfs(int u)
 {
     link(u, T, );
     insert(t[u], , n, H[u], u);
     for (unsigned int i=;i<son[u].size();i++)
     {
         dfs(son[u][i]);
         t[u]=merge(t[u], t[son[u][i]]);
     }
 }

我恨卡内存++