Leetcode 刷题: 面试专项1

1. Leetcode 1367: 二叉树中的链表

题目链接
题目解析：首先看如果root-val是否等于head->val, 若相等，则顺着继续往下看，若不相等，则对root的左右子树递归调用主函数。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool judge(TreeNode *root,  ListNode *head) {
        if (head == nullptr) return true;
        if (root == nullptr) return false;
        if (root->val != head->val) return false;
        return judge(root->left, head->next) || judge(root->right, head->next);
    }
    bool isSubPath(ListNode* head, TreeNode* root) {
        if (head == nullptr) return true;
        if (root == nullptr) return false;
        if (head->val == root->val && judge(root, head)) return true;  
        return isSubPath(head, root->left) or isSubPath(head, root->right);
    }
};

2. Leetcode 958: 二叉树的完全性检验

题目链接
题目解析：首先可以用广搜的方法，从上到下、从左到右层序遍历二叉树，当遍历到null时，之后遍历到的必须都是null, 否则就不是一个完全二叉树。这种方法的空间复杂度和时间复杂度都是$O(n)$。
还可以用节点数判断的方法，时间复杂度为$O(n)$，空间复杂度可达到$O(1)$。比如对于任意一个总节点数确定的完全二叉树，左右子树的节点数也一定是确定的。
从第一层到倒数第二层一定是满二叉树，每层的节点数依次为1,2,4,8,…,m。利用等比数列求和，截至倒数第二层的总节点数量为 $k=1+2+4+8+...+m=2\ast m-1$。
所以根节点左子树的最后一层，节点数量为 $l=min(m,n-k)$ (取决于剩余n-k个节点是否能铺满左子树)，右子树节点数量为 $r=n-k-l$。
所以递归判断左右子树是否是节点数满足要求的二叉树即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNode(TreeNode *root) {
    	//节点数计数
        if (root == nullptr) return 0;
        return countNode(root->left) + countNode(root->right) + 1;
    }
    bool judge(TreeNode *root, int n, int m) {
        if (root == nullptr && n == 0) return true;
        if (root == nullptr || n == 0) return false;
        if (n == 1) return true;
        int k = 2 * m - 1;
        int l = min(n - k, m), r = n - k - l;
        // printf("%d : %d %d %d\n", n, l, r, m);
        return judge(root->left, (k - 1) / 2 + l, m / 2) && 
            judge(root->right, (k - 1) / 2 + r, m / 2); 
        
    }
    bool isCompleteTree(TreeNode* root) {
        if (root == nullptr) return true;
        int n = countNode(root);
        int m = 1, cnt = 1;
        while (cnt + 2 * m <= n) {
            m *= 2;
            cnt += m;
        } 
        int k = 2 * m - 1;
        return judge(root, n, m);
    }
};

总结：重点在于judge方法，计数左右子树的节点数量。

3. 剑指Offer 36: 二叉搜索树与双向链表

题目链接
题目解析：二叉搜索树的中序遍历结果是一个升序数组。所以在二叉搜索树的中序遍历过程中做一些操作即可。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node *head, *pre;
    void inorder(Node *root) {
        if (root == nullptr) return;
        inorder(root->left);
        //do something
        if (pre == nullptr) {
            head = root;
        }else {
            pre->right = root;
        }
        root->left = pre;
        pre = root;
        inorder(root->right);

    }
    Node* treeToDoublyList(Node* root) {
        if (root == nullptr) return nullptr;
        head = pre = nullptr;
        inorder(root);
        head->left = pre;
        pre->right = head;
        return head;
    }
};

4. Leetcode 464: 我能赢吗

题目链接
题目解析：首先利用博弈的思想，第一个人能赢意味着第二个人会输。所以可以用递归深搜的方法。本题中递归深搜会涉及大量重复的计算，所以用哈希表存储已经算过的答案。

class Solution {
public:
    unordered_map <int, bool> h;
    bool dfs(int mask, int n, int total) {
        if (h.find(mask) != h.end()) return h[mask];
        for (int i = 1; i <= n; i++) {
            if (mask & (1 << i)) continue;
            if (i >= total || !dfs(mask | (1<<i), n, total - i)) {
                return h[mask] = true;
            }
        }
        return h[mask] = false;
    }
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        int n = maxChoosableInteger, total = desiredTotal;
        if (n >= total) return true;
        if ((1 + n) * n / 2 < total) return false;
        int mask = 0;
        h.clear();
        return dfs(mask, n, total);
    }
};

总结：深搜+状态存储+记忆化。

5. Leetcode 172: 阶乘后的零

题目链接
题目解析：阶乘后的零意味着结果因子分解后，有多少对2和5。
而5的因子一定比2的因子少，所以只需看结果的因子分解后有多少个5即可。
假如对于某个数126，阶乘后包含因子5的个数为$126/5$, 中间如果遇到25的倍数，则需要再加上$126/25$, 遇到125的倍数，需要再加上$126/125$。

class Solution {
public:
    int trailingZeroes(int n) {
        int m = 5, cnt = 0;
        while (n / m) {
            cnt += n / m;
            m *= 5;
        }
        return cnt;
    }
};

总结：将2和5的对数转化为5的个数。

6. Leetcode 384: 打乱数组

题目链接
题目解析：随机化方法；保存原始数组。

class Solution {
public:
    vector<int> nums;
    Solution(vector<int>& nums): nums(nums) {
        srand(time(0)); //c++随机种子
    }
    
    vector<int> reset() {
        return nums;
    }
    
    vector<int> shuffle() {
        vector<int> ret(nums);
        for (int i = 0; i < ret.size(); i++) {
            swap(ret[i], ret[rand() % ret.size()]); //一种随机化方法
        }
        return ret;
    }
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */

7. Leetcode 473: 路径总和

题目链接
题目解析：二叉树相当于多个单向链表，从根节点到当前节点的路径总和为total, 目标值为target, 那么就看之前出现过多少次total - target， 则截止当前节点就有多少条路径的和为target。存储出现过多少次前缀和，可以用一个哈希表存储。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    unordered_map<long long, int> h;
    int count(TreeNode *root, long long sum, int targetSum) {
        if (root == nullptr) return 0;
        sum += root->val;
        int ans = h[sum - targetSum];

		//以下为回溯的常规操作
        h[sum] += 1;
        ans += count(root->left, sum, targetSum);
        ans += count(root->right, sum, targetSum);
        h[sum] -= 1;
        return ans;
    }
    int pathSum(TreeNode* root, int targetSum) {
        h.clear();
        h[0] = 1;
        return count(root, 0, targetSum);
    }
};

8. Leetcode 395: 至少有k个重复子串的最长子串

题目链接
解题思路：首先可以确定整个数组中某些字符出现的次数都小于k, 可以记录这些字符的位置，结果子串一定不可能包含这些位置。
所以可以以这些位置为分割点，对于分割后的每一段再重新递归地统计至少有k个重复子串的最长子串。体现了一种分治思想。

class Solution {
public:
    int longestSubstring(string s, int k) {
        // cout << s << " " << k << endl;
        unordered_map<char, int> cnt;
        for (auto x: s) cnt[x] += 1; //统计每个字符出现的次数
        vector<int> splits;
        for (int i = 0; s[i]; ++i) {
            if (cnt[s[i]] < k) {
                splits.push_back(i); //记录出现次数小于k的字符位置
            }
        }
        splits.push_back(s.size()); //末尾增加一个分割点，便于之后循环处理。
        // for (auto x: splits) cout << x << " ";
        // cout << endl;
        if (splits.size() == 1) return s.size();
        int pre = 0, ans = 0;
        for (auto p: splits){
            int len = p - pre;
            if (len >= k) {
                ans = max(ans, longestSubstring(s.substr(pre, len), k));
            }
            pre = p + 1; //下一段的起点
        }
        return ans;
    }
};

总结：1. 转化为排除不符合题目要求的字符位置；2. 分治思想，处理每一段。

9. Leetcode 190: 颠倒二进制位

题目链接
题目解析：依次扫描每一位，遇到1， 则将新数字对称的位设为1。

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        uint32_t m = 0;
        for (int i = 0; i < 32; i++) {
            if (n & (1 << i)) {
                m |= (1 << (31 - i));
            }
        }
        return m;
    }
};

总结：判断二进制的某一位是否为1；将二进制的某一位置为1.

10. Leetcode 8: 字符串转换整数(atoi)

题目链接
题目解析：当数字超界时，无法继续获取和运算，所以可以在数字“即将越界”时做处理。

class Solution {
public:
    int myAtoi(string s) {
        int ind = 0, max_pre = INT_MAX / 10, d = INT_MAX % 10, num = 0, flag = 1;
        while (s[ind] == ' ') ind++;
        if (s[ind] == '-') {
            flag = -1;
            ind++;
        }else if (s[ind] == '+') ind++;
        for (; s[ind]; ind++) {
            if (s[ind] > '9' || s[ind] < '0') break;
            if (num > max_pre || (num == max_pre && ((s[ind] - '0') > d))) {
                if (flag > 0) return INT_MAX;
                else return INT_MIN;
            }
            num = num * 10 + (s[ind] - '0');
        }
        return num * flag;
    }
};

11. Leetcode 380: O(1)时间插入、删除、获取随机元素

题目链接
解题思路：插入、删除直接用哈希表实现即可。获取随机元素哈希表无法实现，可以用一个动态数组实现，获取数组中的一个随机索引对应的值即可，但是只用动态数组又无法做到O(1)时间的插入和删除，以及判断数字是否存在。
因此需要将哈希表和动态数组相结合。
用哈希表存储数字在动态数组中对应的索引。
插入时，数组直接用push_back, 哈希表正常插入；
删除时，首先通过哈希表找到删除数字在数组中对应的索引，然后将其和数组最后一个数字交换，最后用pop_back()方法删除。
获取随机元素时，直接获取数组中的一个随机索引对应的值。

class RandomizedSet {
public:
    unordered_map<int, int> h;
    vector<int> arr;
    RandomizedSet() {
        srand(time(0));
    }
    
    bool insert(int val) {
        if (h.find(val) != h.end()) return false;
        h[val] = arr.size();
        arr.push_back(val);
        return true;
    }
    void swap_item(int i, int j) {
        swap(arr[i], arr[j]);
        h[arr[i]] = i;
        h[arr[j]] = j;
        return;
    }
    bool remove(int val) {
        if (h.find(val) == h.end()) return false;
        int n = h[val], m = arr.size() - 1;
        swap_item(n, m);
        arr.pop_back();
        h.erase(val);
        return true;
    }
    
    int getRandom() {
        return arr[rand() % arr.size()];
    }
};

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet* obj = new RandomizedSet();
 * bool param_1 = obj->insert(val);
 * bool param_2 = obj->remove(val);
 * int param_3 = obj->getRandom();
 */

总结：属于数据结构的封装设计问题。哈希表、动态数组、栈、队列等属于基础数据结构，所谓的“高级数据结构”，都是有基础数据结构组合拼接而成。

12. Leetcode 402 : 移掉K位数字

题目链接
题目解析：本题的核心在于靠近前面的数字尽可能小。当从前到后遍历输入的数字时，遍历到一个数，如果前面有比他大的数，那么就删掉这些数，这种方式下最后得到的数字一定是最小的。
以上的思想正是单调栈的思想，一个元素入栈时首先将前面大于其的数字弹栈，直到弹栈的数量超过k为止，后面的数字原封不动的入栈即可。

class Solution {
public:
    string removeKdigits(string num, int k) {
        if (k >= num.size()) return "0";
        string ret; //单调栈
        for (auto x : num) {
            while (k > 0 && ret.size() > 0 && ret.back() > x) ret.pop_back(), k -= 1;
            ret.push_back(x);
        } //单调栈构造过程
        //构建完单调栈后可能没有删够k个元素，此时数组递增，需要去掉末尾的元素
        if (k > 0) ret = ret.substr(0, ret.size() - k); 
        
        //前导0的处理过程
        int ind = 0;
        while (ret[ind] == '0') ind++;
        ret = ret.substr(ind, ret.size());
        if (ret == "") ret = "0";
        return ret;      
    }
};

总结：单调栈不仅是一种数据结构，也是一种思维方式，即遍历到一个元素时删除掉前面“大于”它的元素。

13. Leetcode 1081: 不同字符的最小序列

题目链接
本题与Leetcode 316题目相同。
题目解析：当字符以升序形式出现时，字典序最小。所以可以用一个单调栈维护序列中的所有元素。从左向右遍历，如果单调栈的末尾元素在之后出现过，而且大于当前元素，则将该末尾元素弹出，最后将当前元素入栈。
判断元素是否在之后出现过，以及判断当前遍历到的元素是否在哈希表中出现过，都可以用哈希表。

class Solution {
public:
    string smallestSubsequence(string s) {
        unordered_set<char> h; //判断元素在哈希表中是否出现过
        string ret; //结果字符串
        unordered_map<char, int> cnt; //判断某个字符在之后是否还有出现过
        for (auto x : s) cnt[x] += 1;
        for (auto x : s){
            if (h.find(x) == h.end()) {
                while (ret.size() && cnt[ret.back()] && ret.back() >= x) {
                    h.erase(h.find(ret.back()));
                    ret.pop_back(); //弹单调栈的末尾元素
                }
                ret.push_back(x); 
                h.insert(x);  //元素入栈
            }
            cnt[x]--;  //元素出现次数减一
        }
        return ret;
    }
};

总结：巧用单调栈解决最小字典序问题。

14. Leetcode 1499: 满足不等式的最大值

题目链接
题目解析：首先对于题目中的不等式$y_i+y_j+|x_i-x_j|$, 可以看出不同的两个点是满足交换律的，所以不妨设$x_j>x_i$, 这样就可以去掉绝对值，将原不等式化为:$(y_j+x_j)+(y_i-x_i)$， 前半部分相当于$j$点，后半部分相当于$i$点。当$j$点固定时，相当于从前面找$(y_i-x_i)$最大的点，同时$x_i,x_j$要在一定的窗口范围之内。
因此相当于滑动窗口的最大值问题。可以用单调递减队列。

class Solution {
public:
    struct Node {
        Node(int x, int y):x(x), y(y){}
        int x, y;
    }; //队列中的元素，点的定义
    int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
        deque<Node>  que; //单调队列用双端队列实现
        int ans = INT_MIN; //结果数字
        for (auto x: points) {
        	//对于一个新进来的点x(分析中的j点), 首先pop 掉前面不在窗口范围内的点
            while (que.size() && x[0] - que.front().x > k) {
                que.pop_front();
            }
			//然后对于新进来的点j求出此时的最大值(y_i - x_i)
            if (que.size()) {
                ans = max(ans, x[0] + x[1] + que.front().y - que.front().x);
            }
			//最后按照单调队列的方式将新进来的点入队。
            while (que.size() && ((que.back().y - que.back().x) < (x[1] - x[0]))) {
                que.pop_back();
            }
            que.push_back(Node(x[0], x[1]));
        }
        return ans;
    }
};

(也可以在队列中存储数组下标)。
总结：化简公式，巧妙化为对于固定点，求前面某一个值的最大值问题，从而化为单调队列问题。

15. Leetcode 321: 拼接最大数

题目链接
题目解析：假设从第一个数组中取了$i$个数 $ret1$，从第二个数组中取$k-i$个数 $ret2$。则当且仅当 $ret1$ 和 $ret2$都最大时，拼接的结果才能最大(假设 $ret1$ 固定，结果数组中 $ret2$ 对应的位置固定，可以想象只有 $ret2$ 越大时结果才能越大)。
所以题目转化为分别从两个数组中获取固定长度的序列，使得每个子序列的结果最大，然后合并两个序列。
对于从某个数组中获取固定长度的最大序列，正好相当于本文中的第12题(Leetcode 402: 移掉k位数字)，可以用单调栈来做。
对于两个数组的合并，可以类比归并排序时的合并方式，不同的是本题中需要将字典序大的数字先合并到结果数组中。
另外c++中可以直接按照字典序方式比较两个数组的大小。所以最终代码如下：

class Solution {
public:
    vector<int> pick_maxk(vector<int> nums, int k) {
        int m = nums.size() - k;
        vector<int> ret;
        //单调栈方法，移除 m 个元素，使得数组尽可能由大到小排列
        for (auto x : nums) {
            while (ret.size() && ret.back() < x && m) {
                ret.pop_back();
                m--;
            }
            ret.push_back(x);
        }
        if (m > 0) {
            for (int i = 0; i < m; i++) ret.pop_back();
        }
        return ret;
    }
    vector<int> merge(vector<int> arr1, vector<int> arr2) {
        vector<int> ret;
        while (arr1.size() || arr2.size()) {
            if (arr1 > arr2) {
                ret.push_back(arr1[0]);
                arr1.erase(arr1.begin()); //删除动态数组的第一个元素
            }else {
                ret.push_back(arr2[0]);
                arr2.erase(arr2.begin()); 
            }
        }
        return ret;
    }
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        vector<int> ans;
        for (int i = 0; i <= k; i++) {
            if (i > nums1.size() || (k - i > nums2.size())) continue;
            vector<int> ret1 = pick_maxk(nums1, i); //nums1中挑出i个字典序最大的数字
            vector<int> ret2 = pick_maxk(nums2, k - i); //nums2中挑出k-i个字典序最大的数字
            ans = max(ans, merge(ret1, ret2)); //按照字典序大小合并
        }
        return ans;
    }
};

总结：本题属于移除m个元素的变体，单调栈的妙用；合并时也应根据字典序合并。