[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=4000004;
const int sizeOfEdge=2000002;
const int sizeOfPoint=320032;
const int sizeOfNote=10001;

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=0; T=n+1; V=n+1;
    for (int i=2;i<=n;i++)
    {
        P[i]=getint();
        son[P[i]].push_back(i);
    }
    for (int i=1;i<=n;i++)
        H[i]=getint();

    dfs(1);

    for (int i=1;i<=m;i++)
    {
        L=getint(), R=getint(), D=getint(), M=getint();
        link(S, ++V, M);
        query(t[D], 1, n, L, R, V);
    }

    putint(isap());

    return 0;
}
inline int min(int x, int y)
{
    return x<y?x:y;
}
inline int getint()
{
    register int num=0;
    register char ch;
    do ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num==0) stack[top=1]='0';
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    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, 0, e[v]);
    e[u]->pair=e[v]; e[v]->pair=e[u];
}
inline bool bfs()
{
    memset(h, 0xFF, sizeof(h)); h[T]=0;
    head=tail=0;
    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]==-1)
        {
            h[i->point]=h[u]+1;
            queue[tail++]=i->point;
        }
    }
    return h[S]>-1;
}
inline int isap()
{
    int flow=0;
    int hmin=0;

    if (!bfs()) return 0;

    memcpy(r, e, sizeof(e));
    memset(p, 0, 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]+1!=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]+1<hmin)
            {
                r[u]=j;
                hmin=h[j->point]+1;
            }
            ++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)>>1;
        if (p<=m) insert(t->l, l, m, p, v), link(t->p, t->l->p, inf);
        else insert(t->r, m+1, 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)>>1;
        if (qr<=m) query(t->l, l, m, ql, qr, p);
        else if (ql>=m+1) query(t->r, m+1, r, ql, qr, p);
        else query(t->l, l, m, ql, m, p), query(t->r, m+1, r, m+1, qr, p);
    }
}
void dfs(int u)
{
    link(u, T, 1);
    insert(t[u], 1, n, H[u], u);
    for (unsigned int i=0;i<son[u].size();i++)
    {
        dfs(son[u][i]);
        t[u]=merge(t[u], t[son[u][i]]);
    }
}