Visual Studio 中文 C++ 编程
雾
#define 浮点型 double
#define 整型 int
#define 大整型 long long
#define 无符号 unsigned
#define 布尔型 bool
#define 内联 inline
#define 上取整 ceil
#define 返回 return
#define 如果 if
#define 否则 else
#define 大于等于 >=
#define 小于等于 <=
#define 大于 >
#define 小于 <
#define 等于 ==
#define 不等于 !=
#define 是 =
#define 加 +
#define 减 -
#define 自增 ++
#define 自减 --
#define 乘 *
#define 除以 /
#define 模 %
#define 按位异或 ^
#define 按位与 &
#define 按位或 |
#define 按位取反 ~
#define 取反 !
#define 逻辑与 &&
#define 逻辑或 ||
#define 加等于 +=
#define 减等于 -=
#define 乘等于 *=
#define 除等于 /=
#define 模等于 %=
#define 异或等于 ^=
#define 与等于 &=
#define 或等于 |=
#define 循环 for
#define 当型循环 while
#define 常量 const
#define 自动类型 auto
#define 读入 scanf
#define 输出 printf
#define 主函数 int main例1：
#include <iostream>
using namespace std;
主函数 ()
{
整型 甲, 乙;
输入("%d%d", &甲, &乙);
输出("%d\n", 甲 加 乙);
返回 0;
}例2：
#include <...>
using namespace std;
常量 整型 最大点数 = 220000;
常量 整型 正无穷 = 2147483647;
常量 浮点型 平衡常数 = 0.75;
整型 操作数, 节点数, 树根;
结构体 节点类型 { 整型 父, 子[2], 键值, 子树大小; } 点[最大点数];
整型 总和, 数组[最大点数];
内联 整型 快读()
{
整型 x = 0, f = 1; char ch = 0;
当型循环 (ch > '9' || ch < '0') { 如果 (ch == '-') f = -1; ch = getchar(); }
当型循环 (ch <= '9' && ch >= '0') { x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); }
返回 x * f;
}
内联 void 快写(整型 x)
{
如果 (x < 0) putchar('-'), x = -x;
如果 (x > 9) 快写(x / 10);
putchar(x % 10 + '0');
}
整型 平衡数(整型 x)
{
浮点型 big = max(点[点[x].子[0]].子树大小, 点[点[x].子[1]].子树大小);
返回 平衡常数 * 点[x].子树大小 >= big;
}
整型 建树(整型 l, 整型 r, 整型 父亲)
{
如果 (l > r) 返回 0;
整型 mid = (l + r) >> 1, x = 数组[mid];
点[x].父 = 父亲;
点[x].子[0] = 建树(l, mid - 1, x);
点[x].子[1] = 建树(mid + 1, r, x);
点[x].子树大小 = 点[点[x].子[0]].子树大小 + 点[点[x].子[1]].子树大小 + 1;
返回 x;
}
void 回收(整型 x)
{
如果 (点[x].子[0]) 回收(点[x].子[0]);
数组[++总和] = x;
如果 (点[x].子[1]) 回收(点[x].子[1]);
}
void 重建(整型 x)
{
整型 父亲 = 点[x].父;
总和 = 0, 回收(x);
整型 y = 建树(1, 总和, 父亲);
如果 (x == 树根) 树根 = y;
否则 点[父亲].子[点[父亲].子[1] == x] = y;
}
void 插入(整型 key_)
{
整型 x = 树根; ++ 节点数;
点[节点数].子树大小 = 1; 点[节点数].键值 = key_;
当型循环 (true)
{
点[x].子树大小 ++;
整型 nxt = key_ >= 点[x].键值;
如果 (点[x].子[nxt]) x = 点[x].子[nxt];
否则 { 点[x].子[nxt] = 节点数; 点[节点数].父 = x; break;}
}
整型 re = 0;
当型循环 (x) { 如果 (!平衡数(x)) re = x; x = 点[x].父; }
如果 (re) 重建(re);
}
void 删除(整型 x)
{
当型循环 (点[x].子[0] || 点[x].子[1])
{
整型 y = 0;
如果 (y = 点[x].子[0]) 当型循环 (点[y].子[1]) y = 点[y].子[1];
否则 如果 (y = 点[x].子[1]) 当型循环 (点[y].子[0]) y = 点[y].子[0];
swap(点[x].键值, 点[y].键值); x = y;
}
点[点[x].父].子[点[点[x].父].子[1] == x] = 0;
当型循环 (x) { 点[x].子树大小 --; x = 点[x].父; }
}
整型 得到编号(整型 key_)
{
整型 x = 树根;
当型循环 (x)
{
如果 (点[x].键值 == key_) 返回 x;
x = 点[x].子[key_ > 点[x].键值];
} 返回 x;
}
整型 得到排名(整型 key_)
{
整型 x = 树根, ans = 0;
当型循环 (x)
{
如果 (点[x].键值 < key_) ans += 点[点[x].子[0]].子树大小 + 1, x = 点[x].子[1];
否则 x = 点[x].子[0];
}
返回 ans;
}
整型 得到第几个数(整型 k)
{
整型 x = 树根;
当型循环 (k)
{
如果 (点[点[x].子[0]].子树大小 + 1 == k) break;
如果 (点[点[x].子[0]].子树大小 + 1 <= k) { k -= 点[点[x].子[0]].子树大小 + 1; x= 点[x].子[1]; }
否则 x = 点[x].子[0];
}
返回 点[x].键值;
}
整型 得到前驱(整型 key_)
{
整型 x = 树根, ans = -正无穷;
当型循环 (x)
{
如果 (点[x].键值 < key_) ans = max(ans, 点[x].键值), x = 点[x].子[1];
否则 x = 点[x].子[0];
}
返回 ans;
}
整型 得到后继(整型 key_)
{
整型 x = 树根, ans = 正无穷;
当型循环 (x)
{
如果 (点[x].键值 > key_) ans = min(ans, 点[x].键值), x = 点[x].子[0];
否则 x = 点[x].子[1];
}
返回 ans;
}
void 初始化()
{
节点数 = 2; 树根 = 1;
点[1].子[1] = 2; 点[1].键值 = -正无穷; 点[1].子树大小 = 2;
点[2].父 = 1; 点[2].键值 = 正无穷; 点[2].子树大小 = 1;
}
主函数()
{
初始化();
操作数 = 快读();
循环 (整型 i = 1; i <= 操作数; i++)
{
整型 q, a;
q = 快读(); a = 快读();
如果 (q == 1) 插入(a);
否则 如果 (q == 2) 删除(得到编号(a));
否则 如果 (q == 3) 快写(得到排名(a)), putchar('\n');
否则 如果 (q == 4) 快写(得到第几个数(a + 1)), putchar('\n');
否则 如果 (q == 5) 快写(得到前驱(a)), putchar('\n');
否则 如果 (q == 6) 快写(得到后继(a)), putchar('\n');
}
返回 0;
}