406/421

MaskRay · MaskRay · commit 4e9a79a0544f · 2016-11-12T19:50:24.000-08:00
diff --git a/README.md b/README.md
@@ -2,7 +2,7 @@
 
 [LeetCode solutions](http://maskray.me/blog/2014-06-29-leetcode-solutions) gives some thoughts on selected problems.
 
-Solved 386/386 problems.
+Solved 406/421 problems.
 
 ## Database
 
@@ -12,6 +12,26 @@ See [database.md](database.md)
 
 | # | Title | Solution |
 |---| ----- | -------- |
+|453|[Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements)|[minimum-moves-to-equal-array-elements.cc](minimum-moves-to-equal-array-elements.cc)|
+|447|[Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs)|[number-of-boomerangs.cc](number-of-boomerangs.cc)|
+|438|[Find All Anagrams in a String](https://leetcode.com/problems/find-all-anagrams-in-a-string)|[find-all-anagrams-in-a-string.cc](find-all-anagrams-in-a-string.cc)|
+|437|[Path Sum III](https://leetcode.com/problems/path-sum-iii)|[path-sum-iii.cc](path-sum-iii.cc)|
+|436|[Find Right Interval](https://leetcode.com/problems/find-right-interval)|[find-right-interval.cc](find-right-interval.cc)|
+|435|[Non-overlapping Intervals](https://leetcode.com/problems/non-overlapping-intervals)|[non-overlapping-intervals.cc](non-overlapping-intervals.cc)|
+|421|[Maximum XOR of Two Numbers in an Array](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array)|[maximum-xor-of-two-numbers-in-an-array.cc](maximum-xor-of-two-numbers-in-an-array.cc)|
+|420|[Strong Password Checker](https://leetcode.com/problems/strong-password-checker)|[strong-password-checker.cc](strong-password-checker.cc)|
+|419|[Battleships in a Board](https://leetcode.com/problems/battleships-in-a-board)|[battleships-in-a-board.cc](battleships-in-a-board.cc)|
+|417|[Pacific Atlantic Water Flow](https://leetcode.com/problems/pacific-atlantic-water-flow)|[pacific-atlantic-water-flow.cc](pacific-atlantic-water-flow.cc)|
+|416|[Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum)|[partition-equal-subset-sum.cc](partition-equal-subset-sum.cc)|
+|415|[Add Strings](https://leetcode.com/problems/add-strings)|[add-strings.cc](add-strings.cc)|
+|414|[Third Maximum Number](https://leetcode.com/problems/third-maximum-number)|[third-maximum-number.cc](third-maximum-number.cc)|
+|413|[Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices)|[arithmetic-slices.cc](arithmetic-slices.cc)|
+|412|[Fizz Buzz](https://leetcode.com/problems/fizz-buzz)|[fizz-buzz.cc](fizz-buzz.cc)|
+|410|[Split Array Largest Sum](https://leetcode.com/problems/split-array-largest-sum)|[split-array-largest-sum.cc](split-array-largest-sum.cc)|
+|409|[Longest Palindrome](https://leetcode.com/problems/longest-palindrome)|[longest-palindrome.cc](longest-palindrome.cc)|
+|406|[Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height)|[queue-reconstruction-by-height.cc](queue-reconstruction-by-height.cc)|
+|405|[Convert a Number to Hexadecimal](https://leetcode.com/problems/convert-a-number-to-hexadecimal)|[convert-a-number-to-hexadecimal.cc](convert-a-number-to-hexadecimal.cc)|
+|404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves)|[sum-of-left-leaves.cc](sum-of-left-leaves.cc)|
 |403|[Frog Jump](https://leetcode.com/problems/frog-jump)|[frog-jump.cc](frog-jump.cc)|
 |402|[Remove K Digits](https://leetcode.com/problems/remove-k-digits)|[remove-k-digits.cc](remove-k-digits.cc)|
 |401|[Binary Watch](https://leetcode.com/problems/binary-watch)|[binary-watch.cc](binary-watch.cc)|
diff --git a/add-strings.cc b/add-strings.cc
@@ -0,0 +1,17 @@
+// Add Strings
+class Solution {
+public:
+  string addStrings(string a, string b) {
+    string r;
+    int m = a.size(), n = b.size(), c = 0;
+    for (int i = 0; i < max(m, n); i++) {
+      c += (i < m ? a[m-1-i]-'0' : 0) + (i < n ? b[n-1-i]-'0' : 0);
+      r += '0'+c%10;
+      c /= 10;
+    }
+    if (c)
+      r += '1';
+    reverse(r.begin(), r.end());
+    return r;
+  }
+};
diff --git a/arithmetic-slices.cc b/arithmetic-slices.cc
@@ -0,0 +1,13 @@
+// Arithmetic Slices
+class Solution {
+public:
+  int numberOfArithmeticSlices(vector<int>& A) {
+    int r = 0, s = 0;
+    for (int i = 2; i < A.size(); i++)
+      if (A[i-1]-A[i-2] == A[i]-A[i-1])
+        r += ++s;
+      else
+        s = 0;
+    return r;
+  }
+};
diff --git a/battleships-in-a-board.cc b/battleships-in-a-board.cc
@@ -0,0 +1,15 @@
+// Battleships in a Board
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  int countBattleships(vector<vector<char>>& a) {
+    int r = 0;
+    REP(i, a.size())
+      REP(j, a[0].size())
+        if (a[i][j] == 'X' && (! i || a[i-1][j] != 'X') && (! j || a[i][j-1] != 'X'))
+          r++;
+    return r;
+  }
+};
diff --git a/convert-a-number-to-hexadecimal.cc b/convert-a-number-to-hexadecimal.cc
@@ -0,0 +1,11 @@
+// Convert a Number to Hexadecimal
+class Solution {
+public:
+  string toHex(int num) {
+    string r;
+    unsigned x = num;
+    while (r += x%16 < 10 ? '0'+x%16 : 'a'+x%16-10, x /= 16);
+    reverse(r.begin(), r.end());
+    return r;
+  }
+};
diff --git a/find-all-anagrams-in-a-string.cc b/find-all-anagrams-in-a-string.cc
@@ -0,0 +1,29 @@
+// Find All Anagrams in a String
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  vector<int> findAnagrams(string s, string p) {
+    vector<int> r;
+    if (s.size() < p.size()) return r;
+    int c[26] = {}, d = 0;
+    for (char i: p)
+      c[i-'a']--;
+    REP(i, p.size())
+      c[s[i]-'a']++;
+    for (int i: c)
+      if (i)
+        d++;
+    if (! d)
+      r.push_back(0);
+    REP(i, s.size()-p.size()) {
+      if (! c[s[i+p.size()]-'a']++) d++;
+      if (! c[s[i+p.size()]-'a']) d--;
+      if (! c[s[i]-'a']--) d++;
+      if (! c[s[i]-'a']) d--;
+      if (! d) r.push_back(i+1);
+    }
+    return r;
+  }
+};
diff --git a/find-right-interval.cc b/find-right-interval.cc
@@ -0,0 +1,19 @@
+// Find Right Interval
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  vector<int> findRightInterval(vector<Interval>& intervals) {
+    vector<int> r;
+    vector<pair<int, int>> a;
+    REP(i, intervals.size())
+      a.emplace_back(intervals[i].start, i);
+    sort(a.begin(), a.end());
+    for (auto& x: intervals) {
+      auto it = lower_bound(a.begin(), a.end(), make_pair(x.end, 0));
+      r.push_back(it == a.end() ? -1 : it->second);
+    }
+    return r;
+  }
+};
diff --git a/fizz-buzz.cc b/fizz-buzz.cc
@@ -0,0 +1,18 @@
+// Fizz Buzz
+class Solution {
+public:
+  vector<string> fizzBuzz(int n) {
+    int fizz = 3, buzz = 5, fizzbuzz = 15;
+    vector<string> r;
+    for (int i = 1; i <= n; i++)
+      if (i == fizzbuzz)
+        r.push_back("FizzBuzz"), fizz += 3, buzz += 5, fizzbuzz += 15;
+      else if (i == fizz)
+        r.push_back("Fizz"), fizz += 3;
+      else if (i == buzz)
+        r.push_back("Buzz"), buzz += 5;
+      else
+        r.push_back(to_string(i));
+    return r;
+  }
+};
diff --git a/longest-palindrome.cc b/longest-palindrome.cc
@@ -0,0 +1,14 @@
+// Longest Palindrome
+class Solution {
+public:
+  int longestPalindrome(string s) {
+    int c[52] = {}, d = 0, r = 0;
+    for (char i: s)
+      c[i >= 'a' ? i-'a' : i-'A'+26]++;
+    for (int i: c) {
+      d |= i%2;
+      r += i-i%2;
+    }
+    return r+d;
+  }
+};
diff --git a/maximum-xor-of-two-numbers-in-an-array.cc b/maximum-xor-of-two-numbers-in-an-array.cc
@@ -0,0 +1,21 @@
+// Maximum XOR of Two Numbers in an Array
+class Solution {
+public:
+  int findMaximumXOR(vector<int>& nums) {
+    int m = 0, r = 0;
+    unordered_set<int> s;
+    for (int i = 30; i >= 0; i--) {
+      m |= 1<<i;
+      s.clear();
+      for (int x: nums)
+        s.insert(x & m);
+      int t = r|1<<i;
+      for (int x: s)
+        if (s.count(x^t)) {
+          r = t;
+          break;
+        }
+    }
+    return r;
+  }
+};
diff --git a/minimum-moves-to-equal-array-elements.cc b/minimum-moves-to-equal-array-elements.cc
@@ -0,0 +1,7 @@
+// Minimum Moves to Equal Array Elements
+class Solution {
+public:
+  int minMoves(vector<int>& a) {
+    return accumulate(a.begin(), a.end(), 0L)-*min_element(a.begin(), a.end())*a.size();
+  }
+};
diff --git a/non-overlapping-intervals.cc b/non-overlapping-intervals.cc
@@ -0,0 +1,16 @@
+// Non-overlapping Intervals
+class Solution {
+public:
+  int eraseOverlapIntervals(vector<Interval>& a) {
+    sort(a.begin(), a.end(), [](const Interval& x, const Interval& y) {
+      return x.end < y.end;
+    });
+    int r = 0, y = INT_MIN;
+    for (auto& x: a)
+      if (y <= x.start) {
+        y = x.end;
+        r++;
+      }
+    return a.size()-r;
+  }
+};
diff --git a/number-of-boomerangs.cc b/number-of-boomerangs.cc
@@ -0,0 +1,25 @@
+// Number of Boomerangs
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  int numberOfBoomerangs(vector<pair<int, int>>& a) {
+    int r = 0;
+    REP(i, a.size()) {
+      vector<int> d;
+      REP(j, a.size())
+        if (j != i)
+          d.push_back((a[i].first-a[j].first)*
+                      (a[i].first-a[j].first)+
+                      (a[i].second-a[j].second)*
+                      (a[i].second-a[j].second));
+      sort(d.begin(), d.end());
+      for (int k = 0, j = 0; j < d.size(); j = k) {
+        for (; k < d.size() && d[j] == d[k]; k++);
+        r += (k-j)*(k-j-1);
+      }
+    }
+    return r;
+  }
+};
diff --git a/pacific-atlantic-water-flow.cc b/pacific-atlantic-water-flow.cc
@@ -0,0 +1,53 @@
+// Pacific Atlantic Water Flow
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  vector<pair<int, int>> pacificAtlantic(vector<vector<int>>& matrix) {
+    if (matrix.empty())
+      return {};
+    int m = matrix.size(), n = matrix[0].size();
+    queue<pair<int, int>> q;
+    vector<vector<char>> a(m, vector<char>(n, 0));
+    auto bfs = [&](int b) {
+      while (q.size()) {
+        int x, y;
+        tie(x, y) = q.front();
+        q.pop();
+        if (x && ! (a[x-1][y] & b) && matrix[x][y] <= matrix[x-1][y])
+          a[x-1][y] |= b, q.emplace(x-1, y);
+        if (x+1 < m && ! (a[x+1][y] & b) && matrix[x][y] <= matrix[x+1][y])
+          a[x+1][y] |= b, q.emplace(x+1, y);
+        if (y && ! (a[x][y-1] & b) && matrix[x][y] <= matrix[x][y-1])
+          a[x][y-1] |= b, q.emplace(x, y-1);
+        if (y+1 < n && ! (a[x][y+1] & b) && matrix[x][y] <= matrix[x][y+1])
+          a[x][y+1] |= b, q.emplace(x, y+1);
+      }
+    };
+    REP(i, m) {
+      q.emplace(i, 0);
+      a[i][0] = 1;
+    }
+    FOR(i, 1, n) {
+      q.emplace(0, i);
+      a[0][i] = 1;
+    }
+    bfs(1);
+    REP(i, m) {
+      q.emplace(i, n-1);
+      a[i][n-1] |= 2;
+    }
+    REP(i, n-1) {
+      q.emplace(m-1, i);
+      a[m-1][i] |= 2;
+    }
+    bfs(2);
+    vector<pair<int, int>> r;
+    REP(i, m)
+      REP(j, n)
+        if (a[i][j] == 3)
+          r.emplace_back(i, j);
+    return r;
+  }
+};
diff --git a/partition-equal-subset-sum.cc b/partition-equal-subset-sum.cc
@@ -0,0 +1,13 @@
+// Partition Equal Subset Sum
+class Solution {
+public:
+  bool canPartition(vector<int>& nums) {
+    int s = accumulate(nums.begin(), nums.end(), 0);
+    vector<char> a(s/2+1);
+    a[0] = 1;
+    for (int x: nums)
+      for (int i = a.size(); --i >= x; )
+        a[i] |= a[i-x];
+    return s%2 == 0 && a[s/2];
+  }
+};
diff --git a/path-sum-iii.cc b/path-sum-iii.cc
@@ -0,0 +1,22 @@
+// Path Sum III
+class Solution {
+  int sum, r = 0;
+  unordered_map<int, int> m;
+  void f(TreeNode* x, int s) {
+    if (! x) return;
+    s += x->val;
+    r += m[s-sum];
+    m[s]++;
+    f(x->left, s);
+    f(x->right, s);
+    m[s]--;
+  }
+public:
+  int pathSum(TreeNode* root, int sum) {
+    this->sum = sum;
+    m[0] = 1;
+    f(root, 0);
+    return r;
+  }
+};
+
diff --git a/queue-reconstruction-by-height.cc b/queue-reconstruction-by-height.cc
@@ -0,0 +1,24 @@
+// Queue Reconstruction by Height
+class Solution {
+public:
+  vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
+    vector<pair<int, int>> r(people.size());
+    for (auto& p: people)
+      p.second *= -1;
+    sort(people.begin(), people.end());
+    vector<int> fenwick(people.size());
+    for (int i = 0; i < people.size(); i++)
+      fenwick[i] = i+1 & ~ i;
+    for (auto& p: people) {
+      p.second *= -1;
+      int c = 0, x = -1;
+      for (int k = 1 << 31-__builtin_clz(people.size()); k; k >>= 1)
+        if (x+k < people.size() && c+fenwick[x+k] <= p.second)
+          c += fenwick[x += k];
+      r[++x] = p;
+      for (; x < people.size(); x |= x+1)
+        fenwick[x]--;
+    }
+    return r;
+  }
+};
diff --git a/split-array-largest-sum.cc b/split-array-largest-sum.cc
@@ -0,0 +1,22 @@
+// Split Array Largest Sum
+class Solution {
+public:
+  int splitArray(vector<int>& a, int m) {
+    long l = 0, h = 0;
+    for (long i: a) {
+      l = max(l, i);
+      h += i;
+    }
+    while (l < h) {
+      long x = l+h >> 1, s = 0, n = m;
+      for (long i: a)
+        if ((s += i) > x && (s = i, --n <= 0))
+          break;
+      if (n <= 0)
+        l = x+1;
+      else
+        h = x;
+    }
+    return l;
+  }
+};
diff --git a/strong-password-checker.cc b/strong-password-checker.cc
diff --git a/sum-of-left-leaves.cc b/sum-of-left-leaves.cc
diff --git a/third-maximum-number.cc b/third-maximum-number.cc
