Add 18/132 solutions.

Author: iphkwan

Best_Time_to_Buy_and_Sell_Stock.cc

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (prices.size() == 0)
+            return 0;
+        int cnt = prices[0];
+        int ans = -0x7ffffff;
+        for (int i = 0; i < prices.size(); i++) {
+            ans = max(ans, prices[i] - cnt);
+            cnt = min(cnt, prices[i]);
+        }
+        return ans;
+    }
+};

Best_Time_to_Buy_and_Sell_Stock_II.cc

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (prices.size() == 0)
+            return 0;
+        int ans = 0;
+        for (int i = 1; i < prices.size(); i++)
+            if (prices[i] > prices[i - 1])
+                ans += (prices[i] - prices[i - 1]);
+        return ans;
+    }
+};

Best_Time_to_Buy_and_Sell_Stock_III.cc

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        if (prices.size() == 0)
+            return 0;
+        int cnt = prices[0];
+        vector<int> ans1, ans2;
+        int ans = 0;
+        for (int i = 0; i < prices.size(); i++) {
+            ans1.push_back(prices[i] - cnt);
+            ans2.push_back(0);
+            cnt = min(prices[i], cnt);
+        }
+        cnt = prices[prices.size() - 1];
+        for (int i = prices.size() - 1; i >= 0; i--) {
+            ans2[i] = cnt - prices[i];
+            cnt = max(cnt, prices[i]);
+        }
+        for (int i = 1; i < prices.size(); i++) {
+            ans1[i] = max(ans1[i], ans1[i - 1]);
+            ans2[prices.size() - i - 1] = max(ans2[prices.size() - i - 1], ans2[prices.size() - i]);
+        }
+        for (int i = 0; i < prices.size(); i++)
+            ans = max(ans, ans1[i] + ans2[i]);
+        return ans;
+    }
+};

Binary_Tree_Maximum_Path_Sum.cc

@@ -0,0 +1,39 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int dfs (TreeNode *rt, int &ans) {
+        ans = max(ans, rt->val);
+        if (rt->left == NULL && rt->right == NULL)
+            return rt->val;
+        if (rt->left != NULL && rt->right == NULL) {
+            int tmp = rt->val + dfs(rt->left, ans);
+            ans = max(ans, tmp);
+            return max(rt->val, tmp);
+        }
+        if (rt->left == NULL && rt->right != NULL) {
+            int tmp = rt->val + dfs(rt->right, ans);
+            ans = max(ans, tmp);
+            return max(rt->val, tmp);
+        }
+        int tmp1 = dfs(rt->left, ans);
+        int tmp2 = dfs(rt->right, ans);
+        ans = max(ans, rt->val + max(tmp1, tmp2));
+        ans = max(ans, rt->val + tmp1 + tmp2);
+        return max(rt->val, rt->val + max(tmp1, tmp2));
+    }
+    int maxPathSum(TreeNode *root) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int ans = -0x7ffffff;
+        dfs(root, ans);
+        return ans;
+    }
+};

Distinct_Subsequences.cc

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int numDistinct(string S, string T) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int slen = S.length();
+        int tlen = T.length();
+        if (slen == 0 || tlen == 0)
+            return 0;
+        vector<vector<int>> dp;
+        vector<int> tmp;
+        for (int i = 0; i < tlen; i++)
+            tmp.push_back(0);
+        for (int i = 0; i < slen; i++)
+            dp.push_back(tmp);
+        for (int i = 0; i < slen; i++)
+            for (int j = 0; j <= i && j < tlen; j++) {
+                if (S[i] == T[j]) {
+                    dp[i][j] = (i == 0 || j == 0) ? 1 : dp[i - 1][j - 1];
+                }
+                if (i > j)
+                    dp[i][j] += dp[i - 1][j];
+            }
+        return dp[slen - 1][tlen - 1];
+    }
+};

Longest_Consecutive_Sequence.cc

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int longestConsecutive(vector<int> &num) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        set<int> hm;
+        int n = num.size();
+        for (int i = 0; i < n; i++)
+            hm.insert(num[i]);
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            int cnt = 1;
+            int tmp = num[i];
+            if (hm.find(tmp) == hm.end())
+                continue;
+            hm.erase(tmp);
+            while (hm.find(++tmp) != hm.end()) {
+                cnt++;
+                hm.erase(tmp);
+            }
+            tmp = num[i];
+            while (hm.find(--tmp) != hm.end()) {
+                cnt++;
+                hm.erase(tmp);
+            }
+            ans = max(ans, cnt);
+        }
+        return ans;
+    }
+};

Palindrome_Partitioning.cc

@@ -0,0 +1,52 @@
+class Solution {
+public:
+    vector<vector<string>> ans;
+    vector<string> vt;
+    vector<vector<int>> g;
+    int len;
+    
+    bool judge(string &s, int i, int j) {
+        if (i > j)
+            return false;
+        if (g[i][j] != -1)
+            return g[i][j];
+        if (i == j)
+            return g[i][j] = 1;
+        if (s[i] != s[j])
+            return g[i][j] = 0;
+        else {
+            if (i + 1 == j)
+                return g[i][j] = 1;
+            return g[i][j] = judge(s, i + 1, j - 1);
+        }
+    }
+    
+    void dfs(string &s, int cnt) {
+        if (cnt == len) {
+            ans.push_back(vt);
+            return;
+        }
+        for (int i = len - 1; i >= cnt; i--) {
+            if (judge(s, cnt, i)) {
+                vt.push_back(s.substr(cnt, i - cnt + 1));
+                dfs(s, i + 1);
+                vt.pop_back();
+            }
+        }
+    }
+    
+    vector<vector<string>> partition(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        ans.clear(), vt.clear(), g.clear();
+        len = s.length();
+        vector<int> tmp;
+        for (int i = 0; i < len; i++)
+            tmp.push_back(-1);
+        for (int i = 0; i < len; i++)
+            g.push_back(tmp);
+        
+        dfs(s, 0);
+        return ans;
+    }
+};

Palindrome_Partitioning_II.cc

@@ -0,0 +1,51 @@
+class Solution {
+public:
+    vector< vector<int> > vt;
+    bool judge(string &s, int i, int j) {
+        if (i > j)
+            return false;
+        if (vt[i][j] != -1)
+            return vt[i][j];
+        if (i == j)
+            return vt[i][j] = 1;
+        if (s[i] != s[j])
+            return vt[i][j] = 0;
+        else {
+            if (i + 1 == j)
+                return vt[i][j] = 1;
+            else
+                return vt[i][j] = judge(s, i + 1, j - 1);
+        }
+    }
+    int minCut(string s) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        int len = s.length();
+        if (len < 2)
+            return 0;
+        vector<int> dp, tmp;
+        dp.clear(), tmp.clear(), vt.clear();
+        for (int i = 0; i < len; i++) {
+            dp.push_back(0);
+            tmp.push_back(-1);
+        }
+        for (int i = 0; i < len; i++) {
+            vt.push_back(tmp);
+        }
+        for (int i = 1; i < len; i++) {
+            if (judge(s, 0, i)) {
+                dp[i] = 0;
+                continue;
+            }
+            int ans = i;
+            for (int j = 0; j < i; j++) {
+                if (judge(s, j + 1, i))
+                    ans = min(ans, dp[j] + 1);
+                else
+                    ans = min(ans, dp[j] + i - j);
+            }
+            dp[i] = ans;
+        }
+        return dp[len - 1];
+    }
+};

Pascal's_Triangle II.cc

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    vector<int> getRow(int rowIndex) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        vector<int> cnt, pre;
+        for (int i = 1; i <= rowIndex + 1; i++) {
+            if (pre.size() == 0) {
+                cnt.push_back(1);
+            } else {
+                cnt.push_back(1);
+                for (int j = 1; j < i - 1; j++)
+                    cnt.push_back(pre[j - 1] + pre[j]);
+                cnt.push_back(1);
+            }
+            pre = cnt;
+            cnt.clear();
+        }
+        return pre;
+    }
+};

Pascal's_Triangle.cc

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<vector<int> > generate(int numRows) {
+        // Start typing your C/C++ solution below
+        // DO NOT write int main() function
+        vector<vector<int>> ans;
+        vector<int> cnt, pre;
+        for (int i = 1; i <= numRows; i++) {
+            if (pre.size() == 0) {
+                cnt.push_back(1);
+            } else {
+                cnt.push_back(1);
+                for (int j = 1; j < i - 1; j++)
+                    cnt.push_back(pre[j - 1] + pre[j]);
+                cnt.push_back(1);
+            }
+            ans.push_back(cnt);
+            pre = cnt;
+            cnt.clear();
+        }
+        return ans;
+    }
+};