update solutions

Author: amitbansal7

all-elements-in-two-binary-search-trees.cpp

@@ -0,0 +1,32 @@
+// Runtime: 268 ms
+// Memory Usage: 60.5 MB
+class Solution {
+public:
+  void traverse(TreeNode* root, vector<int> &l) {
+    if (!root) return;
+    traverse(root->left, l);
+    l.push_back(root->val);
+    traverse(root->right, l);
+  }
+  vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {
+    vector<int> l1, l2;
+    traverse(root1, l1);
+    traverse(root2, l2);
+    vector<int> res;
+    int i = 0, j = 0;
+    while (i < l1.size() && j < l2.size()) {
+      if (l1[i] < l2[j]) {
+        res.push_back(l1[i++]);
+      } else {
+        res.push_back(l2[j++]);
+      }
+    }
+    while (i < l1.size()) {
+      res.push_back(l1[i++]);
+    }
+    while (j < l2.size()) {
+      res.push_back(l2[j++]);
+    }
+    return res;
+  }
+};

check-if-n-and-its-double-exist.cpp

@@ -0,0 +1,15 @@
+// Runtime: 4 ms
+// Memory Usage: 9.2 MB
+class Solution {
+public:
+  bool checkIfExist(vector<int>& arr) {
+    set<int> s;
+    for (int a : arr) {
+      if (s.find(a * 2) != s.end() || (a % 2 == 0 && s.find(a / 2) != s.end())) {
+        return true;
+      }
+      s.insert(a);
+    }
+    return false;
+  }
+};

contiguous-array.cpp

@@ -0,0 +1,21 @@
+// Runtime: 176 ms
+// Memory Usage: 17.7 MB
+class Solution {
+public:
+  int findMaxLength(vector<int>& nums) {
+    int count = 0;
+    int res = 0;
+    unordered_map<int, int> mp;
+    for (int i = 0; i < nums.size(); i++) {
+      count += nums[i] == 0 ? -1 : 1;
+      if (count == 0) {
+        res = i + 1;
+      } else if (mp.find(count) != mp.end()) {
+        res = max(res, i - mp[count]);
+      } else {
+        mp[count] = i;
+      }
+    }
+    return res;
+  }
+};

convert-integer-to-the-sum-of-two-no-zero-integers.cpp

@@ -0,0 +1,17 @@
+// Runtime: 0 ms
+// Memory Usage: 8.5 MB
+class Solution {
+public:
+  vector<int> getNoZeroIntegers(int n) {
+    vector<int> res;
+    for (int i = 1; i < n; i++) {
+      string s = to_string(i) + to_string(n - i);
+      if (s.find('0') == string::npos) {
+        res.push_back(n - i);
+        res.push_back(i);
+        return res;
+      }
+    }
+    return res;
+  }
+};

count-negative-numbers-in-a-sorted-matrix.cpp

@@ -0,0 +1,14 @@
+// Runtime: 20 ms
+// Memory Usage: 10.3 MB
+class Solution {
+public:
+	int countNegatives(vector<vector<int>>& grid) {
+		int res = 0;
+		for (int i = grid.size() - 1; i >= 0 && grid[i][grid[i].size() - 1] < 0; i--) {
+			for (int j = grid[i].size() - 1; j >= 0 && grid[i][j] < 0; j--) {
+				res++;
+			}
+		}
+		return res;
+	}
+};

count-servers-that-communicate.cpp

@@ -0,0 +1,27 @@
+// Runtime: 56 ms
+// Memory Usage: 15.1 MB
+class Solution {
+public:
+  int countServers(vector<vector<int>>& grid) {
+    vector<int> row(grid.size(), 0);
+    vector<int> col(grid[0].size(), 0);
+
+    for (int i = 0; i < grid.size(); i++) {
+      for (int j = 0; j < grid[0].size(); j++) {
+        if (grid[i][j]) {
+          row[i]++;
+          col[j]++;
+        }
+      }
+    }
+    int res = 0;
+    for (int i = 0; i < grid.size(); i++) {
+      for (int j = 0; j < grid[i].size(); j++) {
+        if (grid[i][j] && (row[i] > 1 || col[j] > 1)) {
+          res++;
+        }
+      }
+    }
+    return res;
+  }
+};

decrypt-string-from-alphabet-to-integer-mapping.cpp

@@ -0,0 +1,16 @@
+// Runtime: 0 ms
+// Memory Usage: 8.5 MB
+class Solution {
+public:
+  string freqAlphabets(string s) {
+    string res;
+    for (int i = 0; i < s.size(); i++) {
+      if (i + 2 < s.size() && s[i + 1] != '#' && s[i + 2] == '#') {
+        res += 'a' - 1 + ((s[i++] - '0') * 10 + s[i++] - '0');
+      } else {
+        res += 'a' - 1 + (s[i] - '0');
+      }
+    }
+    return res;
+  }
+};

deepest-leaves-sum.cpp

@@ -0,0 +1,24 @@
+// Runtime: 48 ms
+// Memory Usage: 31.3 MB
+class Solution {
+public:
+  void solve(TreeNode* root, int &res, int d, int &md) {
+    if (!root) return;
+    solve(root->left, res, d + 1, md);
+    solve(root->right, res, d + 1, md);
+    if (!root->left && !root->right) {
+      if (d == md) {
+        res += root->val;
+      } else if (d > md) {
+        res = root->val;
+      }
+    }
+    md = max(d, md);
+  }
+  int deepestLeavesSum(TreeNode* root) {
+    int res = 0;
+    int md = 0;
+    solve(root, res, 0, md);
+    return res;
+  }
+};

delete-leaves-with-a-given-value.cpp

@@ -0,0 +1,15 @@
+// Runtime: 20 ms
+// Memory Usage: 21.5 MB
+class Solution {
+public:
+	TreeNode* removeLeafNodes(TreeNode* root, int target) {
+		if (!root) return root;
+		root->left = removeLeafNodes(root->left, target);
+		root->right = removeLeafNodes(root->right, target);
+
+		if (!root->left && !root->right && root->val == target) {
+			return NULL;
+		}
+		return root;
+	}
+};

find-elements-in-a-contaminated-binary-tree.cpp

@@ -0,0 +1,24 @@
+// Runtime: 52 ms
+// Memory Usage: 30.1 MB
+class FindElements {
+public:
+
+  set<int> st;
+
+  void solve(TreeNode* root, int val) {
+    if (!root) return;
+
+    root->val = val;
+    st.insert(val);
+    solve(root->left, val * 2 + 1);
+    solve(root->right, val * 2 + 2);
+  }
+
+  FindElements(TreeNode* root) {
+    solve(root, 0);
+  }
+
+  bool find(int target) {
+    return st.find(target) != st.end();
+  }
+};

find-n-unique-integers-sum-up-to-zero.cpp

@@ -0,0 +1,14 @@
+// Runtime: 4 ms
+// Memory Usage: 8.7 MB
+class Solution {
+public:
+	vector<int> sumZero(int n) {
+		vector<int> res;
+		res.push_back(0);
+		for (int i = 1; i < n; i++) {
+			res[0] -= i;
+			res.push_back(i);
+		}
+		return res;
+	}
+};

get-watched-videos-by-your-friends.cpp

@@ -0,0 +1,48 @@
+// Runtime: 124 ms
+// Memory Usage: 31.5 MB
+class Solution {
+public:
+
+  vector<string> watchedVideosByFriends(vector<vector<string>>& watchedVideos, vector<vector<int>>& friends, int id, int level) {
+    map<string, int> viewCount;
+    vector<int> vis(friends.size(), 0);
+
+    queue<int >q;
+    q.push(id);
+    int d = 0;
+    vis[id] = 1;
+    while (!q.empty()) {
+      int size = q.size();
+      while (size--) {
+        int t = q.front();
+        q.pop();
+        if (d == level) {
+          for (string a : watchedVideos[t]) {
+            viewCount[a]++;
+          }
+        }
+
+        for (int f : friends[t]) {
+          if (!vis[f]) {
+            vis[f] = 1;
+            q.push(f);
+          }
+        }
+      }
+      if (d >= level) {
+        break;
+      }
+      d++;
+    }
+
+    vector<pair<string, int> >countVec(viewCount.begin(), viewCount.end());
+    sort(countVec.begin(), countVec.end(), [](pair<string, int> &a, pair<string, int> &b) {
+      return a.second == b.second ? a.first < b.first : a.second < b.second;
+    });
+    vector<string> res;
+    for (auto a : countVec) {
+      res.push_back(a.first);
+    }
+    return res;
+  }
+};

iterator-for-combination.cpp

@@ -0,0 +1,29 @@
+// Runtime: 12 ms
+// Memory Usage: 14.4 MB
+class CombinationIterator {
+private:
+  vector<string> res;
+  int curr = 0;
+  void backtrack(string &chars, int idx, string s, int &len) {
+    if (s.size() == len) {
+      res.push_back(s);
+      return;
+    }
+    for (int i = idx; i < chars.size(); i++) {
+      if (s.size() == 0 || s[s.size() - 1] < chars[i]) {
+        backtrack(chars, i + 1, s + chars[i], len);
+      }
+    }
+  }
+public:
+  CombinationIterator(string characters, int combinationLength) {
+    backtrack(characters, 0, "", combinationLength);
+  }
+  string next() {
+    return res[curr++];
+  }
+
+  bool hasNext() {
+    return curr < res.size();
+  }
+};

maximum-69-number.rb

@@ -0,0 +1,5 @@
+# Runtime: 28 ms
+# Memory Usage: 9.3 MB
+def maximum69_number (num)
+  num.to_s.sub('6', '9').to_i
+end

maximum-length-of-a-concatenated-string-with-unique-characters.cpp

@@ -0,0 +1,38 @@
+// Runtime: 236 ms
+// Memory Usage: 64.6 MB
+class Solution {
+public:
+
+  bool allUniq(string &s) {
+    set<char> st;
+    for (char a : s) {
+      if (st.find(a) != st.end()) {
+        return false;
+      }
+      st.insert(a);
+    }
+    return true;
+  }
+
+  void solve(vector<string> &arr, string s, int idx, int &res) {
+    if (allUniq(s)) {
+      if (res < s.size()) {
+        res = s.size();
+      }
+    } else {
+      if (s.size() > 0) {
+        return;
+      }
+    }
+    for (int i = idx; i < arr.size(); i++) {
+      solve(arr, s + arr[i], i + 1, res);
+    }
+  }
+
+  int maxLength(vector<string>& arr) {
+    int res = 0;
+    string s = "";
+    solve(arr, s, 0, res);
+    return res;
+  }
+};

maximum-product-of-splitted-binary-tree.cpp

@@ -0,0 +1,19 @@
+// Runtime: 160 ms
+// Memory Usage: 58.3 MB
+class Solution {
+public:
+  long res = 0;
+  long total = 0;
+  long solve(TreeNode* root) {
+    if (!root) return 0;
+    long curr = solve(root->left) + solve(root->right) + root->val;
+    res = max(res, curr * (total - curr));
+    return curr;
+
+  }
+  int maxProduct(TreeNode* root) {
+    total = solve(root);
+    solve(root);
+    return res % (int)(1e9 + 7);
+  }
+};