Merge branch 'master' of https://github.com/BNSC1/leetcode-kotlin

Author: BNSC1

LeetCode/130. Surrounded Regions.kt

@@ -0,0 +1,48 @@
+class Solution {
+    fun solve(b: Array<CharArray>): Unit {
+        val rows = b.size
+        val cols = b[0].size
+        val dirs = intArrayOf(-1,0,1,0,-1)
+
+        val visit = HashSet<Pair<Int,Int>>() //mark NOT to be flipped
+        fun dfs(r: Int, c: Int) {
+            val coord = r to c
+            if (r !in 0 until rows ||
+                c !in 0 until cols ||
+                coord in visit ||
+                b[r][c] != 'O') return
+            visit.add(coord)
+            for (d in 0 until 4) {
+                val nr = r + dirs[d]
+                val nc = c + dirs[d+1]
+                dfs(nr, nc)
+            }
+        }
+        repeat(rows) { r ->
+            val coordLeft = r to 0
+            val coordRight = r to cols-1
+            for (coord in listOf(coordLeft, coordRight)) {
+                if (coord !in visit &&
+                    b[coord.first][coord.second] == 'O') {
+                        dfs(coord.first, coord.second)
+                    }
+            }
+        }
+        repeat(cols) { c ->
+            val coordTop = 0 to c
+            val coordBottom = rows-1 to c
+            for (coord in listOf(coordTop, coordBottom)) {
+                if (coord !in visit &&
+                    b[coord.first][coord.second] == 'O') {
+                        dfs(coord.first, coord.second)
+                    }
+            }
+        }
+        repeat(rows) { r ->
+            repeat(cols) { c ->
+                val coord = r to c
+                if (coord !in visit && b[r][c] == 'O') b[r][c] = 'X'
+            }
+        }
+    }
+}

LeetCode/684. Redundant Connection.kt

@@ -0,0 +1,23 @@
+class Solution {
+    fun findRedundantConnection(edges: Array<IntArray>): IntArray {
+        val parent = IntArray(edges.size + 1) {it}
+        fun union(x: Int, y: Int) {
+            parent[x] = y
+        }
+        fun find(x: Int): Int {
+            if (x == parent[x]) return x
+            parent[x] = find(parent[x])
+            return parent[x]
+        }
+
+        for (edge in edges) {
+            val v1 = edge[0]
+            val v2 = edge[1]
+            val p1 = find(v1)
+            val p2 = find(v2)
+            if (p1 == p2) return intArrayOf(v1, v2)
+            union(p1, p2)
+        }
+        return intArrayOf()
+    }
+}

LeetCode/695. Max Area of Island.kt

@@ -0,0 +1,44 @@
+class Solution {
+    fun maxAreaOfIsland(g: Array<IntArray>): Int {
+        val rows = g.size
+        val cols = g[0].size
+        val dirs = intArrayOf(-1,0,1,0,-1)
+
+        var res = 0
+        val visit = HashSet<Pair<Int,Int>>()
+        val q = LinkedList<Pair<Int,Int>>()
+        fun count(): Int {
+            var res = 0
+            while (q.isNotEmpty()) {
+                res++
+                val coord = q.poll()
+                for (d in 0 until 4) {
+                    val nr = coord.first + dirs[d]
+                    val nc = coord.second + dirs[d+1]
+                    val newCoord = nr to nc
+                    if (nr in 0 until rows &&
+                        nc in 0 until cols &&
+                        newCoord !in visit &&
+                        g[nr][nc] == 1) {
+                            q.add(newCoord)
+                            visit.add(newCoord)
+                        }
+                }
+            }
+            return res
+        }
+
+        repeat(rows) { r ->
+            repeat(cols) { c ->
+                val coord = r to c
+                if (coord !in visit &&
+                    g[r][c] == 1) {
+                        q.add(coord)
+                        visit.add(coord)
+                        res = maxOf(res, count())
+                    }
+            }
+        }
+        return res
+    }
+}

LeetCode/721. Accounts Merge_union_find.kt

@@ -1,35 +1,40 @@
 class Solution {
-    val parents = HashMap<String, String>() //child email: parent email
-
     fun accountsMerge(accs: List<List<String>>): List<List<String>> {
-        val owner = HashMap<String, String>() //email: owner
-        val unions = HashMap<String, TreeSet<String>>() //parent email: set of children email, TreeSet will sort elements automatically
+        val parents = HashMap<String, String>() //child email: parent email
+        val owners = HashMap<String, String>() //email: owner
+        val unions = HashMap<String, TreeSet<String>>().withDefault {TreeSet()} //parent email : child emails, TreeSet will sort children automatically
         val res = mutableListOf<List<String>>()
 
-        accs.forEach { a ->
-            for (i in 1 until a.size) {
-                parents[a[i]] = a[i] //set each email to be its own parent, including the parent itself
-                owner[a[i]] = a[0] //set owner of each email
+        fun findParent(email: String): String =
+            if (parents[email] === email) email else findParent(parents[email]!!)
+
+        accs.forEach { acc ->
+            val owner = acc[0]
+            for (i in 1 until acc.size) {
+                val email = acc[i]
+                parents[email] = email //set each email to be its own parent, including the parent itself
+                owners[email] = owner //set owner of each email
             }
         }
-        accs.forEach { a ->
-            val p = find(a[1])
-            for (i in 2 until a.size) parents[find(a[i])] = p //set other emails in the account to have the first email in the account as parent email
+        accs.forEach { acc ->
+            val parent = findParent(acc[1])
+            for (i in 2 until acc.size) {
+                val email = acc[i]
+                parents[findParent(email)] = parent
+            } //set other emails in the account to have the first email in the account as parent email
         }
-        accs.forEach { a ->
-            val p = find(a[1])
-            if (p !in unions) unions[p] = TreeSet() //new a set if the parent does not exist in the map
-            for (i in 1 until a.size) unions[p]!!.add(a[i]) //assign emails with the same parent to 1 set
+        accs.forEach { acc ->
+            val parent = findParent(acc[1])
+            for (i in 1 until acc.size) {
+                unions[parent] = unions.getValue(parent).apply {add(acc[i])}
+            } //assign emails with the same parent to 1 set
         }
-        for (p in unions.keys) {
-            val emails = LinkedList(unions[p]!!).apply { push(owner[p]) } //new a list with emails in it, then push the owner to start of it
-            res.add(emails) //add to result
+        unions.keys.forEach { parent ->
+            val emails = LinkedList(unions[parent]!!).apply {push(owners[parent])} //new a list with emails in it, then push the owner to start of it
+            res.add(emails)
         }
         return res
     }
-
-    fun find(email: String): String = // find parent email of this email
-        if (parents[email] === email) email else find(parents[email]!!)
 }
 
 /*

LeetCode/75. Sort Colors.kt

@@ -1,24 +1,31 @@
 class Solution {
+    val RED = 0
+    val WHITE = 1
+    val BLUE = 2
+
     fun sortColors(nums: IntArray) {
         var red = 0
         var white = 0
         var blue = nums.size - 1
+        
+        fun swap(a: Int, b: Int) {
+            val tmp = nums[a]
+            nums[a] = nums[b]
+            nums[b] = tmp
+        }
 
         while(white <= blue) {
-            if (nums[white] == 0) { //when white pointer is pointing to red element
-                val tmp = nums[red]
-                nums[red] = nums[white]
-                nums[white] = tmp //swap red pointer element with white pointer element
-
-                white++
-                red++ //the pointed element is in correct position, increment both what they are pointing to by 1
-            } else if (nums[white] == 1) { //if white pointer is pointing to white element
-                white++  //increment white pointer by 1
-            } else { //when white pointer is pointing to blue element
-                val tmp = nums[white]
-                nums[white] = nums[blue]
-                nums[blue] = tmp //swap white pointer element with blue pointer element
-                blue-- //subtract by 1 as the previous element does not need moving anymore
+            when (nums[white]) {
+                RED -> {
+                    swap(white, red)
+                    red++
+                    white++ //the pointed element is in correct position, increment both what they are pointing to by 1
+                }
+                WHITE -> white++
+                BLUE -> {
+                    swap(white, blue)
+                    blue-- //subtract by 1 as the previous element does not need moving anymore
+                }
             }
         }
     }