update

Author: Liang Wang

leetcode/CanPlaceFlowers.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+ bool canPlaceFlowers(vector<int>& flowerbed, int n) {
+ int ptr = 0;
+ int res = 0;
+ while (ptr < flowerbed.size()) {
+ if (flowerbed[ptr] == 1) {
+ ++ptr;
+ continue;
+ }
+ int start = ptr;
+ while (ptr < flowerbed.size() && flowerbed[ptr] == 0) {
+ ++ptr;
+ }
+ int slots = ptr - start;
+ if (start > 0) --slots;
+ if (ptr < flowerbed.size()) --slots;
+ res += (max(slots, 0) + 1) / 2;
+ }
+ return res >= n;
+ }
+};

leetcode/ConstructStringFromBinaryTree.cpp

@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+ string tree2str(TreeNode* t) {
+ string res;
+ if (NULL == t) {
+ return res;
+ }
+ res += to_string(t->val);
+ if (t->left == NULL && t->right == NULL) {
+ return res;
+ } else if (t->left != NULL && t->right == NULL) {
+ res += "(";
+ res += tree2str(t->left);
+ res.push_back(')');
+ return res;
+ } else if (t->left == NULL && t->right != NULL) {
+ res += "()(";
+ res += tree2str(t->right);
+ res += ")";
+ return res;
+ } else {
+ res.push_back('(');
+ res += tree2str(t->left);
+ res += ")(";
+ res += tree2str(t->right);
+ res.push_back(')');
+ return res;
+ }
+ }
+};

leetcode/FindDuplicateFileInSystem.cpp

@@ -0,0 +1,43 @@
+class Solution {
+public:
+ vector<vector<string>> findDuplicate(vector<string>& paths) {
+ vector<vector<string>> res;
+ map<string, vector<string> > content2path;
+ for (auto& path : paths) {
+ bool in_dir = true, in_name = false, in_content = false;
+ string dir, name, content;
+ for (int i = 0; i < path.size(); ++i) {
+ if (in_dir && path[i] != ' ') {
+ dir.push_back(path[i]);
+ } else if (in_dir && path[i] == ' ') {
+ in_dir = false;
+ dir.push_back('/');
+ in_name = true;
+ } else if (in_name && path[i] != '(' && path[i] != ' ') {
+ name.push_back(path[i]);
+ } else if (in_name && path[i] == '(') {
+ in_name = false;
+ in_content = true;
+ } else if (in_content && path[i] != ')') {
+ content.push_back(path[i]);
+ } else if (in_content && path[i] == ')') {
+ in_content = false;
+ in_name = true;
+ if (content2path.find(content) == content2path.end()) {
+ vector<string> v;
+ content2path[content] = v;
+ }
+ content2path[content].push_back(dir + name);
+ content.clear();
+ name.clear();
+ }
+ }
+ }
+ for (auto it = content2path.begin(); it != content2path.end(); ++it) {
+ if (it->second.size() > 1) {
+ res.push_back(it->second);
+ }
+ }
+ return res;
+ }
+};

leetcode/LongestHarmoniousSubsequence.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+ int findLHS(vector<int>& nums) {
+ sort(nums.begin(), nums.end());
+ int res = 0;
+ int ptr = 0;
+ for (int i = 0; i < nums.size(); ++i) {
+ if (i - 1 >= 0 && nums[i - 1] == nums[i]) {
+ continue;
+ }
+ while (ptr < nums.size() && nums[ptr] - nums[i] <= 1) {
+ ++ptr;
+ }
+ if (nums[ptr - 1] == nums[i] + 1) {
+ res = max(res, ptr - i);
+ }
+ }
+ return res;
+ }
+};

leetcode/MinimumIndexSumOfTwoLists.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+ vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
+ map<string, int> name2idx;
+ for (int i = 0; i < list1.size(); ++i) {
+ name2idx[list1[i]] = i;
+ }
+ int mn = list1.size() + list2.size();
+ vector<string> res;
+ for (int i = 0; i < list2.size(); ++i) {
+ if (name2idx.find(list2[i]) != name2idx.end()) {
+ int sm = i + name2idx[list2[i]];
+ if (sm < mn) {
+ res.clear();
+ res.push_back(list2[i]);
+ mn = sm;
+ } else if (sm == mn) {
+ res.push_back(list2[i]);
+ }
+ }
+ }
+ return res;
+ }
+};

leetcode/RangeAdditionII.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+ int maxCount(int m, int n, vector<vector<int>>& ops) {
+ if (ops.empty()) {
+ return m * n;
+ }
+ int r = m, c = n;
+ for (int i = 0; i < ops.size(); ++i) {
+ int nr = ops[i][0], nc = ops[i][1];
+ r = min(r, nr);
+ c = min(c, nc);
+ }
+ return r * c;
+ }
+};

leetcode/ValidTriangleNumber.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+ int triangleNumber(vector<int>& nums) {
+ int res = 0;
+ sort(nums.begin(), nums.end());
+ for (int i = 0; i < nums.size(); ++i) {
+ for (int j = 0; j < i; ++j) {
+ if (nums[j] > 0) {
+ int idx = lower_bound(nums.begin(), nums.end(), nums[i] + nums[j]) - nums.begin();
+ res += idx - (i + 1);
+ }
+ }
+ }
+ return res;
+ }
+};