youtube_live strings and dp

Livestream: https://www.youtube.com/watch?v=lU6dNcpCzPU

Problems solved: https://leetcode.com/problems/unique-email-addresses/
https://leetcode.com/problems/find-and-replace-pattern
https://leetcode.com/problems/palindromic-substrings/
https://leetcode.com/problems/find-the-longest-substring-containing-vowels-in-even-counts/

Author: rachitiitr

LeetCode/1371.find-the-longest-substring-containing-vowels-in-even-counts.cpp

@@ -0,0 +1,59 @@
+string vowels = "aeiou";
+class Solution {
+public:
+    int findTheLongestSubstring(string s) {
+        int n = s.size();
+        int ans = 0;
+        unordered_map<char, vector<int>> pref = {};
+        for (char v: vowels) pref[v] = {0};
+        
+        for(char cur: s) {
+            for(char v: vowels) {
+                int last_parity = *pref[v].rbegin();
+                if (cur == v) pref[v].push_back(1 - last_parity);
+                else pref[v].push_back(last_parity);
+            }
+        }
+        
+        auto get_column = [&](int j) { // 1 based
+            int id = 0;
+            for(char v: vowels) {
+                int x = pref[v][j];
+                id = 2*id + x;
+            }
+            return id;
+        };
+        
+        int rightmost[33];
+        rightmost[0] = 0;
+        for (int i = 1; i <= n; i++) {
+            int id = get_column(i);
+            rightmost[id] = i;
+        }
+   
+        for (int i = 1; i <= n; i++) {
+            // find the rightmost j substring(i, j) is valid
+            // ith column
+            int id = get_column(i-1);
+            int j = rightmost[id];
+            if (j < i) continue;
+            ans = max(ans, j-i+1);
+        }    
+        return ans;
+    }
+};
+
+/*
+_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
+    i                 ^   ^
+    maintain prefix count of all vowels pref[a][7] 
+      a,b,a,e,e,a,e
+          i   j
+a - 0,1,1,0,0,0,1,1
+e - 0,0,0,0,1,0,0,1
+i - ...,1,.....,1
+o - ...,0,.....,1
+u - ...,0,.....,0
+10100 <-- 20
+n^2 substrings -> O(n) => overall O(n^3)
+*/

LeetCode/647.panlindrmoic-substrings.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int countSubstrings(string s) {
+        int n = s.size();
+        vector<vector<bool>> dp(n, vector<bool>(n, 0));
+        for(int i = 0; i < n; i++)
+            dp[i][i] = 1;
+        
+        // fill this dp
+        for(int len = 2; len <= n; len++) {
+            for(int i = 0; i + len - 1 < n; i++) {
+                // starting from i, and length len
+                int j = i + len - 1;
+                if (i+1 == j) {
+                    dp[i][j] = s[i] == s[j];
+                }
+                else {
+                    dp[i][j] = s[i] == s[j] && dp[i+1][j-1];
+                }
+            }
+        }
+        
+        int ans = 0;
+        for(int i = 0; i < n; i++)
+        for(int j = 0; j < n; j++)
+            ans += dp[i][j];
+        return ans;
+    }
+};
+/*
+for substring in all_subtrings;
+    if palindrome(substring)
+        ans++;
+
+
+dp[i][j] = substring(i, i+1, ..., j) = is this a palindrome
+
+s[i] == s[j] && dp[i+1][j-1] should be true
+*/

LeetCode/890.find-and-replace-patterns.cpp

@@ -0,0 +1,45 @@
+class Solution {
+    bool matches(string word, string pattern) {
+        int n = word.size();
+        vector<int> forward(26, -1), backward(26, -1);
+        // map<char, char> forward, backward; unordered_map
+        for(int i = 0; i < n; i++) {
+            int x = word[i] - 'a', y = pattern[i] - 'a';
+            // I am trying to map x to y
+            if(forward[x] != -1 && forward[x] != y) return false;
+            if(backward[y] != -1 && backward[y] != x) return false;
+            forward[x] = y;
+            backward[y] = x;
+        }
+        
+        return true;
+    }
+    
+public:
+    vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
+        vector<string> ans = {};
+        // O(n * k) k is avg word size
+        for (auto word: words) {
+            if (matches(word, pattern)) ans.push_back(word);
+        }
+        
+        return ans;
+    }
+};
+
+/* abb xyy yxx 
+
+// abbccc 
+// matches - xyyzzz yzzxxx
+// does not match - xyyxxx
+
+abbccc yzzxxx
+abbccc xyyxxx
+
+if a is mapped to y, then - 
+    - a shall never be mapped to anything else
+    - no other char shall be mapped to y
+    
+math background - 
+1:1 mapping
+*/

LeetCode/929.unique-email-address.cpp

@@ -0,0 +1,32 @@
+class Solution {
+    string get_normalized(string email) {
+        int i;
+        string local_name = "";
+        bool ignore_chars = false;
+        for(i = 0; i < email.size(); i++) {
+            char c = email[i];
+            if (c == '@') {
+                break;
+            }
+            
+            if (c == '.' || ignore_chars) continue;
+            if (c == '+') {
+                ignore_chars = true;
+                continue;
+            }
+            
+            local_name += c;
+        }
+        string domain = email.substr(i);
+        return local_name + domain;
+    }
+public:
+    int numUniqueEmails(vector<string>& emails) {
+        set<string> email_set;
+        for(string email: emails) {
+            email_set.insert(get_normalized(email));
+        }
+        
+        return email_set.size();
+    }
+};