Add solutions for Valid Sudoku, Minimum Number of People to Teach, Maximum Number of Processable Queries, Count Key Changes, and Maximum Length of Subset

Author: trinhminhtriet

solutions/0000-0099/0036.valid-sudoku/Solution.cs

@@ -0,0 +1,25 @@
+public class Solution {
+    public bool IsValidSudoku(char[][] board) {
+        bool[,] row = new bool[9, 9];
+        bool[,] col = new bool[9, 9];
+        bool[,] sub = new bool[9, 9];
+
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                char c = board[i][j];
+                if (c == '.') {
+                    continue;
+                }
+                int num = c - '0' - 1;
+                int k = (i / 3) * 3 + (j / 3);
+                if (row[i, num] || col[j, num] || sub[k, num]) {
+                    return false;
+                }
+                row[i, num] = true;
+                col[j, num] = true;
+                sub[k, num] = true;
+            }
+        }
+        return true;
+    }
+}

solutions/0000-0099/0036.valid-sudoku/Solution.rs

@@ -0,0 +1,25 @@
+impl Solution {
+    pub fn is_valid_sudoku(board: Vec<Vec<char>>) -> bool {
+        let mut row = vec![vec![false; 9]; 9];
+        let mut col = vec![vec![false; 9]; 9];
+        let mut sub = vec![vec![false; 9]; 9];
+
+        for i in 0..9 {
+            for j in 0..9 {
+                let c = board[i][j];
+                if c == '.' {
+                    continue;
+                }
+                let num = (c as u8 - b'0' - 1) as usize;
+                let k = i / 3 * 3 + j / 3;
+                if row[i][num] || col[j][num] || sub[k][num] {
+                    return false;
+                }
+                row[i][num] = true;
+                col[j][num] = true;
+                sub[k][num] = true;
+            }
+        }
+        true
+    }
+}

solutions/1700-1799/1733.minimum-number-of-people-to-teach/Solution.rs

@@ -0,0 +1,36 @@
+use std::collections::{HashMap, HashSet};
+
+impl Solution {
+    pub fn minimum_teachings(n: i32, languages: Vec<Vec<i32>>, friendships: Vec<Vec<i32>>) -> i32 {
+        fn check(u: usize, v: usize, languages: &Vec<Vec<i32>>) -> bool {
+            for &x in &languages[u - 1] {
+                for &y in &languages[v - 1] {
+                    if x == y {
+                        return true;
+                    }
+                }
+            }
+            false
+        }
+
+        let mut s: HashSet<usize> = HashSet::new();
+        for edge in friendships.iter() {
+            let u = edge[0] as usize;
+            let v = edge[1] as usize;
+            if !check(u, v, &languages) {
+                s.insert(u);
+                s.insert(v);
+            }
+        }
+
+        let mut cnt: HashMap<i32, i32> = HashMap::new();
+        for &u in s.iter() {
+            for &l in &languages[u - 1] {
+                *cnt.entry(l).or_insert(0) += 1;
+            }
+        }
+
+        let mx = cnt.values().cloned().max().unwrap_or(0);
+        (s.len() as i32) - mx
+    }
+}

solutions/1700-1799/1733.minimum-number-of-people-to-teach/Solution.ts

@@ -0,0 +1,29 @@
+function minimumTeachings(n: number, languages: number[][], friendships: number[][]): number {
+    function check(u: number, v: number): boolean {
+        for (const x of languages[u - 1]) {
+            for (const y of languages[v - 1]) {
+                if (x === y) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    const s = new Set<number>();
+    for (const [u, v] of friendships) {
+        if (!check(u, v)) {
+            s.add(u);
+            s.add(v);
+        }
+    }
+
+    const cnt = new Map<number, number>();
+    for (const u of s) {
+        for (const l of languages[u - 1]) {
+            cnt.set(l, (cnt.get(l) || 0) + 1);
+        }
+    }
+
+    return s.size - Math.max(0, ...cnt.values());
+}

solutions/3000-3099/3018.maximum-number-of-removal-queries-that-can-be-processed-i/Solution.rs

@@ -0,0 +1,41 @@
+impl Solution {
+    pub fn maximum_processable_queries(nums: Vec<i32>, queries: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let m = queries.len();
+        let mut f = vec![vec![0; n]; n];
+
+        for i in 0..n {
+            for j in (i..n).rev() {
+                if i > 0 {
+                    let idx = f[i - 1][j] as usize;
+                    if idx < m {
+                        f[i][j] = f[i][j]
+                            .max(f[i - 1][j] + if nums[i - 1] >= queries[idx] { 1 } else { 0 });
+                    }
+                }
+                if j + 1 < n {
+                    let idx = f[i][j + 1] as usize;
+                    if idx < m {
+                        f[i][j] = f[i][j]
+                            .max(f[i][j + 1] + if nums[j + 1] >= queries[idx] { 1 } else { 0 });
+                    }
+                }
+                if f[i][j] as usize == m {
+                    return m as i32;
+                }
+            }
+        }
+
+        let mut ans = 0;
+        for i in 0..n {
+            let idx = f[i][i] as usize;
+            if idx < m {
+                ans = ans.max(f[i][i] + if nums[i] >= queries[idx] { 1 } else { 0 });
+            } else {
+                ans = ans.max(f[i][i]);
+            }
+        }
+
+        ans
+    }
+}

solutions/3000-3099/3019.number-of-changing-keys/Solution.rs

@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn count_key_changes(s: String) -> i32 {
+        let s = s.to_lowercase();
+        let bytes = s.as_bytes();
+        let mut ans = 0;
+        for i in 1..bytes.len() {
+            if bytes[i] != bytes[i - 1] {
+                ans += 1;
+            }
+        }
+        ans
+    }
+}

solutions/3000-3099/3020.find-the-maximum-number-of-elements-in-subset/Solution.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn maximum_length(nums: Vec<i32>) -> i32 {
+        let mut cnt: HashMap<i64, i32> = HashMap::new();
+        for &x in &nums {
+            *cnt.entry(x as i64).or_insert(0) += 1;
+        }
+
+        let mut ans = 0;
+        if let Some(t) = cnt.remove(&1) {
+            ans = t - ((t % 2) ^ 1);
+        }
+
+        for &key in cnt.keys() {
+            let mut x = key;
+            let mut t = 0;
+            while *cnt.get(&x).unwrap_or(&0) > 1 {
+                x = x * x;
+                t += 2;
+            }
+            t += cnt.get(&x).unwrap_or(&-1);
+            ans = ans.max(t);
+        }
+
+        ans
+    }
+}