COGS 1583. [POJ3237]树的维护

二次联通门 : COGS 1583. [POJ3237]树的维护

/*
    COGS 1583. [POJ3237]树的维护

    树链剖分 + 边权化点权
    线段树 单点修改 +  区间取相反数 + 查询区间最大

    对于区间取相反数
        考虑在线段树中维护两个值
        一个区间最大, 一个区间最小
        对于更改, 只需把区间最大与最小分别取相反数后交换即可

        然后对于标记, 由于对区间连续取反两次相当于不变
        则只需开一个bool 标记, 每次放标记时对标记取反即可

*/
#include <cstdio>

#define INF 1e7
#define Max 20005

inline int max (int a, int b)
{
    return a > b ? a : b;
}

inline int min (int a, int b)
{
    return a < b ? a : b;
}

inline int swap (int &a, int &b)
{
    int now = a;
    a = b;
    b = now;
}

void read (int &now)
{
    now = ;
    bool temp = false;
    register char word = getchar ();
    while (word < '' || word > '')
    {
        if (word == '-')
            temp = true;
        word = getchar ();
    }
    while (word <= '' && word >= '')
    {
        now = now *  + word - '';
        word = getchar ();
    }
}

int tree_value[Max];

class Segment_Tree_Type
{
    private :

        struct Tree_Date
        {
            int l;
            int r;
            int Maxn;
            int Minn;
            int Mid;
            bool Flandre_Scarlet;
        }
        tree[Max << ];

    public :

        void Build (int l, int r, int now)
        {
            tree[now].l = l;
            tree[now].r = r;
            if (l == r)
            {
                tree[now].Maxn = tree_value[l];
                tree[now].Minn = tree_value[r];
                return ;
            }
            tree[now].Mid = l + r >> ;
            Build (l, tree[now].Mid, now << );
            Build (tree[now].Mid + , r, now <<  | );
            tree[now].Maxn = max (tree[now << ].Maxn, tree[now <<  | ].Maxn);
            tree[now].Minn = min (tree[now << ].Minn, tree[now <<  | ].Minn);
        }

        int Query_Section (int l, int r, int now)
        {
            if (tree[now].l == l && tree[now].r == r)
                return tree[now].Maxn;
            if (tree[now].Flandre_Scarlet)
            {
                tree[now << ].Maxn = -tree[now << ].Maxn;
                tree[now <<  | ].Maxn = -tree[now <<  | ].Maxn;
                tree[now << ].Minn = -tree[now << ].Minn;
                tree[now <<  | ].Minn = -tree[now <<  | ].Minn;
                swap (tree[now << ].Maxn, tree[now << ].Minn);
                tree[now << ].Flandre_Scarlet = !tree[now << ].Flandre_Scarlet;
                swap (tree[now <<  | ].Maxn, tree[now <<  | ].Minn);
                tree[now <<  | ].Flandre_Scarlet = !tree[now <<  | ].Flandre_Scarlet;
                tree[now].Flandre_Scarlet = false;
            }
            tree[now].Maxn = max (tree[now << ].Maxn, tree[now <<  | ].Maxn);
            tree[now].Minn = min (tree[now << ].Minn, tree[now <<  | ].Minn);
            if (r <= tree[now].Mid)
                return Query_Section (l, r, now << );
            else if (l > tree[now].Mid)
                return Query_Section (l, r, now <<  | );
            else
                return max (Query_Section (l, tree[now].Mid, now << ), Query_Section (tree[now].Mid + , r, now <<  | ));
        }

        void Change_Section (int l, int r, int now)
        {
            if (tree[now].l == l && tree[now].r == r)
            {
                tree[now].Maxn = -tree[now].Maxn;
                tree[now].Minn = -tree[now].Minn;
                swap (tree[now].Maxn, tree[now].Minn);
                tree[now].Flandre_Scarlet = !tree[now].Flandre_Scarlet;
                return ;
            }
            if (tree[now].Flandre_Scarlet)
            {
                tree[now << ].Maxn = -tree[now << ].Maxn;
                tree[now <<  | ].Maxn = -tree[now <<  | ].Maxn;
                tree[now << ].Minn = -tree[now << ].Minn;
                tree[now <<  | ].Minn = -tree[now <<  | ].Minn;
                swap (tree[now << ].Maxn, tree[now << ].Minn);
                tree[now << ].Flandre_Scarlet = !tree[now << ].Flandre_Scarlet;
                swap (tree[now <<  | ].Maxn, tree[now <<  | ].Minn);
                tree[now <<  | ].Flandre_Scarlet = !tree[now <<  | ].Flandre_Scarlet;
                tree[now].Flandre_Scarlet = false;
            }
            if (r <= tree[now].Mid)
                Change_Section (l, r, now << );
            else if (l > tree[now].Mid)
                Change_Section (l, r, now <<  | );
            else
            {
                Change_Section (l, tree[now].Mid, now << );
                Change_Section (tree[now].Mid + , r, now <<  | );
            }
            tree[now].Maxn = max (tree[now << ].Maxn, tree[now <<  | ].Maxn);
            tree[now].Minn = min (tree[now << ].Minn, tree[now <<  | ].Minn);
        }

        void Change_Single (int pos, int now, int number)
        {
            if (tree[now].l == tree[now].r)
            {
                tree[now].Maxn = number;
                tree[now].Minn = number;
                return;
            }
            if (tree[now].Flandre_Scarlet)
            {
                tree[now << ].Maxn = -tree[now << ].Maxn;
                tree[now <<  | ].Maxn = -tree[now <<  | ].Maxn;
                tree[now << ].Minn = -tree[now << ].Minn;
                tree[now <<  | ].Minn = -tree[now <<  | ].Minn;
                swap (tree[now << ].Maxn, tree[now << ].Minn);
                tree[now << ].Flandre_Scarlet = !tree[now << ].Flandre_Scarlet;
                swap (tree[now <<  | ].Maxn, tree[now <<  | ].Minn);
                tree[now <<  | ].Flandre_Scarlet = !tree[now <<  | ].Flandre_Scarlet;
                tree[now].Flandre_Scarlet = false;
            }
            if (pos <= tree[now].Mid)
                Change_Single (pos, now << , number);
            else
                Change_Single (pos, now <<  | , number);
            tree[now].Maxn = max (tree[now << ].Maxn, tree[now <<  | ].Maxn);
            tree[now].Minn = min (tree[now << ].Minn, tree[now <<  | ].Minn);
        }
};

Segment_Tree_Type Segment_Tree;

class Tree_Chain_Type
{
    private :

        struct Edge_Date
        {
            int to;
            int next;
            int key;
            int from;
        }
        edge[Max << ];

        struct Point_Date
        {
            int size;
            int father;
            int up_chain_point;
            int deep;
            int segment_tree_pos;
        }
        point[Max];

        int Edge_Count;
        int edge_list[Max];
        int Segment_Pos;
        int Count;

    public :

        inline int Add_Edge (int from, int to, int dis)
        {
            Edge_Count++;
            edge[Edge_Count].to = to;
            edge[Edge_Count].from = from;
            edge[Edge_Count].next = edge_list[from];
            edge_list[from] = Edge_Count;
            edge[Edge_Count].key = dis;
            Edge_Count++;
            edge[Edge_Count].to = from;
            edge[Edge_Count].from = to;
            edge[Edge_Count].next = edge_list[to];
            edge_list[to] = Edge_Count;
            edge[Edge_Count].key = dis;
        }

        void Dfs_1 (int now, int father)
        {
            int pos = Count++;
            point[now].father = father;
            point[now].deep = point[father].deep + ;
            for (int i = edge_list[now]; i; i = edge[i].next)
                if (edge[i].to != father)
                    Dfs_1 (edge[i].to, now);
            point[now].size = Count - pos;
        }

        void Dfs_2 (int now, int chain)
        {
            point[now].segment_tree_pos = ++Segment_Pos;
            for (int i = edge_list[now]; i; i = edge[i].next)
                if (edge[i].to == point[now].father)
                {
                    tree_value[Segment_Pos] = edge[i].key;
                    break;
                }
            point[now].up_chain_point = chain;
            int pos = ;
            for (int i = edge_list[now]; i; i = edge[i].next)
                if (!point[edge[i].to].segment_tree_pos && point[edge[i].to].size >  point[pos].size)
                    pos = edge[i].to;
            if (!pos)
                return;
            Dfs_2 (pos, chain);
            for (int i = edge_list[now]; i; i = edge[i].next)
                if (!point[edge[i].to].segment_tree_pos && edge[i].to != pos)
                    Dfs_2 (edge[i].to, edge[i].to);
        }

        int Query_chain (int x, int y)
        {
            int Answer = -INF;
            while (point[x].up_chain_point != point[y].up_chain_point)
            {
                if (point[point[x].up_chain_point].deep < point[point[y].up_chain_point].deep)
                    swap (x, y);
                Answer = max (Answer, Segment_Tree.Query_Section (point[point[x].up_chain_point].segment_tree_pos, point[x].segment_tree_pos, ));
                x = point[point[x].up_chain_point].father;
            }
            if (point[x].deep > point[y].deep)
                swap (x, y);
            if (x != y)
                Answer = max (Answer, Segment_Tree.Query_Section (point[x].segment_tree_pos + , point[y].segment_tree_pos, ));
            return Answer;
        }

        void Change_chain (int x, int y)
        {
            while (point[x].up_chain_point != point[y].up_chain_point)
            {
                if (point[point[x].up_chain_point].deep < point[point[y].up_chain_point].deep)
                    swap (x, y);
                Segment_Tree.Change_Section (point[point[x].up_chain_point].segment_tree_pos, point[x].segment_tree_pos, );
                x = point[point[x].up_chain_point].father;
            }
            if (point[x].deep > point[y].deep)
                swap (x, y);
            if (x != y)
                Segment_Tree.Change_Section (point[x].segment_tree_pos + , point[y].segment_tree_pos, );
        }

        void Change_Single (int x, int number)
        {
            x = (x << ) - ;
            int pos = point[edge[x].to].deep > point[edge[x].from].deep ? point[edge[x].to].segment_tree_pos : point[edge[x].from].segment_tree_pos;
            Segment_Tree.Change_Single (pos, , number);
            return ;
        }
};

Tree_Chain_Type Make;

int main (int argc, char *argv[])
{
    freopen ("maintaintree.in", "r", stdin);
    freopen ("maintaintree.out", "w", stdout);
    int N;
    read (N);
    int x, y, z;
    for (int i = ; i < N; i++)
    {
        read (x);
        read (y);
        read (z);
        Make.Add_Edge (x, y, z);
    }
    Make.Dfs_1 (, );
    Make.Dfs_2 (, );
    Segment_Tree.Build (, N, );
    char type[];
    while (scanf ("%s", type) && type[] != 'D')
    {
        read (x);
        read (y);
        if (type[] == 'Q')
            printf ("%d\n", Make.Query_chain (x, y));
        else if (type[] == 'C')
            Make.Change_Single (x, y);
        else
            Make.Change_chain (x, y);
    }
    return ;
}