chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-04-12-1320-Minimum-Distance-to-Type-a-Word-Using-Two-Fingers/explanation.md

@@ -0,0 +1,34 @@
+# Minimum Distance to Type a Word Using Two Fingers (Hard)
+
+**Problem ID:** 1320  
+**Date:** 2026-04-12  
+**Link:** https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/
+
+## Approach
+
+To solve the problem of finding the minimum distance to type a word using two fingers on a keyboard represented in a 2D plane, we can adopt a dynamic programming approach. Here’s a concise breakdown of the solution:
+
+### Main Idea:
+The goal is to minimize the total distance traveled by two fingers as they type out the given word, where the distance between two letters is defined by their Manhattan distance on the keyboard layout. We will use dynamic programming to keep track of the minimum distances for typing each letter in the word while considering the positions of both fingers.
+
+### Data Structures:
+1. **Distance Matrix**: Precompute the distances between all pairs of letters based on their coordinates on the keyboard. This will allow us to quickly look up the distance between any two letters.
+2. **Dynamic Programming Table**: Use a 3D DP table `dp[i][j][k]`, where:
+   - `i` represents the index of the current letter in the word.
+   - `j` represents the position of the first finger (the last letter typed by finger 1).
+   - `k` represents the position of the second finger (the last letter typed by finger 2).
+   The value `dp[i][j][k]` will store the minimum distance required to type the first `i` letters of the word with finger 1 on letter `j` and finger 2 on letter `k`.
+
+### Approach:
+1. **Initialization**: Start by initializing the DP table for the first letter of the word, allowing both fingers to start on any letter without any initial cost.
+2. **Transition**: For each letter in the word (from the second letter onward):
+   - Iterate through all possible positions of the two fingers (from the previous letter).
+   - Calculate the cost of moving either finger to the current letter and update the DP table accordingly.
+   - The transition will consider moving either finger to the current letter and accumulating the distance based on the previous positions of both fingers.
+3. **Final Computation**: After processing all letters, the answer will be the minimum value in the last layer of the DP table, which corresponds to typing the entire word.
+
+### Complexity:
+- **Time Complexity**: O(n * 26 * 26), where `n` is the length of the word (up to 300) and 26 represents the number of uppercase English letters. This is because for each letter, we consider all pairs of finger positions.
+- **Space Complexity**: O(n * 26 * 26) for the DP table, although optimizations can be made to reduce space usage by only storing the last two layers of the DP table.
+
+This approach ensures that we systematically explore all possible configurations of finger placements while efficiently calculating the minimum distance required to type the word.

Hard/2026-04-12-1320-Minimum-Distance-to-Type-a-Word-Using-Two-Fingers/solution.java

@@ -0,0 +1,36 @@
+class Solution {
+    private final int[][] keyboard = new int[26][2];
+
+    public int minimumDistance(String word) {
+        initializeKeyboard();
+        int n = word.length();
+        Integer[][][] dp = new Integer[n + 1][27][27];
+        return dfs(word, 0, 26, 26, dp);
+    }
+
+    private int dfs(String word, int index, int finger1, int finger2, Integer[][][] dp) {
+        if (index == word.length()) return 0;
+        if (dp[index][finger1][finger2] != null) return dp[index][finger1][finger2];
+
+        int letterIndex = word.charAt(index) - 'A';
+        int distance1 = (finger1 == 26) ? 0 : getDistance(finger1, letterIndex);
+        int distance2 = (finger2 == 26) ? 0 : getDistance(finger2, letterIndex);
+
+        int moveFinger1 = distance1 + dfs(word, index + 1, letterIndex, finger2, dp);
+        int moveFinger2 = distance2 + dfs(word, index + 1, finger1, letterIndex, dp);
+
+        dp[index][finger1][finger2] = Math.min(moveFinger1, moveFinger2);
+        return dp[index][finger1][finger2];
+    }
+
+    private int getDistance(int finger, int letter) {
+        return Math.abs(keyboard[finger][0] - keyboard[letter][0]) + Math.abs(keyboard[finger][1] - keyboard[letter][1]);
+    }
+
+    private void initializeKeyboard() {
+        for (int i = 0; i < 26; i++) {
+            keyboard[i][0] = i / 6; // x-coordinate
+            keyboard[i][1] = i % 6; // y-coordinate
+        }
+    }
+}

Hard/2026-04-12-1320-Minimum-Distance-to-Type-a-Word-Using-Two-Fingers/solution.js

@@ -0,0 +1,27 @@
+var minimumDistance = function(word) {
+    const positions = {};
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    
+    for (let i = 0; i < alphabet.length; i++) {
+        positions[alphabet[i]] = [Math.floor(i / 6), i % 6];
+    }
+    
+    const n = word.length;
+    const dp = Array.from({ length: n + 1 }, () => Array(27).fill(Infinity));
+    dp[0][26] = 0; // Starting with both fingers free
+
+    for (let i = 0; i < n; i++) {
+        const [x1, y1] = positions[word[i]];
+        for (let j = 0; j <= 26; j++) {
+            if (dp[i][j] === Infinity) continue;
+            // Move finger 1 to current letter
+            const dist1 = j === 26 ? 0 : Math.abs(x1 - positions[alphabet[j]][0]) + Math.abs(y1 - positions[alphabet[j]][1]);
+            dp[i + 1][i] = Math.min(dp[i + 1][i], dp[i][j] + dist1);
+            // Move finger 2 to current letter
+            const dist2 = j === 26 ? 0 : Math.abs(x1 - positions[alphabet[j]][0]) + Math.abs(y1 - positions[alphabet[j]][1]);
+            dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j] + dist2);
+        }
+    }
+
+    return Math.min(...dp[n]);
+};

Hard/2026-04-12-1320-Minimum-Distance-to-Type-a-Word-Using-Two-Fingers/solution.py

@@ -0,0 +1,27 @@
+class Solution:
+    def minimumDistance(self, word: str) -> int:
+        # Keyboard layout coordinates
+        keyboard = {chr(i): (i // 6, i % 6) for i in range(ord('A'), ord('Z') + 1)}
+        
+        n = len(word)
+        dp = [[[float('inf')] * 26 for _ in range(26)] for _ in range(n + 1)]
+        
+        # Initial positions of fingers are free
+        for i in range(26):
+            dp[0][i][i] = 0
+        
+        for i in range(1, n + 1):
+            curr_char = word[i - 1]
+            curr_x, curr_y = keyboard[curr_char]
+            for j in range(26):
+                for k in range(26):
+                    # Move finger 1 to current character
+                    dp[i][ord(curr_char) - ord('A')][k] = min(dp[i][ord(curr_char) - ord('A')][k], 
+                                                                dp[i - 1][j][k] + (abs(curr_x - keyboard[chr(j + ord('A'))][0]) + 
+                                                                                   abs(curr_y - keyboard[chr(j + ord('A'))][1])))
+                    # Move finger 2 to current character
+                    dp[i][j][ord(curr_char) - ord('A')] = min(dp[i][j][ord(curr_char) - ord('A')], 
+                                                                dp[i - 1][j][k] + (abs(curr_x - keyboard[chr(k + ord('A'))][0]) + 
+                                                                                   abs(curr_y - keyboard[chr(k + ord('A'))][1])))
+        
+        return min(dp[n][j][k] for j in range(26) for k in range(26))

README.md

@@ -421,3 +421,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-09 — [XOR After Range Multiplication Queries II](https://leetcode.com/problems/xor-after-range-multiplication-queries-ii/) (Hard) → `Hard/2026-04-09-3655-XOR-After-Range-Multiplication-Queries-II`
 - 2026-04-10 — [Minimum Distance Between Three Equal Elements I](https://leetcode.com/problems/minimum-distance-between-three-equal-elements-i/) (Easy) → `Easy/2026-04-10-3740-Minimum-Distance-Between-Three-Equal-Elements-I`
 - 2026-04-11 — [Minimum Distance Between Three Equal Elements II](https://leetcode.com/problems/minimum-distance-between-three-equal-elements-ii/) (Medium) → `Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II`
+- 2026-04-12 — [Minimum Distance to Type a Word Using Two Fingers](https://leetcode.com/problems/minimum-distance-to-type-a-word-using-two-fingers/) (Hard) → `Hard/2026-04-12-1320-Minimum-Distance-to-Type-a-Word-Using-Two-Fingers`