feat: leetcode contest 311 & 312

Author: upupming

leetcode/contest-311/6180. Smallest Even Multiple.js

@@ -0,0 +1,8 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const smallestEvenMultiple = function (n) {
+  if (n % 2 === 0) return n
+  return 2 * n
+}

leetcode/contest-311/6181. Length of the Longest Alphabetical Continuous Substring.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestContinuousSubstring = function (s) {
+  s = s.split('').map((x) => x.charCodeAt(0) - 'a'.charCodeAt(0))
+  const n = s.length
+  let ans = 0
+  for (let i = 0; i < n;) {
+    let j = i
+    while (j < n && (j === i || s[j] - s[j - 1] === 1)) j++
+    ans = Math.max(ans, j - i)
+    i = j
+  }
+  return ans
+}

leetcode/contest-311/6182. Reverse Odd Levels of Binary Tree.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const reverseOddLevels = function (root) {
+  let q = [[root, 0]]
+  const a = []; let idx = 0
+  while (q.length) {
+    const [node, dep] = q.pop()
+    a.push(node.val)
+    if (node.right) q.push([node.right, dep + 1])
+    if (node.left) q.push([node.left, dep + 1])
+  }
+  q = [[root, 0]]
+  while (q.length) {
+    const [node, dep] = q.pop()
+    if (dep % 2 === 1) node.val = a[idx]
+    idx++
+    if (node.left) q.push([node.left, dep + 1])
+    if (node.right) q.push([node.right, dep + 1])
+  }
+  return root
+}

leetcode/contest-311/6183. Sum of Prefix Scores of Strings.ts

@@ -0,0 +1,92 @@
+export {}
+class TrieNode {
+  char: string
+  count: number = 0
+  countPrefix: number = 0
+  children: { [key: string]: TrieNode | undefined } = {}
+  constructor (char: string) {
+    this.char = char
+  }
+};
+class Trie {
+  trie: TrieNode
+  /**
+   * @description Initialize the trie
+   */
+  constructor () {
+    this.trie = new TrieNode('/')
+  }
+
+  /**
+   * @description Insert strings into the trie
+   * @param str the string to be inserted
+   * @param count number of `str` to be inserted, can be negative for deleting x from the trie
+   */
+  insert (str: string, count: number = 1): void {
+    let cur = this.trie
+    for (const char of str) {
+      cur.children[char] ??= new TrieNode(char)
+      cur = cur.children[char]!
+      cur.countPrefix += count
+    }
+    cur.count += count
+  }
+
+  /**
+   * Traverse the trie with a callback function
+   * @param str An input string
+   * @param callbackfn A callback function. traverse calls the callbackfn function one time for each char in `str`, however it may skip ending chars in str if the trie has no children to go deeper, the returned char from callbackfn will be used as the direction of traversing
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value
+   */
+  traverse (str: string, callbackfn: (char: string, idx: number, node: TrieNode) => string, thisArg?: any): void {
+    let cur = this.trie
+    for (let i = 0; i < str.length; i++) {
+      const retChar = callbackfn.call(thisArg, str[i], i, cur)
+      const tmp = cur.children[retChar]
+      if (!tmp || tmp.countPrefix <= 0) return
+      cur = tmp
+    }
+  }
+
+  /**
+   * @description Search a string in the trie
+   * @returns Number of `str` in the trie
+   */
+  count (str: string): number {
+    let ans = 0
+    this.traverse(str, (char, idx, node) => {
+      const nextNode = node.children[char]
+      if (idx === str.length - 1 && nextNode) {
+        ans = nextNode.count
+      }
+      return char
+    })
+    return ans
+  }
+
+  /**
+   * @description Search a string in the trie
+   * @returns Number of prefix of `str` in the trie
+   */
+  countPrefix (str: string): number {
+    let ans = 0
+    this.traverse(str, (char, idx, node) => {
+      const nextNode = node.children[char]
+      ans += nextNode?.countPrefix ?? 0
+      return char
+    })
+    return ans
+  }
+};
+
+function sumPrefixScores (words: string[]): number[] {
+  const trie = new Trie()
+  const ans = []
+  for (const w of words) {
+    trie.insert(w, 1)
+  }
+  for (const w of words) {
+    ans.push(trie.countPrefix(w))
+  }
+  return ans
+};

leetcode/contest-312/6188. Sort the People.js

@@ -0,0 +1,8 @@
+/**
+ * @param {string[]} names
+ * @param {number[]} heights
+ * @return {string[]}
+ */
+const sortPeople = function (names, heights) {
+  return names.map((x, idx) => [x, heights[idx]]).sort((a, b) => b[1] - a[1]).map(x => x[0])
+}

leetcode/contest-312/6189. Longest Subarray With Maximum Bitwise AND.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const longestSubarray = function (nums) {
+  const max = Math.max(...nums)
+  let maxLen = 0
+  const n = nums.length
+  for (let i = 0; i < n; i++) {
+    let j = i
+    while (j < n && nums[j] === nums[i]) j++
+    if (nums[i] === max) {
+      const len = j - i
+      maxLen = Math.max(maxLen, len)
+    }
+    i = j - 1
+  }
+  return maxLen
+}

leetcode/contest-312/6190. Find All Good Indices.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const goodIndices = function (nums, k) {
+  const n = nums.length
+  const ans = []
+  const left = []; const right = []
+  // nums[-1] = 1e10, nums[n] = 1e10
+  for (let i = 0; i < n; i++) {
+    left[i] = i
+    let j = i + 1
+    while (j < n && nums[j] <= nums[j - 1]) left[j] = i, j++
+    i = j - 1
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    right[i] = i
+    let j = i - 1
+    while (j >= 0 && nums[j] <= nums[j + 1]) right[j] = i, j--
+    i = j + 1
+  }
+  // console.log(left, right)
+  for (let i = k; i < n - k; i++) {
+    const a = i - 1; const b = i + 1
+    // console.log(i, a, b, left[a], a-k, right[b], b+k, a-left[a]+1>=k&&right[b]-b+k>=k)
+    if (a - left[a] + 1 >= k && right[b] - b + 1 >= k) ans.push(i)
+  }
+  return ans
+}

leetcode/contest-312/6191. Number of Good Paths.js

@@ -0,0 +1,58 @@
+/**
+ * @param {number[]} vals
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const numberOfGoodPaths = function (vals, edges) {
+  const n = vals.length
+  const fa = Array(n).fill(0).map((_, idx) => idx)
+  const sz = Array(n).fill(1)
+  const cnts = Array(n).fill(0).map((_, idx) => ({ [vals[idx]]: 1 }))
+  edges = edges.map((e, idx) => [...e, Math.max(vals[e[0]], vals[e[1]])]).sort((a, b) => a[2] - b[2])
+  const m = edges.length
+  let ans = n
+  const cnt = {}
+  const get = (x) => {
+    if (x === fa[x]) return x
+    return fa[x] = get(fa[x])
+  }
+  const merge = (x, y) => {
+    let fx = get(x); let fy = get(y)
+    if (fx === fy) return
+    if (sz[fx] > sz[fy]) [fx, fy] = [fy, fx]
+    fa[fx] = fy
+    sz[fy] += sz[fx]
+    const cx = cnts[fx]; const cy = cnts[fy]
+    // 必须要用按秩合并，否则这里的复制次数太多会导致 TLE/MLE
+    for (const [k, v] of Object.entries(cx)) {
+      cy[k] ??= 0
+      cy[k] += v
+    }
+    // console.log(x, y, cnts[fy])
+  }
+  for (let i = 0; i < m; i++) {
+    let j = i
+    const p = new Set(); const t = edges[i][2]
+    while (j < m && edges[j][2] === edges[i][2]) {
+      merge(edges[j][0], edges[j][1])
+      j++
+    }
+    for (let k = i; k < j; k++) {
+      if (vals[edges[k][0]] === t) {
+        p.add(get(edges[k][0]))
+      }
+      if (vals[edges[k][1]] === t) {
+        p.add(get(edges[k][1]))
+      }
+    }
+    // console.log(t, p)
+    for (const x of p) {
+      // console.log(x, t, cnts[x][t])
+      const c = cnts[x][t]
+      ans += c * (c - 1) / 2
+    }
+
+    i = j - 1
+  }
+  return ans
+}

leetcode/残酷刷题/2402. Meeting Rooms III.cpp

@@ -1,8 +1,8 @@
 typedef pair<long long, int> PII;
 class Solution {
-public:
-    int mostBooked(int n, vector<vector<int>>& meetings) {
-        sort(meetings.begin(), meetings.end(), [](auto &m1, auto &m2){
+   public:
+    int mostBooked(int n, vector<vector<int>> &meetings) {
+        sort(meetings.begin(), meetings.end(), [](auto &m1, auto &m2) {
             return m1[0] < m2[0];
         });
         vector<int> cnt(n, 0);
@@ -20,9 +20,10 @@ class Solution {
             if (!free.size()) {
                 auto t = pq.top().first;
                 // 这里不能把所有 t 时刻结束的都放入 free
+                // https://leetcode.cn/problems/meeting-rooms-iii/solution/shuang-dui-mo-ni-pythonjavacgo-by-endles-ctwc/1738683
                 free.insert(pq.top().second);
                 pq.pop();
-                e = e-s+t, s = t;
+                e = e - s + t, s = t;
             }
             auto it = free.begin();
             pq.push({e, *it});