【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 == 0) { return true; }
        map<int, int> money;
        for (auto& bill : bills) {
            if (bill == 5) {
                money[5]++;
            } else if (bill == 10) {
                if (money.find(5) == money.end() || money[5] == 0) {
                    return false;
                }
                money[5]--, money[10]++;
            } else if (bill == 20) {
                if (money[10] >= 1 && money[5] >= 1) {
                    money[10]--; money[5]--;
                } else if (money[5] >= 3) {
                    money[5] -= 3;
                } else {
                    return false;
                }
                money[20]++;
            }
        }
        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[0].size();
        for (auto& row : A) {
            row = getLargerRows(row);
        }
      
        for (int j = 0; j < m; ++j) {
            vector<int> col(n);
            for (int i = 0; i < n; ++i) {
                col[i] = A[i][j];
            }
            col = getLargerCols(col);    
            for (int i = 0; i < n; ++i) {
                A[i][j] = col[i];
            }
        }
        int res = 0;
        for (int i = 0; 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(1 - c);
        }
        if (strOri >= strNew) {
            return ori;
        } 
        vector<int> neww(ori);
        for (auto& c : neww) {
            c = 1- c;
        }
        return neww;
    }
    
    
    vector<int> getLargerCols(vector<int>& ori) {
        const int n = ori.size();
        int cnt1 = 0;
        for (auto& ele : ori) {
            if (ele) { ++cnt1; }
        }
        if (cnt1 >= n - cnt1) {return ori;}
        for (auto& ele : ori) {
            ele = 1 - ele;
        }
        return ori;
    }
    
    int getDecimal(const vector<int>& vec) {
        int res = 0;
        for (int i = 0; i < vec.size(); ++i) {
            res = (res * 2) + vec[i];
        }
        //printf ("%d ", res);
        return res;
    }
    
    
    void print(vector<vector<int>>& mat) {
        const int n = mat.size(), m = mat[0].size();
        for (int i = 0; i < n; ++i) {
            for (int j = 0; 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 + 1;
        vector<int> summ (n + 1, 0);
        for (int i = 1; i < n + 1; ++i) {
            summ[i] = summ[i-1] + A[i-1];
        }
        deque<int> dq;
        for (int i = 0; i < n + 1; ++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 + 1 ? -1 : 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 == 0) {ans = {target->val};  return ans;}
        findPath(root, target);
        
        for (int i = 0; i < path.size(); ++i) {
            if (K - i < 0) { break; }
            int dir = NONE;
            if (i > 0) {
                if (path[i-1] == path[i]->left) {
                    dir = RIGHT;
                } else if (path[i-1] == path[i]->right) {
                    dir = LEFT;
                }
            }
            findChild(path[i], 0, 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+1, K, NONE);
        }
        if (cur->right && dir != LEFT) {
            findChild(cur->right, height+1, 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[0].size();
        vector<vector<int>> mat(m, vector<int>(n, 0));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; 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, 0);
        for (auto& p : path) {
            if (p.size() == globalHeight) {
                maxPath.push_back(p);
            }
        }
        //找最后一个每条路径都一样的结点。
        TreeNode* firstCommonNode = root;
        for (int i = 1; i < globalHeight; ++i) {
            TreeNode* node = maxPath[0][i];
            for (int j = 1; 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 + 1);
        getPath(root->right, temp, height + 1);
        temp.pop_back();
        return;
    }
    
    vector<vector<TreeNode*>> path;
    vector<vector<TreeNode*>> maxPath;
    int globalHeight = 0;
};

 

【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 = 0, end = strN.size()-1;
        while (start < end) {
            if (strN[start] != strN[end]) {
                return false;
            }
            start++, end--;
        }
        return true;
    }
    bool isPrime(int num) {
        if (num == 1) {return false;}
        for (int i = 2; i <= sqrt(num); ++i) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
    int getNextGreaterPalindrome(int num) {
        if (num <= 9) {
            return num == 9 ? 11 : num + 1;
        }
        string strNum = to_string(num);
        const int n = strNum.size();
        int halfIdx = (n - 1) / 2;  //n = 3, halfIdx = 1; n = 4, halfIdx = 1;
        string strHalf = "", strNew = "";
        if (n & 1) { //odd size
            int p1 = halfIdx - 1, p2 = halfIdx + 1;
            while (p1 >= 0 && p2 < n) {
                if (strNum[p1] != strNum[p2]) {
                    break;
                }
                p1--, p2++;
            }
            if (p1 == -1 || strNum[p1] < strNum[p2]) {  //increase by 1
                strHalf = strNum.substr(0, halfIdx + 1);
                int intHalf = atoi(strHalf.c_str());
                ++intHalf;
                string strHalfNew = to_string(intHalf);
                string t = strHalfNew.substr(0, strHalfNew.size()-1);
                reverse(t.begin(), t.end());
                strNew = strHalfNew + t;
                
            } else {
                strHalf = strNum.substr(0, halfIdx);
                string t = strHalf;
                reverse(t.begin(), t.end());
                strNew = strHalf + strNum[halfIdx] + t;
            }
        } else { // even size
            int p1 = halfIdx, p2 = halfIdx + 1;
            while (p1 >= 0 && 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 == -1 || strNum[p1] < strNum[p2]) {  //increase by 1
                strHalf = strNum.substr(0, halfIdx + 1);
                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(1, (int)strHalfNew.size()-1);
                } else {
                    strNew = strHalfNew + t;
                }           
            } else {
                strHalf = strNum.substr(0, halfIdx  + 1);
                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 % 10;
            cnt[r]++;
            t /= 10;
        }
        long long x = 1;
        int size = to_string(N).size();
        while (to_string(x).size() < size) {
            x*= 2;
        }
        while (to_string(x).size() == size) {
            if (isSameWithN(x, cnt)) {
                return true;
            }
            x *= 2;
        }
        return false;
    }
    bool isSameWithN(int x, map<int, int> cnt) {
        while (x) {
            int r = x % 10;
            if (cnt[r] > 0) {
                cnt[r]--;
            } else {
                return false;
            }
            x /= 10;
        }
        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, 0), copyA = A;
        for (int i = 0; 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] = -1;
            }
        }
        auto iter = A.begin();
        for (int i = 0; i < n; ++i) {
            if (ans[i] == -1) {
                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 = 0; 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[0], p[1]));
        }
        pair<long long, long long> curPos(0, 0);
        dir curDir = north;
        
        vector<long long> simpleCommands;
        int idx = 0;
        while (idx < commands.size()) {
            if (commands[idx] < 0) {
                simpleCommands.push_back(commands[idx]);
                ++idx;
            } else {
                long long step = 0;
                while (idx < commands.size() && commands[idx] > 0) {
                    step += (long long)commands[idx];
                    ++idx;
                }
                simpleCommands.push_back(step);
            }
        }
        
        long long ans = 0;
        for (auto& com : simpleCommands) {
            if (com < 0) {
                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 = 1,
        east = 2,
        south = 3,
        west = 4,
    };
    set<pair<int, int>> stObs;
    dir changeDir(dir NowDir, int turn) {
        if (NowDir == north) {
            return turn == -1 ? east : west;
        } else if (NowDir == east) {
            return turn == -1 ? south : north;
        } else if (NowDir == south) {
            return turn == -1 ? west : east;
        } else if (NowDir == west) {
            return turn == -1 ? 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 = 0; 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 = 0; 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 = 0; 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 = 0; 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 = 1, right = piles[n-1] + 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (!canFinish(piles, H, mid)) { //吃不完
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        int K = left;
        return K;
    }
    bool canFinish(vector<int>& piles, int H, int K) {
        int cntH = 0;
        for (auto p : piles) {
            cntH += p % K ? p / K + 1 : 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 = 0;
        for (auto p : piles) {
            summ += p;
        }
        int score = f(piles, 0, n-1);  //玩家 1 的分数
        int score2 = s(piles, 0, n-1); //玩家 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+1, j), piles[j] + s(piles, i, j-1));
    }
    int s(vector<int>& piles, int i, int j) {
        if (i == j) {
            return 0;
        }
        return min(f(piles, i+1, j), f(piles, i, j-1));
    }
};

下面介绍 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 = 0;
        for (auto p : piles) {
            summ += p;
        }
        vector<vector<int>> f(n, vector<int>(n, 0));
        vector<vector<int>> s = f;
        for (int j = 0; j < n; ++j) {
            f[j][j] = piles[j];
            for (int i = j - 1;i >= 0; --i) {
                f[i][j] = max(piles[i] + s[i+1][j], piles[j] + s[i][j-1]);
                s[i][j] = min(f[i+1][j], f[i][j-1]);
            } 
        }
        int score = f[0][n-1];
        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) - 1;
        long long times = N / step;
        long long r = N % step;
        long long base = (times * L) % MOD;
        long long ans = 0;
        if (r == 0) {
            ans = base;
        } else {
            long long numA = A, numB = B;
            int cnt = 0;
            long long number = 0;
            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 == 0) {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[0].size();
        //cal xy;
        int xy = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j]) {
                    xy++;
                }
            }
        }
        //cal xz (max of col)
        int xz = 0;
        for (int j = 0; j < m; ++j) {
            int maxx = grid[0][j];
            for (int i = 1; i < n; ++i) {
                maxx = max(maxx, grid[i][j]);
            }
            xz += maxx;
        }
        // cal yz (max of row) {
        int yz = 0;
        for (int i = 0; i < n; ++i) {
            int maxx = grid[i][0];
            for (int j = 1; 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, -1); //boats[i] means the ith people int boats[i]
        int p1 = 0, p2 = n-1;
        int tot = 0;
        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 = 0;
        for (auto& p : boats) {
            if (p == -1) {
                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 = 0;
        string use = "";
        char c;
        while (ss) {
            ss >> c;
            use += c;
            if (isdigit(c)) {
                len = len * (c - '0');
                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 - '0');
        int left = K % preLen;
        if (left == 0) {
            string ans = "";
            for (int k = use.size(); k >= 0; --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 = 0, summB = 0;
        int sizeA = A.size(), sizeB = B.size();
        for (int i = 0; i < sizeA; ++i) {
            summA += (long long)A[i];
        }
        for (int i = 0; i < sizeB; ++i) {
            summB += (long long)B[i];
        }
        long long tot = summA + summB, half = tot / 2;
        sort(A.begin(), A.end()), sort(B.begin(), B.end());
        vector<int> ans;
        int diff = half - summA;
        for (int i = 0; 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 == 0) {return ans;}
        for (auto& word : words) {
            bool inAns = true;
            map<char, char> mp; // word -> pattern
            set<char> usedPattern;
            for (int i = 0; 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 == 0) {return nullptr;}
        if (n == 1) {
            TreeNode* root = new TreeNode(pre[0]);
            return root;
        }
        int rootVal = pre[0], leftRootVal = pre[1];
        int idxPostLeftRootVal = 0;
        for (idxPostLeftRootVal = 0; idxPostLeftRootVal < post.size(); ++idxPostLeftRootVal) {
            if (leftRootVal == post[idxPostLeftRootVal]) {break;}
        }
        int leftPreSize = idxPostLeftRootVal + 1;
        TreeNode* root = new TreeNode(rootVal);
        vector<int> leftPre(pre.begin() + 1, pre.begin() + 1 + leftPreSize);
        vector<int> leftPost(post.begin(), post.begin() + leftPreSize);
        vector<int> rightPre(pre.begin() + 1 + leftPreSize, pre.end());
        vector<int> rightPost(post.begin() + leftPreSize, post.end() - 1);
        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 1:
Input: [[2]]
Output: 10

Example 2:
Input: [[1,2],[3,4]]
Output: 34

Example 3:
Input: [[1,0],[0,2]]
Output: 16

Example 4:
Input: [[1,1,1],[1,0,1],[1,1,1]]
Output: 32


Example 5:
Input: [[2,2,2],[2,1,2],[2,2,2]]
Output: 46

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

class Solution {
public:
    int surfaceArea(vector<vector<int>>& grid) {
        const int n = grid.size();
        int front = 0, side = 0, top = 0;
        for (int i = 0; i < n; ++i) {
            side += grid[i][0];
            for (int j = 0; j < n; ++j) {
                if (grid[i][j]) { top++; }
                if (j > 0) {
                    side += abs(grid[i][j] - grid[i][j-1]);
                }
            }
            side += grid[i][n-1];
        }
        for (int j = 0; j < n; ++j) {
            front += grid[0][j];
            for (int i = 1; i < n; ++i) {
                front += abs(grid[i][j] - grid[i-1][j]);
            }
            front += grid[n-1][j];
        }
        //printf("side = %d, front = %d \n", side, front);
        int ret = top * 2 + 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 = 0;
        const int n = A.size(), m = A[0].size();
        set<pair<string, string>> st; //odd, even
        for (auto& w : A) {
            string odd = "", even = "";
            for (int i = 0; i < m; ++i) {
                if (i & 1) {
                    odd += string(1, w[i]);
                } else {
                    even += string(1, 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 == 0) {return ret;}
        if (N == 1) {
            TreeNode* root = new TreeNode(0);
            ret.push_back(root);
            return ret;
        }
        
        for (int leftSize = 1; leftSize < N - 1; leftSize = leftSize + 2) {
            int rightSize = N - 1 - leftSize;
            vector<TreeNode*> left = allPossibleFBT(leftSize);
            vector<TreeNode*> right = allPossibleFBT(rightSize);
            for (auto l : left) {
                for (auto r : right) {
                    TreeNode* root = new TreeNode(0);
                    root->left = l; 
                    root->right = r;
                    ret.push_back(root);
                }
            }
        }
        return ret;
    }
    
};

 

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