Feb-17

Author: geemaple

README.md

@@ -0,0 +1,87 @@
+//  Tag: Hash Table, String, Backtracking, Counting
+//  Time: O(N!)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/Q2z9GbjkWmo
+
+//  You have n  tiles, where each tile has one letter tiles[i] printed on it.
+//  Return the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.
+//   
+//  Example 1:
+//  
+//  Input: tiles = "AAB"
+//  Output: 8
+//  Explanation: The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".
+//  
+//  Example 2:
+//  
+//  Input: tiles = "AAABBC"
+//  Output: 188
+//  
+//  Example 3:
+//  
+//  Input: tiles = "V"
+//  Output: 1
+//  
+//   
+//  Constraints:
+//  
+//  1 <= tiles.length <= 7
+//  tiles consists of uppercase English letters.
+//  
+//  
+
+class Solution {
+public:
+    int numTilePossibilities(string tiles) {
+        int n = tiles.size();
+        sort(tiles.begin(), tiles.end());
+        vector<bool> used(n, false);
+        vector<string> res;
+        helper(tiles, used, res, "");
+
+        return res.size();
+    }
+
+    void helper(string tiles, vector<bool> &used, vector<string> &res, string tmp) {
+        for (int i = 0; i < tiles.size(); i++) {
+            if (used[i]) {
+                continue;
+            }
+
+            if (i == 0 || tiles[i] != tiles[i - 1] || used[i - 1]) {
+                used[i] = true;
+                string sub = tmp + tiles[i];
+                res.push_back(sub);
+                helper(tiles, used, res, sub);
+                used[i] = false;
+            }
+        }
+    }
+};
+
+class Solution {
+public:
+    int res = 0;
+
+    int numTilePossibilities(string tiles) {
+        unordered_map<char,int>map;
+        for(char ch : tiles) {
+            map[ch]++;
+        }   
+        backtrack(map); 
+        return res;
+    }
+
+    void backtrack(unordered_map<char, int>& map) {
+        for(auto &[ch,count] : map) {
+            if(count > 0) {
+                res++;
+                map[ch]--;
+                backtrack(map);
+                map[ch]++;
+            }
+        }
+    }
+};

leetcode/1079.letter-tile-possibilities.cpp

@@ -0,0 +1,70 @@
+#  Tag: Hash Table, String, Backtracking, Counting
+#  Time: O(N!)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/Q2z9GbjkWmo
+
+#  You have n  tiles, where each tile has one letter tiles[i] printed on it.
+#  Return the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.
+#   
+#  Example 1:
+#  
+#  Input: tiles = "AAB"
+#  Output: 8
+#  Explanation: The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".
+#  
+#  Example 2:
+#  
+#  Input: tiles = "AAABBC"
+#  Output: 188
+#  
+#  Example 3:
+#  
+#  Input: tiles = "V"
+#  Output: 1
+#  
+#   
+#  Constraints:
+#  
+#  1 <= tiles.length <= 7
+#  tiles consists of uppercase English letters.
+#  
+#  
+
+class Solution:
+    def numTilePossibilities(self, tiles: str) -> int:
+        n = len(tiles)
+        used = [False for i in range(n)]
+        res = []
+
+        self.helper(sorted(tiles), used, res, "")
+        return len(res)
+
+    def helper(self, tiles: list, used: list, res: list, tmp: str):
+        for i in range(len(tiles)):
+            if used[i]:
+                continue
+
+            if i == 0 or tiles[i] != tiles[i - 1] or used[i - 1]:
+                used[i] = True
+                sub = tmp + tiles[i]
+                res.append(sub)
+                self.helper(tiles, used, res, sub)
+                used[i] = False
+
+from collections import Counter
+class Solution:
+    def numTilePossibilities(self, tiles: str) -> int:
+        self.res = 0 
+        freq = Counter(tiles)
+        self.backtrack(freq)
+        return self.res
+
+    def backtrack(self, freq):
+        for ch in freq:
+            if freq[ch] > 0:
+                self.res += 1
+                freq[ch] -= 1
+                self.backtrack(freq)
+                freq[ch] += 1

leetcode/1079.letter-tile-possibilities.py

@@ -0,0 +1,103 @@
+//  Tag: String, Dynamic Programming, Greedy, Sliding Window
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  You are given a binary string s. You are allowed to perform two types of operations on the string in any sequence:
+//  
+//  Type-1: Remove the character at the start of the string s and append it to the end of the string.
+//  Type-2: Pick any character in s and flip its value, i.e., if its value is '0' it becomes '1' and vice-versa.
+//  
+//  Return the minimum number of type-2 operations you need to perform such that s becomes alternating.
+//  The string is called alternating if no two adjacent characters are equal.
+//  
+//  For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
+//  
+//   
+//  Example 1:
+//  
+//  Input: s = "111000"
+//  Output: 2
+//  Explanation: Use the first operation two times to make s = "100011".
+//  Then, use the second operation on the third and sixth elements to make s = "101010".
+//  
+//  Example 2:
+//  
+//  Input: s = "010"
+//  Output: 0
+//  Explanation: The string is already alternating.
+//  
+//  Example 3:
+//  
+//  Input: s = "1110"
+//  Output: 1
+//  Explanation: Use the second operation on the second element to make s = "1010".
+//  
+//   
+//  Constraints:
+//  
+//  1 <= s.length <= 105
+//  s[i] is either '0' or '1'.
+//  
+//  
+
+class Solution {
+public:
+    int minFlips(string s) {
+        int n = s.size();
+        vector<int> counter = {0, 0};
+        int outer = (n + 1) / 2;
+        int inner = n - outer;
+        int res = n;
+        for (int i = 0; i < 2 * n; i++) {
+            if (i >= n) {
+                counter[(i - n) & 1] -= (s[i - n] - '0');
+            }
+
+            counter[i & 1] += (s[i % n] - '0');
+            if (i >= n - 1) {
+                int k = (i - n + 1) % 2;
+                int count = min(outer - counter[k] + counter[1 - k], counter[k] + inner - counter[1 - k]);
+                res = min(res, count);
+            }
+        }
+
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int minFlips(string s) {
+        int k = s.size();
+        s += s; 
+        int n = s.size();
+        string s1 = "", s2 = "";
+
+        for (int i = 0; i < n; ++i) {
+            s1 += (i % 2 == 0) ? '1' : '0';
+            s2 += (i % 2 == 1) ? '1' : '0';
+        }
+
+        int res = k;
+        int count1 = 0, count2 = 0;
+
+
+        for (int i = 0; i < n; ++i) {
+            if (i >= k) {
+                if (s[i - k] != s1[i - k]) count1--;
+                if (s[i - k] != s2[i - k]) count2--;
+            }
+
+            if (s[i] != s1[i]) count1++;
+            if (s[i] != s2[i]) count2++;
+
+            if (i >= k - 1) {
+                res = min(res, min(count1, count2));
+            }
+        }
+
+        return res;
+    }
+};

leetcode/1888.minimum-number-of-flips-to-make-the-binary-string-alternating.cpp

@@ -0,0 +1,95 @@
+#  Tag: String, Dynamic Programming, Greedy, Sliding Window
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  You are given a binary string s. You are allowed to perform two types of operations on the string in any sequence:
+#  
+#  Type-1: Remove the character at the start of the string s and append it to the end of the string.
+#  Type-2: Pick any character in s and flip its value, i.e., if its value is '0' it becomes '1' and vice-versa.
+#  
+#  Return the minimum number of type-2 operations you need to perform such that s becomes alternating.
+#  The string is called alternating if no two adjacent characters are equal.
+#  
+#  For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
+#  
+#   
+#  Example 1:
+#  
+#  Input: s = "111000"
+#  Output: 2
+#  Explanation: Use the first operation two times to make s = "100011".
+#  Then, use the second operation on the third and sixth elements to make s = "101010".
+#  
+#  Example 2:
+#  
+#  Input: s = "010"
+#  Output: 0
+#  Explanation: The string is already alternating.
+#  
+#  Example 3:
+#  
+#  Input: s = "1110"
+#  Output: 1
+#  Explanation: Use the second operation on the second element to make s = "1010".
+#  
+#   
+#  Constraints:
+#  
+#  1 <= s.length <= 105
+#  s[i] is either '0' or '1'.
+#  
+#  
+
+class Solution:
+    def minFlips(self, s: str) -> int:
+        k = len(s)
+        s += s
+        n = len(s)
+        s1 = ""
+        s2 = ""
+        for i in range(n):
+            s1 += '1' if i % 2 == 0 else '0'
+            s2 += '1' if i % 2 == 1 else '0'
+
+        res = k
+        count1 = 0
+        count2 = 0
+        for i in range(n):
+            if i >= k:
+                if s[i - k] != s1[i - k]:
+                    count1 -= 1
+                if s[i - k] != s2[i - k]:
+                    count2 -= 1
+
+            if s[i] != s1[i]:
+                count1 += 1
+            if s[i] != s2[i]:
+                count2 += 1
+
+            if i >= k - 1:
+                res = min(res, count1, count2)
+     
+        return res
+
+class Solution:
+    def minFlips(self, s: str) -> int:
+        n = len(s)
+        counter = [0, 0]
+        outer = (n + 1) // 2
+        inner = n - outer
+
+        res = n
+        for i in range(2 * n):
+            if i >= n:
+                counter[(i - n) & 1] -= int(s[i - n])
+
+            counter[i & 1] += int(s[i % n])
+
+            if i >= n - 1:
+                k = (i - n + 1) % 2
+                count = min(outer - counter[k] + counter[1 - k], counter[k] + inner - counter[1 - k])
+                res = min(res, count)
+
+        return res