[JLOI2015]城池攻占 左偏树

表示调这道题已经调到失智了。。。 因为昨天刚写完线段树2，所以pushdown就写得和线段树2一模一样，，，，于是，，，成功的在pushdown的地方，，，各种错

下面讲做法： 首先我们可以观察到每个骑士都是独立的，因此对于每个城池我们可以建一个堆，堆中维护的是在这个城池的骑士。

维护一个小根堆，所以如果堆顶的骑士攻击力不够的话，就可以直接pop掉，并且给城池死亡人数统计++（dead），这样用while pop完后，堆里的骑士就都是可以占领这个城池的了，

由于下面的骑士可以上来，所以这个堆要支持合并，所以我们用左偏树

因为pop完后剩下的都是合法的，所以这个时候我们就可以对剩下的骑士进行修改了。但是我们观察到，骑士很多，城池也很多，直接修改显然不太妥当。于是我们借鉴线段树的lazy标记，但是由于这里有乘法也有加法，所以我们维护两个标记，一个mul（乘法标记）,一个lazy(加法标记），

由于(x+h)q=xq+hq,所以我们可以把h当做lazy，x当做当前值，q是mul,所以我们更改和下传乘法标记的时候，要同时把lazy也=mul，

这时lazy==hq,mul==q,因此我们要得到xq+h*q这个结果，我们需要先乘后加

deadin[i]代表骑士i死在哪里了，dead代表死在这个城池的人数，keep是城市的生命值，其他数组应该都好懂了

因为我们观察到如果还要下传一个标记won来标记骑士又占领了一个城池的话显然是不划算的，因为mul和lazy之所以有必要就是因为过程中要用到，而won标记仅仅是最后要用而已，并且由于骑士的前进路径是一条链，所以我们直接用死亡城市深度-出发城市深度就可以得到攻占几座城了，如果没死的话死亡城市就是0，因此为了维护死亡城市-出发城市这个式子的正确性，我们的deep统计从1开始

如果还有不懂的就看代码吧，还是有少量注释的

推荐写之前先写线段树2（luogu3373），有利于理解如何同时维护乘法和加法标记，这里的标记本质上是一样的，但是注意不要像我一样，写完线段树2，pushdown就全写成线段树版本的，，，，于是就各种错，，，

下面的输出格式是为了方便我调试改的，所以。。。。

写的可能比较复杂？？？

表示并不知道为什么我的代码一直比别人长。。。。

-------2018.10.11-------优化了代码格式

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 300050
#define LL long long
#define D printf("line in %d\n",__LINE__);
int n, m;
int date[AC], Next[AC], Head[AC], tot, cnt;//前向星
LL v[AC], keep[AC];
int deep[AC], a[AC], dead[AC], deadin[AC];//城池属性, 答案
int b[AC], root[AC];

inline LL read()
{
    LL x = 0; char c = getchar(); bool z = false;
    while(c > '9' || c < '0') 
    {
        if(c == '-') z = true;
        c = getchar();
    }
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    if(!z) return x;
    else return -x;
}

inline void add(int f, int w)
{
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot;
}

struct left_heap
{
    LL s[AC], mul[AC], lazy[AC];//骑士属性和标记,error!!!标记也要LL啊啊啊啊啊啊啊啊，因为标记也可能乘到很大啊，比如lazy和mul各种乘之类的
    int l[AC], r[AC], num[AC];

    inline void pushdown(int x)
    {
        int ll = l[x], rr = r[x];//error!!!这又不是线段树啊！！！！干嘛乘2啊 
        if(!mul[x]) return ;//如果mul为0，说明没有这个堆，所以
        if(mul[x] != 1)
        {
            s[ll] *= mul[x], mul[ll] *= mul[x], lazy[ll] *= mul[x];//error!!!加法标记也要乘啊！！！
            s[rr] *= mul[x], mul[rr] *= mul[x], lazy[rr] *= mul[x];
            mul[x] = 1;
        }
        if(lazy[x])
        {
            s[ll] += lazy[x], lazy[ll] += lazy[x];
            s[rr] += lazy[x], lazy[rr] += lazy[x];
            lazy[x]=0;//error!!!不是线段树啊，，，，r,l不是区间了
        }
    }

    inline void change_add(int x, int k)
    {
        if(!x) return ;
        s[x] += k, lazy[x] += k;
    }

    inline void change_mul(int x, int k)
    {
        if(!x) return ;
        s[x] *= k, lazy[x]*=k, mul[x]*=k;
    }

    int merge(int x, int y)
    {
        pushdown(x), pushdown(y);
        if(!x || !y) return x + y;
    //  pushdown(x),pushdown(y);
        if(s[x] > s[y]) swap(x, y);
        r[x] = merge(r[x], y);
        swap(l[x], r[x]);
        return x;
    }

    void pop(int &x)
    {
        x=merge(l[x], r[x]);
    }

    inline void insert(int x, int k)
    {
        s[++cnt] = x, num[cnt] = k, mul[cnt] = 1;
        root[b[k]] = merge(cnt, root[b[k]]);
    }
}heap;

void DFS(int x)
{
/*  if(a[x]) heap.change_mul(root[x],v[x]);
    else heap.change_add(root[x],v[x]);
    if(!Head[x]) return ;//如果到叶节点就返回，因为没有儿子给它了
    */
    R now;
    for(R i = Head[x]; i; i = Next[i])
    {

        now = date[i], deep[now] = deep[x] + 1;
        DFS(now);
        root[x] = heap.merge(root[now], root[x]);
    }
    while(root[x] && heap.s[root[x]] < keep[x])
    {
        dead[x] ++;
        deadin[heap.num[root[x]]] = x;
        heap.pop(root[x]);
    }
    if(a[x]) heap.change_mul(root[x], v[x]);
    else heap.change_add(root[x], v[x]);
}

void pre()
{
    int aa;
    n = read(), m = read();
    deep[1] = 1;
    for(R i = 1; i <= n; i ++) keep[i] = read(), heap.mul[i] = 1;
    for(R i = 2; i <= n; i ++)
    {
        aa = read(), a[i] = read(), v[i] = read();
        add(aa, i);
    }
    for(R i = 1; i <= m; i ++)
    {
        aa = read(), b[i] = read();
    //  printf("%d %d\n",aa,b[i]);
        if(aa >= keep[b[i]])//如果第一座城池打得下才建堆
        {
            if(!root[b[i]])
            {
                root[b[i]] = ++cnt;//应该要给城池开堆,堆里存士兵，不然士兵在哪个城市有上面区别
                heap.num[cnt] = i, heap.s[cnt] = aa, heap.mul[cnt] = 1;//因为是给城池开的堆，所以就要存编号了
                //printf("%d\n",i);
            }
            else heap.insert(aa, i);
        }
        else dead[b[i]] ++, deadin[i] = b[i];//不然就别来了
    }
}

void work()
{
    for(R i = 1; i <= n; i ++) printf("%d\n", dead[i]);
    printf("\n");
    for(R i = 1; i <= m; i ++)
        printf("%d\n", deep[b[i]] - deep[deadin[i]]);
}

int main()
{
    freopen("in.in","r",stdin);
    pre();
    DFS(1);
    work();
    fclose(stdin);
    return 0;
}