【Leetcode周赛】从contest-91开始。（一般是10个contest写一篇文章）

Contest 91 （2018年10月24日，周三）

链接：https://leetcode.com/contest/weekly-contest-91/

模拟比赛情况记录：第一题柠檬摊的那题6分钟AC，然后是第二题树的距离K的结点那题比较久，大概写了30分钟，第三题翻转矩阵那题第一次提交错误了，列的优化方法思路错了，WA。后来比赛时间到了才改过来。最后一题最短子数组的和比K大的这题不会做。

【860】Lemonade Change   （第一题）

一个柠檬摊，有一队人排队要买柠檬，一个5刀，一开始摊主没有零钱，买柠檬的人给的钱有5刀，10刀，20刀的，问摊主是否能找开钱。

题解：直接模拟。

 class Solution {
 public:
     bool lemonadeChange(vector<int>& bills) {
         const int n = bills.size();
         if (n == ) { return true; }
         map<int, int> money;
         for (auto& bill : bills) {
             if (bill == ) {
                 money[]++;
             } else if (bill == ) {
                 if (money.find() == money.end() || money[] == ) {
                     return false;
                 }
                 money[]--, money[]++;
             } else if (bill == ) {
                 if (money[] >=  && money[] >= ) {
                     money[]--; money[]--;
                 } else if (money[] >= ) {
                     money[] -= ;
                 } else {
                     return false;
                 }
                 money[]++;
             }
         }
         return true;
     }
 };

【861】Score After Flipping Matrix  （第三题）

给了一个0，1矩阵，我们每次能把每一行或者每一列的0，1做翻转，（0变成1，1变成0）。然后我们把每行的二进制数加起来，问最大和是多少。

题解：这个题目有点像二进制的竖式加法，对于每一行来说，高位为1数才大，所以我们比较翻转前和翻转后数的大小就行了。对于每一列来说，相当于同位相加，我们想要尽可能多的 1， 所以我们数 1 的个数，1 的个数比 0 的个数少就翻转。

 //这个题目行的翻转相当于高低位的翻转，我们希望每行的数字最大，那么每一行代表的数字就要比它翻转以后的大，不然我们就要翻转。
 //列的翻转相当于做竖式加法时候的同位相加，我们希望同一列的 1 尽可能的多，所以如果这一列 0 的数量比 1 的数量多了，我们就要翻转 01 .
 class Solution {
 public:
     int matrixScore(vector<vector<int>>& A) {
         const int n = A.size(), m = A[].size();
         for (auto& row : A) {
             row = getLargerRows(row);
         }

         for (int j = ; j < m; ++j) {
             vector<int> col(n);
             for (int i = ; i < n; ++i) {
                 col[i] = A[i][j];
             }
             col = getLargerCols(col);
             for (int i = ; i < n; ++i) {
                 A[i][j] = col[i];
             }
         }
         int res = ;
         for (int i = ; i < n; ++i) {
             res += getDecimal(A[i]);
         }
         return res;
     }

     vector<int> getLargerRows(const vector<int>& ori) {
         string strOri = "", strNew = "";
         for (auto& c : ori) {
             strOri += to_string(c);
             strNew += to_string( - c);
         }
         if (strOri >= strNew) {
             return ori;
         }
         vector<int> neww(ori);
         for (auto& c : neww) {
             c = - c;
         }
         return neww;
     }

     vector<int> getLargerCols(vector<int>& ori) {
         const int n = ori.size();
         int cnt1 = ;
         for (auto& ele : ori) {
             if (ele) { ++cnt1; }
         }
         if (cnt1 >= n - cnt1) {return ori;}
         for (auto& ele : ori) {
             ele =  - ele;
         }
         return ori;
     }

     int getDecimal(const vector<int>& vec) {
         int res = ;
         for (int i = ; i < vec.size(); ++i) {
             res = (res * ) + vec[i];
         }
         //printf ("%d ", res);
         return res;
     }

     void print(vector<vector<int>>& mat) {
         const int n = mat.size(), m = mat[].size();
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 printf("%d ", mat[i][j]);
             }
             printf("\n");
         }
         return;
     }
 };

【862】Shortest Subarray with Sum at Least K   （monotonic queue，2018年10月25日学习）（第四题）

给了一个数组 A 有正有负和一个正整数K，我们要求最短的子数组长度使得子数组的和大于K。

题解：看到数组大小是 50000，所以肯定不能用  O(N^2)  的算法暴力枚举所有子数组。最近学习了单调队列这种数据结构（deque实现）。结果尝试写了，还是思路不对。哈哈。

看了答案，说我们可以先求A数组的前缀和P数组。然后用单调队列搞一下就行了。单调队列怎么搞，解释如下：

P [i]  代表 A数组前 i 个数的前缀和。 我们想要得到 P[y] - P[x] >= K ，（0  <= x < y ） 。我们的目标是优化 min (y - x) 。

通过观察， 我们可以发现 （1）单调队列中的P数组必须是递增的，原因我们可以用反证法，我们假设 x1 < x2 && P[x1] > P[x2] ，对于一个固定的 y， P[y] - P[x] >= K ，变换一下就变成 P [x] <= P[y] - K,  我们假设 P[x1]  <= P[y] - K ，那么必然有  P [x2] < P[x1] < P[y] - K 。然而因为 x2  > x1 ，所以 x2 的答案可能比 x1 优秀。所以单调队列中的 P 数组必然是递增的。

（2）对于 一个 x 来说，假如我们已经找到了一个 P[y1] 跟它组成了一个区间子数组满足大于等于 K 的条件，那么这个 x 就可以从队列里面弹出去了，因为后面的 y2 即使满足条件也肯定不如当前的 y1 优秀。

  //这题是单调队列 monotonic queue
 class Solution {
 public:
     int shortestSubarray(vector<int>& A, int K) {
         const int n = A.size();
         int ans = n + ;
         vector<int> summ (n + , );
         for (int i = ; i < n + ; ++i) {
             summ[i] = summ[i-] + A[i-];
         }
         deque<int> dq;
         for (int i = ; i < n + ; ++i) {
             int y = summ[i];
             while (!dq.empty() && summ[dq.back()] > y) {
                 dq.pop_back();
             }
             while (!dq.empty() && y - summ[dq.front()] >= K) {
                 ans = min(ans, i - dq.front());
                 dq.pop_front();
             }
             dq.push_back(i);
         }
         return ans == n +  ? - : ans;
     }
 };

【863】All Nodes Distance K in Binary Tree （第二题）

给了一棵二叉树和一个结点 target，求距离 target 长度为 K 的结点有哪些。

题解：结果可以是target的子孙或者target的父节点的其他儿子的子孙。我用了一个vector记录从根节点到target结点的路径，然后把路径上每个结点的其他儿子都找了一遍。

 /**
  * 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:
     #define NONE 0
     #define LEFT 1
     #define RIGHT 2

     vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
         if (!root || !target) { return vector<int>(); }
         if (K == ) {ans = {target->val};  return ans;}
         findPath(root, target);

         for (int i = ; i < path.size(); ++i) {
             if (K - i < ) { break; }
             int dir = NONE;
             if (i > ) {
                 if (path[i-] == path[i]->left) {
                     dir = RIGHT;
                 } else if (path[i-] == path[i]->right) {
                     dir = LEFT;
                 }
             }
             findChild(path[i], , K - i, dir);
         }
         return ans;
     }

     void findChild(TreeNode* cur, int height, const int K, int dir) {
         if (height == K) {
             ans.push_back(cur->val);
             return;
         }
         if (cur->left && dir != RIGHT) {
             findChild(cur->left, height+, K, NONE);
         }
         if (cur->right && dir != LEFT) {
             findChild(cur->right, height+, K, NONE);
         }
         return;
     }

     bool findPath(TreeNode* cur, TreeNode* target) {
         if (!cur) {return false;}
         if (cur == target) {
             path.push_back(cur);
             return true;
         }
         if (cur->left) {
             if (findPath(cur->left, target)) {
                 path.push_back(cur);
                 return true;
             }
         }
         if (cur->right) {
             if (findPath(cur->right, target)) {
                 path.push_back(cur);
                 return true;
             }
         }
         return false;
     }  

     vector<int> ans;
     vector<TreeNode*> path;
 };

Contest 92 （2018年10月25日，周四，题号 864-867）

链接：https://leetcode.com/contest/weekly-contest-92/

比赛情况：第一题3分钟，第二题少于20分钟左右，然后从第三题就开始坑。第三题跟2014年的亚马逊的一个笔试题很像，就是求比N大的第一个回文数字，然后加上判断这个数是不是素数。第三题还没debug完毕，比赛就结束了。第四题没看。

【867】Transpose Matrix  （第一题 2分）

题意就是把一个二维数组旋转90度，行变成列，列变成行。

题解：直接做。

 class Solution {
 public:
     vector<vector<int>> transpose(vector<vector<int>>& A) {
         const int n = A.size(), m = A[].size();
         vector<vector<int>> mat(m, vector<int>(n, ));
         for (int i = ; i < m; ++i) {
             for (int j = ; j < n; ++j) {
                 mat[i][j] = A[j][i];
             }
         }
         return mat;
     }
 };

【865】Smallest Subtree with all the Deepest Nodes （第二题 5分）

一棵二叉树，找到它所有最深的子节点的最小公共祖先。（好像是lca？？？？不确定，但是还是自己做出来了）

题解：先dfs这棵树，然后找到最大的height，dfs的同时记录所有的路径保存在数组里面。然后从路径的数组里面挑出和最大height长度一样的路径，在这些路径中找一个结点 i， 满足如果 i 不是最后一个结点，那么必然存在两条路径 path1[i+1] != path2[i+1]

 /**
  * 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:
     TreeNode* subtreeWithAllDeepest(TreeNode* root) {
         if (!root) {return root;}
         vector<TreeNode*> temp;
         getPath(root, temp, );
         for (auto& p : path) {
             if (p.size() == globalHeight) {
                 maxPath.push_back(p);
             }
         }
         //找最后一个每条路径都一样的结点。
         TreeNode* firstCommonNode = root;
         for (int i = ; i < globalHeight; ++i) {
             TreeNode* node = maxPath[][i];
             for (int j = ; j < maxPath.size(); ++j) {
                 if (maxPath[j][i] != node) {
                     return firstCommonNode;
                 }
             }
             firstCommonNode = node;
         }
         return firstCommonNode;

     }
     //dfs，获取最大高度和所有路径。
     void getPath(TreeNode* root, vector<TreeNode*>& temp, int height) {
         if (!root) {
             path.push_back(temp);
             globalHeight = max(globalHeight, height);
             return;
         }
         temp.push_back(root);
         getPath(root->left, temp, height + );
         getPath(root->right, temp, height + );
         temp.pop_back();
         return;
     }

     vector<vector<TreeNode*>> path;
     vector<vector<TreeNode*>> maxPath;
     int globalHeight = ;
 };

【866】Prime Palindrome（第三题 7分）

题意很简单，就是给了一个数字N，要求大于等于N的第一个回文素数。

题解：这题其实一开始有两个思路，第一个思路是先找比N大的素数，然后再判断它是不是回文；第二个思路是先找比N大的回文数，然后判断它是不是素数。我是先找回文然后再判断是不是素数的。

这题有个标准小题就是如何求比N大的第一个素数。这个做法见：https://blog.csdn.net/cjllife/article/details/39938187

算法如图所示：

当 num 是一位数的时候，num 小于 9 就返回 num + 1， num 等于 9 返回 11。

然后我们来看 num 是个 n 位数的情况，（1）当 n 是个奇数的时候，num 的前半段我们定义为比较长的半段（half）。我们从中间位置开始往两边找，找到第一个两边不对称的位置，p1 为左边不对称的下标， p2为右边不对称的下标，如果 num[p1] < num[p2]，或者都扫描完了发现两边完全对称，那么就把 前半段(half)+1。注意如果加一以后进位了从 x 位变成 x+1 位了要特殊判断，特殊值写一下就能找到规律。然后加一之后的数就是新的数的前半段，后半段按照前半段翻转即可。如果 num[p1] > num[p2] 的话，我们直接翻转前半段half就行了。(2).同理，如果 n 是偶数的时候，前半段和后半段完全长度相同。我们从中间位置开始往两边找，依旧找 p1, p2。剩下的同理（1）。

总之写的 if-else 比较多，要注意好好测试。

 //先构造回文，再判断是不是素数，比 N 大的回文数怎么构造。
 class Solution {
 public:
     int primePalindrome(int N) {
         if (isPalindrome(N) && isPrime(N)) {
             return N;
         }
         int palin = N;
         do {
             //printf("palin = %d \n", palin);
             palin = getNextGreaterPalindrome(palin); 

         } while (!isPrime(palin));
         return palin;
     }
     bool isPalindrome(int num) {
         string strN = to_string(num);
         int start = , end = strN.size()-;
         while (start < end) {
             if (strN[start] != strN[end]) {
                 return false;
             }
             start++, end--;
         }
         return true;
     }
     bool isPrime(int num) {
         if (num == ) {return false;}
         for (int i = ; i <= sqrt(num); ++i) {
             if (num % i == ) {
                 return false;
             }
         }
         return true;
     }
     int getNextGreaterPalindrome(int num) {
         if (num <= ) {
             return num ==  ?  : num + ;
         }
         string strNum = to_string(num);
         const int n = strNum.size();
         int halfIdx = (n - ) / ;  //n = 3, halfIdx = 1; n = 4, halfIdx = 1;
         string strHalf = "", strNew = "";
         if (n & ) { //odd size
             int p1 = halfIdx - , p2 = halfIdx + ;
             while (p1 >=  && p2 < n) {
                 if (strNum[p1] != strNum[p2]) {
                     break;
                 }
                 p1--, p2++;
             }
             if (p1 == - || strNum[p1] < strNum[p2]) {  //increase by 1
                 strHalf = strNum.substr(, halfIdx + );
                 int intHalf = atoi(strHalf.c_str());
                 ++intHalf;
                 string strHalfNew = to_string(intHalf);
                 string t = strHalfNew.substr(, strHalfNew.size()-);
                 reverse(t.begin(), t.end());
                 strNew = strHalfNew + t;

             } else {
                 strHalf = strNum.substr(, halfIdx);
                 string t = strHalf;
                 reverse(t.begin(), t.end());
                 strNew = strHalf + strNum[halfIdx] + t;
             }
         } else { // even size
             int p1 = halfIdx, p2 = halfIdx + ;
             while (p1 >=  && p2 < n) {
                 if (strNum[p1] != strNum[p2]) {
                     break;
                 }
                 p1--, p2++;
             }
             //printf("p1 = %d, p2 = %d ,strNum[p1] = %c, strNum[p2] = %c \n", p1, p2, strNum[p1], strNum[p2]);
             if (p1 == - || strNum[p1] < strNum[p2]) {  //increase by 1
                 strHalf = strNum.substr(, halfIdx + );
                 int intHalf = atoi(strHalf.c_str());
                 ++intHalf;
                 string strHalfNew = to_string(intHalf);
                 string t = strHalfNew;
                 reverse(t.begin(), t.end());

                 // 是否有进位。。。
                 if ((int)strHalfNew.size() != (int)strHalf.size()) {
                     strNew = strHalfNew + t.substr(, (int)strHalfNew.size()-);
                 } else {
                     strNew = strHalfNew + t;
                 }
             } else {
                 strHalf = strNum.substr(, halfIdx  + );
                 string t = strHalf;
                 reverse(t.begin(), t.end());
                 strNew = strHalf  + t;
             }
         }

         //string -> int
         int res = atoi(strNew.c_str());
         return res;
     }

 };

【864】Shortest Path to Get All Keys （第四题 9分）

Contest 93 （2018年10月26日，周五，题号 868-871）

链接：https://leetcode.com/contest/weekly-contest-93/

比赛情况记录：前三题都不难，甚至于最后放弃的第四题我觉得我好像见过。（42min 3道题）

【868】Binary Gap （第一题 3分）

给了一个正整数 N，返回 N 的二进制表示中，两个连续 1 的最长距离， 如果没有两个连续的 1，就直接返回 0。 比如 N = 6， 二进制是 110， 那么就返回 1，比如 N = 5，二进制是 101，就返回 2。

题解：（我的解法）转换成二进制，然后直接用两个指针比较。时间复杂度是 O(N)。

然而，solution给了 O(logN) 的做法。区别在于我存的是二进制的表示，人家存的是二进制表示中 1 的下标（index）。最后甚至于可以用滚动数组优化，把存储的矩阵给搞没了。（厉害了。）

【869】Reordered Power of 2 （第二题 5分）

给了一个正整数 N， 我们可以把 N 的数字进行重新排列，搞出来一个新的 N （新的数不能以 0 开头），问包括 N 在内的 N 的所有排列能不能有一个数是2的幂。

题解：（我的解法）我先把 N 字符串化，然后用 next_permutation 生成下一个排列，next_permutation() 这个方法有个小点要注意，使用前先对数组排序，才能生成所有的排列（在这里WA了一次）。然后一开始我搞了一个set，里面存了所有长度为10位以及以下的所有的2的幂。用 next_permutaion 生成的数去 set 里面找。

 class Solution {
 public:
     bool reorderedPowerOf2(int N) {
         map<int, int> cnt;
         int t = N;
         while (t) {
             int r = t % ;
             cnt[r]++;
             t /= ;
         }
         long long x = ;
         int size = to_string(N).size();
         while (to_string(x).size() < size) {
             x*= ;
         }
         while (to_string(x).size() == size) {
             if (isSameWithN(x, cnt)) {
                 return true;
             }
             x *= ;
         }
         return false;
     }
     bool isSameWithN(int x, map<int, int> cnt) {
         while (x) {
             int r = x % ;
             if (cnt[r] > ) {
                 cnt[r]--;
             } else {
                 return false;
             }
             x /= ;
         }
         return true;
     }
 };

然而，solution里面还有更优秀的解法。看完优秀解法我觉得我就是一个智障。我们可以先生成一个 2^x 这个数，然后判断它和 N 是不是由相同的数字构成。(时间复杂度？？how)

【870】Advantage Shuffle （第三题 7分）

给了两个长度一样的数组 A 和 B，如果 A[i] > B[i]，那么说明 A[i] 比 B[i] 优秀。返回一个 A数组的排列，使得 A 比 B 优秀数最多。

题解：我是直接贪心了。就是先把 A 做个排序，然后对于 B 中的每个元素用 upper_bound 求 A 中第一个比B[i] 大的元素，然后把这个元素从A删除。剩下的 A 的元素填补空缺。

discuss中有个说法我更喜欢，就是说如果 A中有比 B[i] 大的元素，就应该使用第一个(最小的)比 B[i] 大的元素，如果没有比 B[i] 大的元素，就是用 A 中最小的元素。

 class Solution {
 public:
     vector<int> advantageCount(vector<int>& A, vector<int>& B) {
         const int n = A.size();
         sort(A.begin(), A.end());
         vector<int> ans(n, ), copyA = A;
         for (int i = ; i < n; ++i) {
             auto iter = upper_bound(A.begin(), A.end(), B[i]);
             if (iter != A.end()) {
                 int idx = distance(A.begin(), iter);
                 ans[i] = *iter;
                 A.erase(iter);
             } else {
                 ans[i] = -;
             }
         }
         auto iter = A.begin();
         for (int i = ; i < n; ++i) {
             if (ans[i] == -) {
                 ans[i] = *iter;
                 ++iter;
             }
         }
         return ans;
     }
 };

【871】Minimum Number of Refueling Stops （第四题 9分）

Contest 94 （2018年10月27日，周六，题号 872-875）

链接：https://leetcode.com/contest/weekly-contest-94

比赛情况记录：这场总体来比较简单，第一题是二叉树的遍历，第二题是模拟题（比赛的时候不知道哪里错了，没法AC），第三题是个二分答案，第四题我用dp做的，最后比赛完超时了不算提交。

【872】Leaf-Similar Trees （第一题 4分）

判断两棵二叉树叶子结点的序列是不是一样的。

题解：我是把两棵树的序列都求出来然后做比较的。

 /**
  * 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:
     bool leafSimilar(TreeNode* root1, TreeNode* root2) {
         if (!root1 && !root2) { return true; }
         if (!root1 || !root2) { return false; }
         vector<int> leaf1, leaf2;
         getLeafArray(root1, leaf1);
         getLeafArray(root2, leaf2);
         if (leaf1.size() != leaf2.size()) {
             return false;
         }
         for (int i = ; i < leaf1.size(); ++i) {
             if (leaf1[i] != leaf2[i]) { return false; }
         }
         return true;
     }
     void getLeafArray(TreeNode* root, vector<int>& leaf) {
         if (!root) { return; }
         if (!root->left && !root->right) {
             leaf.push_back(root->val);
             return;
         }
         if (root->left) {
             getLeafArray(root->left, leaf);
         }
         if (root->right) {
             getLeafArray(root->right, leaf);
         }
         return;
     }
 };

【874】Walking Robot Simulation （第二题 4分）

一个机器人在无限大的地板上行走，给了一个 commands 数组，行走规则如下：

(1) commands[i] 等于 -2， 机器人向左转90度

(2) commands[i] 等于 -1， 机器人向右转90度

(3) commands[i] 属于 [1, 9] , 机器人向前走 commands[i] 步

要求返回机器人所有走过的点中距离原点欧式距离最大的点，返回最大欧式距离的平方。

题解：审题是多么的重要！！！！！这题我 WA 了好多遍都没想明白为啥，最后看了 solution 发现他是要求最大值！！！！ 直接模拟，不说了。（让我哭一会儿）

 class Solution {
 public:
     int robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
         for (auto& p : obstacles) {
             stObs.insert(make_pair(p[], p[]));
         }
         pair<long long, long long> curPos(, );
         dir curDir = north;

         vector<long long> simpleCommands;
         int idx = ;
         while (idx < commands.size()) {
             if (commands[idx] < ) {
                 simpleCommands.push_back(commands[idx]);
                 ++idx;
             } else {
                 long long step = ;
                 while (idx < commands.size() && commands[idx] > ) {
                     step += (long long)commands[idx];
                     ++idx;
                 }
                 simpleCommands.push_back(step);
             }
         }

         long long ans = ;
         for (auto& com : simpleCommands) {
             if (com < ) {
                 curDir = changeDir(curDir, com);
                 //printf("changeDir succ. curDir = %d \n", curDir);
             } else {
                 pair<long long, long long> newPos;
                 newPos = getNewPos(curPos, curDir, com);
                 //printf("getNewPos succ. dir = %d, curPos = (%d, %d), newPos = (%d, %d), len = %d\n",
                       //curDir, curPos.first, curPos.second, newPos.first, newPos.second, com);
                 curPos = newPos;
                 ans = max(ans, curPos.first * curPos.first + curPos.second * curPos.second);
             }
         }
         return (int)ans;
     }

     //朝向转换
     enum dir {
         north = ,
         east = ,
         south = ,
         west = ,
     };
     set<pair<int, int>> stObs;
     dir changeDir(dir NowDir, int turn) {
         if (NowDir == north) {
             return turn == - ? east : west;
         } else if (NowDir == east) {
             return turn == - ? south : north;
         } else if (NowDir == south) {
             return turn == - ? west : east;
         } else if (NowDir == west) {
             return turn == - ? north : south;
         }
     }
     pair<long long, long long> getNewPos(pair<long long, long long>& curPos, dir curDir, long long& len) {
         //north curPos.first += len
         //south curPos.first -= len
         //east curPos.second += len
         //west curPos.second -= len
         //printf("begin getNewPos: curPos = (%d, %d), curDir = %d, len = %d \n", curPos.first, curPos.second, curDir, len);
         if (curDir == north) {
             for (int s = ; s < len; ++s) {
                 pair<long long, long long> newPos = curPos;
                 newPos.second++;
                 if (stObs.find(newPos) != stObs.end()) {
                     //printf("encounter an obs. pos(%d, %d) \n", newPos.first, newPos.second);
                     break;
                 }
                 curPos = newPos;
             }
         } else if (curDir == south) {
             for (int s = ; s < len; ++s) {
                 pair<long long, long long> newPos = curPos;
                 newPos.second--;
                 if (stObs.find(newPos) != stObs.end()) {
                     //printf("encounter an obs. pos(%d, %d) \n", newPos.first, newPos.second);
                     break;
                 }
                 curPos = newPos;
             }
         } else if (curDir == east) {
             for (int s = ; s < len; ++s) {
                 pair<long long, long long> newPos = curPos;
                 newPos.first++;
                 if (stObs.find(newPos) != stObs.end()) {
                     //printf("encounter an obs. pos(%d, %d) \n", newPos.first, newPos.second);
                     break;
                 }
                 curPos = newPos;
             }
         } else if (curDir == west) {
             for (int s = ; s < len; ++s) {
                 pair<long long, long long> newPos = curPos;
                 newPos.first--;
                 if (stObs.find(newPos) != stObs.end()) {
                     //printf("encounter an obs. pos(%d, %d) \n", newPos.first, newPos.second);
                     break;
                 }
                 curPos = newPos;
             }
         }
         return curPos;
     }
 };

【875】Koko Eating Bananas （第三题 6分）（二分答案）

有 N 堆香蕉，每一堆里面有 piles[i] 个香蕉，Koko只能在守卫离开的时候吃香蕉，已知守卫要离开 H 小时，假设Koko吃香蕉的速度是 K 个香蕉每小时， 每个小时内，Koko 只能吃一堆香蕉（即使香蕉堆里面的香蕉不足 K 个，他也不能去别的香蕉堆里面吃），Koko想在 H 小时里面把所有的香蕉吃完，问 K 最小是多少。

题解：首先思考了一个特殊的case，就是当 一共有 H 堆香蕉 而守卫恰好离开 H 小时的时候，K 的最小值就是 max(piles[i])。因为他必须一个小时恰好吃一堆，才能把所有香蕉吃完。然后我们通过思考一下可以发现， 当 香蕉的堆数 N <H 的时候，K 的最小值也可以变小，因为时间变长了，koko可以 2个小时只吃一堆香蕉。所以 我们可以推测出 K 是有范围的， (1 <= K <= max(piles[i]))。

为了方便，我们先把 piles[] 排个序。然后用二分答案的方法求 K 的最小值。二分的条件就是 koko 能不能在当前时间内吃完所有香蕉。

 class Solution {
 public:
     int minEatingSpeed(vector<int>& piles, int H) {
         const int n = piles.size();
         sort(piles.begin(), piles.end());
         if (H == n) {
             return piles.back();
         }
         // 1 <= K <= piles[n-1];
         int left = , right = piles[n-] + ;
         while (left < right) {
             int mid = (left + right) / ;
             if (!canFinish(piles, H, mid)) { //吃不完
                 left = mid + ;
             } else {
                 right = mid;
             }
         }
         int K = left;
         return K;
     }
     bool canFinish(vector<int>& piles, int H, int K) {
         int cntH = ;
         for (auto p : piles) {
             cntH += p % K ? p / K +  : p / K;
         }
         return cntH <= H;
     }
 };

【873】Length of Longest Fibonacci Subsequence （第四题 6分）

这个题最后做出来了。。。

Contest 95（2018年10月29日，周一，题号 876-879）

链接：https://leetcode.com/contest/weekly-contest-95

比赛情况记录：做出了两道题，第三题TLE了，第四题似曾相识然而没思路。ranking: 1078/3750。

【876】Middle of the Linked List   （第一题 3分）

给了一个链表，返回中间结点，如果是奇数长度的链表就返回中间那个，如果是偶数长度的链表就返回中间靠后的那个。

题解：two pointers 一个往前走一步，一个往前走两步。当走的快的结点走到 nullptr 的时候，走的慢的结点正好走到中间。一次 AC 了。

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     ListNode *next;
  *     ListNode(int x) : val(x), next(NULL) {}
  * };
  */
 class Solution {
 public:
     ListNode* middleNode(ListNode* head) {
         if (!head) {return head;}
         ListNode *slow = head, *fast = head;
         while (fast && fast->next) {
             if (fast->next) {
                 fast = fast->next->next;
                 slow = slow->next;
             }
         }
         return slow;
     }
 };

【877】Stone Game （第二题 5分）(这题类似的题也做过了，但是还是不会做，需要往回看)

有 N 堆 (N 是偶数) 石子排成一排，每堆石子有 piles[i] 个，有玩家 1 和玩家 2 。游戏每轮只能从这排石子的最左或者最右两边拿一堆，最后谁的石子总数（石子总数是奇数，所以不会平手）最多谁就是赢家。假设两个玩家都绝顶聪明(play optimally)，玩家 1 先开始游戏，问玩家 1 最后能不能赢，玩家 1 能赢返回 true， 不然返回false。

题解：这题还是不会啊，要 go die 了啊。做过的类似的题目有 lc 486 Predict the Winner; 464 Can I Win; 这种模式还是掌握不了。（dp; Minimax）。也可以参考 《程序员代码面试指南》Chp4. P233

《程序员代码面试指南》原题（排成一条线的纸牌博弈问题）：给定一个数组 arr，代表数值不同的纸牌排成一条线。玩家 A 和玩家 B 依次拿走每张纸牌，规定玩家 A 先拿，玩家 B 后拿，但是每个玩家每次只能拿走最左或者最右的纸牌，玩家 A 和玩家 B 都绝顶聪明。请返回最后获胜者的分数。

抄一遍题解：定义递归函数 f(i, j), 表示如果 arr[i, j] 这个排列上的纸牌（石子）被绝顶聪明的人先拿，最终能获得什么分数。定义递归函数 s(i, j)，表示如果 arr[i,j] 这个排列上的纸牌（石子）被绝顶聪明的人后拿，最终能获得什么分数。

我们首先来分析 f(i, j)，具体过程如下：（1）当 i == j (即 a[i..j] )上只剩一张纸牌。那么当然会被先拿纸牌的人拿走， 所以返回 arr[i]。 （2）如果 i != j，那么当前拿纸牌的人有两个选择，要么拿走 arr[i], 要么拿走 arr[j]。如果拿走了 arr[i]，那么排列剩下了 arr[i+1 ..j]，对当前的玩家来说，面对 arr[i+1 .. j] 排列的纸牌，他成了后拿的人，所以他后续能获得的分数是 s(i+1, j)。如果这个人拿走了 a[j]，那么排列将剩下 arr[i .. j+1]。对当前的玩家来说，面对 arr[i .. j-1] 排列的纸牌，他成了后拿的人，所以后续他能获得的分数是 s(i, j+1)。作为绝顶聪明的人，必然会在两种决策中选择最优的。所以返回 max{arr[i]+s(i+1, j), arr[j]+s(i, j-1)}。

然后来分析 s(i, j)，具体过程如下：(1) 如果 i == j (即 a[i..j]) 上只剩一张纸牌。作为后拿纸牌的人必然什么也的不到，返回 0。 (2) 如果 i != j，根据函数 s(i, j) 的定义，玩家的对手会先拿纸牌。对手要么拿走 arr[i]，要么拿走 arr[j]。如果对手拿走 arr[i]，那么排列将剩下 arr[i+1.. j]，然后轮到玩家拿。如果对手拿走 arr[j]，那么排列将剩下 arr[i.. j-1]，然后轮到玩家拿。对手也是决定聪明的人，所以，必然会把最差的情况留给玩家。所以返回 min{f(i+1, j), f(i, j-1)}。

暴力递归代码如下 win1： 在暴力递归的方法中，递归函数一共有 N 层，并且是 f 和 s 交替出现的。

///等待补充中

 class Solution {
 public:
     bool stoneGame(vector<int>& piles) {
         const int n = piles.size();
         int summ = ;
         for (auto p : piles) {
             summ += p;
         }
         int score = f(piles, , n-);  //玩家 1 的分数
         int score2 = s(piles, , n-); //玩家 2 的分数
         return score + score > summ ? true : false;
     }
     int f(vector<int>& piles, int i, int j) {
         if (i == j) {
             return piles[i];
         }
         return max(piles[i] + s(piles, i+, j), piles[j] + s(piles, i, j-));
     }
     int s(vector<int>& piles, int i, int j) {
         if (i == j) {
             return ;
         }
         return min(f(piles, i+, j), f(piles, i, j-));
     }
 };

下面介绍 dp 方法，假如数组 arr 的长度为 N，生成两个大小为 N * N的矩阵 f 和 s，f[i][j] 表示 f(i,j) 的返回值，s[i][j] 返回 s(i, j) 的返回值。规定一下计算方向即可。时间复杂度是  O(N^2)，空间复杂度是 O(N^2)。

 class Solution {
 public:
     bool stoneGame(vector<int>& piles) {
         const int n = piles.size();
         int summ = ;
         for (auto p : piles) {
             summ += p;
         }
         vector<vector<int>> f(n, vector<int>(n, ));
         vector<vector<int>> s = f;
         for (int j = ; j < n; ++j) {
             f[j][j] = piles[j];
             for (int i = j - ;i >= ; --i) {
                 f[i][j] = max(piles[i] + s[i+][j], piles[j] + s[i][j-]);
                 s[i][j] = min(f[i+][j], f[i][j-]);
             }
         }
         int score = f[][n-];
         return score + score > summ ? true : false;
     }
 };

【878】Nth Magical Number （第三题 7分）(数学题，求循环节)

A positive integer is magical if it is divisible by either A or B. Return the N-th magical number.  Since the answer may be very large, return it modulo 10^9 + 7.

Example 1:

Input: N = 1, A = 2, B = 3
Output: 2

Example 2:

Input: N = 4, A = 2, B = 3
Output: 6

Note:

1. 1 <= N <= 10^9
2. 2 <= A <= 40000
3. 2 <= B <= 40000


题解：这道题我一开始想的是丑数那题，按照那个方法做了直接tle。因为 N 太大了，O(N)的算法肯定是tle了。然后看了solution，答案说先求 A， B 的 lcm， 我们发现一个 lcm 里面包含了这样 step 个数 （step = (L/A) + (L/B) - 1) ，然后求循环节 times = N / step ; r = N % lcm; 所求的第 N 个数就相当于 lcm走了 times，然后剩余 r 个。(然后你知道怎么搞了...)。然后暴力求剩下的 r 个的时候，注意求数的时候一定不要 取 MOD，不然要凉凉。

 #define MOD 1000000007
 class Solution {
 public:
     int nthMagicalNumber(int N, int A, int B) {
         long long L = getLcm(A, B);
         long long step = (L / A) + (L / B) - ;
         long long times = N / step;
         long long r = N % step;
         long long base = (times * L) % MOD;
         long long ans = ;
         if (r == ) {
             ans = base;
         } else {
             long long numA = A, numB = B;
             int cnt = ;
             long long number = ;
             while (cnt < r) {
                 if (numA <= numB) {
                     number = numA;
                     //这里一定不要取 mod，当有一个数取了mod之后变成一个很小的数，后面就没法继续比较了，它只会一直加这个比较小的数
                     numA += A;  //numA = (numA + A) % MOD;
                 } else if (numA > numB) {
                     number = numB;
                     //这里一定不要取 mod，当有一个数取了mod之后变成一个很小的数，后面就没法继续比较了，它只会一直加这个比较小的数
                     numB += B;   //numB = (numB + B) % MOD;
                 }
                 cnt++;
             }
             ans = (base + number) % MOD;
         }
         return (int)ans;
     }
     long long getLcm(int A, int B) {
         if (A < B) {
             swap(A, B);
         }
         int gcd = getGcd(A, B);
         long long mul = (long long)A * B;
         return  mul / gcd;
     }
     int getGcd(int A, int B) { // A max, B min
         if (B == ) {return A;}
         while (B) {
             int r = A % B;
             A = B;
             B = r;
         }
         return A;
     }
 };

discuss 里面居然还有人用二分，有空学习一下。

【879】Profitable Schemes （第四题 7分）

Contest 96（2018年11月1日，周四，题号 880-883）

比赛情况记录： 前三题都做出来了，前两题比较稳，第三题不怎么会写，最后直接尾递归搞过了。第四题啊，图论啊，不会做哇。吐血。ranking：199/3916

【883】Projection Area of 3D Shapes （第一题 4分）

题意就是把小方块累起来的一个建筑物求三面的投影数，返回三面投影的总数。

题解：就是单纯的模拟。没啥说的。

 class Solution {
 public:
     int projectionArea(vector<vector<int>>& grid) {
         const int n = grid.size(), m = grid[].size();
         //cal xy;
         int xy = ;
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 if (grid[i][j]) {
                     xy++;
                 }
             }
         }
         //cal xz (max of col)
         int xz = ;
         for (int j = ; j < m; ++j) {
             int maxx = grid[][j];
             for (int i = ; i < n; ++i) {
                 maxx = max(maxx, grid[i][j]);
             }
             xz += maxx;
         }
         // cal yz (max of row) {
         int yz = ;
         for (int i = ; i < n; ++i) {
             int maxx = grid[i][];
             for (int j = ; j < m; ++j) {
                 maxx = max(maxx, grid[i][j]);
             }
             yz += maxx;
         }
         int ans = xy + xz + yz;
         return ans;
     }
 };

【881】Boats to Save People （第二题 5分）

题意：给了一个people数组，和一个 limit 整数。people[i] 代表第 i 个人的体重，每个小船最多可以载两个人，总重量不能超过 limit。问最少要几艘小船才能装完所有人。（题目保证肯定有解，没有人的体重超过 limit）

题解：贪心。先把 people 数组排序，然后最小体重的人和最大体重的人一组，看能不能一艘船，不能的话，就把大体重的人换成一个稍微小体重的人。剩下的没有上船的大体重的人都是自己一艘船。时间复杂度是O(nlogn)。

 class Solution {
 public:
     int numRescueBoats(vector<int>& people, int limit) {
         const int n = people.size();
         sort(people.begin(), people.end());
         vector<int> boats(n, -); //boats[i] means the ith people int boats[i]
         int p1 = , p2 = n-;
         int tot = ;
         while (p1 < p2) {
             if (people[p1] + people[p2] <= limit) {
                 boats[p1] = boats[p2] = tot;
                 tot++;
                 p1++, p2--;
             } else if (people[p1] + people[p2] > limit) {
                 --p2;
             }
         }
         int left = ;
         for (auto& p : boats) {
             if (p == -) {
                 left++;
             }
         }
         return left + tot;
     }
 };

【880】Decoded String at Index （第三题 6分）

题意：给了一个编码过的字符串，如果字符串中的字符是字母的话，那这个字母就是tape中的，如果这个字符是数字 d 的话，就要把前面所有的字符串重复 d 次（共 d 次）。返回整个字符串中下标是 K 的字符。

1. 2 <= S.length <= 100
2. S will only contain lowercase letters and digits 2 through 9.
3. S starts with a letter.
4. 1 <= K <= 10^9
5. The decoded string is guaranteed to have less than 2^63 letters。

题解：比赛的时候我这题是做出来的，但是代码写的太挫了，直接尾递归了。  K 那么大肯定不能生成那么大的字符串，于是我想的是找出每个循环节，然后每次可以缩小 K。

 class Solution {
 public:
     string decodeAtIndex(string S, int K) {
         vector<long long> repeat;
         stringstream ss;
         ss << S;
         long long len = ;
         string use = "";
         char c;
         while (ss) {
             ss >> c;
             use += c;
             if (isdigit(c)) {
                 len = len * (c - '');
                 repeat.push_back(len);
                 if (len >= K) {break;}
             } else {
                 ++len;
                 if (len == K) {
                     string temp = "";
                     temp += c;
                     return temp;
                 }
             }
         }
         const int n = repeat.size();
         long long preLen = repeat.back() / (c - '');
         int left = K % preLen;
         if (left == ) {
             string ans = "";
             for (int k = use.size(); k >= ; --k) {
                 if (use[k] >= 'a' && use[k] <= 'z') {
                     ans += use[k];
                     break;
                 }
             }
             return ans;
         }
         return decodeAtIndex(S, left);
     }
 };

比赛代码--挫

看了solution：

【882】Reachable Nodes In Subdivided Graph （第四题 7分）

Contest 97（2018年11月3日，周六，题号 884-887）

链接：

比赛情况记录：

Contest 98（2018年11月5日，周一，题号 888-891）

链接：https://leetcode.com/contest/weekly-contest-98

比赛情况记录：做出来了三道题，结果：3/4，ranking：295/2883。看到第四题的时候还有45分钟，有思路，小数据能过，大数据过不了。（为啥大数据过不了我很懵逼）

【888】Fair Candy Swap（第一题 3分）

有两个人小A和小B，每个人都有一个数组作为他们的糖果堆（小A和小B的堆数可能不一样），小A和小B只能交换一堆糖果，返回交换哪堆能让小A和小B的糖果数相等。题目保证有答案。

题解：先求总数然后求一半，这就是最后他们每个人的糖果数。然后枚举小A的一堆，看能不能找到小B中对应的那堆，使得两个人糖果数量相等。

 class Solution {
 public:
     vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {
         long long summA = , summB = ;
         int sizeA = A.size(), sizeB = B.size();
         for (int i = ; i < sizeA; ++i) {
             summA += (long long)A[i];
         }
         for (int i = ; i < sizeB; ++i) {
             summB += (long long)B[i];
         }
         long long tot = summA + summB, half = tot / ;
         sort(A.begin(), A.end()), sort(B.begin(), B.end());
         vector<int> ans;
         int diff = half - summA;
         for (int i = ; i < sizeA; ++i) {
             int target = A[i] + diff;
             auto iter = lower_bound(B.begin(), B.end(), target);
             if (iter != B.end() && *iter == target) {
                 ans.push_back(A[i]);
                 ans.push_back(target);
                 break;
             }
         }
         return ans;
     }
 };

【890】Find and Replace Pattern （第二题 5分）

给了一堆words和一个pattern，找出符合pattern形式的所有words返回。

Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
Output: ["mee","aqq"]
Explanation: "mee" matches the pattern because there is a permutation {a -> m, b -> e, ...}.
"ccc" does not match the pattern because {a -> c, b -> c, ...} is not a permutation,
since a and b map to the same letter.

题解：用个 map 记录对应关系，没有对应关系的话加上，但是有一点需要注意，例子中的数据，abc是不能对应abb（pattern）的，所以还需要一个set记录pattern中的字符是否被别的字符对应了。

 class Solution {
 public:
     vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
         const int n = words.size(), size = pattern.size();
         vector<string> ans;
         if (n == ) {return ans;}
         for (auto& word : words) {
             bool inAns = true;
             map<char, char> mp; // word -> pattern
             set<char> usedPattern;
             for (int i = ; i < size; ++i) {
                 if (mp.find(word[i]) == mp.end()) {
                     if (usedPattern.find(pattern[i]) == usedPattern.end()) {
                         mp[word[i]] = pattern[i];
                         usedPattern.insert(pattern[i]);
                     } else { //conflict
                         inAns = false;
                         break;
                     }
                 } else {
                     if (mp[word[i]] != pattern[i]) {
                         inAns = false;
                         break;
                     }
                 }
             }
             if (inAns) {
                 ans.push_back(word);
             }
         }
         return ans;
     }
 };

【889】Construct Binary Tree from Preorder and Postorder Traversal （第三题 5分）

给了二叉树的先序遍历和后序遍历，重建二叉树。

题解：我还稍微想了一会儿，主要是靠什么区分左子树的pre，post和右子树的pre，post。通过观察发现，pre的第二个元素一定是左子树的根，post中左子树根之前的元素都属于左子树。所以就能区分左右子树的pre和post数组了。然后递归重建就行了。

 /**
  * 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:
     TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
         const int n = pre.size();
         if (n == ) {return nullptr;}
         if (n == ) {
             TreeNode* root = new TreeNode(pre[]);
             return root;
         }
         int rootVal = pre[], leftRootVal = pre[];
         int idxPostLeftRootVal = ;
         for (idxPostLeftRootVal = ; idxPostLeftRootVal < post.size(); ++idxPostLeftRootVal) {
             if (leftRootVal == post[idxPostLeftRootVal]) {break;}
         }
         int leftPreSize = idxPostLeftRootVal + ;
         TreeNode* root = new TreeNode(rootVal);
         vector<int> leftPre(pre.begin() + , pre.begin() +  + leftPreSize);
         vector<int> leftPost(post.begin(), post.begin() + leftPreSize);
         vector<int> rightPre(pre.begin() +  + leftPreSize, pre.end());
         vector<int> rightPost(post.begin() + leftPreSize, post.end() - );
         root->left = constructFromPrePost(leftPre, leftPost);
         root->right = constructFromPrePost(rightPre, rightPost);
         return root;
     }
 };

【891】Sum of Subsequence Widths （第四题 7分）

Contest 99（2018年11月6日，周二凌晨，题号 892-895）

链接：https://leetcode.com/contest/weekly-contest-99

比赛情况记录：第一题有点卡住，后来还是解决了。30分钟做了三道题，第四题放弃了。总之我这周要狂攻hard题。结果： 3/4， ranking：286/3153

【892】Surface Area of 3D Shapes（第一题 4分）

给了一个 N * N 的grid，我们想放 1 * 1 * 1 的 cubes，v = grid[i][j] 相当于在坐标(i, j)处放了一个高度 v 的塔。返回所搭建模型的表面积。

Example :
Input: [[]]
Output: 10
Example :
Input: [[,],[,]]
Output: 34
Example :
Input: [[,],[,]]
Output: 16
Example :
Input: [[,,],[,,],[,,]]
Output: 32

Example :
Input: [[,,],[,,],[,,]]
Output: 

题解：我本来想用每行每列的最大值直接当作侧面然后乘以2的，结果我发现那个模型可能里面有个凹坑。比如 example 4.和 example 5. 后来就一行一行，一列一列的求差，求侧面积。

 class Solution {
 public:
     int surfaceArea(vector<vector<int>>& grid) {
         const int n = grid.size();
         int front = , side = , top = ;
         for (int i = ; i < n; ++i) {
             side += grid[i][];
             for (int j = ; j < n; ++j) {
                 if (grid[i][j]) { top++; }
                 if (j > ) {
                     side += abs(grid[i][j] - grid[i][j-]);
                 }
             }
             side += grid[i][n-];
         }
         for (int j = ; j < n; ++j) {
             front += grid[][j];
             for (int i = ; i < n; ++i) {
                 front += abs(grid[i][j] - grid[i-][j]);
             }
             front += grid[n-][j];
         }
         //printf("side = %d, front = %d \n", side, front);
         int ret = top *  + side + front;
         return ret;
     }
 };

【893】Groups of Special-Equivalent Strings （第二题 4分）

字符串 S 等价于 字符串T的定义是 S字符串的奇数和奇数下标元素间任意交换，偶数和偶数下标之间任意交换，最后可以变换成 T。给了一个字符串数组，题目保证数组里面的字符串长度都是一样的。问这个数组能分成几个小组，每个小组里面的字符串都是等价的。

题解：我是设计了一种数据结构 set<pair<string, string>> 用这个 pair 结构来存每个单词的奇数下标组成的字符串，偶数下标组成的字符串（需要排序），结果就是 set 的大小。

 class Solution {
 public:
     int numSpecialEquivGroups(vector<string>& A) {
         int ret = ;
         const int n = A.size(), m = A[].size();
         set<pair<string, string>> st; //odd, even
         for (auto& w : A) {
             string odd = "", even = "";
             for (int i = ; i < m; ++i) {
                 if (i & ) {
                     odd += string(, w[i]);
                 } else {
                     even += string(, w[i]);
                 }
             }
             sort(odd.begin(), odd.end());
             sort(even.begin(), even.end());
             st.insert(make_pair(odd, even));
         }
         ret = st.size();
         return ret;
     }
 };

【894】All Possible Full Binary Trees （第三题 6分）

一个满二叉树的定义是一个结点要么左右两个儿子，要么它是叶子结点。给了一个数字 N， 要求返回 N 个结点的满二叉树的所有形态。

题解：这棵满二叉树的左儿子的大小可能是 {1, 3, 5 .. n - 2}， 右儿子的大小可能是 {n - 2, n - 4, .. ,1}。我们可以递归的生成左儿子和右儿子的集合，然后左儿子里选一个，右儿子里面选一个，再加上根节点组成一棵二叉树。

 /**
  * 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:
     vector<TreeNode*> allPossibleFBT(int N) {
         vector<TreeNode*> ret;
         if (N == ) {return ret;}
         if (N == ) {
             TreeNode* root = new TreeNode();
             ret.push_back(root);
             return ret;
         }

         for (int leftSize = ; leftSize < N - ; leftSize = leftSize + ) {
             int rightSize = N -  - leftSize;
             vector<TreeNode*> left = allPossibleFBT(leftSize);
             vector<TreeNode*> right = allPossibleFBT(rightSize);
             for (auto l : left) {
                 for (auto r : right) {
                     TreeNode* root = new TreeNode();
                     root->left = l;
                     root->right = r;
                     ret.push_back(root);
                 }
             }
         }
         return ret;
     }

 };

【895】Maximum Frequency Stack （第四题 8分）