SPOJ 6779 Can you answer these queries VII

SPOJ_6779

    这个题目和GSS1的思想是一样的，只不过由于变成了树，所以可以先用树链剖分先将树划分成若干棵线段树再进行求解。

    另外我的代码写得确实比较挫，推荐一份效率比较高的用动态树写的代码：http://ideone.com/wA3Pr。

View Code // 轻重边树链剖分

#include<stdio.h>

#include<string.h>

#define MAXD 100010

#define MAXM 200010

#define INF 0x3f3f3f3f

int N, a[MAXD], mc[4 * MAXD], lc[4 * MAXD], rc[4 * MAXD], to[4 * MAXD], sum[4 * MAXD];

int first[MAXD], e, next[MAXM], v[MAXM];

int q[MAXD], fa[MAXD], dep[MAXD], size[MAXD], son[MAXD], top[MAXD], w[MAXD], cnt;

void Swap(int &x, int &y)

{

    int t;

    t = x, x = y, y = t;

}

int Max(int x, int y)

{

    return x > y ? x : y;

}

void add(int x, int y)

{

    v[e] = y;

    next[e] = first[x], first[x] = e ++;

}

void pushdown(int cur, int x, int y)

{

    if(to[cur] != INF)

    {

        int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;

        to[ls] = to[rs] = to[cur];

        sum[ls] = (mid - x + 1) * to[cur], sum[rs] = (y - mid) * to[cur];

        mc[ls] = lc[ls] = rc[ls] = to[cur] > 0 ? sum[ls] : to[cur];

        mc[rs] = lc[rs] = rc[rs] = to[cur] > 0 ? sum[rs] : to[cur];

        to[cur] = INF;

    }

}

void update(int cur, int x, int y)

{

    int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;

    sum[cur] = sum[ls] + sum[rs];

    mc[cur] = Max(Max(mc[ls], mc[rs]), rc[ls] + lc[rs]);

    lc[cur] = Max(lc[ls], sum[ls] + lc[rs]);

    rc[cur] = Max(rc[rs], sum[rs] + rc[ls]);

}

void refresh(int cur, int x, int y, int s, int t, int v)

{

    int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;

    if(x >= s && y <= t)

    {

        to[cur] = v;

        sum[cur] = v * (y - x + 1);

        mc[cur] = lc[cur] = rc[cur] = v > 0 ? sum[cur] : v;

        return ;

    }

    pushdown(cur, x, y);

    if(mid >= s)

        refresh(ls, x, mid, s, t, v);

    if(mid + 1 <= t)

        refresh(rs, mid + 1, y, s, t, v);

    update(cur, x, y);

}

int Search(int cur, int x, int y, int s, int t, int flag, int &ans, int &ts, int &tc, int tflag)

{

    int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;

    if(x >= s && y <= t)

    {

        ans = Max(ans, mc[cur]);

        tc = Max(tc, ts + (tflag == 0 ? lc[cur] : rc[cur]));

        ts += sum[cur];

        return flag == 0 ? lc[cur] : rc[cur];

    }

    pushdown(cur, x, y);

    if(mid >= t)

        return Search(ls, x, mid, s, t, 0, ans, ts, tc, tflag);

    else if(mid + 1 <= s)

        return Search(rs, mid + 1, y, s, t, 1, ans, ts, tc, tflag);

    else

    {

        int ln, rn;

        if(tflag == 0)

            ln = Search(ls, x, mid, s, t, 1, ans, ts, tc, tflag), rn = Search(rs, mid + 1, y, s, t, 0, ans, ts, tc, tflag);

        else

            rn = Search(rs, mid + 1, y, s, t, 0, ans, ts, tc, tflag), ln = Search(ls, x, mid, s, t, 1, ans, ts, tc, tflag);

        ans = Max(ans, ln + rn);

        if(flag == 0)

            return Max(lc[ls], sum[ls] + rn);

        else

            return Max(rc[rs], sum[rs] + ln);

    }

}

void prepare()

{

    int i, j, k, x, rear = 0;

    q[rear ++] = 1;

    dep[1] = 1, fa[1] = 0;

    for(i = 0; i < rear; i ++)

    {

        x = q[i];

        for(j = first[x]; j != -1; j = next[j])

            if(v[j] != fa[x])

            {

                dep[v[j]] = dep[x] + 1;

                fa[v[j]] = x;

                q[rear ++] = v[j];

            }

    }

    size[0] = 0;

    for(i = rear - 1; i >= 0; i --)

    {

        x = q[i];

        son[x] = 0, size[x] = 1;

        for(j = first[x]; j != -1; j = next[j])

            if(v[j] != fa[x])

            {

                size[x] += size[v[j]];

                if(size[v[j]] > size[son[x]])

                    son[x] = v[j];

            }

    }

    memset(top, 0, sizeof(top));

    cnt = 0;

    for(i = 0; i < rear; i ++)

    {

        x = q[i];

        if(!top[x])

        {

            j = x;

            while(j != 0)

                top[j] = x, w[j] = ++ cnt, j = son[j];

        }

    }

}

void init()

{

    int i, j, k, x, y;

    for(i = 1; i <= N; i ++)

        scanf("%d", &a[i]);

    memset(first, -1, sizeof(first));

    e = 0;

    for(i = 1; i < N; i ++)

    {

        scanf("%d%d", &x, &y);

        add(x, y), add(y, x);

    }

    prepare();

    memset(to, 0x3f, sizeof(to));

    for(i = 1; i <= N; i ++)

        refresh(1, 1, N, w[i], w[i], a[i]);

}

void query(int x, int y)

{

    int fx = top[x], fy = top[y], cx, cy, ans, ts, tc;

    cx = cy = ans = 0;

    while(fx != fy)

    {

        if(dep[fx] > dep[fy])

            Swap(fx, fy), Swap(x, y), Swap(cx, cy);

        ts = tc = 0;

        Search(1, 1, N, w[fy], w[y], 0, ans, ts, tc, 1);

        ans = Max(ans, tc + cy);

        ts = tc = 0;

        Search(1, 1, N, w[fy], w[y], 0, ans, ts, tc, 0);

        cy = Max(ts + cy, tc);

        y = fa[fy], fy = top[y];

    }

    if(dep[x] > dep[y])

        Swap(x, y), Swap(cx, cy);

    ts = tc = 0;

    Search(1, 1, N, w[x], w[y], 0, ans, ts, tc, 0);

    ans = Max(ans, tc + cx);

    ts = tc = 0;

    Search(1, 1, N, w[x], w[y], 0, ans, ts, tc, 1);

    ans = Max(ans, tc + cy);

    ans = Max(ans, cx + ts + cy);

    printf("%d\n", ans);

}

void change(int x, int y, int v)

{

    int fx = top[x], fy = top[y];

    while(fx != fy)

    {

        if(dep[fx] > dep[fy])

            Swap(x, y), Swap(fx, fy);

        refresh(1, 1, N, w[fy], w[y], v);

        y = fa[fy], fy = top[y];

    }

    if(dep[x] > dep[y])

        Swap(x, y);

    refresh(1, 1, N, w[x], w[y], v);

}

void solve()

{

    int i, j, a, b, c, op, q;

    scanf("%d", &q);

    for(i = 0; i < q; i ++)

    {

        scanf("%d%d%d", &op, &a, &b);

        if(op == 1)

            query(a, b);

        else

        {

            scanf("%d", &c);

            change(a, b, c);

        }

    }

}

int main()

{

    while(scanf("%d", &N) == 1)

    {

        init();

        solve();

    }

    return 0;

}

 

    就这个题目而言，我写的link-cut-tree的代码要比树链剖分快一些，大概有这么两个原因：①树链剖分或者线段树更新的部分我写得太挫了；②用树链剖分写的话，在求解最大连续和的时候本身就比较麻烦，而link-cut-tree求解的时候则很方便。

View Code // link-cut-tree