LeetCode Weekly Contest 27

1. 557. Reverse Words in a String III

分割字符串，翻转。

 class Solution {
 public:
 string reverseWords(string s) {
     int n = s.size();
     if(n < ) return s;
     string res;
     int i = ;
     n += ;
     s += " ";
     int last = ;
     while(i < n) {
         last = i;
         while(i < n && s[i] != ' ') i++;
         string t = s.substr(last, i - last);
         reverse(t.begin(), t.end());
         res += t + " ";
         i++;
     }
     return res.substr(, n - );
 }
 };

2. 554. Brick Wall

这刚好是以前做的hihocode的一道题目：https://hihocoder.com/problemset/problem/1494

就是统计边界的最大次数，然后n- max求出最小的穿过次数。

 class Solution {
 public:
 int leastBricks(vector<vector<int>>& wall) {
     int n = wall.size();
     if(n == ) return ;
     map<int, int> ma;
     int res = ;
     for (vector<int> &it:wall) {
         int m = it.size();
         int s = ;
         for (int i = ; i < m - ; i++) {
             s += it[i];
             ma[s]++;
             res = max(res, ma[s]);
         }
     }
     return n - res;
 }
 };

3. 556. Next Greater Element III

要求下一个比较大的，可以采用next_permutation来做，然后判断下是不是真的比n大，然后还要check是否超过int的表示范围。

 class Solution {
 public:
 int nextGreaterElement(int n) {
     if(n < ) return -;
     vector<int> v;
     int t = n;
     while(t > ) {
         v.push_back(t % );
         t /= ;
     }
     int sz = v.size();
     //cout << sz << endl;
     if(sz == ) return -;
     reverse(v.begin(), v.end());
     if(next_permutation(v.begin(), v.end())) {
         long long res = ;
         for (int t : v) {
             res = res *  + t;
         }
         if(res > INT_MAX)
             return -;
         return res;
     } else
     return -;
 }
 };

4. 549. Binary Tree Longest Consecutive Sequence II

这个题跟求二叉树的最长路径的方法是一致的，维护信息，以及更新结果。

我当时写的有点复杂，只需要维护每个点的最长上升和下降长度就行。注意：题目要求必须连续。

 /**
  * 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:
 int res;
 typedef pair<pair<int, int>, pair<int, int>> pp;
 typedef pair<int, int> pii;
 pair<pair<int, int>, pair<int, int>> work(TreeNode* root) {
     if(!root) {
         return {{,}, {, } };
     }
     if(!root->left && !root->right) {
         int v = root->val;
         res = max(res, );
         return {{, v}, {, v} };
     }
     int v = root->val;
     pp m1 = work(root->left), m2 = work(root->right);
     int a1 = m1.first.first, a2 = m1.first.second, b1 = m1.second.first, b2 = m1.second.second;
     int ta1 = m2.first.first, ta2 = m2.first.second, tb1 = m2.second.first, tb2 = m2.second.second;
     int ra1 = , ra2 = v, rb1 = , rb2 = v;
     if(v == a2 + ) {
         ra1  = a1 + ;
     }
     if(v == ta2 + ) {
         ra1 = max(ra1, ta1 + );
     }
     if(v == b2 - ) {
         rb1 = b1 + ;
     }
     if(v == tb2 - ) {
         rb1 = max(rb1, tb1 + );
     }
     if(v == a2 +  && v == tb2 - ) {
         res = max(res,  + a1 + tb1);
     }
     if(v == ta2 +  && v == b2 - ) {
         res = max(res,  + ta1 + b1);
     }
     res = max(res, max(ra1, rb1));
     return {{ra1, ra2}, {rb1, rb2} };

 }
 int longestConsecutive(TreeNode* root) {
     if(!root) return ;
     res = ;
     work(root);
     return res;
 }
 };