Finished 84/142

3sum-closest.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    int threeSumClosest(vector<int> &num, int target) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        sort(num.begin(), num.end());
+        int sz = num.size(), res = 0, abso = 0x7fffffff;
+        for(int i = 0; i < sz - 1; ++i) {
+            if(i > 0 && num[i] == num[i-1])
+                continue;
+            int lp = i + 1, rp = sz - 1;
+            while(lp < rp) {
+                int sum = num[i] + num[lp] + num[rp];
+                if(sum == target)
+                    return target;
+                if(abs(sum - target) < abso) {
+                    res = sum;
+                    abso = abs(sum - target);
+                }
+                if(sum > target) {
+                    int tmp = num[rp];
+                    while(lp < --rp && num[rp] == tmp);
+                } else {
+                    int tmp = num[lp];
+                    while(++lp < rp && num[lp] == tmp);
+                }
+            }
+        }
+        return res;
+    }
+};

3sum.cpp

@@ -63,4 +63,55 @@ class Solution { //extremely ugly code, extremely ...
         }
         return vv;
     }
+};
+
+
+/**********************************************************
+ a better way to solve this problem, to solve K SUM problem
+ **********************************************************/
+class Solution { //better and extensible code
+public:
+    vector<vector<int> > vv;
+    int binarySearch(vector<int> &a, int left, int right, int target) {
+        while(left <= right) {
+            int middle = left + (right - left) / 2;
+            if(a[middle] == target)
+                return middle;
+            else if(a[middle] < target)
+                left = middle + 1;
+            else
+                right = middle - 1;
+        }
+        return -1;
+    }
+    void kSum(vector<int> &a, int target, int k, int index, vector<int> &helper) {
+        int sz = a.size();
+        if(k > sz - index)
+            return;
+        if(k == 1) {
+            int pos = binarySearch(a, index, sz - 1, target);
+            if(pos != -1) {
+                helper.push_back(a[pos]);
+                vv.push_back(helper);
+                helper.pop_back();
+            }
+            return;
+        }
+        for(int i = index; i <= sz - k; ++i) {
+            if(i != index && a[i] == a[i-1])
+                continue;
+            helper.push_back(a[i]);
+            kSum(a, target - a[i], k - 1, i + 1, helper);
+            helper.pop_back();
+        }
+    }
+    vector<vector<int> > threeSum(vector<int> &num) {//an O(n^2) method
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        vv.clear();
+        sort(num.begin(), num.end());
+        vector<int> tmp;
+        kSum(num, 0, 3, 0, tmp);
+        return vv;
+    }
 };

4sum.cpp

@@ -0,0 +1,46 @@
+class Solution {
+public:
+    vector<vector<int> > vv;
+    int binarySearch(vector<int> &a, int left, int right, int target) {
+        while(left <= right) {
+            int middle = left + (right - left) / 2;
+            if(a[middle] == target)
+                return middle;
+            else if(a[middle] < target)
+                left = middle + 1;
+            else
+                right = middle - 1;
+        }
+        return -1;
+    }
+    void kSum(vector<int> &a, int target, int k, int index, vector<int> &helper) {
+        int sz = a.size();
+        if(k > sz - index)
+            return;
+        if(k == 1) {
+            int pos = binarySearch(a, index, sz - 1, target);
+            if(pos != -1) {
+                helper.push_back(a[pos]);
+                vv.push_back(helper);
+                helper.pop_back();
+            }
+            return;
+        }
+        for(int i = index; i <= sz - k; ++i) {
+            if(i != index && a[i] == a[i-1])
+                continue;
+            helper.push_back(a[i]);
+            kSum(a, target - a[i], k - 1, i + 1, helper);
+            helper.pop_back();
+        }
+    }
+    vector<vector<int> > fourSum(vector<int> &num, int target) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        vv.clear();
+        sort(num.begin(), num.end());
+        vector<int> tmp;
+        kSum(num, target, 4, 0, tmp);
+        return vv;
+    }
+};

letter-combinations-of-a-phone-number.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    char m[11][5] = {
+        {0}, {0}, {3, 'a', 'b', 'c'}, {3, 'd', 'e', 'f'}, {3, 'g', 'h', 'i'},
+        {3, 'j', 'k', 'l'}, {3, 'm', 'n', 'o'}, {4, 'p', 'q', 'r', 's'},
+        {3, 't', 'u', 'v'}, {4, 'w', 'x', 'y', 'z'}, {0}
+    } ;
+    vector<string> letterCombinations(string digits) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        int sz = digits.size();
+        vector<string> ans({""});
+        for(int i = 0; i < sz; ++i) {
+            int ed = ans.size(), digit = digits[i] - '0';
+            for(int j = 0; j < ed; ++j) {
+                string stmp = ans[j];
+                ans[j].append(1, m[digit][1]);
+                for(int k = 2; k <= m[digit][0]; ++k)
+                    ans.push_back(stmp + string(1, m[digit][k]));
+            }
+        }
+        return ans;
+    }
+};

readme.md

@@ -1,3 +1,3 @@
 ###__Greatness from Basis comes__    
-Finished 80/142.   
+Finished 84/142.   
 Reetsee.Xu     

substring-with-concatenation-of-all-words.cpp

@@ -0,0 +1,82 @@
+class Solution {
+public:
+    vector<int> findSubstring(string S, vector<string> &L) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        vector<int> v;
+        if(L.size() == 0 || L[0].size() == 0) {
+            for(int i = 0; i < S.size(); ++i) {
+                v.push_back(i);
+            }
+            return v;
+        }
+        unordered_map<string, int> str_set;  //after test, use map is better
+        unordered_map<string, int> res_set;  //after test, use map is better
+        //map<string, int> res_set;
+        int ssz = S.size(), lsz = L.size(), len = L[0].size();
+        for(int i = 0; i < lsz; ++i)
+            ++str_set[L[i]];
+        for(int i = 0; i + lsz * len <= ssz; ++i) {
+            res_set.clear();
+            bool f = true;
+            for(int j = 0; j < lsz; ++j) {
+                string stmp = S.substr(i + j * len, len);
+                if(str_set[stmp] > res_set[stmp]) {
+                    res_set[stmp]++;
+                } else {
+                    f = false;
+                    break;
+                }
+            }
+            if(f)
+                v.push_back(i);
+        }
+        return v;
+    }
+};
+
+/************************************
+ * Solution 2: ugly codes
+ ************************************/
+class Solution {
+public:
+    vector<int> findSubstring(string S, vector<string> &L) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        vector<int> v;
+        if(L.size() == 0 || L[0].size() == 0) {
+            for(int i = 0; i < S.size(); ++i) {
+                v.push_back(i);
+            }
+            return v;
+        }
+        unordered_map<string, int> str_set;
+        unordered_map<string, int> res_set;
+        unordered_map<string, int>::iterator p;
+        //map<string, int> res_set;
+        int st, ssz = S.size(), lsz = L.size(), len = L[0].size();
+        for(int i = 0; i < L.size(); ++i)
+            ++str_set[L[i]];
+        for(int i = 0; i + lsz * len <= ssz; ++i) {
+            st = i;
+            res_set = str_set;
+            while(st + len <= ssz) {
+                string stmp = S.substr(st, len);
+                p = res_set.find(stmp);
+                if(p != res_set.end()) {
+                    p->second -= 1;
+                    if(p->second == 0)
+                        res_set.erase(p);
+                    if(res_set.size() == 0) {
+                        v.push_back(i);
+                        break;
+                    }
+                } else {
+                    break;
+                }
+                st += len;
+            }
+        }
+        return v;
+    }
+};//ugly codes