Swaps in Permutation

You are given a permutation of the numbers 1, 2, …, n and m pairs of positions (aj, bj).

At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?

Let p and q be two permutations of the numbers 1, 2, …, n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.

Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.

The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.

Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.

Output
Print the only line with n distinct integers p’i (1 ≤ p’i ≤ n) — the lexicographically maximal permutation one can get.

Example
input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
output
7 8 9 4 5 6 1 2 3

#include <iostream>
#include <queue>

using namespace std;

const int N=1e6+10;

priority_queue<int>ans[N];
int a[N],pre[N];

struct DSU
{
    void Init(int n)
    {
        for(int i=1;i<=n;i++)   pre[i]=i;
    }
    int Find(int x)
    {
        return x==pre[x] ? x:pre[x]=Find(pre[x]);
    }
    void Union(int a,int b)
    {
        int x=Find(a);
        int y=Find(b);
        if(x==y)    return;
        pre[y]=x;
    }
}dsu;

int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        dsu.Init(n);
        for(int i=1;i<=n;i++)   cin>>a[i];
        int x,y;
        for(int i=1;i<=m;i++)
        {
            cin>>x>>y;
            dsu.Union(x,y);
        }

        for(int i=1;i<=n;i++)   ans[pre[dsu.Find(i)]].push(a[i]);
        for(int i=1;i<=n;i++)
        {
            cout<<ans[pre[i]].top()<<(i==n ? '\n':' ');
            ans[pre[i]].pop();
        }
    }
    return 0;
}