More solutions

Author: andy2git

Add_Two_Numbers.cpp

@@ -0,0 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
+        if(l1 == nullptr && l2 == nullptr) return nullptr;
+        
+        int cbit = 0;
+        ListNode *p = l1;
+        ListNode *pre = nullptr;
+        ListNode *q = l2;
+        int sum = 0;
+        while(p && q){
+            p->val = add(p->val, q->val, cbit);
+            pre = p;
+            p = p->next;
+            q = q->next;
+        }
+        
+        if(q) {
+            pre->next = q;
+            p = q;
+        }
+        
+        while (p){
+            p->val = add(p->val, 0, cbit);
+            pre = p;
+            p = p->next;
+        }
+        
+        if(cbit == 1){
+            pre->next = new ListNode(1);
+        }
+        
+        return l1;
+        
+        // cbit = 1 after last node
+    }
+private:
+    int add(int a, int b, int &cbit){
+        int sum = 0;
+        
+        sum = a+b+cbit;
+        cbit = 0;
+        if(sum >= 10){
+            sum %= 10;
+            cbit = 1;
+        }
+        return sum;
+    }
+};

Best_Time_to_Buy_and_Sell_Stock.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+        if(prices.size() < 2) return 0;
+        
+        vector<int> diff(prices.size()-1);
+        
+        adjacent_difference(prices.begin(), prices.end(), diff.begin());
+        
+        int sum = 0; 
+        int max_sum = 0;
+        
+        for(int i = 0; i < diff.size(); i++){
+            sum += diff[i];
+            if(sum < 0){
+                sum = 0;
+            }
+            
+            if(sum > max_sum){
+                max_sum = sum;
+            }
+        }
+        
+        return max_sum;
+    }
+};

Best_Time_to_Buy_and_Sell_Stock_2.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+       if(prices.size() < 2) return 0;
+       
+       int mp = 0;
+       
+       for(int i = 1; i < prices.size(); i++){
+           if(prices[i] > prices[i-1]){
+               mp += prices[i] - prices[i-1];
+           }
+       }
+       
+       return mp;
+    }
+};

Candy.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int candy(vector<int> &ratings) {
+        if(ratings.empty()) return 0;
+        if(ratings.size() == 1) return 1;
+        
+        vector<int> l(ratings.size(), 1);
+        vector<int> r(ratings.size(), 1);
+        
+        for(int i = 1; i < ratings.size(); i++){
+            if(ratings[i] > ratings[i-1]){
+                l[i] = l[i-1]+1;
+            }
+        }
+        
+        for(int i = ratings.size()-2; i >= 0; i--){
+            if(ratings[i] > ratings[i+1]){
+                r[i] = r[i+1]+1;
+            }
+        }
+        
+        int sum = 0;
+        for(int i = 0; i < l.size(); i++){
+            sum += max(l[i], r[i]);
+        }
+        
+        return sum;
+    }
+};

Combinations.cpp

@@ -0,0 +1,62 @@
+class Solution {
+public:
+    vector<vector<int> > combine(int n, int k) {
+        vector<int> nums;
+        
+        for(int i = 1; i <= n; i++){
+            nums.push_back(i);
+        }
+        
+        vector<vector<int>> result;
+        combine_helper(result, vector<int>(), nums, k);
+        return result;
+    }
+    
+private:
+    void combine_helper(vector<vector<int>> &result, vector<int> sofar, vector<int> rest, int k){
+        if(sofar.size() == k){
+            result.push_back(sofar);
+            return;
+        }
+        if(rest.empty()) return;
+        
+        int x = 0;
+        if(sofar.empty()) x = 0;
+        else x = sofar[sofar.size()-1];
+        
+        while(!rest.empty() && rest[0] < x){
+            rest.erase(rest.begin());
+        }
+        
+        while(!rest.empty()){
+            sofar.push_back(rest[0]);
+            rest.erase(rest.begin());
+            combine_helper(result, sofar, rest, k);
+            sofar.pop_back();
+        }
+    }
+};
+
+
+class Solution {
+public:
+    vector<vector<int> > combine(int n, int k) {
+        vector<vector<int>> result;
+        combine_helper(result, vector<int>(), n, 1, k);
+        return result;
+    }
+    
+private:
+    void combine_helper(vector<vector<int>> &result, vector<int> sofar, int n, int s, int k){
+        if(k == 0){
+            result.push_back(sofar);
+            return;
+        }
+        
+        for(int i = s; i <= n; i++){
+            sofar.push_back(i);
+            combine_helper(result, sofar, n, i+1, k-1);
+            sofar.pop_back();
+        }
+    }
+};

Insertion_Sort_List.cpp

@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *insertionSortList(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return head;
+        
+        ListNode *pre = head;
+        ListNode *p = head->next;
+        ListNode dummy(0);
+        ListNode *d = &dummy;
+        d->next = head;
+        
+        while(p){
+            if(pre->val <= p->val){
+                pre = p;
+                p = p->next;
+            }else{
+                d = &dummy;
+                while(d->next->val < p->val){
+                    d = d->next;
+                }
+                
+                pre->next = p->next;
+                p->next = d->next;
+                d->next = p;
+                p = pre->next;
+            }
+        }
+        
+        return dummy.next;
+    }
+};

Integer_to_Roman.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    string intToRoman(int num) {
+        if(num <= 0) return "";
+        
+        vector<int> n_map = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        vector<string> s_map = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+        
+        int i = 0;
+        string result;
+        while(num > 0){
+            if(num - n_map[i] >= 0){
+                num -= n_map[i];
+                result += s_map[i];
+            }else{
+                i++;
+            }
+        }
+        
+        return result;
+    }
+};

Interleaving_String.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    bool isInterleave(string s1, string s2, string s3) {
+        if(s1 == "") return s2 == s3;
+        if(s2 == "") return s1 == s3;
+        
+        int m = s1.size();
+        int n = s2.size();
+        
+        if(n+m != s3.size()) return false;
+        
+        vector<vector<bool>> tbl(m+1, vector<bool>(n+1, false));
+        tbl[0][0] = true;
+        
+        for(int j = 1; j <= n; j++){
+            if(s2[j-1] == s3[j-1]) tbl[0][j] = true;
+        }
+        for(int i = 1; i <= m; i++){
+            if(s1[i-1] == s3[i-1]) tbl[i][0] = true;
+        }
+        
+        int k;
+        for(int i = 1; i <=m; i++){
+            for(int j = 1; j<=n; j++){
+                k = i+j-1;
+                if(s1[i-1] == s3[k] && s2[j-1] != s3[k]){
+                    tbl[i][j] = tbl[i-1][j];
+                }else if(s1[i-1] != s3[k] && s2[j-1] == s3[k]){
+                    tbl[i][j] = tbl[i][j-1];
+                }else if(s1[i-1] == s3[k] && s2[j-1] == s3[k]){
+                    tbl[i][j] = tbl[i-1][j] || tbl[i][j-1];
+                }else{
+                    tbl[i][j] = false;
+                }
+            }
+        }
+        return tbl[m][n];
+    }
+};

Longest_Palindromic_Substring.cpp

@@ -0,0 +1,45 @@
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        if(s == "") return "";
+        
+        int n = s.size();
+        vector<vector<bool>> tbl(n, vector<bool>(n, false));
+        
+        for(int i = 0; i < n; i++){
+            tbl[i][i] = true;
+        }
+        
+        int max_len = 1;
+        int s_ind = 0;
+        
+        for(int i = 0; i < n-1; i++){
+            if(s[i] == s[i+1]) {
+                tbl[i][i+1] = true;
+                max_len = 2;
+                s_ind = i;
+            }else{
+                tbl[i][i+1] = false;
+            }
+        }
+        
+        int j;
+        for(int len = 3; len <= n; len++){
+            for(int i = 0; i <= n-len; i++){
+                j = i + len -1;
+                
+                if(s[i] == s[j] && tbl[i+1][j-1]){
+                    tbl[i][j] = true;
+                    if(len > max_len){
+                        max_len = len;
+                        s_ind = i;
+                    }
+                }else{
+                    tbl[i][j] = false;
+                }
+            }
+        }
+        
+        return s.substr(s_ind, max_len);
+    }
+};

Palindrome_Number.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        if(x < 0) return false;
+        if(x < 10) return true;
+        
+        int y = x;
+        int a = 1;
+        while(y >= 10){
+            y /= 10;
+            a *= 10;
+        }
+        
+        while(a > 1){
+            if(x/a != x%10) return false;
+            x %= a;
+            x /= 10;
+            a /= 100;
+        }
+        
+        return true;
+    }
+};