Add solutions, explanations, and update normalize_json.py for problems 1925, 3100, 3133, 3164, 3197, 3228, 3260, 3291, 3320, 3351, 3380, 3413, 3444, 3471

- Solutions verified and accepted via LeetCode submitter
- Created explanations following required structure
- Updated normalize_json.py to follow Prettier style with one number per line for arrays
- Fixed solutions for 3380 (rectangle validation) and 3291 (Trie optimization)

Author: vikahaze

data/book-sets.json

@@ -0,0 +1,51 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to count the number of square triples (a, b, c) where a² + b² = c² and all three numbers are between 1 and n.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= n <= 250`
+- **Time Complexity:** O(n²) where n is the input value, as we iterate over all pairs (a, b)
+- **Space Complexity:** O(1) as we only use a counter variable
+- **Edge Case:** When n = 1, there are no valid triples since we need at least 3 numbers
+
+**1.2 High-level approach:**
+We iterate through all possible pairs (a, b), calculate c² = a² + b², and check if the square root of c² is an integer and within the range [1, n].
+
+![Pythagorean triple visualization](https://assets.leetcode.com/static_assets/others/pythagorean-triple.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Try all combinations of (a, b, c) and check if a² + b² = c², which would be O(n³)
+- **Optimized Strategy:** For each pair (a, b), calculate c and verify it's a perfect square, achieving O(n²) time
+- **Emphasize the optimization:** By calculating c from a and b, we eliminate the need to iterate over c, reducing complexity from O(n³) to O(n²)
+
+**1.4 Decomposition:**
+1. Initialize a counter to zero
+2. Iterate through all possible values of a from 1 to n
+3. For each a, iterate through all possible values of b from 1 to n
+4. Calculate c² = a² + b² and find c as the integer square root
+5. Verify that c is a perfect square (c * c == c²) and within range [1, n]
+6. Increment the counter for each valid triple
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `n = 5`
+- Initialize counter: `res = 0`
+
+**2.2 Start Checking:**
+We iterate through all pairs (a, b).
+
+**2.3 Trace Walkthrough:**
+
+| a | b | a² | b² | c² | c | c*c == c²? | 1 <= c <= 5? | Count |
+|---|---|----|----|----|---|------------|---------------|-------|
+| 3 | 4 | 9 | 16 | 25 | 5 | Yes | Yes | 1 |
+| 4 | 3 | 16 | 9 | 25 | 5 | Yes | Yes | 2 |
+
+**2.4 Increment and Loop:**
+After checking all pairs, we continue to the result.
+
+**2.5 Return Result:**
+The result is 2, representing the two valid triples: (3, 4, 5) and (4, 3, 5).

explanations/1925/en.md

@@ -0,0 +1,52 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We start with numBottles full bottles. We can drink bottles (turning them into empty bottles) and exchange empty bottles for full ones. Each exchange requires numExchange empty bottles and increases the exchange rate by 1. We want to maximize the total bottles drunk.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= numBottles <= 100`, `1 <= numExchange <= 100`
+- **Time Complexity:** O(numBottles) in the worst case, as we exchange until we can't
+- **Space Complexity:** O(1) as we only track a few variables
+- **Edge Case:** If numExchange > numBottles initially, we can only drink the initial bottles
+
+**1.2 High-level approach:**
+We drink all initial bottles, then repeatedly exchange empty bottles for full ones while the exchange rate allows. Each exchange gives us one more bottle to drink and increases the exchange rate.
+
+![Water bottles exchange visualization](https://assets.leetcode.com/static_assets/others/greedy-algorithm.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Simulate each operation step by step, which is what we do - this is already optimal
+- **Optimized Strategy:** Greedily exchange whenever possible, maximizing drinks at each step
+- **Emphasize the optimization:** The greedy approach ensures we always maximize drinks by exchanging as soon as we have enough empty bottles
+
+**1.4 Decomposition:**
+1. Drink all initial bottles and count them
+2. While we have enough empty bottles for an exchange, exchange them for one full bottle
+3. Drink the newly obtained full bottle
+4. Increase the exchange rate by 1 for the next exchange
+5. Repeat until we can't exchange anymore
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `numBottles = 13`, `numExchange = 6`
+- Initial state: `res = 0`, `empty = 0`, `exchange = 6`
+- Drink all 13 bottles: `res = 13`, `empty = 13`
+
+**2.2 Start Exchanging:**
+We check if we can exchange empty bottles for a full one.
+
+**2.3 Trace Walkthrough:**
+
+| Step | Empty | Exchange Rate | Can Exchange? | Action | Empty After | res |
+|------|-------|---------------|---------------|--------|-------------|-----|
+| Initial | 13 | 6 | Yes | Exchange 6 for 1, drink it | 8 | 14 |
+| 1 | 8 | 7 | Yes | Exchange 7 for 1, drink it | 2 | 15 |
+| 2 | 2 | 8 | No | Stop | 2 | 15 |
+
+**2.4 Increment and Loop:**
+After each exchange, we increment the exchange rate and continue until we can't exchange.
+
+**2.5 Return Result:**
+The result is 15, which is the maximum number of bottles we can drink.

explanations/3100/en.md

@@ -0,0 +1,53 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to construct an array of n positive integers where each element is greater than the previous, and the bitwise AND of all elements equals x. We want to minimize the last element.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= n, x <= 10^8`
+- **Time Complexity:** O(log(max(n, x))) as we process bits of n-1
+- **Space Complexity:** O(1) as we only use a few variables
+- **Edge Case:** When n = 1, the result is simply x
+
+**1.2 High-level approach:**
+We merge x with (n-1) by keeping all set bits of x and filling the remaining bit positions with bits from (n-1). This ensures the AND equals x while creating the smallest possible last element.
+
+![Bit manipulation visualization](https://assets.leetcode.com/static_assets/others/bit-manipulation.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Try all possible arrays starting from x, which would be exponential
+- **Optimized Strategy:** Use bit manipulation to merge x with (n-1), ensuring AND equals x while minimizing the result
+- **Emphasize the optimization:** Bit manipulation allows us to directly construct the optimal value without searching
+
+**1.4 Decomposition:**
+1. Start with x as the base result
+2. Process each bit of (n-1) from right to left
+3. For each bit position where x has 0, find the next available 0 position
+4. If the current bit of (n-1) is 1, set the corresponding bit in the result
+5. Continue until all bits of (n-1) are processed
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `n = 3`, `x = 4`
+- Binary: x = 4 = `100`, n-1 = 2 = `10`
+- Initialize: `res = 4` (`100`), `v = 2` (`10`), `bit_pos = 0`
+
+**2.2 Start Processing:**
+We process bits of v and merge them into res.
+
+**2.3 Trace Walkthrough:**
+
+| Step | v | v binary | bit_pos | res binary | Action | res after |
+|------|---|----------|---------|------------|--------|-----------|
+| Start | 2 | 10 | 0 | 100 | Check bit 0 of v | - |
+| 1 | 2 | 10 | 1 | 100 | v has 0 at bit 0, skip | 100 |
+| 2 | 1 | 1 | 1 | 100 | Find pos 1 (x has 0), v has 1, set bit 1 | 110 (6) |
+| 3 | 0 | 0 | 2 | 110 | v is 0, done | 110 (6) |
+
+**2.4 Increment and Loop:**
+After processing all bits, we have the final result.
+
+**2.5 Return Result:**
+The result is 6, which is the minimum last element. The array [4, 5, 6] has AND = 4 and satisfies the conditions.

explanations/3133/en.md

@@ -0,0 +1,53 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to count subarrays of size (m+1) in nums that match a given pattern. The pattern specifies relationships between consecutive elements: 1 means increasing, 0 means equal, -1 means decreasing.
+
+**1.1 Constraints & Complexity:**
+- Input size: `2 <= n <= 100`, `1 <= m < n`
+- **Time Complexity:** O(n * m) where n is array length and m is pattern length, as we check each starting position and each pattern element
+- **Space Complexity:** O(1) as we only use a counter
+- **Edge Case:** When m = 0, all subarrays of size 1 match (trivially)
+
+**1.2 High-level approach:**
+For each possible starting position, we check if the subarray matches the pattern by verifying each pattern condition against the corresponding elements in the subarray.
+
+![Pattern matching visualization](https://assets.leetcode.com/static_assets/others/pattern-matching.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Check all subarrays and verify pattern, which is what we do - this is already optimal for the constraints
+- **Optimized Strategy:** For each starting position, verify pattern conditions sequentially, breaking early if a condition fails
+- **Emphasize the optimization:** Early termination when a pattern condition fails avoids unnecessary checks
+
+**1.4 Decomposition:**
+1. Iterate through all possible starting positions i (from 0 to n-m-1)
+2. For each starting position, check if the subarray matches the pattern
+3. For each pattern element k, verify the relationship between nums[i+k] and nums[i+k+1]
+4. If all pattern conditions are satisfied, increment the counter
+5. Return the total count
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `nums = [1,2,3,4,5,6]`, `pattern = [1,1]`
+- Initialize counter: `res = 0`
+- Pattern means: nums[i+1] > nums[i] and nums[i+2] > nums[i+1]
+
+**2.2 Start Checking:**
+We check each possible starting position.
+
+**2.3 Trace Walkthrough:**
+
+| Start i | Subarray | Check nums[i+1] > nums[i]? | Check nums[i+2] > nums[i+1]? | Match? | Count |
+|---------|----------|----------------------------|------------------------------|--------|-------|
+| 0 | [1,2,3] | 2 > 1 ✓ | 3 > 2 ✓ | Yes | 1 |
+| 1 | [2,3,4] | 3 > 2 ✓ | 4 > 3 ✓ | Yes | 2 |
+| 2 | [3,4,5] | 4 > 3 ✓ | 5 > 4 ✓ | Yes | 3 |
+| 3 | [4,5,6] | 5 > 4 ✓ | 6 > 5 ✓ | Yes | 4 |
+
+**2.4 Increment and Loop:**
+After checking all starting positions, we have the total count.
+
+**2.5 Return Result:**
+The result is 4, representing the 4 subarrays that match the pattern.

explanations/3164/en.md

@@ -0,0 +1,56 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to make the XOR of all array elements equal to k by flipping bits in the binary representation of elements. Each bit flip counts as one operation. We want the minimum number of operations.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= nums.length <= 10^5`
+- **Time Complexity:** O(n) where n is the length of nums, as we iterate once to calculate XOR
+- **Space Complexity:** O(1) as we only use a few variables
+- **Edge Case:** If the XOR of all elements already equals k, we need 0 operations
+
+**1.2 High-level approach:**
+Calculate the XOR of all elements, then count how many bits differ between this XOR value and k. Each differing bit requires exactly one flip operation to correct.
+
+![Bit manipulation visualization](https://assets.leetcode.com/static_assets/others/bit-manipulation.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Try all possible bit flips, which would be exponential
+- **Optimized Strategy:** Calculate the XOR of all elements, find the difference with k, and count the number of set bits in the difference
+- **Emphasize the optimization:** We can determine the minimum operations directly from the bitwise difference, avoiding any search
+
+**1.4 Decomposition:**
+1. Calculate the XOR of all elements in the array
+2. Compute the bitwise XOR between the result and k to find differing bits
+3. Count the number of set bits in the difference
+4. Return the count as the minimum number of operations
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `nums = [2,1,3,4]`, `k = 1`
+- Initialize: `xor_all = 0`
+
+**2.2 Start Calculating:**
+We iterate through the array to calculate XOR.
+
+**2.3 Trace Walkthrough:**
+
+| Element | Binary | xor_all Before | xor_all After | Binary After |
+|---------|--------|----------------|---------------|--------------|
+| 2 | 010 | 000 | 010 | 010 |
+| 1 | 001 | 010 | 011 | 011 |
+| 3 | 011 | 011 | 000 | 000 |
+| 4 | 100 | 000 | 100 | 100 |
+
+Final XOR: 100 (binary) = 4 (decimal)
+k = 1 = 001 (binary)
+Difference: 100 XOR 001 = 101 (binary) = 5 (decimal)
+Set bits in 101: 2 bits
+
+**2.4 Increment and Loop:**
+After processing all elements, we calculate the difference and count bits.
+
+**2.5 Return Result:**
+The result is 2, meaning we need to flip 2 bits to make the XOR equal to k.

explanations/3197/en.md

@@ -0,0 +1,55 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We can remove pairs of elements from the array (first two, last two, or first and last) and get a score equal to their sum. We want to maximize the number of operations where all operations have the same score.
+
+**1.1 Constraints & Complexity:**
+- Input size: `2 <= nums.length <= 2000`
+- **Time Complexity:** O(n²) for DP with memoization, where n is array length
+- **Space Complexity:** O(n²) for the memoization cache
+- **Edge Case:** If all elements are the same, we can perform many operations with the same score
+
+**1.2 High-level approach:**
+Try all three possible first operation scores. For each fixed score, use dynamic programming with memoization to find the maximum number of operations we can perform with that score.
+
+![Dynamic programming visualization](https://assets.leetcode.com/static_assets/others/dynamic-programming.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Try all possible sequences of operations, which is exponential
+- **Optimized Strategy:** Fix the first operation score, then use DP with memoization to find the maximum operations for that score, achieving O(n²) time
+- **Emphasize the optimization:** Memoization avoids recalculating the same subproblems, dramatically reducing time complexity
+
+**1.4 Decomposition:**
+1. Identify the three possible first operation scores (first two, last two, first and last)
+2. For each possible score, use DP to find maximum operations
+3. In DP, for each subarray [l, r], try all three removal options if they match the target score
+4. Use memoization to cache results for subarrays
+5. Return the maximum across all three possible scores
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `nums = [3,2,1,2,3,4]`
+- Possible first scores: 3+2=5, 3+4=7, 4+3=7
+- Try target_score = 5
+
+**2.2 Start DP:**
+We use memoized DP to find maximum operations for score 5.
+
+**2.3 Trace Walkthrough:**
+
+| Subarray | Options | Best Result |
+|----------|---------|-------------|
+| [3,2,1,2,3,4] | Remove first two (5), Remove last two (7), Remove first+last (7) | 1 + dp([1,2,3,4]) |
+| [1,2,3,4] | Remove first+last (5) | 1 + dp([2,3]) |
+| [2,3] | Remove first+last (5) | 1 + dp([]) |
+| [] | Base case | 0 |
+
+Total: 1 + 1 + 1 = 3 operations
+
+**2.4 Increment and Loop:**
+After trying all three possible scores, we take the maximum.
+
+**2.5 Return Result:**
+The result is 3, which is the maximum number of operations with the same score.

explanations/3228/en.md

@@ -0,0 +1,53 @@
+## Explanation
+
+### Strategy (The "Why")
+
+**Restate the problem:** We need to form the target string by concatenating valid strings, where a valid string is any prefix of a word in the words array. We want the minimum number of valid strings needed.
+
+**1.1 Constraints & Complexity:**
+- Input size: `1 <= words.length <= 100`, `1 <= target.length <= 5000`
+- **Time Complexity:** O(sum(word_lengths) + n * m) where n is target length and m is average prefix length, using Trie
+- **Space Complexity:** O(sum(word_lengths)) for the Trie
+- **Edge Case:** If target starts with a character not in any word, return -1
+
+**1.2 High-level approach:**
+Build a Trie of all prefixes from words, then use dynamic programming where dp[i] represents the minimum valid strings needed to form target[0:i]. For each position, use the Trie to find all matching prefixes.
+
+![Trie and DP visualization](https://assets.leetcode.com/static_assets/others/trie-dp.png)
+
+**1.3 Brute force vs. optimized strategy:**
+- **Brute Force:** Try all possible prefix combinations, which is exponential
+- **Optimized Strategy:** Use Trie for efficient prefix matching and DP to track minimum cost, achieving polynomial time
+- **Emphasize the optimization:** The Trie allows O(m) prefix matching instead of O(m * word_count), and DP avoids recalculating subproblems
+
+**1.4 Decomposition:**
+1. Build a Trie containing all prefixes from all words
+2. Initialize DP array where dp[i] = minimum valid strings for target[0:i]
+3. For each position i in target, use Trie to find all matching prefixes starting at i
+4. Update dp[j] for each matching prefix ending at j
+5. Return dp[n] or -1 if impossible
+
+### Steps (The "How")
+
+**2.1 Initialization & Example Setup:**
+Let's use the example: `words = ["abc","aaaaa","bcdef"]`, `target = "aabcdabc"`
+- Build Trie with prefixes: "a", "aa", "aaa", ..., "abc", "bcd", "bcde", "bcdef", ...
+- Initialize: `dp = [0, inf, inf, ...]`
+
+**2.2 Start Processing:**
+We use DP with Trie to find matching prefixes.
+
+**2.3 Trace Walkthrough:**
+
+| Position i | Trie Match | Prefix | End j | dp[j] Before | dp[j] After |
+|------------|-----------|--------|-------|--------------|-------------|
+| 0 | "aa" | "aa" | 2 | inf | 1 |
+| 0 | "a" | "a" | 1 | inf | 1 |
+| 2 | "bcd" | "bcd" | 5 | inf | 2 |
+| 5 | "abc" | "abc" | 8 | inf | 3 |
+
+**2.4 Increment and Loop:**
+After processing all positions, we have dp[8] = 3.
+
+**2.5 Return Result:**
+The result is 3, which is the minimum number of valid strings: "aa" + "bcd" + "abc" = "aabcdabc".