May-28

Author: geemaple

README.md

@@ -0,0 +1,54 @@
+//  Tag: Array, Two Pointers
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.
+//  Note that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.
+//   
+//  Example 1:
+//  
+//  Input: arr = [1,0,2,3,0,4,5,0]
+//  Output: [1,0,0,2,3,0,0,4]
+//  Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]
+//  
+//  Example 2:
+//  
+//  Input: arr = [1,2,3]
+//  Output: [1,2,3]
+//  Explanation: After calling your function, the input array is modified to: [1,2,3]
+//  
+//   
+//  Constraints:
+//  
+//  1 <= arr.length <= 104
+//  0 <= arr[i] <= 9
+//  
+//  
+
+class Solution {
+public:
+    void duplicateZeros(vector<int>& arr) {
+        int n = arr.size();
+        int shift = 0;
+        int i = 0;
+        for (; i + shift < n; i++) {
+            shift += arr[i] == 0;
+        }
+
+        for (int j = i - 1; shift > 0; j--) {
+            if (j + shift < n) {
+                arr[j + shift] = arr[j];
+            }
+
+            if (arr[j] == 0) {
+                arr[j + shift - 1] = arr[j];
+                shift -= 1;
+            }
+
+        }
+
+
+    }
+};

leetcode/1089.duplicate-zeros.cpp

@@ -0,0 +1,48 @@
+#  Tag: Array, Two Pointers
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.
+#  Note that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.
+#   
+#  Example 1:
+#  
+#  Input: arr = [1,0,2,3,0,4,5,0]
+#  Output: [1,0,0,2,3,0,0,4]
+#  Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]
+#  
+#  Example 2:
+#  
+#  Input: arr = [1,2,3]
+#  Output: [1,2,3]
+#  Explanation: After calling your function, the input array is modified to: [1,2,3]
+#  
+#   
+#  Constraints:
+#  
+#  1 <= arr.length <= 104
+#  0 <= arr[i] <= 9
+#  
+#  
+
+class Solution:
+    def duplicateZeros(self, arr: List[int]) -> None:
+        """
+        Do not return anything, modify arr in-place instead.
+        """
+        n = len(arr)
+        shift = 0
+        i = 0
+        while i + shift < n:
+            shift += arr[i] == 0
+            i += 1
+
+        for j in range(i - 1, -1, -1):
+            if j + shift < n:
+                arr[j + shift] = arr[j]
+
+            if arr[j] == 0:
+                arr[j + shift - 1] = arr[j]
+                shift -= 1

leetcode/1089.duplicate-zeros.py

@@ -0,0 +1,78 @@
+//  Tag: Hash Table, Dynamic Programming, Graph, Topological Sort, Memoization, Counting
+//  Time: O(N + M)
+//  Space: O(N + M)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/_zRcPgszGK8
+
+//  There is a directed graph of n colored nodes and m edges. The nodes are numbered from 0 to n - 1.
+//  You are given a string colors where colors[i] is a lowercase English letter representing the color of the ith node in this graph (0-indexed). You are also given a 2D array edges where edges[j] = [aj, bj] indicates that there is a directed edge from node aj to node bj.
+//  A valid path in the graph is a sequence of nodes x1 -> x2 -> x3 -> ... -> xk such that there is a directed edge from xi to xi+1 for every 1 <= i < k. The color value of the path is the number of nodes that are colored the most frequently occurring color along that path.
+//  Return the largest color value of any valid path in the given graph, or -1 if the graph contains a cycle.
+//   
+//  Example 1:
+//  
+//  
+//  Input: colors = "abaca", edges = [[0,1],[0,2],[2,3],[3,4]]
+//  Output: 3
+//  Explanation: The path 0 -> 2 -> 3 -> 4 contains 3 nodes that are colored "a" (red in the above image).
+//  
+//  Example 2:
+//  
+//  
+//  Input: colors = "a", edges = [[0,0]]
+//  Output: -1
+//  Explanation: There is a cycle from 0 to 0.
+//  
+//   
+//  Constraints:
+//  
+//  n == colors.length
+//  m == edges.length
+//  1 <= n <= 105
+//  0 <= m <= 105
+//  colors consists of lowercase English letters.
+//  0 <= aj, bj < n
+//  
+
+class Solution {
+public:
+    int largestPathValue(string colors, vector<vector<int>>& edges) {
+        int n = colors.size();
+        int res = 0;
+        vector<vector<int>>dp(n, vector<int>(26, 0));
+        unordered_map<int, vector<int>> graph;
+        vector<int> indegree(n, 0);
+        for (auto &e: edges) {
+            graph[e[0]].push_back(e[1]);
+            indegree[e[1]] += 1;
+        }
+
+        queue<int> q;
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                q.push(i);
+            }
+        }
+
+        int visited = 0;
+        while (!q.empty()) {
+            int i = q.front();
+            q.pop();
+            visited += 1;
+            dp[i][colors[i] - 'a'] += 1; 
+            res = max(res, dp[i][colors[i] - 'a']);
+
+            for (auto &j: graph[i]) {
+                for (int c = 0; c < 26; c++) {
+                    dp[j][c] = max(dp[j][c], dp[i][c]);
+                }
+                indegree[j] -= 1;
+                if (indegree[j] == 0) {
+                    q.push(j);
+                }
+            }
+        }
+        return visited == n ? res : -1;
+    }
+};

leetcode/1857.largest-color-value-in-a-directed-graph.cpp

@@ -0,0 +1,71 @@
+#  Tag: Hash Table, Dynamic Programming, Graph, Topological Sort, Memoization, Counting
+#  Time: O(N + M)
+#  Space: O(N + M)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/_zRcPgszGK8
+
+#  There is a directed graph of n colored nodes and m edges. The nodes are numbered from 0 to n - 1.
+#  You are given a string colors where colors[i] is a lowercase English letter representing the color of the ith node in this graph (0-indexed). You are also given a 2D array edges where edges[j] = [aj, bj] indicates that there is a directed edge from node aj to node bj.
+#  A valid path in the graph is a sequence of nodes x1 -> x2 -> x3 -> ... -> xk such that there is a directed edge from xi to xi+1 for every 1 <= i < k. The color value of the path is the number of nodes that are colored the most frequently occurring color along that path.
+#  Return the largest color value of any valid path in the given graph, or -1 if the graph contains a cycle.
+#   
+#  Example 1:
+#  
+#  
+#  Input: colors = "abaca", edges = [[0,1],[0,2],[2,3],[3,4]]
+#  Output: 3
+#  Explanation: The path 0 -> 2 -> 3 -> 4 contains 3 nodes that are colored "a" (red in the above image).
+#  
+#  Example 2:
+#  
+#  
+#  Input: colors = "a", edges = [[0,0]]
+#  Output: -1
+#  Explanation: There is a cycle from 0 to 0.
+#  
+#   
+#  Constraints:
+#  
+#  n == colors.length
+#  m == edges.length
+#  1 <= n <= 105
+#  0 <= m <= 105
+#  colors consists of lowercase English letters.
+#  0 <= aj, bj < n
+#  
+
+from collections import defaultdict, deque
+class Solution:
+    def largestPathValue(self, colors: str, edges: List[List[int]]) -> int:
+        n = len(colors)
+        graph = defaultdict(list)
+        indegree = defaultdict(int)
+        for s, e in edges:
+            graph[s].append(e)
+            indegree[e] += 1
+
+        q = deque()
+        dp = [[0] * 26 for i in range(n)]
+        res = 0
+        for i in range(n):
+            if indegree[i] == 0:
+                q.append(i)
+
+        visited = 0
+        while len(q) > 0:
+            i = q.popleft()
+            visited += 1
+            k = ord(colors[i]) - ord('a')
+            dp[i][k] += 1
+            res = max(res, dp[i][k])
+
+            for j in graph[i]:
+                for c in range(26):
+                    dp[j][c] = max(dp[j][c], dp[i][c])
+
+                indegree[j] -= 1
+                if indegree[j] == 0:
+                    q.append(j)
+
+        return res if visited == n else -1

leetcode/1857.largest-color-value-in-a-directed-graph.py

@@ -0,0 +1,68 @@
+//  Tag: Array, Hash Table, String, Greedy, Counting
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/NJQJtJu8drg
+
+//  You are given an array of strings words. Each element of words consists of two lowercase English letters.
+//  Create the longest possible palindrome by selecting some elements from words and concatenating them in any order. Each element can be selected at most once.
+//  Return the length of the longest palindrome that you can create. If it is impossible to create any palindrome, return 0.
+//  A palindrome is a string that reads the same forward and backward.
+//   
+//  Example 1:
+//  
+//  Input: words = ["lc","cl","gg"]
+//  Output: 6
+//  Explanation: One longest palindrome is "lc" + "gg" + "cl" = "lcggcl", of length 6.
+//  Note that "clgglc" is another longest palindrome that can be created.
+//  
+//  Example 2:
+//  
+//  Input: words = ["ab","ty","yt","lc","cl","ab"]
+//  Output: 8
+//  Explanation: One longest palindrome is "ty" + "lc" + "cl" + "yt" = "tylcclyt", of length 8.
+//  Note that "lcyttycl" is another longest palindrome that can be created.
+//  
+//  Example 3:
+//  
+//  Input: words = ["cc","ll","xx"]
+//  Output: 2
+//  Explanation: One longest palindrome is "cc", of length 2.
+//  Note that "ll" is another longest palindrome that can be created, and so is "xx".
+//  
+//   
+//  Constraints:
+//  
+//  1 <= words.length <= 105
+//  words[i].length == 2
+//  words[i] consists of lowercase English letters.
+//  
+//  
+
+class Solution {
+public:
+    int longestPalindrome(vector<string>& words) {
+        unordered_map<string, int> counter;
+        for (auto &s: words) {
+            counter[s] += 1;
+        }
+
+        int res = 0;
+        int center = 0;
+        for (auto &[w, count]: counter) {
+            auto reversed = string(w.rbegin(), w.rend());
+            if (w == reversed) {
+                res += 2 * (count / 2) ;
+                center = max(center, count % 2);
+            } else {
+                auto it = counter.find(reversed);
+                if (it != counter.end()) {
+                    res += min(count, it->second);
+                }
+            }
+        }
+
+        return (res + center) * 2;
+    }
+};

leetcode/2131.longest-palindrome-by-concatenating-two-letter-words.cpp

@@ -0,0 +1,60 @@
+#  Tag: Array, Hash Table, String, Greedy, Counting
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/NJQJtJu8drg
+
+#  You are given an array of strings words. Each element of words consists of two lowercase English letters.
+#  Create the longest possible palindrome by selecting some elements from words and concatenating them in any order. Each element can be selected at most once.
+#  Return the length of the longest palindrome that you can create. If it is impossible to create any palindrome, return 0.
+#  A palindrome is a string that reads the same forward and backward.
+#   
+#  Example 1:
+#  
+#  Input: words = ["lc","cl","gg"]
+#  Output: 6
+#  Explanation: One longest palindrome is "lc" + "gg" + "cl" = "lcggcl", of length 6.
+#  Note that "clgglc" is another longest palindrome that can be created.
+#  
+#  Example 2:
+#  
+#  Input: words = ["ab","ty","yt","lc","cl","ab"]
+#  Output: 8
+#  Explanation: One longest palindrome is "ty" + "lc" + "cl" + "yt" = "tylcclyt", of length 8.
+#  Note that "lcyttycl" is another longest palindrome that can be created.
+#  
+#  Example 3:
+#  
+#  Input: words = ["cc","ll","xx"]
+#  Output: 2
+#  Explanation: One longest palindrome is "cc", of length 2.
+#  Note that "ll" is another longest palindrome that can be created, and so is "xx".
+#  
+#   
+#  Constraints:
+#  
+#  1 <= words.length <= 105
+#  words[i].length == 2
+#  words[i] consists of lowercase English letters.
+#  
+#  
+
+from collections import Counter
+class Solution:
+    def longestPalindrome(self, words: List[str]) -> int:
+        counter = Counter(words)
+        res = 0
+        center = 0
+
+        for w in counter:
+            p = w[::-1]
+            if w == p:
+                count = counter[w]
+                res += 2 * (count // 2)
+                center = max(center, count % 2)
+            elif p in counter:
+                count = min(counter[w], counter[p])
+                res += count
+ 
+        return (res + center) * 2