🚀 13-May-2022

Author: sureshmangs

competitive programming/leetcode/1047. Remove All Adjacent Duplicates In String.cpp

@@ -1,8 +1,10 @@
-Given a string S of lowercase letters, a duplicate removal consists of choosing two adjacent and equal letters, and removing them.
+Given a string S of lowercase letters, a duplicate removal consists of 
+choosing two adjacent and equal letters, and removing them.
 
 We repeatedly make duplicate removals on S until we no longer can.
 
-Return the final string after all such duplicate removals have been made.  It is guaranteed the answer is unique.
+Return the final string after all such duplicate removals have been made.  
+It is guaranteed the answer is unique.
 
 
 
@@ -11,7 +13,9 @@ Example 1:
 Input: "abbaca"
 Output: "ca"
 Explanation:
-For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal,
+and this is the only possible move.  The result of this move is that the string is "aaca", 
+of which only "aa" is possible, so the final string is "ca".
 
 
 Note:
@@ -28,38 +32,85 @@ S consists only of English lowercase letters.
 
 
 
-
+// TC -> O(n)
+// SC -> O(n)
 
 class Solution {
-public:
+    public:
     string removeDuplicates(string S) {
         stack<char> s;
-        int n=S.length();
+        int n = S.length();
         s.push(S[0]);
-        for(int i=1;i<n;i++){
-            if(!s.empty() && s.top()==S[i])
+        for (int i = 1; i < n; i++) {
+            if (!s.empty() && s.top() == S[i])
                 s.pop();
-            else s.push(S[i]);
+            else
+                s.push(S[i]);
         }
-        string res="";
+        string res = "";
 
-        while(!s.empty()){
-            res=s.top()+res;
+        while (!s.empty()) {
+            res = s.top() + res;
             s.pop();
         }
         return res;
     }
 };
 
 
+
+
+
+
+
+
+
+
+
+// TC -> O(n)
+// SC -> O(n)
+
 class Solution {
 public:
+    string removeDuplicates(string s) {
+        int n = s.length();
+        string tmp = "";
+        
+        for (int i = 0; i < n; i++) {
+            if (tmp.length() == 0) tmp += s[i];
+            else if (tmp[tmp.length() - 1] != s[i]) tmp += s[i];
+            else tmp.erase(tmp.length() - 1);
+        }
+        
+        return tmp;
+    }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// TC -> O(n)
+// SC -> O(1)
+
+class Solution {
+    public:
     string removeDuplicates(string S) {
-        int k=0, n=S.length();
-        for(int i=0;i<n;i++, k++){
-            S[k]=S[i];
-            if(k>0 && S[k-1]==S[k]) k-=2;
+        int k = 0, n = S.length();
+        for (int i = 0; i < n; i++, k++) {
+            S[k] = S[i];
+            if (k > 0 && S[k - 1] == S[k]) k -= 2;
         }
         return S.substr(0, k);
     }
 };
+

competitive programming/leetcode/117. Populating Next Right Pointers in Each Node II.cpp

@@ -0,0 +1,88 @@
+Given a binary tree
+
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+Populate each next pointer to point to its next right node. 
+If there is no next right node, the next pointer should be set to NULL.
+
+Initially, all next pointers are set to NULL.
+
+ 
+
+Example 1:
+
+
+Input: root = [1,2,3,4,5,null,7]
+Output: [1,#,2,3,#,4,5,7,#]
+Explanation: Given the above binary tree (Figure A), your function should 
+populate each next pointer to point to its next right node, just like in Figure B. 
+The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+Example 2:
+
+Input: root = []
+Output: []
+ 
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 6000].
+-100 <= Node.val <= 100
+ 
+
+Follow-up:
+
+You may only use constant extra space.
+The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.
+
+
+
+
+
+
+
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+    Node* next;
+
+    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
+
+    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
+
+    Node(int _val, Node* _left, Node* _right, Node* _next)
+        : val(_val), left(_left), right(_right), next(_next) {}
+};
+*/
+
+class Solution {
+public:
+    Node* connect(Node* root) {
+        if (!root) return root;
+        queue <Node*> q;
+        q.push(root);
+        
+        while (!q.empty()) {
+            int size = q.size();
+            while (size--) {
+                Node *curr = q.front();
+                q.pop();
+                
+                if (size == 0) curr->next = NULL;
+                else curr->next = q.front();
+                
+                if (curr->left) q.push(curr->left);
+                if (curr->right) q.push(curr->right);
+            }
+        }
+        return root;
+    }
+};

competitive programming/leetcode/1202. Smallest String With Swaps.cpp

@@ -0,0 +1,97 @@
+You are given a string s, and an array of pairs of indices in the string pairs 
+where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.
+
+You can swap the characters at any pair of indices in the given pairs any number of times.
+
+Return the lexicographically smallest string that s can be changed to after using the swaps.
+
+ 
+
+Example 1:
+
+Input: s = "dcab", pairs = [[0,3],[1,2]]
+Output: "bacd"
+Explaination: 
+Swap s[0] and s[3], s = "bcad"
+Swap s[1] and s[2], s = "bacd"
+Example 2:
+
+Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
+Output: "abcd"
+Explaination: 
+Swap s[0] and s[3], s = "bcad"
+Swap s[0] and s[2], s = "acbd"
+Swap s[1] and s[2], s = "abcd"
+Example 3:
+
+Input: s = "cba", pairs = [[0,1],[1,2]]
+Output: "abc"
+Explaination: 
+Swap s[0] and s[1], s = "bca"
+Swap s[1] and s[2], s = "bac"
+Swap s[0] and s[1], s = "abc"
+ 
+
+Constraints:
+
+1 <= s.length <= 10^5
+0 <= pairs.length <= 10^5
+0 <= pairs[i][0], pairs[i][1] < s.length
+s only contains lower case English letters.
+
+
+
+
+
+
+
+
+#define MAX 100000
+
+class Solution {
+public:
+    vector <int> adj[MAX];
+    vector <bool> vis;
+    void dfs(int src, vector <char> &characters, vector <int> &indices, string &s) {
+        vis[src] = true;
+        characters.push_back(s[src]);
+        indices.push_back(src);
+        
+        for (auto &dst: adj[src]) {
+            if (!vis[dst]){
+                dfs(dst, characters, indices, s);
+            }
+        }
+    }
+    
+    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
+        int n = s.length();
+        vis.resize(n, false);
+        
+        for (auto &pair: pairs) {
+            adj[pair[0]].push_back(pair[1]);
+            adj[pair[1]].push_back(pair[0]);
+        }
+        
+        for (int i = 0; i < n; i++) {
+            if (!vis[i]) {
+                vector <char> characters;
+                vector <int> indices;
+                
+                dfs(i, characters, indices, s);
+                
+                sort(characters.begin(), characters.end());
+                sort(indices.begin(), indices.end());
+
+                for (int index = 0; index < indices.size(); index++) {
+                    s[indices[index]] = characters[index];
+                }
+            }
+        }
+        return s;
+    }
+};
+
+
+// TC: O(VlogV + E)
+// SC: O(V + E)