View difference between Paste ID: SrMSTrTN and iBHYYh1R

 // Author : Saurav Kalsoor
-// K Unique String - JAVA
+// Count Coins - KOTLIN
 
 import java.util.*;
 
-public class Test {
+var sc = Scanner(System.`in`)
-    static Scanner sc = new Scanner(System.in);
+
-    public static void main(String[] args) {
+class Edge(var u: Int, var v: Int)
-        String s = sc.next();
+
-		int k = sc.nextInt();
+fun main() {
     val n = sc.nextInt()
-		System.out.println(kUniqueString(s, k));
+    val m = sc.nextInt()
     val coins = ArrayList<Int>()
     for (i in 0 until n) {
-    public static int kUniqueString(String s, int k) {
+        coins.add(sc.nextInt())
-        HashMap<Character, Integer> freq = new HashMap<>();
+
     val arr: ArrayList<Edge> = ArrayList<Edge>()
-		for(int i = 0; i < s.length(); i++){
+    for (i in 0 until m) {
-			freq.put(s.charAt(i), freq.getOrDefault(s.charAt(i), 0) + 1);
+        val u = sc.nextInt()
-		}
+        val v = sc.nextInt()
         arr.add(Edge(u, v))
-        Set<MyPair> st = new TreeSet<>(new Comparator<MyPair>() {
+
-			@Override
+    println(coinsCount(arr, coins, n))
-			public int compare(MyPair a, MyPair b) {
+
-				if(a.frequency == b.frequency)
+
-					return a.ch - b.ch;
+fun coinsCount(arr: ArrayList<Edge>, coins: ArrayList<Int>, n: Int): Int {
-				return a.frequency - b.frequency;
+    val tree = ArrayList<ArrayList<Int>>()
-			}
+    for (i in 0 until n) tree.add(ArrayList())
-		});
+    for (e in arr) {
         tree[e.u].add(e.v)
-        for(Map.Entry<Character, Integer> x : freq.entrySet()){
+        tree[e.v].add(e.u)
-			st.add(new MyPair(x.getKey(), x.getValue()) );
+
-		}
+    val mp = HashMap<Int, Int>()
     return uniqueCount(tree, mp, coins, 0, -1)
-        int distinct = freq.size(), changes = 0;
+
 
-        for(MyPair x : st){
+fun uniqueCount(
-            if(distinct <= k)
+    tree: ArrayList<ArrayList<Int>>,
-                break;
+    mp: HashMap<Int, Int>,
     coins: ArrayList<Int>,
-			changes += x.frequency;
+    node: Int,
-            distinct--;
+    parent: Int
-		}
+): Int {
     var res = 0
-        return changes;
+    mp[coins[node]] = mp.getOrDefault(coins[node], 0) + 1
     for (child in tree[node]) {
-
+        if (child == parent) continue
         res = Math.max(res, uniqueCount(tree, mp, coins, child, node))
     }
-class MyPair{
+    res = Math.max(res, mp.size)
-	public char ch;
+    mp[coins[node]] = mp[coins[node]]!! - 1
-    public int frequency;
+    if (mp[coins[node]] == 0) mp.remove(coins[node])
     return res
-	public MyPair(char ch, int frequency){
+
-		this.ch = ch;
+