ADD: update leetcode solutions

Author: intfloat

leetcode/CanIWin.cpp

@@ -0,0 +1,50 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<bool> isWin(1<<20);
+vector<bool> isLose(1<<20);
+class Solution {
+public:
+ bool canIWin(int maxChoosableInteger, int desiredTotal) {
+ if (maxChoosableInteger * (maxChoosableInteger + 1) / 2 < desiredTotal) {
+ return false;
+ }
+ if (desiredTotal <= 0) {
+ return true;
+ }
+ fill(isWin.begin(), isWin.begin() + (1 << maxChoosableInteger), false);
+ fill(isLose.begin(), isLose.begin() + (1 << maxChoosableInteger), false);
+ this->mx = maxChoosableInteger;
+ return solve(0, desiredTotal);
+ }
+private:
+ int mx;
+ bool solve(int status, int total) {
+ if (isWin[status]) return true;
+ if (isLose[status]) return false;
+ if (total <= 0) {
+ isLose[status] = true;
+ return false;
+ }
+ for (int i = 1; i <= this->mx; ++i) {
+ if (!((1 << (i - 1)) & status)) {
+ bool nt = solve(status | (1 << (i - 1)), total - i);
+ if (!nt) {
+ isWin[status] = true;
+ return true;
+ }
+ }
+ }
+ isLose[status] = true;
+ return false;
+ }
+};
+
+int main() {
+ Solution sol;
+ cout << sol.canIWin(10, 11) << endl;
+ for (int i = 10; i <= 160; ++i) {
+ cout << i << " " << sol.canIWin(20, i) << endl;
+ }
+ return 0;
+}

leetcode/DeleteNodeInBST.cpp

@@ -0,0 +1,102 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode {
+ int val;
+ TreeNode *left;
+ TreeNode *right;
+ TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+private:
+ bool find_key(TreeNode* root, int key, TreeNode*& parent, TreeNode*& target) {
+ parent = NULL;
+ target = root;
+ while (target != NULL && target->val != key) {
+ if (target->val < key) {
+ parent = target;
+ target = target->right;
+ } else {
+ parent = target;
+ target = target->left;
+ }
+ }
+ return (target != NULL);
+ }
+public:
+ TreeNode* deleteNode(TreeNode* root, int key) {
+ if (NULL == root) {
+ return root;
+ }
+ TreeNode *parent = NULL, *to_del = NULL;
+ if (!find_key(root, key, parent, to_del)) {
+ return root;
+ }
+ assert(to_del->val == key);
+
+ if (to_del->left == NULL && to_del->right == NULL) {
+ if (parent == NULL) {
+ return NULL;
+ } else if (parent->left == to_del) {
+ parent->left = NULL;
+ } else {
+ parent->right = NULL;
+ }
+ return root;
+ } else if (to_del->left == NULL) {
+ if (parent == NULL) {
+ return to_del->right;
+ } else if (parent->left == to_del) {
+ parent->left = to_del->right;
+ } else {
+ parent->right = to_del->right;
+ }
+ return root;
+ } else if (to_del->right == NULL) {
+ if (parent == NULL) {
+ return to_del->left;
+ } else if (parent->left == to_del) {
+ parent->left = to_del->left;
+ } else {
+ parent->right = to_del->left;
+ }
+ return root;
+ } else {
+ TreeNode* r_node = to_del->right;
+ if (r_node->left == NULL) {
+ r_node->left = to_del->left;
+ if (parent == NULL) {
+ return r_node;
+ } else if (parent->left == to_del) {
+ parent->left = r_node;
+ } else {
+ parent->right = r_node;
+ }
+ return root;
+ } else {
+ TreeNode* pl_node = r_node;
+ TreeNode* l_node = r_node->left;
+ while (l_node->left != NULL) {
+ pl_node = pl_node->left;
+ l_node = l_node->left;
+ }
+ pl_node->left = l_node->right;
+ l_node->left = to_del->left;
+ l_node->right = to_del->right;
+ if (parent == NULL) {
+ return l_node;
+ } else if (parent->left == to_del) {
+ parent->left = l_node;
+ } else {
+ parent->right = l_node;
+ }
+ return root;
+ }
+ }
+ }
+};
+
+int main() {
+ return 0;
+}

leetcode/EncodeAndDecodeTinyURL.py

@@ -0,0 +1,39 @@
+from random import randint
+
+class Codec:
+
+ ch_list = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+
+ def __init__(self):
+ self.forward_mp = {}
+ self.backward_mp = {}
+
+ def encode(self, longUrl):
+ """Encodes a URL to a shortened URL.
+
+ :type longUrl: str
+ :rtype: str
+ """
+ while True:
+ s = 'http://tinyurl.com/' + self._get_random_str()
+ if not s in self.forward_mp:
+ self.forward_mp[longUrl] = s
+ self.backward_mp[s] = longUrl
+ return s
+
+ def decode(self, shortUrl):
+ """Decodes a shortened URL to its original URL.
+
+ :type shortUrl: str
+ :rtype: str
+ """
+ return self.backward_mp[shortUrl]
+
+ def _get_random_str(self):
+ return ''.join([Codec.ch_list[randint(0, len(Codec.ch_list) - 1)] for i in range(10)])
+
+# Your Codec object will be instantiated and called as such:
+codec = Codec()
+s = codec.encode('http://baidu.com')
+print(s)
+print(codec.decode(s))

leetcode/FindComplement.cpp

@@ -0,0 +1,24 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ int findComplement(int num) {
+ for (int i = 31; i >= 0; --i) {
+ if ((1 << i) & num) {
+ int res = 0;
+ for (int j = i - 1; j >= 0; --j) {
+ if (!((1 << j) & num)) {
+ res += (1 << j);
+ }
+ }
+ return res;
+ }
+ }
+ return 0;
+ }
+};
+
+int main() {
+ return 0;
+}

leetcode/FindMaxForm.cpp

@@ -0,0 +1,44 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int dp[2][105][105];
+class Solution {
+public:
+ int findMaxForm(vector<string>& strs, int m, int n) {
+ for (int i = 0; i < 2; ++i) {
+ for (int j = 0; j <= m; ++j) {
+ for (int k = 0; k <= n; ++k) {
+ dp[i][j][k] = 0;
+ }
+ }
+ }
+ int sz = strs.size();
+ vector<int> zeros(sz, 0), ones(sz, 0);
+ for (int i = 0; i < strs.size(); ++i) {
+ string& s = strs[i];
+ for (int j = 0; j < s.size(); ++j) {
+ if (s[j] == '0') ++zeros[i];
+ else ++ones[i];
+ }
+ }
+ for (int i = 0; i < sz; ++i) {
+ for (int j = 0; j <= m; ++j) {
+ for (int k = 0; k <= n; ++k) {
+ int cur = i % 2;
+ int prev = 1 - cur;
+ int r1 = dp[prev][j][k];
+ int r2 = 0;
+ if (j >= zeros[i] && k >= ones[i]) {
+ r2 = dp[prev][j - zeros[i]][k - ones[i]] + 1;
+ }
+ dp[cur][j][k] = max(r1, r2);
+ }
+ }
+ }
+ return dp[(sz - 1) % 2][m][n];
+ }
+};
+
+int main() {
+ return 0;
+}

leetcode/HammingDistance.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+ int hammingDistance(int x, int y) {
+ return __builtin_popcount(x ^ y);
+ }
+};

leetcode/Heaters.cpp

@@ -0,0 +1,28 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ int findRadius(vector<int>& houses, vector<int>& heaters) {
+ if (houses.empty()) {
+ return 0;
+ }
+ sort(heaters.begin(), heaters.end());
+ int mx = 0;
+ for (int i = 0; i < houses.size(); ++i) {
+ vector<int>::iterator it = lower_bound(heaters.begin(), heaters.end(), houses[i]);
+ if (it == heaters.end()) {
+ mx = max(mx, houses[i] - heaters.back());
+ } else if (it == heaters.begin()) {
+ mx = max(mx, heaters[0] - houses[i]);
+ } else {
+ mx = max(mx, min(*it - houses[i], houses[i] - *(it - 1)));
+ }
+ }
+ return mx;
+ }
+};
+
+int main() {
+ return 0;
+}

leetcode/MatchsticksToSquare.cpp

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+private:
+ vector<int> dp;
+ vector<int> len;
+ int edge_len, sz;
+ bool solve(int status) {
+ if (dp[status] > 0) {
+ return true;
+ } else if (dp[status] < 0) {
+ return false;
+ }
+ int sum = 0;
+ for (int i = 0; i < sz; ++i) {
+ if ((1 << i) & status) {
+ continue;
+ }
+ sum += len[i];
+ }
+ int rem = sum % edge_len;
+ if (rem == 0) {
+ rem = edge_len;
+ }
+ for (int i = 0; i < sz; ++i) {
+ if ((1 << i) & status) {
+ continue;
+ }
+ if (len[i] > rem) {
+ continue;
+ }
+ if (solve(status | (1 << i))) {
+ dp[status] = 1;
+ return true;
+ }
+ }
+ dp[status] = -1;
+ return false;
+ }
+public:
+ bool makesquare(vector<int>& nums) {
+ int total = accumulate(nums.begin(), nums.end(), 0);
+ if (total % 4 || nums.size() < 4) {
+ return false;
+ }
+ len = nums;
+ edge_len = total / 4;
+ sz = nums.size();
+ dp.resize(1 << sz);
+ fill(dp.begin(), dp.end(), 0);
+ dp[(1 << sz) - 1] = 1;
+ return solve(0);
+ }
+};
+
+int main() {
+ Solution sol;
+ // std::vector<int> v = {5,5,5,5,16,4,4,4,4,4,3,3,3,3,4};
+ std::vector<int> v = {1,1,2,2,2};
+ cout << sol.makesquare(v) << endl;
+ std::vector<int> u = {3, 3, 3, 3, 4};
+ cout << sol.makesquare(u) << endl;
+ return 0;
+}