HZOI帝国2019欢乐时刻

前言：#

update 只是恢复一下原来手残删掉的博客，不是在水，嘤嘤嘤#

update 以后改成Stack，但是之前的就懒得改了。。。 by 10.31#

为了窝的访问量大家的好心情，模仿学长搞了一个这个东西#

大家有什么有意思的事可以积极投稿~~#

以下为正文：怎么突然某乎了起来#

爷直接诈尸好吧

ljh gyp

你看小割的头像嵌在背景上就莫名的生草。。。

建议改成： h z o i 萌新群#

硬核伪代码：

copy

copy#include <bits/stdc++.h>

#define 里面的 ::
#define 的 ->
#define 里的 .
#define 空 void
#define 循环 for
#define 如果 if
#define 否则 else
#define 结构体 struct
#define 命名空间 namespace
#define 新建 new
#define 布尔值 bool
#define 整数 int
#define 只读的 const
#define 返回 return
#define 字符 char
#define 使用 using
#define 自己 this
#define 真 true
#define 假 false
#define 主函数 main
#define 标准库 std
#define 交换 swap
#define 取较大值 max
#define 格式化输入 scanf
#define 格式化输出 printf
#define 标准错误流 cerr
#define 换行 endl
#define 填充 fill
#define 取随机数 rand
#define 等于 ==
#define 设为 =
#define 或者 ||
#define 的第 [
#define 共 [
#define 个 ]
#define 零 0
#define 一 1
#define 二 2
#define 两 2
#define 十 10

#define 艹(甲) 标准库 里面的 标准错误流 << #甲 << " = " << 甲 << 标准库 里面的 换行

只读的 整数 点的最大数量 设为 30031, 无穷大 设为 0x3FFFFFFF;

命名空间 动态树 {
    结构体 节点 {
        节点 *孩子 共 两 个, *父亲;
        布尔值 翻转;
        整数 乙, 甲, 丙;

        节点() {}
        节点(节点 *左子节点, 节点 *右子节点, 节点 *父亲, 整数 数值乙, 整数 数值甲, 整数 数值丙) : 父亲(父亲), 翻转(假), 乙(数值乙), 甲(数值甲), 丙(数值丙) {
            孩子 的第 零 个 设为 左子节点;
            孩子 的第 一 个 设为 右子节点;
        }

        空 标记下传() {
            如果(翻转) {
                孩子 的第 零 个 的 翻转 ^= 一;
                孩子 的第 一 个 的 翻转 ^= 一;
                标准库 里面的 交换(孩子 的第 零 个, 孩子 的第 一 个);
                翻转 设为 零;
            }
        }

        空 更新() {
            甲 设为 标准库 里面的 取较大值(乙,
                    标准库 里面的 取较大值(孩子 的第 零 个 的 甲, 孩子 的第 一 个 的 甲));
            丙 设为 乙 + 孩子 的第 零 个 的 丙 + 孩子 的第 一 个 的 丙;
        }

        布尔值 不是根() {
            返回 父亲 的 孩子 的第 零 个 等于 自己 或者 父亲 的 孩子 的第 一 个 等于 自己;
        }
    } *空节点 设为 新建 节点(零, 零, 零, 零, -无穷大, 零), *不知道干啥的点;

    空 旋转(节点 *甲) {
        甲 的 标记下传();
        节点 *乙 设为 甲 的 父亲;
        整数 左 设为 乙 的 孩子 的第 一 个 等于 甲, 右 设为 左 ^ 一;
        乙 的 孩子 的第 左 个 设为 甲 的 孩子 的第 右 个;
        甲 的 孩子 的第 右 个 的 父亲 设为 乙;
        甲 的 父亲 设为 乙 的 父亲;
        如果(乙 的 不是根())
        乙 的 父亲 的 孩子 的第 乙 的 父亲 的 孩子 的第 一 个 等于 乙 个 设为 甲;
        甲 的 孩子 的第 右 个 设为 乙;
        乙 的 父亲 设为 甲;
        乙 的 更新();
    }

    空 伸展(节点 *甲) {
        甲 的 标记下传();
        循环(; 甲 的 不是根(); 旋转(甲)) {
            节点 *乙 设为 甲 的 父亲, *丙 设为 乙 的 父亲;
            如果(乙 的 不是根())
            丙 的 标记下传();
            乙 的 标记下传();
            如果(乙 的 不是根())
            旋转((甲 等于 乙 的 孩子 的第 一 个) ^ (乙 等于 丙 的 孩子 的第 一 个) ? 甲 : 乙);
        }
        甲 的 更新();
    }

    空 访问(节点 *甲) {
        循环(节点 *乙 设为 空节点; 甲 != 空节点;
               (乙 设为 甲) 的 更新(), 甲 设为 甲 的 父亲) 伸展(甲),
               甲 的 孩子 的第 一 个 设为 乙;
    }

    空 转到根(节点 *甲) {
        访问(甲);
        伸展(甲);
        甲 的 翻转 ^= 一;
        甲 的 标记下传();
    }
}  // 命名空间 动态树

使用 动态树 里面的 空节点;
使用 动态树 里面的 节点;

节点 甲 共 点的最大数量 个;

空 修改(整数 u, 整数 乙) {
    动态树 里面的 伸展(甲 + u);
    甲 的第 u 个 里的 乙 设为 乙;
    甲 的第 u 个 里的 更新();
}

整数 查询总和(整数 u, 整数 乙) {
    动态树 里面的 转到根(甲 + u);
    动态树 里面的 访问(甲 + 乙);
    动态树 里面的 伸展(甲 + 乙);
    返回 甲 的第 乙 个 里的 丙;
}

整数 查询最大值(整数 u, 整数 乙) {
    动态树 里面的 转到根(甲 + u);
    动态树 里面的 访问(甲 + 乙);
    动态树 里面的 伸展(甲 + 乙);
    返回 甲 的第 乙 个 里的 甲;
}

整数 节点数量 设为 零, 查询数量 设为 零;

整数 主函数() {
    动态树 里面的 不知道干啥的点 设为 甲;
    格式化输入("%d", &节点数量);
    标准库 里面的 填充(甲, 甲 + 节点数量 + 一, 节点(空节点, 空节点, 空节点, 零, 零,
                               零));
    循环(整数 第几个 设为 一; 第几个 < 节点数量; 第几个++) {
        整数 节点一编号 设为 零, 节点二编号 设为 零;
        格式化输入("%d%d", &节点一编号, &节点二编号);
        动态树 里面的 转到根(甲 + 节点一编号);
        甲 的第 节点一编号 个 里的 父亲 设为 甲 + 节点二编号;
    }
    循环(整数 第几个 设为 一; 第几个 <= 节点数量; 第几个++) {
        整数 节点一编号 设为 零;
        格式化输入("%d", &节点一编号);
        修改(第几个, 节点一编号);
    }
    循环(格式化输入("%d", &查询数量); 查询数量--;) {
        字符 操作 共 十 个;
        整数 节点一编号 设为 零, 节点二编号 设为 零;
        格式化输入("%s%d%d", 操作, &节点一编号, &节点二编号);
        如果(操作 的第 一 个 等于 'H')
        修改(节点一编号, 节点二编号);
        否则
        格式化输出("%d\n", 操作 的第 一 个 等于 'S' ? 查询总和(节点一编号,
                        节点二编号) : 查询最大值(节点一编号, 节点二编号));
        动态树 里面的 转到根(甲 + (取随机数() % 节点数量 + 一));
    }
    返回 零;
}