feat: leetcode contest 314

Author: upupming

leetcode/contest-314/6200. The Employee That Worked on the Longest Task.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number[][]} logs
+ * @return {number}
+ */
+ var hardestWorker = function(n, logs) {
+  let l = 0, mp = {}
+  for (let i = 0; i < logs.length; i++) {
+      logs[i].push(logs[i][1] - (logs[i-1]?.[1] ?? 0))
+  }
+  logs.sort((a, b) => {
+      if (a[2] === b[2]) return a[0]-b[0]
+      return -(a[2]-b[2])
+  })
+    // console.log(logs)
+    return logs[0][0]
+};

leetcode/contest-314/6201. Find The Original Array of Prefix Xor.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} pref
+ * @return {number[]}
+ */
+ var findArray = function(pref) {
+  let ans = [pref[0]], t = pref[0]
+  for (let i = 1; i < pref.length; i++) {
+      ans.push(t^pref[i])
+      t ^= t^pref[i]
+  }
+  return ans
+};

leetcode/contest-314/6202. Using a Robot to Print the Lexicographically Smallest String.js

@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const robotWithString = function (s) {
+  s = s.split('')
+  const n = s.length
+  const min = []; let ans = ''
+  min[n] = n, s[n] = String.fromCharCode('z'.charCodeAt(0) + 1)
+  for (let i = n - 1; i >= 0; i--) {
+    if (s[i] <= s[min[i + 1]]) min[i] = i
+    else min[i] = min[i + 1]
+  }
+  // console.log(min)
+  const stk = []
+  let i = min[0]
+  for (let j = 0; j <= i; j++) stk.push(s[j])
+  while (i < n) {
+    ans += stk.pop()
+    oldI = i
+    i = min[i + 1]
+    while (stk.length && stk[stk.length - 1] <= s[i]) ans += stk.pop()
+    for (let j = oldI + 1; j <= i; j++) stk.push(s[j])
+  }
+  while (stk.length) ans += stk.pop()
+  return ans.slice(0, -1)
+//     "bdevfziy"
+}

leetcode/contest-314/6203. Paths in Matrix Whose Sum Is Divisible by K.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ dp[i][j][l] 模 k 为 l 的方案数量
+ */
+const numberOfPaths = function (g, k) {
+  const m = g.length; const n = g[0].length; const P = 1e9 + 7
+  const dp = Array(m).fill(0).map(() => Array(n).fill(0).map(() => Array(k).fill(0)))
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      for (let l = 0; l < k; l++) {
+        if (i === 0 && j === 0) {
+          if (l === (g[i][j] % k)) dp[i][j][l] = 1
+          else dp[i][j][l] = 0
+          continue
+        }
+
+        const l1 = ((l - g[i][j]) % k + k) % k
+        let sum = 0
+        if (i - 1 >= 0) sum += dp[i - 1][j][l1]
+        if (j - 1 >= 0) sum += dp[i][j - 1][l1]
+        // if (Number.isNaN(sum)) console.log(i, j, l, l1, dp[i][j-1][l1])
+        dp[i][j][l] = sum % P
+      }
+    }
+  }
+  // console.log(dp)
+  return dp[m - 1][n - 1][0]
+}

leetcode/残酷刷题/2197. Replace Non-Coprime Numbers in Array.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const replaceNonCoprimes = function (nums) {
+  const s = []
+  const gcd = (a, b) => b ? gcd(b, a % b) : a
+  for (let a of nums) {
+    if (!s.length) {
+      s.push(a)
+      continue
+    }
+    let b = s[s.length - 1]
+    let d = gcd(a, b)
+
+    while (s.length && d > 1) {
+      s.pop()
+      a = a / d * b, b = s[s.length - 1]
+      d = gcd(a, b)
+    }
+    s.push(a)
+  }
+  return s
+}

leetcode/残酷刷题/85. Maximal Rectangle.js

@@ -0,0 +1,32 @@
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+const maximalRectangle = function (g) {
+  const m = g.length; const n = g[0].length
+  const f = Array(n).fill(0)
+  let ans = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      f[j] = (g[i][j] === '0') ? 0 : (f[j] + 1)
+    }
+    f[-1] = -1, f[n] = -1
+    const l = []; const r = []
+    let s = [-1]
+    for (let i = 0; i < n; i++) {
+      while (f[s[s.length - 1]] >= f[i]) s.pop()
+      l[i] = s[s.length - 1]
+      s.push(i)
+    }
+    s = [n]
+    for (let i = n - 1; i >= 0; i--) {
+      while (f[s[s.length - 1]] >= f[i]) s.pop()
+      r[i] = s[s.length - 1]
+      s.push(i)
+    }
+    for (let i = 0; i < n; i++) {
+      ans = Math.max(ans, f[i] * (r[i] - l[i] - 1))
+    }
+  }
+  return ans
+}