519/592 problems solved. amazon.com interview ahead

Author: kaidul

README.md

@@ -0,0 +1,19 @@
+class Solution {
+    int dfs(int indx, vector<int>& arr, vector<bool>& visited) {
+        if(visited[indx]) { return 0; }
+        visited[indx] = true;
+        return 1 + dfs(arr[indx], arr, visited);
+    }
+public:
+    int arrayNesting(vector<int>& nums) {
+        int n = (int) nums.size();
+        vector<bool> visited(n, false);
+        int result = 0;
+        for(int i = 0; i < n; i++) {
+            if(!visited[i]) {
+                result = max(result, dfs(i, nums, visited));
+            }
+        }
+        return result;
+    }
+};

source-code/Array_Nesting.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    string optimalDivision(vector<int>& nums) {
+        string result;
+        if(nums.empty()) {
+            return result;
+        }
+        result = to_string(nums[0]);
+        if(nums.size() == 1) {
+            return result;
+        }
+        if(nums.size() == 2) {
+            return result + "/" + to_string(nums[1]);
+        }
+        result += "/(" + to_string(nums[1]);
+        for(int i = 2; i < (int)nums.size(); ++i) {
+            result += "/" + to_string(nums[i]);    
+        }
+        result += ")";
+        return result;
+    }
+};

source-code/Optimal_Division.cpp

@@ -0,0 +1,27 @@
+class Solution {
+    const static int MAX = 26;
+public:
+    bool checkInclusion(string s1, string s2) {
+        vector<int> freq(MAX, 0);
+        int n = (int)s1.length();
+        for(int i = 0; i < n; i++) {
+            freq[s1[i] - 'a']++;
+        }
+        int i = 0, k = 0;
+        int m = (int)s2.length();
+        while(k < m) {
+            freq[s2[k] - 'a']--;
+            if(freq[s2[k] - 'a'] < 0) {
+                while(i <= k and freq[s2[k] - 'a'] < 0) {
+                    freq[s2[i] - 'a']++;
+                    i++;
+                }
+            }
+            if(k - i + 1 == n) {
+                return true;
+            }
+            k++;
+        }
+        return false;
+    }
+};

source-code/Permutation_in_String.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int removeBoxes(vector<int>& boxes) {
+        const int n = (int)boxes.size();
+        if(n == 0) return 0;
+        // vector<vector<vector<int>>> dp(n + 1, vector<vector<int>>(n + 1, vector<int>(n + 1, 0))); // MLE
+        int dp[n + 1][n + 1][n + 1] = {0};
+        for(int i = 0; i < n; i++) {
+            for(int k = 1; k <= i; k++) {
+                dp[i][i][k] = (k + 1) * (k + 1);
+            }
+        }
+        
+        for(int len = 1; len <= n; len++) {
+            for(int i = 0; i <= n - len; i++) {
+                int j = i + len - 1;
+                for(int k = 0; k <= i; k++) {
+                    dp[i][j][k] = (k + 1) * (k + 1) + dp[i + 1][j][0];
+                    for(int l = i + 1; l <= j; l++) {
+                        if(boxes[i] == boxes[l]) {
+                            dp[i][j][k] = max(dp[i][j][k], dp[i + 1][l - 1][0] + dp[l][j][k + 1]);    
+                        }
+                    }
+                }
+            }
+        }
+        
+        return dp[0][n - 1][0];
+    }
+};