feat: leetcode contest 345

Author: upupming

leetcode/contest-345/6430. Find the Losers of the Circular Game.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number[]}
+ */
+const circularGameLosers = function (n, k) {
+  const s = new Set(); let cur = 1; let j = 1
+  while (true) {
+    if (s.has(cur)) break
+    s.add(cur)
+    cur = ((cur + k * (j++) - 1) % n) + 1
+  }
+  const ans = []
+  for (let i = 1; i <= n; i++) {
+    if (!s.has(i)) ans.push(i)
+  }
+  return ans
+}

leetcode/contest-345/6431. Neighboring Bitwise XOR.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} derived
+ * @return {boolean}
+ */
+const doesValidArrayExist = function (d) {
+  let c = 0
+  for (const x of d) {
+    c ^= x
+  }
+  return c === 0
+}

leetcode/contest-345/6432. Count the Number of Complete Components.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countCompleteComponents = function (n, edges) {
+  const fa = Array(n).fill(0).map((_, idx) => idx)
+  const get = (x) => {
+    if (fa[x] === x) return x
+    return fa[x] = get(fa[x])
+  }
+  const merge = (x, y) => {
+    const fx = get(x); const fy = get(y)
+    fa[fx] = fy
+  }
+  const e = {}
+  for (const [x, y] of edges) {
+    e[x] ??= new Set()
+    e[x].add(y)
+    e[y] ??= new Set()
+    e[y].add(x)
+    merge(x, y)
+  }
+  const f = []; const fs = {}
+  for (let i = 0; i < n; i++) {
+    s = get(i)
+    f.push(s)
+    fs[s] ??= []
+    fs[s].push(i)
+  }
+  // console.log(fs)
+  let ans = 0
+  for (const t of Object.values(fs)) {
+    let ok = true
+    for (let i = 0; i < t.length; i++) {
+      if (!ok) break
+      for (let j = i + 1; j < t.length; j++) {
+        if (!e[t[i]].has(t[j])) {
+          ok = false
+          break
+        }
+      }
+    }
+    ans += ok
+  }
+  return ans
+}

leetcode/contest-345/6433. Maximum Number of Moves in a Grid.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maxMoves = function (g) {
+  const cache = {}
+  const m = g.length; const n = g[0].length
+  const dx = [0, -1, 1]; const dy = [1, 1, 1]
+  const dfs = (i, j) => {
+    if (cache[`${i}_${j}`]) return cache[`${i}_${j}`]
+    if (j === 0) return cache[`${i}_${j}`] = 0
+    let s = -1
+    for (let k = 0; k < 3; k++) {
+      const x = i - dx[k]; const y = j - dy[k]
+      if (x >= 0 && x < m && y >= 0 && y < n && g[i][j] > g[x][y]) {
+        s = Math.max(s, dfs(x, y))
+        // console.log(x, y, i, j, cache, s)
+      }
+    }
+    if (s === -1) return cache[`${i}_${j}`] = -1
+    return cache[`${i}_${j}`] = s + 1
+  }
+  let ans = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      // console.log(i, j, dfs(i, j))
+      ans = Math.max(ans, dfs(i, j))
+    }
+  }
+  return ans
+}