Merge pull request #1880 from yhkee0404/main

[yhkee0404] WEEK 07 solutions

Author: yhkee0404

longest-substring-without-repeating-characters/yhkee0404.scala

@@ -0,0 +1,26 @@
+import scala.util.control.Breaks._
+
+object Solution {
+    def lengthOfLongestSubstring(s: String): Int = {
+        var ans = 0
+        val visited = Array.fill(128)(false) // S(n) = O(1)
+        var i = 0
+        var j = 0
+        while (j != s.length) {
+            breakable { // but no continue in scala!
+                while (j != s.length) { // T(n) = O(n)
+                    if (visited(s(j))) {
+                        break
+                    }
+                    visited(s(j)) = true
+                    j += 1
+                }
+            }
+            ans = Math.max(ans, j - i)
+
+            visited(s(i)) = false
+            i += 1
+        }
+        ans
+    }
+}

number-of-islands/yhkee0404.go

@@ -0,0 +1,40 @@
+var DRCS = [][]int{
+    {0, -1,},
+    {0, 1,},
+    {-1, 0,},
+    {1, 0,},
+}
+
+func numIslands(grid [][]byte) int {
+    visited := make([][]bool, len(grid)) // S(n) = O(n)
+    for i, row := range grid {
+        visited[i] = make([]bool, len(row))
+    }
+    ans := 0
+    stack := [][]int{}
+    for i, row := range grid {
+        for j, c := range row {
+            if visited[i][j] || c == '0' {
+                continue
+            }
+            ans++
+            visited[i][j] = true
+            stack = append(stack, []int{i, j})
+            for len(stack) != 0 { // T(n) = O(n)
+                u := stack[len(stack) - 1]
+                stack = stack[: len(stack) - 1]
+                for _, drc := range DRCS {
+                    x := u[0] + drc[0]
+                    y := u[1] + drc[1]
+                    if x == -1 || x == len(grid) || y == -1 || y == len(row) ||
+                            grid[x][y] == '0' || visited[x][y] {
+                        continue
+                    }
+                    visited[x][y] = true
+                    stack = append(stack, []int{x, y})
+                }
+            }
+        }
+    }
+    return ans
+}

reverse-linked-list/yhkee0404.dart

@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *   int val;
+ *   ListNode? next;
+ *   ListNode([this.val = 0, this.next]);
+ * }
+ */
+class Solution {
+  ListNode? reverseList(ListNode? head) {
+    var u = null; // S(n) = O(1)
+    while (head != null) { // T(n) = O(n)
+        final temp = head.next;
+        head.next = u;
+        u = head;
+        head = temp;
+    }
+    return u;
+  }
+}

set-matrix-zeroes/yhkee0404.rs

@@ -0,0 +1,42 @@
+impl Solution {
+    pub fn set_zeroes(matrix: &mut Vec<Vec<i32>>) {
+        let m = matrix.len();
+        let n = matrix.first().unwrap().len();
+        let erased_row_0 = (0..n).any(|i| matrix[0][i] == 0);
+        let erased_col_0 = (0..m).any(|i| matrix[i][0] == 0);
+        for i in 1..m {
+            for j in 1..n {
+                if matrix[i][j] == 0 {
+                    *matrix[i].first_mut().unwrap() = 0;
+                    matrix.first_mut().unwrap()[j] = 0;
+                }
+            }
+        }
+        for i in 1..m {
+            if *matrix[i].first().unwrap() != 0 {
+                continue;
+            }
+            for j in 0..n {
+                matrix[i][j] = 0;
+            }
+        }
+        for j in 1..n {
+            if matrix.first().unwrap()[j] != 0 {
+                continue;
+            }
+            for i in 0..m {
+                matrix[i][j] = 0;
+            }
+        }
+        if erased_row_0 {
+            for j in 0..n {
+                matrix[0][j] = 0;
+            }
+        }
+        if erased_col_0 {
+            for i in 0..m {
+                matrix[i][0] = 0;
+            }
+        }
+    }
+}

unique-paths/yhkee0404.kt

@@ -0,0 +1,12 @@
+class Solution {
+    fun uniquePaths(m: Int, n: Int): Int {
+        val dp = List(m + 1) {MutableList(n + 1) {0}}
+        dp[0][1] = 1
+        for (i in 1..m) {
+            for (j in 1..n) {
+                dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
+            }
+        }
+        return dp.last().last()
+    }
+}