Merge pull request #1899 from yhkee0404/main

[yhkee0404] WEEK 08 solutions

Author: yhkee0404

clone-graph/yhkee0404.scala

@@ -0,0 +1,33 @@
+import scala.collection.mutable.ListBuffer
+
+/**
+ * Definition for a Node.
+ * class Node(var _value: Int) {
+ *   var value: Int = _value
+ *   var neighbors: List[Node] = List()
+ * }
+ */
+
+object Solution {
+    def cloneGraph(graph: Node): Node = {
+        if (graph == null) {
+            return null
+        }
+        val dp = Array.fill[Node](101)(null)
+        cloneGraph(dp, graph)
+    }
+    def cloneGraph(dp: Array[Node], graph: Node): Node = {
+        if (dp(graph.value) != null) {
+            return dp(graph.value)
+        }
+        val u = Node(graph.value)
+        dp(graph.value) = u
+        val neighbors = ListBuffer[Node]()
+        graph.neighbors
+                .foreach {
+                    neighbors += cloneGraph(dp, _)
+                }
+        u.neighbors ++= neighbors
+        u
+    }
+}

longest-common-subsequence/yhkee0404.dart

@@ -0,0 +1,14 @@
+class Solution {
+  int longestCommonSubsequence(String text1, String text2) {
+    final dp = List.generate(
+                text1.length + 1,
+                (_) => List.filled(text2.length + 1, 0),
+            );
+    for (int i = 1; i <= text1.length; i++) {
+        for (int j = 1; j <= text2.length; j++) {
+            dp[i][j] = text1[i - 1] == text2[j - 1] ? dp[i - 1][j - 1] + 1 : max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp[text1.length][text2.length];
+  }
+}

longest-repeating-character-replacement/yhkee0404.kt

@@ -0,0 +1,27 @@
+class Solution {
+    fun characterReplacement(s: String, k: Int): Int {
+        val cnts = MutableList<Int>('Z'.code - 'A'.code + 1) {0}
+        var max_cnt = 0
+        var ans = 0
+        var i = 0
+        var j = 0
+        while (j != s.length) { // T(n) = S(n) = O(n)
+            while (j != s.length) {
+                val diff = j - i - max_cnt
+                if (diff > k) {
+                    break
+                }
+                val d = s[j].code - 'A'.code
+                if (diff == k && max_cnt != cnts[d]) {
+                    break
+                }
+                j++
+                max_cnt = maxOf(max_cnt, ++cnts[d])
+            }
+            ans = maxOf(ans, j - i)
+            val d = s[i++].code - 'A'.code
+            cnts[d]--
+        }
+        return ans
+    }
+}

palindromic-substrings/yhkee0404.go

@@ -0,0 +1,38 @@
+func countSubstrings(s string) int {
+    runes := []rune{} // S(n) = O(n)
+    for _, c := range s {
+        runes = append(runes, c)
+        runes = append(runes, '\000')
+    }
+    ans := 0
+    dp := make([]int, len(runes) - 1)
+    lastR := -1
+    lastMid := -1
+    i := 0
+    for i != len(dp) { // Manacher T(n) = O(n)
+        diff := lastR - i
+        deviation := 0
+        if diff > 0 {
+            deviation = min(diff, dp[lastMid - (i - lastMid)])
+        }
+        l := i - deviation
+        r := i + deviation
+        for l != 0 && r + 1 != len(dp) && runes[l - 1] == runes[r + 1] {
+            deviation++
+            l--
+            r++
+        }
+        dp[i] = deviation
+        if r > lastR {
+            lastR = r
+            lastMid = i
+        }
+        if runes[i] == '\000' {
+            ans += (deviation + 1) >> 1
+        } else {
+            ans += 1 + (deviation >> 1)
+        }
+        i++
+    }
+    return ans
+}

reverse-bits/yhkee0404.rs

@@ -0,0 +1,31 @@
+use std::sync::OnceLock;
+
+static _TABLE: OnceLock<Vec<i32>> = OnceLock::new();
+
+impl Solution {
+
+    pub fn reverse_bits(mut n: i32) -> i32 {
+        let mut x = 0;
+        for i in 0..6 {
+            let shift = if i == 5 {2} else {6};
+            x = x << shift | Self::init_table()[(n & (1 << shift) - 1) as usize] >> 6 - shift;
+            n >>= 6;
+        }
+        x as i32
+    }
+    
+    fn init_table() -> &'static Vec<i32> {
+        _TABLE.get_or_init(|| {
+            let mut table: Vec<i32> = vec![0; 1 << 6];
+            for (i, x) in table.iter_mut().enumerate() {
+                let mut j = i as i32;
+                for k in 0..6 {
+                    *x = *x << 1 | j & 1;
+                    j >>= 1;
+                }
+            }
+            table
+        })
+    }
+
+}