chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-21-1930-Unique-Length-3-Palindromic-Subsequences/explanation.md

@@ -0,0 +1,33 @@
+# Unique Length-3 Palindromic Subsequences (Medium)
+
+**Problem ID:** 1930  
+**Date:** 2025-11-21  
+**Link:** https://leetcode.com/problems/unique-length-3-palindromic-subsequences/
+
+## Approach
+
+To solve the problem of counting unique length-3 palindromic subsequences in a string, we can adopt the following approach:
+
+### Main Idea:
+A palindromic subsequence of length 3 has the form "aba", where 'a' is the first and last character, and 'b' is the middle character. To find all unique palindromic subsequences of this form, we need to identify pairs of characters that can serve as 'a' and 'b' in the string.
+
+### Approach:
+1. **Character Index Tracking**: Use a dictionary to track the indices of each character in the string. This will help us quickly find potential positions for the characters 'a' and 'b'.
+
+2. **Iterate Over Characters**: For each character 'b' in the string (considering it as the middle character of the palindrome):
+   - Check for all characters 'a' that appear before 'b' (using the index list from the dictionary).
+   - Check for all characters 'a' that appear after 'b'.
+   - For each valid pair of indices (one before and one after), we can form the palindrome "aba".
+
+3. **Set for Uniqueness**: Use a set to store the unique palindromic subsequences we find. This ensures that duplicates are automatically handled.
+
+### Data Structures:
+- A dictionary (or hashmap) to store the indices of each character.
+- A set to store unique palindromic subsequences.
+
+### Complexity:
+- **Time Complexity**: O(n^2) in the worst case, where n is the length of the string. This is due to the nested iteration over characters and their indices. However, since we are only considering pairs of indices for each middle character, the average case can be better.
+- **Space Complexity**: O(n) for storing the indices of characters in the dictionary and for the set of unique palindromic subsequences.
+
+### Conclusion:
+By systematically identifying potential palindromic structures and leveraging data structures for efficient lookups, we can effectively count the unique length-3 palindromic subsequences in the string. This method balances clarity and efficiency, making it suitable for the problem's constraints.

Medium/2025-11-21-1930-Unique-Length-3-Palindromic-Subsequences/solution.java

@@ -0,0 +1,22 @@
+import java.util.HashSet;
+
+public class Solution {
+    public int countPalindromicSubseq(String s) {
+        HashSet<String> uniquePalindromes = new HashSet<>();
+        int n = s.length();
+        
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (s.charAt(i) == s.charAt(j)) {
+                    for (int k = j + 1; k < n; k++) {
+                        if (s.charAt(i) == s.charAt(k)) {
+                            uniquePalindromes.add("" + s.charAt(i) + s.charAt(j) + s.charAt(k));
+                        }
+                    }
+                }
+            }
+        }
+        
+        return uniquePalindromes.size();
+    }
+}

Medium/2025-11-21-1930-Unique-Length-3-Palindromic-Subsequences/solution.js

@@ -0,0 +1,18 @@
+var countPalindromicSubsequences = function(s) {
+    const seen = new Set();
+    const n = s.length;
+
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (s[i] === s[j]) {
+                for (let k = 0; k < n; k++) {
+                    if (k !== i && k !== j && s[k] === s[i]) {
+                        seen.add(s[i] + s[j] + s[i]);
+                    }
+                }
+            }
+        }
+    }
+
+    return seen.size;
+};

Medium/2025-11-21-1930-Unique-Length-3-Palindromic-Subsequences/solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def uniquePalindromicSubseq(self, s: str) -> int:
+        seen = set()
+        last = {}
+        for i, char in enumerate(s):
+            if char in last:
+                for j in last[char]:
+                    seen.add(char + s[j] + char)
+            if char not in last:
+                last[char] = []
+            last[char].append(i)
+        return len(seen)
+
+# Example test cases
+sol = Solution()
+print(sol.uniquePalindromicSubseq("aabca"))  # Output: 3
+print(sol.uniquePalindromicSubseq("adc"))    # Output: 0
+print(sol.uniquePalindromicSubseq("bbcbaba")) # Output: 4

README.md

@@ -285,3 +285,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-18 — [1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/) (Easy) → `Easy/2025-11-18-717-1-bit-and-2-bit-Characters`
 - 2025-11-19 — [Keep Multiplying Found Values by Two](https://leetcode.com/problems/keep-multiplying-found-values-by-two/) (Easy) → `Easy/2025-11-19-2154-Keep-Multiplying-Found-Values-by-Two`
 - 2025-11-20 — [Set Intersection Size At Least Two](https://leetcode.com/problems/set-intersection-size-at-least-two/) (Hard) → `Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two`
+- 2025-11-21 — [Unique Length-3 Palindromic Subsequences](https://leetcode.com/problems/unique-length-3-palindromic-subsequences/) (Medium) → `Medium/2025-11-21-1930-Unique-Length-3-Palindromic-Subsequences`