单链表式并查集应用(解决区间合并，区间删除，染色问题)

单链表式并查集应用

普通并查集（树状）： $p[i]$ 表示节点 $i$ 的父节点， $i$ 所在树的根节点是代表元素。

单链表式并查集（单链表状）时间复杂度 $O(m_{元素值域}+n)$ ，空间复杂度不同问题不一样。

1. $p[i]$ 表示 $i$ 在单链表形式并查集中的下一个节点。
2. $find(x)$ 表示从 $x$ 向右找第一个没有被用到的/染色的元素

$i$ 所在树的根节点：表示从 $i$ 出发向右找，第一个没有被用到的位置。

初始化都是：

普通：fo(i,1,n)fa[i] = i;
单链表形式：fo(i,1,n+m)fa[i] = i;

1242. 修改数组

---

const int N=2e6+10,M=1e9+7;

int n,m;
int a[N];
int fa[N]; //最坏情况，1e5个1e6值的元素，所以并查集开n+m

int find(int x){//从x向右找第一个没有被用过的元素
    if(fa[x] == x){
        return fa[x];
    }
    return fa[x] = find(fa[x]);
    // return fa[x] = find(x+1); 这个肯定会 TLE
}   
void solve(){
    cin>>n;
    fo(i,1,n)cin>>a[i]
    fo(i,1,N)fa[i] = i;
    /*我写的感觉就很啰嗦
    fo(i,1,n){
        int t = find(a[i]);
        if(t == a[i]){
            fa[a[i]] = find(a[i]+1);
        }
        else{
            a[i] = t;
            fa[t] = find(t+1);
        }
    }
    */
    // y总写的超级简练
    fo(i,1,n){
        int t = find(a[i]);
   		a[i] = t;
        fa[t] = t+1;
    }
    fo(i,1,n){
        cout<<a[i]<<" ";
    }
}

int main(){
    solve();
    return 0;
}

3115. 疯狂的馒头

---

又学到了一个非常常用的TRICK。就是给定 $M$ 次染色序列，问最后所有位置的颜色是什么。

如果从前向后考虑，后边的染色会覆盖之前的一种染色，可以倒着考虑，如果一段区间 已经 染色就不再被染色了 (每个位置只会被染色一次) ，然后跳过一些状态，进行优化。

---

这类题的想通的地方就是 只会出现一次，只会被染色一次

因为 $fa[i]=i$ 表示这个节点 / 物品，还没有出现过，或者还没有被染色过。

int n,m,p,q;
int fa[1000010];
int a[1100000];
int ans[1100000];
int find(int x){// 找到从x开始的右边的第一个没有被染色的元素
    return fa[x] == x ? fa[x] : fa[x] = find(fa[x]);
}

void solve(){
    cin>>n>>m>>p>>q;
    for(int i=1;i<=1000010;i++){
        fa[i] = i;
    }
    while(m){
        int l = (m*p+q)%n+1;
        int r = (m*q+p)%n+1;
        if(l>r)swap(l,r);
        // 【l，r】
        int x = find(l);
        while(x<=r){
            // [l,x]
            ans [x] = m;
            fa[x] = find(x+1);
            x = find(x);
        }
        m -- ; // 容易错
    }
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<endl;
    }
}