package LeetCode_1202

import java.util.*
import kotlin.collections.HashMap

/**
 * 1202. Smallest String With Swaps
 * https://leetcode.com/problems/smallest-string-with-swaps/
 * You are given a string s,
 * and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.
You can swap the characters at any pair of indices in the given pairs any number of times.
Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:
Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination:
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:
Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination:
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:
Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination:
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:
1. 1 <= s.length <= 10^5
2. 0 <= pairs.length <= 10^5
3. 0 <= pairs[i][0], pairs[i][1] < s.length
4. s only contains lower case English letters.
 * 
 
*/
class Solution {
    /*
    * solution: UnionFind + HashMap + PriorityQueue, group by words which can connect each other,
    * Time:O(nlogn), Space:O(n)
    * */
    fun smallestStringWithSwaps(s: String, pairs: List<List<Int>>): String {
        val n = s.length
        val unionFind = UnionFind(n)
        
 
for (item in pairs) {
            unionFind.union(item[0], item[1])
        }
        val map = HashMap<Int, PriorityQueue<Char>>()
        for (i in 0 until n) {
            //check which group contains current i
            val root = unionFind.find(i)
            map.putIfAbsent(root, PriorityQueue())
            
 
//put in queue which in same group
            map.get(root)!!.offer(s[i])
        }
        val sb = StringBuilder()
        for (i in 0 until n) {
            val root = unionFind.find(i)
            //append current group's minimum char into result
            sb.append(map.get(root)!!.poll())
        }
        return sb.toString()
    }
}

class UnionFind constructor(n: Int) {

    private var parent: IntArray? = null

    init {
        parent = IntArray(n)
        for (i in 0 until n) {
            parent!![i] = i
        }
    }

    fun find(p: Int): Int {
        if (parent!![p] != p) {
            parent!![p] = find(parent!![p])
        }
        return parent!![p]
    }

    fun union(i: Int, j: Int) {
        val parentI = find(i)
        val parentJ = find(j)
        if (parentI != parentJ) {
            parent!![parentJ] = parentI
        }
    }
}