bzoj4399: 魔法少女LJJ
bzoj4399: 魔法少女LJJ
题目描述
在森林中见过会动的树，在沙漠中见过会动的仙人掌过后，魔法少女LJJ已经觉得自己见过世界上的所有稀奇古怪的事情了
LJJ感叹道“这里真是个迷人的绿色世界,空气清新、淡雅,到处散发着醉人的奶浆味；小猴在枝头悠来荡去,好不自在；各式各样的鲜花争相开放,各种树枝的枝头挂满沉甸甸的野果；鸟儿的歌声婉转动听,小河里飘着落下的花瓣真是人间仙境”
SHY觉得LJJ还是太naive，一天，SHY带着自己心爱的图找到LJJ，对LJJ说：“既然你已经见识过动态树，动态仙人掌了，那么今天就来见识一下动态图吧”
LJJ：“要支持什么操作？”
SHY：“
1.新建一个节点，权值为x。
2.连接两个节点。
3.将一个节点a所属于的联通快内权值小于x的所有节点权值变成x。
4.将一个节点a所属于的联通快内权值大于x的所有节点权值变成x。
5.询问一个节点a所属于的联通块内的第k小的权值是多少。
6.询问一个节点a所属联通快内所有节点权值之积与另一个节点b所属联通快内所有节点权值之积的大小。
7.询问a所在联通快内节点的数量
8.若两个节点a，b直接相连，将这条边断开。
9.若节点a存在，将这个点删去。
” LJJ：“我可以离线吗？”
SHY：“可以，每次操作是不加密的，”
LJJ：“我可以暴力吗？”
SHY：“自重”
LJJ很郁闷，你能帮帮他吗
输入格式
第一行有一个正整数m，表示操作个数。
接下来m行，每行先给出1个正整数c。
若c=1，之后一个正整数x，表示新建一个权值为x的节点，并且节点编号为n+1（当前有n个节点）。
若c=2，之后两个正整数a，b，表示在a，b之间连接一条边。
若c=3，之后两个正整数a，x，表示a联通快内原本权值小于x的节点全部变成x。
若c=4，之后两个正整数a，x，表示a联通快内原本权值大于x的节点全部变成x。
若c=5，之后两个正整数a，k，表示询问a所属于的联通块内的第k小的权值是多少。
若c=6，之后两个正整数a，b，表示询问a所属联通快内所有节点权值之积与b所属联通快内所有节点权值之积的大小，
若a所属联通快内所有节点权值之积大于b所属联通快内所有节点权值之积，输出1，否则为0。
若c=7，之后一个正整数a，表示询问a所在联通块大小
若c=8，之后两个正整数a，b，表示断开a，b所连接的边。
若c=9，之后一个正整数a，表示断开a点的所有连边
具体输出格式见样例
样例 #1
样例输入 #1
12
1 2
1 3
1 4
1 5
1 6
2 1 2
2 2 3
2 3 4
2 4 5
9 1
3 2 5
5 3 4
样例输出 #1
5
提示
数据规模与约定
对100%的数据 0<=m<=400000,c<=7,所有出现的数均<=1000000000,所有出现的点保证存在
【HINT】请认真阅读题面
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define lid (tree[id].lson)
#define rid (tree[id].rson)
using namespace std;
int m, tot, poi;
int fa[5211314];
long long op[5211314], a[5211314], b[5211314];//输入的数组
long long origin[5211314], res[5211314], sum, len, now;
// 离散化的数组
long double lognum[5211314];
int root[5211314];
struct SegmentTree {
int lson, rson;
long long summary;
long double product;
}tree[5211314];
//权值线段树
//数组下标为值大小 每个下标对应的数是值为下标的个数
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch - '0');
ch = getchar();
}
return x * f;
}
struct MergeSegmentTree {
inline void PushUp(int id) {
tree[id].summary = tree[lid].summary + tree[rid].summary;
tree[id].product = tree[lid].product + tree[rid].product;
return;
}
inline void Clear(int id) {
tree[id].lson = tree[id].rson = 0;
tree[id].summary = tree[id].product = 0;
return;
}
void Update(int &id, int l, int r, int pos, int num) {
if (id == 0) id = ++ tot;
if (l == r) {
tree[id].summary += num;
tree[id].product += lognum[l] * num;
//注意log的运算法则
return;
}
int mid = (l + r) >> 1;
if (pos <= mid) Update(lid, l, mid, pos, num);
else Update(rid, mid + 1, r, pos, num);
PushUp(id);
return;
}//线段树动态开点更新
int Merge(int a1, int b1, int l, int r) {
if (a1 == 0) return b1;
if (b1 == 0) return a1;
if (l == r) {
tree[a1].summary += tree[b1].summary;
tree[a1].product += tree[b1].product;
return a1;
}
int mid = (l + r) >> 1;
tree[a1].lson = Merge(tree[a1].lson, tree[b1].lson, l, mid);
tree[a1].rson = Merge(tree[a1].rson, tree[b1].rson, mid + 1, r);
PushUp(a1);
return a1;
}//合并
int Reduce(int id, int l, int r, int vl, int vr) {
int ans = tree[id].summary;
//因为下面可能要清空,所以要先保存
if ((vl <= l && r <= vr) || id == 0) {
Clear(id);
return ans;
}
ans = 0;
int mid = (l + r) >> 1;
if (vl <= mid) {
ans += Reduce(lid, l, mid, vl, vr);
}
if (vr > mid) ans += Reduce(rid, mid + 1, r, vl, vr);
//将vl到vr的区间内的数值加起来
PushUp(id);//记得PushUp
return ans;
}
int Query(int id, int l, int r, int k) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (tree[lid].summary < k) {
return Query(rid, mid + 1, r, k - tree[lid].summary);
}
else {
return Query(lid, l, mid, k);
}
//求第k小的数
}
}t;
int Find(int x) {
if (fa[x] == x) return x;
else return fa[x] = Find(fa[x]);
}//并查集找祖先
int main() {
m = read();
for (int i = 1; i <= m; ++ i) {
op[i] = read();
//输入别输入错了呜呜呜
if (op[i] == 7) {
a[i] = read();
}
else if (op[i] == 1) {
a[i] = read();
origin[++ sum] = a[i];
res[sum] = origin[sum];
}
else {
a[i] = read();
b[i] = read();
if (op[i] == 3 || op[i] == 4) {
origin[++ sum] = b[i];
res[sum] = origin[sum];
//只用将题目里的值离散化
}
}
}
sort(origin + 1, origin + 1 + sum);
len = unique(origin + 1, origin + 1 + sum) - (origin + 1);
for (int i = 1; i <= len; ++ i) {
lognum[i] = log(origin[i]);
}
for (int i = 1; i <= sum; ++ i) {
res[i] = lower_bound(origin + 1, origin + 1 + len, res[i]) - origin;
}
//origin是原数组 res是离散化后数组 lognum是原数组的对数数组
//用lognum是为了方便比较两个连通块的乘积大小
for (int i = 1; i <= m; ++ i) {
if (op[i] == 1) {
fa[++ poi] = poi;
t.Update(root[poi], 1, len, res[++ now], 1);
//记得用res[++ now]而不是res[i]
}
else if (op[i] == 2) {
int x = Find(a[i]);
int y = Find(b[i]);
if (x == y) continue;
fa[y] = x;
//并查集并在一起
root[x] = t.Merge(root[x], root[y], 1, len);
//若不在同一个连通块内则合并
}
else if (op[i] == 3) {
int rt = Find(a[i]);
//因为先前的fa[a[i]]的值可能会更改，被并在另一个并查集上，但还没更新fa[a[i]]
//所以记得每次都用Find(a[i])而不是fa[a[i]]
int addnum;
if (res[++ now] != 1) {
//记得用res[++ now]而不是res[i]
addnum = t.Reduce(root[rt], 1, len, 1, res[now] - 1);
//先将1到res[now]-1的sum求出，addnum即在同一块内比res[now]小的数的个数
t.Update(root[rt], 1, len, res[now], addnum);
//更新res[now]的值，将所有的比res[now]的小的值都变成res[now]
}
}
else if (op[i] == 4) {
//同op[i]==3
int rt = Find(a[i]);
int addnum;
if (res[++ now] != len) {
//记得用res[++ now]而不是res[i]
addnum = t.Reduce(root[rt], 1, len, res[now] + 1, len);
t.Update(root[rt], 1, len, res[now], addnum);
}
}
else if (op[i] == 5) {
int rt = Find(a[i]);
printf("%lld\n", origin[t.Query(root[rt], 1, len, b[i])]);
}
else if (op[i] == 6) {
int x = Find(a[i]);
int y = Find(b[i]);
if (tree[root[x]].product > tree[root[y]].product) printf("1\n");
//比较a的连通块乘积大小和b的连通块的乘积大小
else printf("0\n");
}
else {
int x = Find(a[i]);
printf("%lld\n",tree[root[x]].summary);
//连通块内的点的个数
}
}
return 0;
}
//这道题思路不难，主要难在代码实现上，考验代码能力，比较注意细节
