feat: solve problem

HONGJICAI · HONGJICAI · commit dd50eaf0d903 · 2019-06-23T02:25:08.000+08:00
diff --git a/cpp/153.FindMinimumInRotatedSortedArray.cpp b/cpp/153.FindMinimumInRotatedSortedArray.cpp
@@ -0,0 +1,23 @@
+class Solution {
+//Runtime: 4 ms, faster than 89.79% of C++ online submissions for Find Minimum in Rotated Sorted Array.
+//Memory Usage: 8.8 MB, less than 29.27% of C++ online submissions for Find Minimum in Rotated Sorted Array.
+public:
+    int findMin(vector<int>& nums) {
+        int minVal=0x7fffffff;
+        function<void(int,int)> helper=[&](int low,int high){
+            if(low>high)
+                return;
+            if(nums[low]<=nums[high])
+                minVal=min(minVal,nums[low]);
+            else{
+                int mid=(high+low)/2;
+                helper(low,mid-1);
+                helper(mid+1,high);
+                minVal=min(minVal,nums[mid]);
+            }
+        };
+        helper(0,nums.size()-1);
+        return minVal;
+    }
+
+};
diff --git a/cpp/220.ContainsDuplicateIii.cpp b/cpp/220.ContainsDuplicateIii.cpp
@@ -0,0 +1,21 @@
+class Solution {
+//Runtime: 20 ms, faster than 71.64% of C++ online submissions for Contains Duplicate III.
+//Memory Usage: 10.9 MB, less than 32.96% of C++ online submissions for Contains Duplicate III.
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+        if (k < 1 or t < 0) return false;
+        set<int>s;
+        for(int i=0;i<nums.size();++i){
+            if(i>k)
+                s.erase(nums[i-k-1]);
+            auto [it,success]=s.insert(nums[i]);
+            if(not success)
+                return true;
+            if(it!=begin(s) and abs((long long)*prev(it)-(long long)*it)<=t)
+                return true;
+            if(next(it)!=end(s) and abs((long long)*next(it)-(long long)*it)<=t)
+                return true;
+        }
+        return false;
+    }
+};
diff --git a/cpp/241.DifferentWaysToAddParentheses.cpp b/cpp/241.DifferentWaysToAddParentheses.cpp
@@ -0,0 +1,39 @@
+class Solution {
+//Runtime: 0 ms Your runtime beats 100.00 % of cpp submissions
+//Memory Usage: 9.1 MB Your memory usage beats 95.63 % of cpp submissions.
+public:
+	vector<int> diffWaysToCompute(string input) {
+		unordered_map<string_view, vector<int>> dpMap;
+        function<void(string_view)>recursion=[&](string_view input) {
+            vector<int> result;
+            for (int i = 0; i < input.size(); i++) {
+                char cur = input[i];
+                if (cur == '+' || cur == '-' || cur == '*') {
+                    auto substr = input.substr(0, i);
+                    if (dpMap.find(substr) == dpMap.end())
+                        recursion(substr);
+                    auto &result1 = dpMap[substr];
+                    substr = input.substr(i + 1);
+                    if (dpMap.find(substr) == dpMap.end())
+                        recursion(substr);
+                    auto &result2 = dpMap[substr];
+                    for (auto n1 : result1)
+                        for (auto n2 : result2)
+                            switch(cur){
+                                case '+':result.push_back(n1 + n2);break;
+                                case '-':result.push_back(n1 - n2);break;
+                                case '*':result.push_back(n1 * n2);break;
+                            }
+                }
+            }
+            if (result.empty()){
+                int res;
+                from_chars(input.data(), input.data() + input.size(), res);
+                result.push_back(res);
+            }
+            dpMap[input]=move(result);
+        };
+		recursion(input);
+        return dpMap[input];
+	}
+};
diff --git a/cpp/29.DivideTwoIntegers.cpp b/cpp/29.DivideTwoIntegers.cpp
@@ -0,0 +1,26 @@
+class Solution {
+//Runtime: 0 ms, faster than 100.00% of C++ online submissions for Divide Two Integers.
+//Memory Usage: 8.2 MB, less than 47.58% of C++ online submissions for Divide Two Integers.
+public:
+    int divide(int dividend, int divisor) {
+        if(divisor==0)
+            return 0x7fffffff;
+        if(dividend==0)
+            return 0;
+        auto res = [](long long dividend,long long divisor)->long long{
+            auto res=0ll;
+            while(dividend>=divisor){
+                auto level=1ll;
+                for(;(divisor<<level)<dividend;++level);
+                res+=1ll<<(level-1ll);
+                dividend-=divisor<<(level-1ll);
+            }
+            return res;
+        }(abs((long long)dividend),abs((long long)divisor))*((dividend>0 and divisor>0)or(dividend<0 and divisor<0)?1:-1);
+        if(res>2147483647ll)
+            return 0x7fffffff;
+        if(res<-2147483648ll)
+            return -2146483648;
+        return res;
+    }
+};
diff --git a/cpp/365.WaterAndJugProblem.cpp b/cpp/365.WaterAndJugProblem.cpp
@@ -0,0 +1,46 @@
+class Solution {
+//Runtime: 984 ms, faster than 5.08% of C++ online submissions for Water and Jug Problem.
+//Memory Usage: 152.6 MB, less than 5.31% of C++ online submissions for Water and Jug Problem.
+public:
+    bool canMeasureWater(int x, int y, int z) {
+        array<function<void(int&,int&)>,6>ops={
+            [&](int &a,int &){
+                a=x;
+            },
+            [&](int &,int &b){
+                b=y;
+            },
+            [&](int &a,int &){
+                a=0;
+            },
+            [&](int &,int &b){
+                b=0;
+            },
+            [&](int &a,int &b){
+                auto diff=min(y-b,a);
+                a-=diff;
+                b+=diff;
+            },
+            [&](int &a,int &b){
+                auto diff=min(x-a,b);
+                a+=diff;
+                b-=diff;
+            }
+        };
+        unordered_set<long long>seen{0};
+        deque<pair<int,int>> dq{{0,0}};
+        while(dq.size()){
+            for(auto &op:ops){
+                auto [a,b]=dq.front();
+                op(a,b);
+                if(a==z or b==z or a+b==z)
+                    return true;
+                auto [it,ok]=seen.insert(((long long)a<<32)+b);
+                if(ok)
+                    dq.push_back({a,b});
+            }
+            dq.pop_front();
+        }
+        return false;
+    }
+};
diff --git a/cpp/376.WiggleSubsequence.cpp b/cpp/376.WiggleSubsequence.cpp
@@ -0,0 +1,15 @@
+class Solution {
+//Runtime: 4 ms, faster than 86.10% of C++ online submissions for Wiggle Subsequence.
+//Memory Usage: 8.8 MB, less than 7.24% of C++ online submissions for Wiggle Subsequence.
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+        if (nums.size() == 0) return 0;
+        int up = 1, down = 1;
+        for (int i = 1; i < nums.size(); ++i)
+            if (nums[i] > nums[i-1])
+                up = down + 1;
+            else if (nums[i] < nums[i-1])
+                down = up + 1;
+        return max(up, down);
+    }
+};
diff --git a/cpp/380.InsertDeleteGetrandomO(1).cpp b/cpp/380.InsertDeleteGetrandomO(1).cpp
@@ -0,0 +1,43 @@
+class RandomizedSet {
+    vector<int> nums;
+    unordered_map<int, int> m;
+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 (m.find(val) != m.end()) return false;
+        nums.emplace_back(val);
+        m[val] = nums.size() - 1;
+        return true;
+    }
+    
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if (auto it=m.find(val);it == m.end())
+            return false;
+        else{
+            m[nums.back()] = it->second;
+            nums[it->second] = nums.back();
+            nums.pop_back();
+            m.erase(it);
+            return true;
+        }
+    }
+    
+    /** Get a random element from the set. */
+    int getRandom() {
+        return nums[rand() % nums.size()];
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */
diff --git a/cpp/395.LongestSubstringWithAtLeastKRepeatingCharacters.cpp b/cpp/395.LongestSubstringWithAtLeastKRepeatingCharacters.cpp
@@ -0,0 +1,33 @@
+class Solution {
+//Runtime: 0 ms, faster than 100.00% of C++ online submissions for Longest Substring with At Least K Repeating Characters.
+//Memory Usage: 8.8 MB, less than 74.27% of C++ online submissions for Longest Substring with At Least K Repeating Characters.
+public:
+    int longestSubstring(string s, int k) {
+        int ret=0;
+        function<void(string_view)> dfs=[&](string_view ss){
+            if(not ss.size()) return;
+            unordered_map<char,int>counter;
+            for(auto ch:ss)
+                ++counter[ch];
+            for(auto it=counter.begin();it!=counter.end();)
+                if(it->second>=k)
+                    counter.erase(it++);
+                else
+                    ++it;
+            if(counter.size()){
+                int start=0;
+                for(int i=0;i<ss.size();++i)
+                    if(counter.count(ss[i])){
+                        if(i-start>ret)
+                            dfs(ss.substr(start,i-start));
+                        start=i+1;
+                    }
+                dfs(ss.substr(start));
+            }
+            else
+                ret=max(ret,(int)ss.size());
+        };
+        dfs(s);
+        return ret;
+    }
+};
diff --git a/cpp/402.RemoveKDigits.cpp b/cpp/402.RemoveKDigits.cpp
@@ -0,0 +1,18 @@
+class Solution {
+//Runtime: 44 ms, faster than 12.45% of C++ online submissions for Remove K Digits.
+//Memory Usage: 180 MB, less than 8.63% of C++ online submissions for Remove K Digits.
+public:
+    string removeKdigits(string num, int k) {
+        if(k>=num.size())
+            return "0";
+        if(k==0){
+            int i=0;
+            while(i<num.size() and num[i]=='0')++i;
+            return i==num.size()?"0":num.substr(i);
+        }
+        for(int i=0;i+1<num.size();++i)
+            if(num[i]>num[i+1])
+                return removeKdigits(num.substr(0,i)+num.substr(i+1),k-1);
+        return removeKdigits(num.substr(0,num.size()-k),0);
+    }
+};
diff --git a/cpp/410.SplitArrayLargestSum.cpp b/cpp/410.SplitArrayLargestSum.cpp
@@ -0,0 +1,32 @@
+class Solution {
+//Runtime: 4 ms
+//Memory Usage: 8.6 MB
+public:
+    int splitArray(vector<int>& nums, int m) {
+        long long left = 0, right = 0;
+        for (auto num : nums) {
+            left = max(left, (long long)num);
+            right += num;
+        }
+        while (left < right) {
+            auto mid = left + (right - left) / 2;
+            if ([](const vector<int>& nums, int cuts, long long max) {
+                long long acc = 0;
+                for (auto num : nums) {
+                    if (acc + num <= max)
+                        acc += num;
+                    else {
+                        --cuts;
+                        acc = num;
+                        if (cuts < 0) return false;
+                    }
+                }
+                return true;
+                }(nums, m - 1, mid))
+                right = mid;
+            else
+                left = mid + 1;
+        }
+        return left;
+    }
+};
diff --git a/cpp/457.CircularArrayLoop.cpp b/cpp/457.CircularArrayLoop.cpp
@@ -0,0 +1,32 @@
+class Solution {
+//Runtime: 4 ms, faster than 88.75% of C++ online submissions for Circular Array Loop.
+//Memory Usage: 8.4 MB, less than 75.74% of C++ online submissions for Circular Array Loop.
+public:
+    bool circularArrayLoop(vector<int>& nums) {
+        vector<int>visited(nums.size(),0);
+        auto go=[&](int i)->int{
+            if(nums[i]>0)
+                return (i+nums[i])%nums.size();
+            else if(i+nums[i]<0){
+                int offset=abs(i+nums[i])%nums.size();
+                return offset==0?i:(int)nums.size()-offset;
+            }
+            else return i+nums[i];
+        };
+        for(int i=0;i<nums.size();++i){
+            if(not visited[i]){
+                vector<int>curCircle(nums.size(),0);
+                curCircle[i]=1;
+                for(int start=go(i),dir=nums[i]>0;(nums[start]>0)==dir;){
+                    if(curCircle[start])
+                        if(start!=go(start))
+                            return true;
+                        else break;
+                    curCircle[start]=visited[start]=1;
+                    start=go(start);
+                }
+            }
+        }
+        return false;
+    }
+};
diff --git a/cpp/464.CanIWin.cpp b/cpp/464.CanIWin.cpp
@@ -0,0 +1,21 @@
+class Solution {
+//Runtime: 120 ms, faster than 51.55% of C++ online submissions for Can I Win.
+//Memory Usage: 25 MB, less than 49.12% of C++ online submissions for Can I Win.
+public:
+    bool canIWin(int maxChoosableInteger, int desiredTotal) {
+        unordered_map<int, bool> m;
+        if(maxChoosableInteger >= desiredTotal) return true;
+        if((1 + maxChoosableInteger) * maxChoosableInteger / 2 < desiredTotal) return false;
+        function<bool(int,int)> canWin=[&](int target, int visited) {
+            if(auto it=m.find(visited);it != m.end()) return it->second;
+            for(int i = 1; i <= maxChoosableInteger; i++) {
+                int mask = (1 << i);
+                if((mask & visited) == 0 && (i >= target or not canWin(target - i, mask | visited) ))
+                    return m[visited] = true;
+            }
+            return m[visited] = false;
+        };
+        return canWin(desiredTotal, 0);
+    }
+    
+};
diff --git a/cpp/475.Heaters.cpp b/cpp/475.Heaters.cpp
diff --git a/cpp/593.ValidSquare.cpp b/cpp/593.ValidSquare.cpp
diff --git a/cpp/687.LongestUnivaluePath.cpp b/cpp/687.LongestUnivaluePath.cpp
diff --git a/cpp/69.Sqrt(X).cpp b/cpp/69.Sqrt(X).cpp
diff --git a/cpp/697.DegreeOfAnArray.cpp b/cpp/697.DegreeOfAnArray.cpp
diff --git a/cpp/698.PartitionToKEqualSumSubsets.cpp b/cpp/698.PartitionToKEqualSumSubsets.cpp
