我自己 OI 很菜的，偏偏现在又有事情想做，那么想快速了解一下，只能拜托各位大佬了。。。

向上递归？回溯的时候判 ==？ 可是为什么能够做到并+查呢？

[1,2,3,4,5,...] 这么初始化 是有什么缘由的吗

A={3,5,6} B={1,0,2} 这种情况我求一下并查集 AB，然后在上面进行查询操作

首先树的离散化是这样的，每个节点有爸爸

data Tree a = Father a | Children [Tree a]

vec
father(n) = vec[vec[n]]
mkchild(n, m) = vec[m] <- vec[n]

先放数据... 怎么放

要知道他们是不是一个家族的

是... 这样判断『查』(in) 的？并 就是组织这样一个搜索树...

并查集的本质是维护一个森林，把森林里的树合并。只要是达到这个目的都可以。但是初始化成自己的父节点的话会更容易理解并查集的本质。

合并 搜索树？？？？ 爸爸 是什么 为什么要有爸爸 为什么有了爸爸就会使得效率++...

这样的话递归下去也不难找，第一个公共父节点

data Tree a = Leaf a | Pa a (Tree a)

childFamily :: Tree a -> Tree a -> Bool
childFamily l r = case (l, r) of
(Pa x fx, Pa y fy) -> if fx == fy then True else (childFamily fx fy)
otherwise -> False

可是 怎么去构造树 为什么能够通过这种森林来 并查集

离散化怎么做呢... 为什么找到爸爸之后就自己按 id 就被替换掉了

噢，果然是会把人急傻的... 不爱看就算了，我目前的水平也就是以自己的视角整理一下代码而已 只是有点奇怪为啥 ask 的递归里没有重写参数... 好像也没有副作用啊 也只能到时候再看了

现在才知道是可以 AC 的... 我还以为无尽递归栈溢呢（没强调尾递归），没想到是在 readInts...

是这样，目前正在学习为什么就 可以...

源码是冰封写的：

这里 ask 是一个递归查找的子程序，它递归寻找一个树状数组的 i == vec//i
并且
+ i == @i => @i=i
+ 否则，总之就是递归下去找 @@i 什么的，然后存下来结果（就是把这个节点直接重写了）

比如这里有一个小离散化的树

root=3
@1=3
@2=2
@3=1

我们去 ask 这个 3 (ask vec 3)，然后结果是：

l1: i=3, @i==1/=0, @3=rec 1
l2: i=1, @i==3/=1, @1=rec 3
leven: i=3
lodd: i=1...
这样的话就成环(cycle)了... 怪我的图没画好，可是如果没有环就是：

l1: i=3, @i==1/=0, @3=rec 1
l2: i=1, @i==2/=1, @1=rec 2
l3: i=2 @i==2==2, 2

这就是在找... 爸爸的爸爸的... 等于爸爸或者、爸爸的爸爸就是爸爸自己（root）？只不过是离散化的版本？

原来 Vec.produce \n -> (n+1) 是这种原因？每个数字对应一个『爸爸』树？

childFamily l r = case (l, r) of
(Pa x fx, Pa y fy) -> if fx == fy then True else (childFamily fx fy)
otherwise -> False

准确来说也不『新』了，冰封 2016 年 8 月就在博客上发了离散化求并查集的题解...（汗）

which 是我今天看瞎眼也不知道为什么的题目，早在 3 年前...
唉

啊！才发现其实 main 里只是分配初始化一个算法全局要用到的数据结构而已... 本身这个数据结构是边查询边更新的

我自己瞎 JB 写了一个发现也可以 pass 测试数据（时间限制应该也 OK），可是我还是没有那个直觉... 虽然我写了，但是只是默写而已

因为我躺床上也想了很久都没有结果（都是一些比较浅层的结论，似乎靠树形图 也没有特别多的效果）
思量着 要上 可视化 拿命分析 只要分析完能力能有提升，哪怕以后都要拿命分析 也在所不辞

#Haskell XJB 写的树状数组离散化并查集，不过是抄的...（默写的） 自己还不是很理解，看看

#Haskell #Algorithm 仅仅是比原版换了一点命名大概，主体逻辑没有区别，但即使是模板 弄不懂的话 也是没有意义的呢。

来看一下我们的测试题目。首先是初始化并查集内容（Zi=1）部分

O A B
1 1 2
1 3 4
1 2 3

现在这个集合里 应该怎么样呢？
是数组 离散化 存储的一个树，数组是一个 mapping，K 是 Int, V 是 Int

a=1; b=2, 先去找两个 deep ancestor: ap, bp
拿到的肯定是 vec[1] vec[2] 本身（n == i）
然后去存 nodes[1].parent = nodes[2] 就发现 1 和 2 是一锅的

3 4 同理，n[3].parent = n[4]; n[4].parent = nil(4)

2 3 的话，就体现 优化，要找爸爸树
2 的话，找到 n[2] （是 1 的爹），然后它是爹的 child
3 的话，找到 n[3] （是 4 的 娃），然后它的爹就是 4, 顺带传递性相等， n[3] 的爹 也是 4 肯定
n[3] = n[4]

这样的话，A={1,3,2} B={2,4,3}

首先就是构造这种 爹树

1 -> 2
2 -> 2 (inserting 2, 3)
2 -> nil
3 -> 4
3 -> 4 (inserting 2, 3)
4 -> nil

集合并的是那 (A | B) = {1,2,4}，那就发现其实 22 33 都没有意义，为什么不当自己的爹，剪掉
那并还有 B 没有的 为什么不直接用空间 保存住，可是不是分开保存的
必须是树，在一起的话 有一个爹 不是一集人不认一个爹，那爹是怎么一起认的呢？就是当儿子、合并

那如何查找爹树？

1 2 是否在同一集合内？
1 -> 2
2 -> 2 那都是一个爹的 娃，是

2 3 是否在一个集合呢？

2 -> 2 可是 3 是否有一个爹呢？
3 -> 4 -> 4 没有一个爹（找完了都

3 4 是否呢？
3 -> 4
4 -> 4
有一个爹，是一集和的 爹（