Merge branch 'master' of https://github.com/jinshendan/Leetcode

MagicienDeCode · MagicienDeCode · commit 4a6a7fdd88f0 · 2020-06-14T19:36:59.000+02:00
diff --git a/June-LeetCoding-Challenge/09-Is-Subsequence/Is-Subsequence.cpp b/June-LeetCoding-Challenge/09-Is-Subsequence/Is-Subsequence.cpp
@@ -0,0 +1,28 @@
+class Solution1 {
+public:
+    bool isSubsequence(string s, string t) {
+        int i=0, j=0;
+        while(i<s.size() && j<t.size()){
+            if(t[j] == s[i]) ++j, ++i;
+            else ++j;
+        }
+        if(i == s.size()) return true;
+        else return false;
+    }
+};
+
+class Solution2 {
+public:
+    bool isSubsequence(string s, string t) {
+        int n = s.length();
+        int m = t.length();
+        vector<vector<bool>> dp(n+1, vector<bool>(m+1, false));
+        for (int i = 0; i <= m; i++) dp[0][i] = true;
+        for (int i = 1; i <= n; i++)
+            for (int j = 1; j <= m; j++){
+                if (s[i-1] == t[j-1]) dp[i][j] = dp[i][j] or dp[i-1][j-1];
+                dp[i][j] = dp[i][j] or dp[i][j-1];
+            }
+        return dp[n][m];
+    }
+};
diff --git a/June-LeetCoding-Challenge/09-Is-Subsequence/Is-Subsequence.cs b/June-LeetCoding-Challenge/09-Is-Subsequence/Is-Subsequence.cs
@@ -0,0 +1,41 @@
+public class Solution {
+    
+    // A faster method
+    public bool IsSubsequence(string s, string t) {
+        if (s == "")
+            return true;
+        
+        if (s.Length > t.Length)
+            return false;
+        
+        int inds = 0;
+        foreach (char c in t) {
+            if (s[inds] == c) {
+                inds++;
+                if (inds == s.Length)
+                    return true;
+            }
+        }
+        return false;
+    }
+    
+    // A more general method
+    public bool IsSubsequenceMine(string s, string t) {
+        
+        if (s.Length > t.Length)
+            return false;
+        
+        // the following comparison makes the method faster
+        if (s.Length == t.Length)
+            return s == t;
+        
+        int inds = 0, indt = 0;
+        while (inds < s.Length && indt < t.Length) {
+            if (s[inds] == t[indt]) {
+                inds++;
+            }
+            indt++;
+        }
+        return inds > s.Length-1;
+    }
+}
diff --git a/June-LeetCoding-Challenge/10-Search-Insert-Position/Search-Insert-Position.cpp b/June-LeetCoding-Challenge/10-Search-Insert-Position/Search-Insert-Position.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int searchInsert(vector<int>& nums, int target) {
+        return distance(nums.begin(), lower_bound(nums.begin(), nums.end(), target));
+    }
+};
+
+
+class Solution2 {
+public:
+    int searchInsert(vector<int>& nums, int target) {
+       	return lower_bound(nums.begin(), nums.end(), target) - nums.begin();
+    }
+};
diff --git a/June-LeetCoding-Challenge/11-Sort-Colors/Sort-Colors.cpp b/June-LeetCoding-Challenge/11-Sort-Colors/Sort-Colors.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    void swap(int& a, int& b) {
+        int tmp = a;
+        a = b;
+        b = tmp;
+    }
+    
+    void sortColors(vector<int>& nums) {
+        int a = 0, b = nums.size()-1;
+        int i = 0;
+        while (i <= b){
+            if (nums[i] == 2){
+                swap(nums[b], nums[i]);
+                b--;
+                continue;
+            }
+        
+            if (nums[i] == 0) {
+                swap(nums[a], nums[i]);
+                a++;
+            }
+            i++;
+        } 
+    }
+};
diff --git a/June-LeetCoding-Challenge/12-Insert-Delete-GetRandom/Insert-Delete-GetRandom.cpp b/June-LeetCoding-Challenge/12-Insert-Delete-GetRandom/Insert-Delete-GetRandom.cpp
@@ -0,0 +1,58 @@
+class RandomizedSet {
+public:
+    unordered_map<int,int> m;
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+        
+    }
+    
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        return (++m[val])==1;
+    }
+    
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if(m.find(val)==m.end()) return false;
+        m.erase(val);
+        return true;
+    }
+    
+    /** Get a random element from the set. */
+    int getRandom() {
+       return next(begin(m), rand()%m.size())->first;
+    }
+};
+
+class RandomizedSet {
+    unordered_map<int, int> hm;
+    vector<int> datas;
+public:
+    /** Initialize your data structure here. */
+    RandomizedSet() { }
+    
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if (hm.find(val) != hm.end())
+            return false;
+        hm[val] = datas.size();
+        datas.push_back(val);
+        return true;
+    }
+    
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if (hm.find(val) == hm.end())
+            return false;
+        hm[datas.back()] = hm[val];
+        datas[hm[val]] = datas.back();
+        hm.erase(val);
+        datas.pop_back();
+        return true;
+    }
+    
+    /** Get a random element from the set. */
+    int getRandom() {
+        return datas[random()%datas.size()];
+    }
+};
diff --git a/June-LeetCoding-Challenge/13-Largest-Divisible-Subset/Largest-Divisible-Subset.cpp b/June-LeetCoding-Challenge/13-Largest-Divisible-Subset/Largest-Divisible-Subset.cpp
@@ -0,0 +1,106 @@
+class Solution {
+public:
+    vector<int> largestDivisibleSubset(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        int n = nums.size();
+        if (n == 0) return vector<int>();
+        vector<int> dp(n+1, 0);
+        vector<int> prev(n+1, 0);
+        
+        int maxv = 0, p = 0;
+        
+        for (int i = 1; i <= n; i++){
+            dp[i] = 1;
+            prev[i] = i;
+            for (int j = 1; j < i; j++){
+                if (nums[i-1] % nums[j-1] == 0 and dp[j] + 1 > dp[i]){
+                    prev[i] = j;
+                    dp[i] = dp[j] + 1;
+                }
+            }
+            if (dp[i] > maxv){
+                maxv = dp[i];
+                p = i;
+            }
+        }
+        
+        vector<int> ans;
+        while (p != prev[p]) {
+            ans.push_back(nums[p-1]);
+            p = prev[p];
+        }
+        ans.push_back(nums[p-1]);
+        
+        sort(ans.begin(), ans.end());
+        return ans; 
+    }
+};
+
+class Solution {/* time: O(n*n), space: O(n) */
+public:
+    /* 
+     * the idea is for each num in nums, 
+     * find all multiple of num.
+     * each num have a count of previous multiple
+     */
+    vector<int> largestDivisibleSubset(vector<int>& nums) {
+        int i;
+        if (!nums.size())
+            return {};
+
+        map<int, int> m;
+        map<int, int>::iterator it;
+        vector<pair<int, int>> dp(nums.size());
+        unsigned int acc, num;
+        int largest_last_index = 0;
+        int largest_subcount = 0;
+            
+        sort(nums.begin(), nums.end());
+        for (i = 0; i < nums.size(); ++i)
+            m[nums[i]] = i;
+        
+        if (nums[0] == 1) {
+            fill(dp.begin()+1, dp.end(), make_pair(0,1));
+            dp[0].first = -1;
+            dp[0].second = 0;
+            largest_last_index = nums.size()-1;
+            i = 1;
+        } else {
+            i = 0;
+            fill(dp.begin(), dp.end(), make_pair(-1,0));
+        }
+
+        for (; i < nums.size(); ++i) {
+            num = nums[i];
+            acc = num << 1;
+            if ((int)num > (int)acc) // solve overflow problem
+                continue;
+            /* find all multiple of num */
+            while ((it = m.upper_bound(acc-1)) != m.end()) {
+                int mod = it->first % num;
+                auto &ref = dp[i];
+                auto &tgt = dp[it->second];
+                /* current list of multiple is larger than the old one */
+                if (mod == 0 && ref.second >= tgt.second) {
+                    /* move target into biger list */
+                    tgt.first = i ;
+                    tgt.second = ref.second +1;
+                    if (tgt.second > largest_subcount) {
+                        largest_subcount = tgt.second;
+                        largest_last_index = it->second;
+                    }
+                }
+                acc = it->first - mod + num;
+                if ((int)num > (int)acc) // solve overflow problem
+                    break;
+            }
+        }
+        
+        vector<int> ret;
+        while (largest_last_index >= 0) {
+            ret.push_back(nums[largest_last_index]);
+            largest_last_index = dp[largest_last_index].first;
+        }
+        return ret;
+    }
+};
diff --git a/June-LeetCoding-Challenge/14-Cheapest-Flights-Within-K-Stops/Cheapest-Flights-Within-K-Stops.cpp b/June-LeetCoding-Challenge/14-Cheapest-Flights-Within-K-Stops/Cheapest-Flights-Within-K-Stops.cpp
@@ -0,0 +1,61 @@
+class Solution {
+public:
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
+        vector<vector<int>> a(n, vector<int>(n, 0));
+        for (int i = 0; i < flights.size(); i++)
+            a[flights[i][0]][flights[i][1]] = flights[i][2];
+        
+        
+        vector<vector<int>> dp(K+2, vector<int>(n, 0));
+        
+        for (int i = 0; i < n; i++) dp[0][i] = 1000000000;
+        dp[0][src] = 0;
+        
+        int ans = min(dp[0][dst], 1000000000);
+        for (int i = 1; i <= K+1; i++){
+            for (int j = 0; j < n; j++){
+                dp[i][j] = 1000000000;
+                for (int k = 0; k < n; k++)
+                    if (a[k][j])
+                        dp[i][j] = min(dp[i][j], dp[i-1][k] + a[k][j]);
+            }
+            ans = min(ans, dp[i][dst]);
+        }
+        return (ans == 1000000000)?-1:ans;
+    }
+};
+
+class Solution2 {
+    // algo dijkstra
+public:
+    typedef tuple<int, int, int> typeTuple; // (AccumulatedCost, cityId, stopUsed)
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
+        
+        priority_queue<typeTuple, vector<typeTuple>, greater<typeTuple>> neighs;
+        
+        unordered_map<int, vector<pair<int, int>>> g;
+        for (auto& v : flights)
+            g[v[0]].emplace_back(v[1], v[2]);
+
+        neighs.emplace(0, src, 0);
+
+        while (!neighs.empty()) {
+            auto t = neighs.top();
+            int cost = get<0>(t); // accumulated cost
+            int u = get<1>(t); // city u -> city v
+            int stopused = get<2>(t);
+            neighs.pop();
+            
+            if (u == dst) 
+                return cost;
+
+            if (stopused > K) continue;
+
+            for (auto p : g[u]) 
+                neighs.emplace(cost + p.second, p.first, stopused + 1); // increment stopused
+            
+            }
+        return -1;
+
+    }
+};
diff --git a/README.md b/README.md
@@ -16,7 +16,12 @@ Solutions in various programming languages are provided. Enjoy it.
 6. [Queue Reconstruction by Height](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/06-Queue-Reconstruction-By-Height): Greedy
 7. [Coin Change 2](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/07-Coin-Change-2): DP
 8. [Power of Two](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/08-Power-Of-Two): Bitwise manipulation
-
+9. [Is Subsequence](https://github.com/AlgoStudyGroup/Leetcode/blob/master/June-LeetCoding-Challenge/09-Is-Subsequence): Two pointers / DP
+10. [Search Insert Position](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/10-Search-Insert-Position): Binary Search
+11. [Sort Colors](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/11-Sort-Colors): Two Pointers
+12. [Insert Delete GetRandom](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/12-Insert-Delete-GetRandom): Hash Table
+13. [Largest Divisible Subset](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/13-Largest-Divisible-Subset): DP
+14. [Cheapest Flights Within K Stops](https://github.com/AlgoStudyGroup/Leetcode/tree/master/June-LeetCoding-Challenge/14-Cheapest-Flights-Within-K-Stops): DP
 
 
 ## May LeetCoding Challenge
diff --git a/untitled b/untitled
