Feat: Improve 1930 speed for 20x

whats2000 · whats2000 · commit 68a6113a20c7 · 2025-11-21T09:38:50.000+08:00
diff --git a/1930-Unique Length-3 Palindromic Subsequences/Note.md b/1930-Unique Length-3 Palindromic Subsequences/Note.md
@@ -17,64 +17,235 @@ A subsequence of a string is a new string generated from the original string wit
 
 ## 基礎思路
 
-先找尋所有字母的最起始位置和最結束位置，然後再找尋中間的字母是否存在，如果存在則計數加一。
+本題要求計算字串中所有長度為 3 的獨特迴文子序列，形式必定為 **x y x**。
+子序列不需連續，只需保持原本字元出現順序；
+同一種類的迴文（如 `"aba"`）無論可形成幾次，只能計算一次。
+
+在思考解法時，需掌握以下觀察：
+
+- **迴文 x y x 的外層 x 必須同時出現在 y 的左邊與右邊。**
+  因此若以每個位置作為中心 y，我們只需找出左右皆存在的 x。
+
+- **可用 26-bit 的 bitmask 記錄哪些字母已出現在左側或右側。**
+  使用 `leftMask` 表示左側出現過的字元集合；
+  `futureMask` 表示右側仍會出現的字元集合。
+
+- **對於每個中心字元 y，需要避免重複計算同一種迴文 x y x。**
+  因此為每個 y 建立 `visitedOuterMaskForCenter[y]`，避免重複加計。
+
+- **計算新出現的外層字元集合時，可用位元操作加速。**
+
+透過上述策略，我們可以在線性時間內找出所有獨特的長度 3 迴文子序列。
 
 ## 解題步驟
 
-### Step 1: 找尋所有字母的最起始位置和最結束位置
+### Step 1：輔助函式 — 計算位元遮罩中 1 的個數
+
+實作一個工具函式，用 Kernighan 演算法計算 bitmask 中有多少個 bit 為 1，後面用來統計「新出現的外層字元 x」個數。
+
+```typescript
+/**
+ * 計算遮罩中 1 的個數（僅使用最低 26 bits）
+ *
+ * @param mask 32 位元整數遮罩
+ * @returns 遮罩中 1 的數量
+ */
+function countSetBitsInMask(mask: number): number {
+  let bitCount = 0;
+
+  // Kernighan 演算法：反覆移除最低位的 1
+  while (mask !== 0) {
+    mask &= mask - 1;
+    bitCount++;
+  }
+
+  return bitCount;
+}
+```
+
+### Step 2：預處理字串長度與索引
+
+若字串長度小於 3，無法形成長度為 3 的迴文，直接回傳 0；
+否則將每個字元轉成 0–25 的索引，並統計每個字元出現次數。
+
+```typescript
+const length = s.length;
+
+// 若長度不足 3，無法形成 x y x 型迴文
+if (length < 3) {
+  return 0;
+}
+
+// 預先計算每個位置的字母索引與右側總出現次數
+const characterIndices = new Uint8Array(length);
+const rightCharacterCount = new Uint32Array(ALPHABET_SIZE);
+
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  const characterIndex = s.charCodeAt(positionIndex) - 97; // 'a' 的字元編碼為 97
+  characterIndices[positionIndex] = characterIndex;
+  rightCharacterCount[characterIndex]++;
+}
+```
+
+### Step 3：初始化未來字元集合 `futureMask`
+
+`futureMask` 用一個 26-bit mask 表示「從當前中心位置往右看，仍然會出現的字元集合」。
+
+```typescript
+// futureMask：若 bit c = 1 表示字元 c 仍會在當前中心的右側出現
+let futureMask = 0;
+for (let alphabetIndex = 0; alphabetIndex < ALPHABET_SIZE; alphabetIndex++) {
+  if (rightCharacterCount[alphabetIndex] > 0) {
+    futureMask |= 1 << alphabetIndex;
+  }
+}
+```
+
+### Step 4：初始化每個中心字元的「已用外層集合」
+
+為每種中心字元 y 建立一個 mask，紀錄已經搭配過的外層字元 x，避免重複計數同一種迴文 `x y x`。
+
+```typescript
+// visitedOuterMaskForCenter[c]：若 bit o = 1，代表迴文 o c o 已被計數過
+const visitedOuterMaskForCenter = new Uint32Array(ALPHABET_SIZE);
+```
+
+### Step 5：初始化左側集合與結果，並建立主迴圈骨架
+
+`leftMask` 記錄「在目前中心左側出現過的字元集合」，
+`uniquePalindromeCount` 負責統計最終不同迴文個數。
+主迴圈會逐一將每個位置視為中心字元 y，先取得中心字元索引與其對應 bitmask。
+
+```typescript
+// leftMask：bit c = 1 表示字元 c 已在當前中心左側出現過
+let leftMask = 0;
+// 紀錄獨特長度為 3 的迴文子序列數量
+let uniquePalindromeCount = 0;
+
+// 將每個位置視為迴文 x y x 的中心字元
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  const centerCharacterIndex = characterIndices[positionIndex];
+  const centerCharacterBitMask = 1 << centerCharacterIndex;
+
+  // ...
+}
+```
+
+### Step 6：在主迴圈中更新右側計數與 `futureMask`
+
+在同一個主迴圈中，先將當前中心字元從右側計數中扣除，
+若右側已不再出現該字元，則從 `futureMask` 中清除此字元。
 
 ```typescript
-// 標記所有字母的最起始位置和最結束位置為 -1
-const firstIndex = new Array(26).fill(-1);
-const lastIndex = new Array(26).fill(-1);
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  // Step 5：初始化中心字元索引與對應 bitmask
 
-for (let i = 0; i < n; i++) {
-  // 利用 ASCII 碼計算字母的 index
-  const charIndex = s.charCodeAt(i) - 'a'.charCodeAt(0);
+  const centerCharacterIndex = characterIndices[positionIndex];
+  const centerCharacterBitMask = 1 << centerCharacterIndex;
 
-  // 僅在第一次出現時更新最起始位置
-  if (firstIndex[charIndex] === -1) {
-    firstIndex[charIndex] = i;
+  // 從右側剩餘次數中移除這個中心字元
+  const updatedRightCount = rightCharacterCount[centerCharacterIndex] - 1;
+  rightCharacterCount[centerCharacterIndex] = updatedRightCount;
+
+  // 若右側不再出現此字元，則在 futureMask 中清除此 bit
+  if (updatedRightCount === 0) {
+    futureMask &= ~centerCharacterBitMask;
   }
 
-  // 持續更新最結束位置
-  lastIndex[charIndex] = i;
+  // ...
+}
+```
+
+### Step 7：在主迴圈中取得外層候選字元集合
+
+外層字元 x 必須同時出現在左側與右側，因此候選集合為 `leftMask & futureMask`。
+
+```typescript
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  // Step 5：初始化中心字元索引與對應 bitmask
+  
+  // Step 6：更新右側計數與 futureMask
+
+  // 外層字元必須同時存在於左側與右側
+  const outerCandidateMask = leftMask & futureMask;
+
+  // ...
 }
 ```
 
-### Step 2: 找尋中間的字母是否存在
+### Step 8：在主迴圈中排除已使用外層，並累加新迴文數量
+
+對於當前中心字元 y，從候選集合中去除已使用過的外層 x，
+計算新出現的外層 x 數量並累加，最後更新「已用外層集合」。
 
 ```typescript
-// 依序檢查所有字母
-for (let i = 0; i < 26; i++) {
-  const start = firstIndex[i];
-  const end = lastIndex[i];
-
-  // 若字母存在，且中間至少有一個字母時做計數
-  if (start !== -1 && end !== -1 && end > start + 1) {
-    const uniqueChars = new Set();
-
-    // 找尋中間的獨一無二字母
-    for (let j = start + 1; j < end; j++) {
-      uniqueChars.add(s[j]);
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  // Step 5：初始化中心字元索引與對應 bitmask
+  
+  // Step 6：更新右側計數與 futureMask
+
+  // Step 7：取得外層候選字元集合
+  const outerCandidateMask = leftMask & futureMask;
+
+  if (outerCandidateMask !== 0) {
+    const alreadyVisitedMask =
+      visitedOuterMaskForCenter[centerCharacterIndex];
+
+    // 僅保留尚未與此中心字元組成迴文的外層 x
+    const newOuterMask = outerCandidateMask & ~alreadyVisitedMask;
+
+    // 若存在新的外層 x，則可以形成新的 x y x 型迴文
+    if (newOuterMask !== 0) {
+      uniquePalindromeCount += countSetBitsInMask(newOuterMask);
+
+      // 將這些外層 x 標記為已使用
+      visitedOuterMaskForCenter[centerCharacterIndex] =
+        alreadyVisitedMask | newOuterMask;
     }
-    
-    // 計數加上獨一無二字母的數量
-    result += uniqueChars.size;
   }
+
+  // ...
+}
+```
+
+### Step 9：在主迴圈中將中心字元加入左側集合，並結束迴圈後回傳結果
+
+處理完當前位置後，將中心字元納入 `leftMask`，
+讓之後的位置可以把它當作「左側可用外層字元」。
+迴圈結束後回傳最後統計的迴文數。
+
+```typescript
+for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+  // Step 5：初始化中心字元索引與對應 bitmask
+  
+  // Step 6：更新右側計數與 futureMask
+
+  // Step 7：取得外層候選字元集合
+
+  // Step 8：排除已使用外層並累加結果
+
+  // 將當前中心字元加入左側集合，供後續位置使用
+  leftMask |= centerCharacterBitMask;
 }
+
+// 回傳獨特長度 3 迴文子序列的總數
+return uniquePalindromeCount;
 ```
 
 ## 時間複雜度
 
-- 由於需要遍歷所有字串內的字母，因此時間複雜度為 $O(n)$。
+- 每個位置只進行常數次位元運算（包含 mask 加減、bitwise AND/OR/NOT）。
+- `countSetBitsInMask` 最多執行 26 次迴圈（固定字母數量）。
+- 未使用巢狀迴圈、雙指標或額外掃描。
 - 總時間複雜度為 $O(n)$。
 
 > $O(n)$
 
 ## 空間複雜度
 
-- 不論字串內有多少字母，都僅需要建立兩個長度為 26 的陣列，因此空間複雜度為 $O(1)$。
-- 總空間複雜度為 $O(1)$。
+- `characterIndices` 使用 $O(n)$
+- `rightCharacterCount`、`visitedOuterMaskForCenter`、bitmask 等皆為常數空間
+- 無額外動態空間成長
+- 總空間複雜度為 $O(n)$。
 
-> $O(1)$
+> $O(n)$
diff --git a/1930-Unique Length-3 Palindromic Subsequences/answer.ts b/1930-Unique Length-3 Palindromic Subsequences/answer.ts
@@ -1,40 +1,99 @@
+const ALPHABET_SIZE = 26;
+
+/**
+ * Count the number of set bits (1s) in a 32-bit mask.
+ *
+ * Only the lower 26 bits are used in this problem.
+ *
+ * @param mask - 32-bit integer mask.
+ * @returns Number of bits set to 1 in the mask.
+ */
+function countSetBitsInMask(mask: number): number {
+  let bitCount = 0;
+
+  // Kernighan's algorithm: repeatedly remove the lowest set bit
+  while (mask !== 0) {
+    mask &= mask - 1;
+    bitCount++;
+  }
+
+  return bitCount;
+}
+
+
+/**
+ * Count the number of unique palindromic subsequences of length three.
+ *
+ * A valid palindrome has the form x y x, where x and y are lowercase letters.
+ *
+ * @param s - Input string consisting of lowercase English letters.
+ * @returns Number of unique palindromes of length three that are subsequences of s.
+ */
 function countPalindromicSubsequence(s: string): number {
-  const n = s.length;
-  let result = 0;
+  const length = s.length;
 
-  // Mark the appearance of the first and last index of each character
-  const firstIndex = new Array(26).fill(-1);
-  const lastIndex = new Array(26).fill(-1);
+  // If the string is too short, there cannot be any length-3 palindromes
+  if (length < 3) {
+    return 0;
+  }
 
-  for (let i = 0; i < n; i++) {
-    // Convert the character to an index (ASCII)
-    const charIndex = s.charCodeAt(i) - 'a'.charCodeAt(0);
+  // Precompute each character's alphabet index and its total frequency
+  const characterIndices = new Uint8Array(length);
+  const rightCharacterCount = new Uint32Array(ALPHABET_SIZE);
 
-    // Update the first only if first appearance
-    if (firstIndex[charIndex] === -1) {
-      firstIndex[charIndex] = i;
-    }
+  for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+    const characterIndex = s.charCodeAt(positionIndex) - 97; // 'a' has char code 97
+    characterIndices[positionIndex] = characterIndex;
+    rightCharacterCount[characterIndex]++;
+  }
 
-    // Always update the last appearance
-    lastIndex[charIndex] = i;
+  // futureMask: bit c is 1 if character c still appears at or to the right of the current center
+  let futureMask = 0;
+  for (let alphabetIndex = 0; alphabetIndex < ALPHABET_SIZE; alphabetIndex++) {
+    if (rightCharacterCount[alphabetIndex] > 0) {
+      futureMask |= 1 << alphabetIndex;
+    }
   }
 
-  // Iterate through all characters
-  for (let i = 0; i < 26; i++) {
-    const start = firstIndex[i];
-    const end = lastIndex[i];
+  // visitedOuterMaskForCenter[c]: bit o is 1 if palindrome o c o has already been counted
+  const visitedOuterMaskForCenter = new Uint32Array(ALPHABET_SIZE);
+
+  // leftMask: bit c is 1 if character c has appeared strictly to the left of the current center
+  let leftMask = 0;
+  let uniquePalindromeCount = 0;
 
-    // If the character appears and there is at least one character between the first and last appearance
-    if (start !== -1 && end !== -1 && end > start + 1) {
-      const uniqueChars = new Set();
+  // Treat each position as the middle character of x y x
+  for (let positionIndex = 0; positionIndex < length; positionIndex++) {
+    const centerCharacterIndex = characterIndices[positionIndex];
+    const centerCharacterBitMask = 1 << centerCharacterIndex;
 
-      // Count the unique characters between the first and last appearance
-      for (let j = start + 1; j < end; j++) {
-        uniqueChars.add(s[j]);
+    // Remove this occurrence from the right side
+    const updatedRightCount = rightCharacterCount[centerCharacterIndex] - 1;
+    rightCharacterCount[centerCharacterIndex] = updatedRightCount;
+
+    // If no more of this character on the right, clear its bit in futureMask
+    if (updatedRightCount === 0) {
+      futureMask &= ~centerCharacterBitMask;
+    }
+
+    // Outer letters must appear both left and right of the center
+    const outerCandidateMask = leftMask & futureMask;
+
+    if (outerCandidateMask !== 0) {
+      const alreadyVisitedMask = visitedOuterMaskForCenter[centerCharacterIndex];
+      const newOuterMask = outerCandidateMask & ~alreadyVisitedMask;
+
+      // Only count outer letters we have not used with this center letter yet
+      if (newOuterMask !== 0) {
+        uniquePalindromeCount += countSetBitsInMask(newOuterMask);
+        visitedOuterMaskForCenter[centerCharacterIndex] =
+          alreadyVisitedMask | newOuterMask;
       }
-      result += uniqueChars.size;
     }
+
+    // After processing this center, mark it as available on the left side
+    leftMask |= centerCharacterBitMask;
   }
 
-  return result;
+  return uniquePalindromeCount;
 }
