Merge pull request #1422 from PDKhan/main

Author: PDKhan

container-with-most-water/PDKhan.cpp

@@ -0,0 +1,22 @@
+class Solution {
+    public:
+        int maxArea(vector<int>& height) {
+            int result = 0;
+            int left = 0;
+            int right = height.size() - 1;
+    
+            while(left < right){
+                int len = right - left;
+    
+                if(height[left] < height[right]){
+                    result = max(result, height[left] * len);
+                    left++;
+                }else{
+                    result = max(result, height[right] * len);
+                    right--;
+                }
+            }
+    
+            return result;
+        }
+    };

design-add-and-search-words-data-structure/PDKhan.cpp

@@ -0,0 +1,60 @@
+class Trie{
+    public:
+        Trie* children[26];
+        bool isEnd;
+    
+        Trie(){
+            for(int i = 0; i < 26; i++)
+                children[i] = nullptr;
+            
+            isEnd = false;
+        }
+    };
+    
+    class WordDictionary {
+    private:
+        Trie* trie;
+    public:
+        WordDictionary() {
+            trie = new Trie();
+        }
+        
+        void addWord(string word) {
+            Trie* node = trie;
+    
+            for(char ch : word){
+                int index = ch - 'a';
+    
+                if(node->children[index] == nullptr)
+                    node->children[index] = new Trie();
+                
+                node = node->children[index];
+            }
+    
+            node->isEnd = true;
+        }
+        
+        bool dfs(Trie* node, int index, string word){
+            if(node == nullptr)
+                return false;
+    
+            if(index == word.length())
+                return node->isEnd;
+            
+            char ch = word[index];
+    
+            if(ch == '.'){
+                for(int i = 0; i < 26; i++){
+                    if(dfs(node->children[i], index + 1, word) == true)
+                        return true;
+                }
+            }else
+                return dfs(node->children[ch-'a'], index + 1, word);
+            
+            return false;
+        }
+    
+        bool search(string word) {
+            return dfs(trie, 0, word);
+        }
+    };

longest-increasing-subsequence/PDKhan.cpp

@@ -0,0 +1,17 @@
+class Solution {
+    public:
+        int lengthOfLIS(vector<int>& nums) {
+            vector<int> sub;
+    
+            for(int num : nums){
+                auto it = lower_bound(sub.begin(), sub.end(), num);
+    
+                if(it == sub.end())
+                    sub.push_back(num);
+                else
+                    *it = num;
+            }
+    
+            return sub.size();
+        }
+    };

spiral-matrix/PDKhan.cpp

@@ -0,0 +1,57 @@
+class Solution {
+    public:
+        vector<int> spiralOrder(vector<vector<int>>& matrix) {
+            enum direction { R, D, L, U };
+    
+            enum direction dir = R;
+            vector<int> result;
+            int min_R = 0;
+            int max_R = matrix.size() - 1;
+            int min_C = 0;
+            int max_C = matrix[0].size() - 1;
+            int r = 0;
+            int c = 0;
+            int size = matrix.size() * matrix[0].size();
+    
+            while(result.size() < size){
+                result.push_back(matrix[r][c]);
+    
+                switch(dir){
+                    case R:
+                        if(c == max_C){
+                            dir = D;
+                            min_R++;
+                            r++;
+                        }else
+                            c++;
+                        break;
+                    case D:
+                        if(r == max_R){
+                            dir = L;
+                            max_C--;
+                            c--;
+                        }else
+                            r++;
+                        break;
+                    case L:
+                        if(c == min_C){
+                            dir = U;
+                            max_R--;
+                            r--;
+                        }else
+                            c--;
+                        break;
+                    case U:
+                        if(r == min_R){
+                            dir = R;
+                            min_C++;
+                            c++;
+                        }else
+                            r--;
+                        break;
+                }
+            }
+    
+            return result;
+        }
+    };

valid-parentheses/PDKhan.cpp

@@ -0,0 +1,25 @@
+class Solution {
+    public:
+        bool isValid(string s) {
+            stack<char> st;
+    
+            for(char ch : s){
+                if(ch == ')'){
+                    if(st.empty() || st.top() != '(')
+                        return false;
+                    st.pop();
+                }else if(ch == '}'){
+                    if(st.empty() || st.top() != '{')
+                        return false;
+                    st.pop();
+                }else if(ch == ']'){
+                    if(st.empty() || st.top() != '[')
+                        return false;
+                    st.pop();
+                }else
+                    st.push(ch);
+            }
+    
+            return st.empty();
+        }
+    };