【LeetCode】2020-03 每日一题

121. 买卖股票的最佳时机（简单）

【分类】：模拟、思维

【题解】：可以用O(n)的复杂度完成，只需要在遍历的时候记录到当前位置为止买入股票的最小价格minn，再维护一个当前卖出股票价(a-minn)的最大值即可。

【代码】：

C++：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int minn = 0x3f3f3f3f;
        int ans = 0;
        for(int i = 0; i < prices.size(); i++)
        {
            minn = min(prices[i], minn);
            ans = max(ans, prices[i] - minn);
        }
        return ans;
    }
};

Python3：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        ans = 0
        minn = float(inf)
        for a in prices:
            minn = min(minn, a)
            ans = max(ans, a - minn)
        return ans

 

169. 多数元素（简单）

【分类】：模拟、思维

【题解】：

解法1：找到一个出现次数大于n/2向下取整，其实稍微想一下就知道只要排序一下取中位数即可。

解法2：当然也可以直接做，用map存键值对，键为每个数字，值为每个数字出现的次数，然后遍历map找到出现次数大于n/2的键即可。

【代码】：

C++（解法1）：

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        return nums[n / 2];
    }
};

Python3（解法2）：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        dict1 = {}
        for a in nums:
            if a in dict1:
                dict1[a] = dict1[a] + 1
            else:
                dict1[a] = 1
        for k, v in dict1.items():
            if v > (len(nums) / 2):
                return k

 

206. 反转链表（简单）

【分类】：链表、递归

【题解】：

解法1：遍历的思想。其实就是把1->2->3->4变为1<-2<-3<-4。然后就很好理解了，假如说当前head在3，那么需要将head后面的链表保存下来，由于newList已经是1<-2，所以只需要把head指向这个newList就变成1<-2<-3了。当然这种解法也可以携程递归形式。

解法2：递归地思想，还蛮难理解的。假设原理表为1->2->3->4，3和4已经反转那么链表变为1->2->3<-4，此时需要将2->3进行反转，head指向2，那么只需head-->next->nextt = head即可变成2<-3，但是此时head->next也指向3，为了不形成环需要将head->next = NULL，可以看看这个博主的图解，看了就懂的那种。

【代码】

C++（解法1递归形式）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* pre = NULL;
    ListNode* tmp = NULL;
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)return pre;
        tmp = head->next;
        head->next = pre;
        pre = head;
        head = tmp;
        return reverseList(head);
    }
};

C++（解法2）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL || head->next == NULL)return head;
        ListNode* now = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return now;
    }
};

Python3（解法1遍历形式）：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        newList = None
        while(head != None):
            tmp = head.next
            head.next = newList
            newList = head
            head = tmp
        return newList

 

225. 用队列实现栈（简单）

【分类】：队列、模拟

【题解】：

解法1：直接用deque做即可，因为是双端队列，栈该有的操作它都有。

解法2：由于栈是先进后出，队列是先进先出，所以每次有元素进入队列的时候只需要把底下的元素抽上来放到上面，让本次进的元素压在最下面，那么每次取队首元素即是栈顶元素。

【代码】：

C++（解法1）：

class MyStack {
public:
    /** Initialize your data structure here. */
    deque<int>dq;
    MyStack() {

    }
    
    /** Push element x onto stack. */
    void push(int x) {
        dq.push_back(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int x = dq.back();
        dq.pop_back();
        return x;
    }
    
    /** Get the top element. */
    int top() {
        return dq.back();
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return dq.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

Python3（解法2）：

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.ls = []

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.ls.append(x)
        l = len(self.ls)
        while l > 1:
            self.ls.append(self.ls[0])
            self.ls.pop(0)
            l = l - 1


    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        return self.ls.pop(0)



    def top(self) -> int:
        """
        Get the top element.
        """
        return self.ls[0]


    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        if len(self.ls) > 0:
            return False
        else:
            return True




# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

 

300. 最长上升子序列（中等）

【分类】：动态规划、二分、贪心

【题解】：

解法1：动态规划经典题。dp[i]表示[0, i]区间内以nums[i]结尾的最长上升子序列长度。那么易得，对于j < i，只要nums[j] < nums[i]，那么dp[i] = max(dp[i], dp[j] + 1)

解法2：我们可以维护一个数组v用来存放这个最长上升子序列，那么怎么维护呢？我通过样例说明一下：如果nums为[10,9,2,5,3,7,101,18]。

当i = 0时，nums[0] = 10，直接将10插入v中，v = [10]

当i = 1时，nums[1] = 9，因为要保持这个序列递增所以显然不能将9插入10后面，因为位置不能变所以也不能插到10前面，这时候就应该考虑了，如果把10换成9后面是不是更容易找到一个比9大的数字而不是10呢？这句话有点绕口，就是说后面如果出现一个10，那么答案就是1因为10 = 10不能插入，如果现在是9在v中呢，那么9 < 10答案就是2了，所以显然放一个更小的数字进去更容易找到比他大的数，所以v = [9]

当i = 2时，nums[2] = 2，同上，v = [ 2]

当i = 3时，nums[3] = 5，5 > 2所以v = [2, 5]

以此类推

v = [2, 4, 7, 18]

那么问题来了，如何在v中找到比当前nums[i]更大的数呢，由于v保证有序，所以可以通过二分查找，如果能找到那么把那个位置的数字换成nums[i]，如果找不到，那么直接在v中插入即可。

至于二分可以自己手写，也可以用lower_bound函数。

【代码】：

C++（解法2）：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int>v;
        if (nums.size() == 0)return 0;
        v.push_back(nums[0]);
        for (int i = 1; i < nums.size(); i++)
        {
            int pos = lower_bound(v.begin(), v.end(), nums[i]) - v.begin();
            if (pos == v.size())v.push_back(nums[i]);
            else if (pos < v.size())v[pos] = nums[i];
        }
        return v.size();
    }
};

Python3（解法1）：

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        l = len(nums)
        dp = [0] * l
        ans = 0
        for i in range(l):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j])
            dp[i] += 1
            ans = max(ans, dp[i])
        return ans;

 

322. 零钱兑换（中等）

【分类】：贪心、dfs、动态规划

【题解】：

解法1：贪心+dfs。因为题目要求兑换的零钱数目最少，所以可以利用贪心的思想从数目大的零钱开始兑换起，它能够兑换的最大数目是amount / coins[i]，然后剩下的再用次大的零钱兑换，但是这样会存在一个问题，就是可能这种方式适无法兑换成功的，所以在这样的情况下需要回溯，同时还要加上适当的剪枝，比如idx < 0就不用再递归下去了 ，如果当前得到的数目已经比之前的答案大了也不用递归下去了。

解法2：动态规划。dp[i]兑换i的最少硬币数，那么当当前硬币j被放入时dp[i - coins[j]] + 1，如果不放时那么dp[i] = dp[i]，只要取两者最小值即可，易得dp[i] = min( dp[i - coins[j]] + 1, dp[i])。

【代码】：

C++（解法1）：

class Solution {
public:
    int ans = 0x3f3f3f3f;
    void dfs(vector<int>& coins, int idx, int num, int r)
    {
        if (r == 0)
        {
            ans = min(ans, num);
            return;
        }
        if (idx < 0)return;
        for (int i = r / coins[idx]; i >= 0 && num + i < ans; i--)
            dfs(coins, idx - 1, num + i, r - i * coins[idx]);
    }
    int coinChange(vector<int>& coins, int amount) {
        sort(coins.begin(), coins.end());
        dfs(coins, coins.size() - 1, 0, amount);
        if (ans == 0x3f3f3f3f)return -1;
        else return ans;
    }
};

Python3（解法2）：

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dp = [amount + 1] * (amount + 2)
        dp[0] = 0
        for i in range(1, amount + 1):
            for j in range(len(coins)):
                if i - coins[j] >= 0:
                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
        if dp[amount] == amount + 1:
            return -1
        return dp[amount]

 

365. 水壶问题（中等）

【分类】：bfs、数学

【题解】

解法1：经典的倒水问题，可以分为以下六种情况。

（1）将A水杯倒满

（2）将B水杯倒满

（3）将A水杯清空

（4）将B水杯清空

（5）将A水杯中的水倒入B。若A水杯中的水能将B倒满，那么A水杯为空或者还剩水，如果不能将B倒满，那么A水杯为空，B水杯为为两杯之和

（6）将B水杯中的水倒入A。若B水杯中的水能将A倒满，那么B水杯为空或者还剩水，如果不能将A倒满，那么B水杯为空，A水杯为为两杯之和

分布讨论这六种情况，用bfs写一下即可。

解法2：数学题....哎我不懂

首先想让两个杯子x，y倒出一定的水量z，肯定满足ax+by=z，且a和b均为整数。

然后根据贝祖定理：若x,y是整数,且gcd(x, y) = d，那么对于任意的整数a, b, ax+by都一定是d的倍数，特别地，一定存在整数a,b，使ax+by = d成立。

由贝祖定理可知，若存在整数a,b，使得ax+by=z成立，则z一定为x，y最大公因数的整数倍。

所以最终题目就化解成求z是否为x、y的最大公约数的整数倍。

【代码】：

C++（解法2）：

class Solution {
public:
    bool canMeasureWater(int x, int y, int z) {
        if (x == 0 && y == 0) return z == 0;
        if (x + y < z) return false;
        if (z % __gcd(x, y) == 0) return true;
        else return false;     
    }
};

Python3（解法1）：

class Solution:
    def canMeasureWater(self, x: int, y: int, z: int) -> bool:
        q = [(0, 0)]
        vis = set()
        while q:
            rx, ry = q.pop()
            if rx == z or ry == z or rx + ry == z:
                return True
            if (rx, ry) in vis: continue
            vis.add((rx, ry))
            # 将x倒满
            q.append((x, ry))
            # 将y倒满
            q.append((rx, y))
            # 将x清空
            q.append((0, ry))
            # 将y清空
            q.append((rx, 0))
            # 将y倒入x
            if x - rx <= ry:
                q.append((x, ry - (x - rx)))
            else:
                q.append((rx + ry, 0))
            # 将x倒入y
            if y - ry <= rx:
                q.append((rx - (y - ry), y))
            else:
                q.append((0, rx + ry))
        return False

 

409. 最长回文串（简单）

【分类】：思维、模拟

【题解】：刚开始没看清题目，还以为是让我求该字符串中最大回文串的长度。其实是通过字符串提供的字母组合一个最大回文串，这样就简单多了，如果该字符有偶数个那么肯定能构成回文串，如果是奇数个只能就只能是某个字符有奇数个，其他都必须是偶数个。

【代码】：

C++：

class Solution {
public:
    map<char, int>mp;
    int longestPalindrome(string s) {
        int len = s.size(), sum = 0, f = 0;
        for (int i = 0; i < len; i++)
            mp[s[i]]++;
        map<char, int>::iterator it;
        for (it = mp.begin(); it != mp.end(); it++)
        {
            if (it->second % 2 != 0)
            {
                if (!f)
                {
                    f = 1;
                    sum += it->second;
                }
                else sum += it->second - 1;
            }
            else sum += it->second;
        }
        return sum;
    }
};

Python3：

class Solution:
    def longestPalindrome(self, s: str) -> int:
        l = len(s)
        mp = {}
        ans = 0
        f = 0
        for a in s:
            if a in mp:
                mp[a] = mp[a] + 1
            else:
                mp[a] = 1
        for k, v in mp.items():
            if v % 2 != 0:
                if f == 0:
                    f = 1
                    ans += v
                else:
                    ans += v - 1
            else: ans += v
        return ans

 

543. 二叉树的直径（简单）

【分类】：dfs

【题解】：以任意节点为父节点的直径是它的左右子树的最大深度之和，那么我们只要在搜索每个节点的时候维护这样的一个最大值即可。

【代码】：

C++：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int ans = 0;
    int diameterOfBinaryTree(TreeNode* root) {
        int d = dfs(root);
        return ans;

    }
    int dfs(TreeNode *root)
    {
        if (root == NULL)return 0;
        int l = dfs(root->left);
        int r = dfs(root->right);
        ans = max (ans, l + r);
        return max(l, r) + 1;
    }
};

Python3：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def __init__(self):
        self.ans = 0
    def dfs(self, root):
        if not root:
            return 0
        l = self.dfs(root.left)
        r = self.dfs(root.right)
        self.ans = max(self.ans, l + r)
        return max(l, r) + 1
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        d = self.dfs(root)
        return self.ans

 

695. 岛屿的最大面积（中等）

【分类】：dfs

【题解】：比较经典的dfs题，直接搜就好啦，别忘了判断边界。

【代码】：

C++：

class Solution {
public:
    int dirx[4] = {1, -1, 0, 0};
    int diry[4] = {0, 0, 1, -1};
    int dfs(vector<vector<int>>& grid, int x, int y, int n, int m)
    {
        if (x >= n || x < 0 || y >= m || y < 0 || !grid[x][y])
            return 0;
        int num = 1;
        grid[x][y] = 0;
        for (int i = 0; i < 4; i++)
        {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            num += dfs(grid, xx, yy, n, m);
        }
        return num;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int ans = 0;
        int n = grid.size(), m = grid[0].size();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                    ans = max(ans, dfs(grid, i, j, n, m));    
        return ans;
    }
};

Python3：

class Solution:
    def dfs(self, grid, x, y, n, m):
        if x < 0 or x >= n or y < 0 or y >= m or grid[x][y] == 0:
            return 0
        s = 1
        grid[x][y] = 0
        for dx, dy in self.dire:
            xx, yy = x + dx, y + dy
            s += self.dfs(grid, xx, yy ,n , m)
        return s
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        self.dire = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        n = len(grid)
        m = len(grid[0])
        ans = 0
        for i in range(n):
            for j in range(m):
                if grid[i][j] == 1:
                    ans = max(ans, self.dfs(grid, i, j, n, m))
        return ans

 

820. 单词的压缩编码（中等）

【分类】：思维、字典树

【题解】：

解法1：可以先将单词存入set中，遍历每个单词的后缀如果在set中存在就删去，最后输出剩余单词的长度。

解法2：可以将每个单词翻转后插入字典树中，由字典树的定义可得只有当前缀不同时才会有分支，但是这样做的前提是必须先插入长度较长的字符串，最终只要计算每个叶子节点到根节点的个数之和即可。

【代码】：

C++（解法2）：

class TrieNode {
public:
    TrieNode* child[26];
};
class Trie{
public:
    TrieNode *root;
    Trie(){
        root = new TrieNode();
    }
    int insert(string word)
    {
        TrieNode *cur = root;
        bool isNew = false;
        for (int i = word.size() - 1; i >= 0; i--)
        {
            char ch = word[i] - 'a';
            if (cur->child[ch] == NULL)
            {
                cur->child[ch] = new TrieNode();
                isNew = true;
            }
            cur = cur->child[ch];
        }
        if (isNew)return word.size() + 1;
        else return 0;
    }
};
class Solution {
public:
    static bool cmp(string a, string b)
    {
        return a.size() > b.size();
    }
    int minimumLengthEncoding(vector<string>& words) {
        sort(words.begin(), words.end(), cmp);
        int ans = 0;
        Trie *trie = new Trie();
        for (int i = 0; i < words.size(); i++)
            ans += trie->insert(words[i]);
        return ans;
    }
};

Python3（解法1）：

class Solution:
    def minimumLengthEncoding(self, words: List[str]) -> int:
        st = set(words)
        for w in words:
            for i in range(1, len(w)):
                st.discard(w[i:])
        return sum(len(w) + 1 for w in st)

 

836. 矩形重叠（简单）

【分类】：思维、分类

【题解】：需要用到逆向思维，因为两个矩形重叠的情况很多，所以我们可以反过来思考不重叠的情况，那么就只有两个矩形平行分开或竖直分开，除去这两种情况就都是重叠了。

【代码】：

C++：

class Solution {
public:
    bool isRectangleOverlap(vector<int>& rec1, vector<int>& rec2) {
        if (rec1[2] <= rec2[0] || rec2[2] <= rec1[0])return false;
        else if (rec1[3] <= rec2[1] || rec2[3] <= rec1[1])return false;
        else return true;
    }
};

Python3：

class Solution:
    def isRectangleOverlap(self, rec1: List[int], rec2: List[int]) -> bool:
        if (rec1[2] <= rec2[0] or rec2[2] <= rec1[0]):
            return False
        elif (rec1[3] <= rec2[1] or rec2[3] <= rec1[1]):
            return False
        else:
            return True

 

876. 链表的中间结点（简单）

【分类】：思维

【题解】：

解法1：按照常规思维只要先遍历一遍链表知道长度，然后再遍历一遍链表即可找到中间位置。

解法2：快慢指针。说实话没看题解真没想到，看到后恍然大悟，其实只要遍历一次即可，即快指针每次走两个单位，慢指针每次走一个单位，当快指针走完链表后慢指针就刚刚到中间位置。

【代码】：

C++（解法1）：

/**
 * 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) {
        int num = 0;
        ListNode *node = head;
        while(node != NULL)
        {
            num++;
            node = node->next;
        }
        num /= 2;
        while(num--)
        {
            head = head->next;
        }
        return head;
    }
};

Python3（解法2）：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = head
        fast = head
        while (fast and fast.next):
            fast = fast.next.next
            slow = slow.next
        return slow

 

892. 三维形体的表面积（简单）

【分类】：数学

【题解】：所有立方体的表面积-重叠面积。关键是重叠面积怎么计算，重叠面积分为两部分，一部分是自身那一列重叠的面积，另一部分是和周围有接触的列的重叠面积。

【代码】：

C++：

class Solution {
public:
    int surfaceArea(vector<vector<int>>& grid) {
        int num = 0;
        int r = 0;
        int row = grid.size(), col = grid[0].size();
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                num += grid[i][j];
                if (grid[i][j] > 0)r += (grid[i][j] - 1) * 2;
                if (i - 1 >= 0)r += min(grid[i - 1][j], grid[i][j]);
                if (i + 1 < row) r += min(grid[i + 1][j], grid[i][j]);
                if (j - 1 >= 0)r += min(grid[i][j - 1], grid[i][j]);
                if (j + 1 < col) r += min(grid[i][j + 1], grid[i][j]);
            }
        }
        return (num * 6 - r);
    }
};

Python3：

class Solution:
    def surfaceArea(self, grid: List[List[int]]) -> int:
        num = 0
        r = 0
        row = len(grid)
        col = len(grid[0])
        for i in range(row):
            for j in range(col):
                num += grid[i][j];
                if (grid[i][j] > 0):
                    r += (grid[i][j] - 1) * 2;
                if (i - 1 >= 0):
                    r += min(grid[i - 1][j], grid[i][j]);
                if (i + 1 < row):
                    r += min(grid[i + 1][j], grid[i][j]);
                if (j - 1 >= 0):
                    r += min(grid[i][j - 1], grid[i][j]);
                if (j + 1 < col):
                    r += min(grid[i][j + 1], grid[i][j]);
        return (num * 6 - r);

 

912. 排序数组（中等）

【分类】：排序

【题解】：当然可以直接sort做，但是出题者本意应该是想让我们复习一下八大排序。这里就用快排和归并做一下。

【代码】：

C++（归并）：

class Solution {
public:
    void merge(vector<int>&nums, int l, int r)
    {
        if (l >= r)return;
        int tmp[100005] = {0};
        int mid = (l + r) / 2, i = l, j = mid + 1, k = 0;
        while(i <= mid && j <= r)
        {
            if (nums[i] <= nums[j])tmp[k++] = nums[i++];
            else tmp[k++] = nums[j++];
        }
        while(i <= mid)tmp[k++] = nums[i++];
        while(j <= r)tmp[k++] = nums[j++];
        for(int i = 0; i < k; i++)
            nums[i + l] = tmp[i];
    }
    void mergesort(vector<int>& nums, int l, int r)
    {
        if (l >= r)return;
        int mid = (l + r)/ 2;
        mergesort(nums, l, mid);
        mergesort(nums, mid + 1, r);
        merge(nums, l, r);
    }
    vector<int> sortArray(vector<int>& nums) {
        mergesort(nums, 0, nums.size() - 1);
        return nums;
    }
};

Python3（快排）：

class Solution:
    def quicksort(self, nums, begin, end):
        if begin >= end: return
        l = begin
        r = end
        t = nums[l]
        while(l != r):
            while l < r and nums[r] >= t: r -= 1
            nums[l] = nums[r]
            while l < r and nums[l] <= t: l += 1
            nums[r] = nums[l]
        nums[l] = t
        self.quicksort(nums, begin, l)
        self.quicksort(nums, l + 1, end)

    def sortArray(self, nums: List[int]) -> List[int]:
        self.quicksort(nums, 0, len(nums) - 1)
        return nums

 

914. 卡牌分组（简单）

【分类】：数学、gcd

【题解】：理解后即可转换题意为求取这组数据中每个不同的数字的个数的最大公约数，如果最大公约数>1则输出True，反之输出False。这里求取最大公约数记得用辗转相除法哦。

【代码】：

C++：

class Solution {
public:
    int gcd(int a, int b)
    {
        int r;
        while(b > 0)
        {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }
    bool hasGroupsSizeX(vector<int>& deck) {
        map<int, int>mp;
        for (int i = 0; i < deck.size(); i++)
            mp[deck[i]]++;
        map<int, int>::iterator it = mp.begin();
        int gd = it->second;
        for (;it != mp.end(); it++)
            gd = gcd(gd, it->second);
        if (gd == 1)return false;
        else return true;
    }
};

Python3：

class Solution:
    def gcd(self, a, b):
        while b > 0:
            r = a % b
            a = b
            b = r
        return a
    def hasGroupsSizeX(self, deck: List[int]) -> bool:
        mp = {}
        for x in deck:
            if x not in mp:
                mp[x] = 1
            else:
                mp[x] += 1
        ls = list(mp.values())
        gd = ls[0]
        for x in ls:
            gd = self.gcd(x, gd)
        if gd == 1:
            return False
        else:
            return True

 

945. 使数组唯一的最小增量（中等） 

【分类】：贪心

【题解】：排完序利用贪心的思想，因为每个元素只能增加1所以只需要和前面的元素比较，如果和它相等就加1即可。

【代码】：

C++：

class Solution {
public:
    int minIncrementForUnique(vector<int>& A) {
        sort(A.begin(), A.end());
        if (A.size() == 0)return 0;
        int ans = 0;
        for (int i = 1; i < A.size(); i++)
        {
            if (A[i] <= A[i - 1])
            {
                ans += A[i - 1] - A[i] + 1;
                A[i] = A[i - 1] + 1;
            }
        }
        return ans;
    }
};

Python3：

class Solution:
    def minIncrementForUnique(self, A: List[int]) -> int:
        A.sort()
        if len(A) == 0: return 0
        ans = 0
        for i in range(1, len(A)):
            if A[i] <= A[i - 1]:
                ans += A[i - 1] - A[i] + 1
                A[i] = A[i - 1] + 1
        return ans

 

994. 腐烂的橘子（简单）

【分类】：bfs

【题解】：很经典的广搜题。

【代码】：

C++：

class Solution {
public:
    struct Node{
        int x, y, v;
    };
    int vis[15][15] = {0};
    int dirx[4] = {0, 0, 1, -1};
    int diry[4] = {1, -1, 0, 0};
    int orangesRotting(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        queue<Node>q;
        int num = 0;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (grid[i][j] == 2)
                {
                    q.push({i, j, 0});
                    vis[i][j] = 1;
                }
                else if (grid[i][j] == 1)num++;
            }
        }
        int ans = 0;
        while(!q.empty())
        {
            Node t = q.front();
            q.pop();
            ans = max(ans, t.v);
            for (int i = 0; i < 4; i++)
            {
                int xx = t.x + dirx[i];
                int yy = t.y + diry[i];
                if (xx >=0 && xx < m && yy >= 0 && yy < n && !vis[xx][yy] && grid[xx][yy] == 1)
                {
                    vis[xx][yy] = 1;
                    q.push({xx, yy, t.v + 1});
                    num--;
                }
            }
        }
        if (num != 0)return -1;
        else return ans;
    }
};

Python3：

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        dirx = [0, 0, 1, -1]
        diry = [1, -1, 0, 0]
        n = len(grid)
        m = len(grid[0])
        ls = []
        ans = 0
        num = 0
        for i in range(n):
            for j in range(m):
                if (grid[i][j] == 2):
                    ls.append([i, j, 0])
                elif (grid[i][j] == 1):
                    num += 1
        while(len(ls) > 0):
            t = ls.pop(0)
            ans = max(ans, t[2])
            for i in range(4):
                xx = t[0] + dirx[i]
                yy = t[1] + diry[i]
                if (xx >=0 and xx < n and yy >=0 and yy < m and grid[xx][yy] == 1):
                    grid[xx][yy] = 2
                    ls.append([xx, yy, t[2] + 1])
                    num -= 1
        if num > 0:
            return -1
        else:
            return ans

 

999. 可以被一步捕获的棋子数（简单）

【分类】：模拟

【题解】：理解题意即可，分别计算R的四个方向，如果碰到边界或B退出循环，如果碰到p那么num+1退出循环（因为抓到一个就会停下）。

【代码】：

C++：

class Solution {
public:
    int numRookCaptures(vector<vector<char>>& board) {
        int n = board.size();
        int m = board[0].size();
        int x, y, num = 0, xx, yy;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                if (board[i][j] == 'R')
                {
                    x = i;
                    y = j;
                    break;
                }
            }
        }
        xx  = x;
        while(xx > 0)
        {
            xx--;
            if (board[xx][y] == 'p')
            {
                num++;
                break;
            }
            else if (board[xx][y] == 'B')break;
        }
        xx = x;
        while(xx + 1 < n)
        {
            xx++;
            if (board[xx][y] == 'p')
            {
                num++;
                break;
            }
            else if (board[xx][y] == 'B')break;
        }
        yy = y;
        while(yy > 0)
        {
            yy--;
            if (board[x][yy] == 'p')
            {
                num++;
                break;
            }
            else if (board[x][yy] == 'B')break;
        }
        yy = y;
        while(yy + 1 < m)
        {
            yy++;
            if (board[x][yy] == 'p')
            {
                num++;
                break;
            }
            else if (board[x][yy] == 'B')break;
        }  
        return num;         
    }
};

Python3：

class Solution:
    def numRookCaptures(self, board: List[List[str]]) -> int:
        n = len(board)
        m = len(board)
        x, y, num = 0, 0, 0
        for i in range(n):
            for j in range(m):
                if board[i][j] == 'R':
                    x = i
                    y = j
                    break
        xx = x
        while xx > 0:
            xx -= 1
            if board[xx][y] == 'B':break
            elif board[xx][y] == 'p':
                num += 1
                break;
        xx = x
        while xx + 1 < n:
            xx += 1
            if board[xx][y] == 'B':break
            elif board[xx][y] == 'p':
                num += 1
                break;
        yy = y
        while yy > 0:
            yy -= 1
            if board[x][yy] == 'B':break
            elif board[x][yy] == 'p':
                num += 1
                break;
        yy = y
        while yy + 1 < m:
            yy += 1
            if board[x][yy] == 'B':break
            elif board[x][yy] == 'p':
                num += 1
                break;  
        return num

 

1013. 将数组分成和相等的三个部分（简单） 

【分类】：思维、模拟

【题解】：直接暴力做就可以啦，首先排除不能分的情况，即所有所有数之和不能被3整除。然后直接找前两组等于和/3的数，如果还有数字被剩下那么久可以分成三个部分。

【代码】：

C++：

class Solution {
public:
    bool canThreePartsEqualSum(vector<int>& A) {
        int len = A.size(), i, sum = 0;
        for (i = 0; i < len; i++)
        {
            sum += A[i];
        }
        if (sum % 3 != 0)return false;
        else
        {
            sum /= 3;
            int t = 0;
            for (i = 0; i < len; i++)
            {
                t += A[i];
                if (t == sum)break;
            }
            if (t != sum)return false;
            t = 0;
            for (i = i + 1; i < len; i++)
            {
                t += A[i];
                if (t == sum)break;
            }
            if (i >= len - 1)return false;
            else return true;
        }
    }
};

Python3：

class Solution:
    def canThreePartsEqualSum(self, A: List[int]) -> bool:
        s = 0
        for x in A:
            s += x
        if (s % 3 != 0):
            return False
        else:
            s /= 3
            t = 0
            l = len(A)
            for i in range(l):
                t += A[i];
                if (t == s):break
            if t != s:
                return False;
            t = 0
            for x in range(i + 1, l):
                t += A[x];
                if (t == s):break
            if (x >= l - 1):
                return False
            else:
                return True

 

1071. 字符串的最大公因子（简单）

【分类】：思维、模拟

【题解】：只要判断两个字符串是否是两字符串最大公因数串的子串即可。

【代码】：

C++：

class Solution {
public:
    string gcdOfStrings(string str1, string str2) {
        int l1 = str1.size(), l2 = str2.size();
        int gd = __gcd(l1, l2), f = 0;
        string s = str1.substr(0, gd), t;
        for (int i = 0; i < l1; i += gd)
        {
            t = "";
            for (int j = i; j < i + gd; j++)
                t += str1[j];
            if (t != s)
            {
                f = 1;
                break;
            }
        }
        if (t != s || f == 1)return "";
        for (int i = 0; i < l2; i += gd)
        {
            t = "";
            for (int j = i; j < i + gd; j++)
                t += str2[j];
            if (t != s)
            {
                f = 1;
                break;
            }
        }
        if (t != s || f == 1)return "";
        else return s;
    }
};

Python3：

class Solution:
    def gcd(self, a, b):
        while b > 0:
            t = a % b
            a = b
            b = t
        return a
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        l1 = len(str1)
        l2 = len(str2)
        gd = self.gcd(l1, l2)
        s = str1[0: gd]
        p = ""
        f = 0
        for i in range(0, l1, gd):
            p = ""
            for j in range(i, i + gd):
                p = p + str1[j]
            if (p != s):
                f = 1
                break
        if (p != s or f == 1):return ""
        for i in range(0, l2, gd):
            p = ""
            for j in range(i, i + gd):
                p = p + str2[j]
            if (p != s):
                f = 1
                break     
        if (p != s or f == 1):return ""
        else: return s
        

 

1103. 分糖果 II（简单）

【分类】：模拟

【题解】：直接根据题意模拟即可。由于编号上存在循环，用到（i + 1）% 人数。当然也可以通过推数学公式来求。

【代码】：

C++：

class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        vector<int>v;
        int i = 0, num = 1;
        for (int i = 0; i < num_people; i++)
            v.push_back(0);
        while(candies > 0)
        {
            v[i] += num;
            candies -= num;
            if (candies > num + 1)num++;
            else num = candies;
            i = (i + 1) % num_people;
        }
        return v;
    }
};

Python3：

class Solution:
    def distributeCandies(self, candies: int, num_people: int) -> List[int]:
        ans = []
        for i in range(num_people):
            ans.append(0)
        num = 1
        i = 0
        while(candies):
            ans[i] += num
            candies -= num
            if (candies > num + 1):
                num += 1
            else: num = candies
            i = (i + 1) % num_people
        return ans

 

1160. 拼写单词（简单）

【分类】：模拟

【题解】：根据题意直接做即可，记录字母表中每个字母的个数，只要统计每个单词出现的字母的个数小于等于字母表就可以啦。不得不说python真是太方便了！！

【代码】：

C++：

class Solution {
public:
    int countCharacters(vector<string>& words, string chars) {
        map<char, int> mp;
        for (int i = 0; i < chars.size(); i++)
            mp[chars[i]]++;
        int ans  = 0;
        for (int i = 0; i < words.size(); i++)
        {
            int f = 0;
            map<char, int>mp2 = mp;
            for (int j = 0; j < words[i].size(); j++)
            {
                if (mp2[words[i][j]] >= 1)
                    mp2[words[i][j]]--;
                else
                {
                    f = 1;
                    break;
                }
            }
            if (!f)
                ans += words[i].size();
        }
        return ans;
    }
};

Python3：

class Solution:
    def countCharacters(self, words: List[str], chars: str) -> int:
        c = collections.Counter(chars)
        ans = 0
        for s in words:
            w = collections.Counter(s)
            if all([c[i] >= w[i] for i in w]):
                ans += len(s)
        return ans

 

面试题 01.06. 字符串压缩（简单）

【分类】：模拟

【题解】：不难。根据题意直接做就好啦。

【代码】：

C++：

class Solution {
public:
    string compressString(string S) {
        string ans = "";
        if (S == "")return "";
        int num = 1;
        for (int i = 1; i < S.size(); i++)
        {
            if (S[i] != S[i - 1])
            {
                ans += S[i - 1];
                ans += to_string(num);
                num = 1;
            }
            else num++;
        }
        ans += S[S.size() - 1];
        ans += to_string(num);
        if (ans.size() >= S.size())return S;
        else return ans;
    }
};

Python3：

class Solution:
    def compressString(self, S: str) -> str:
        ans = ""
        if S == "": return ""
        num = 1
        for i in range(1, len(S)):
            if (S[i] != S[i - 1]):
                ans += S[i - 1]
                ans += str(num)
                num = 1
            else: num += 1
        ans += S[len(S) - 1]
        ans += str(num)
        if len(ans) >= len(S): return S
        else: return ans

 

面试题 10.01. 合并排序的数组（简单）

【分类】：排序、思维

【题解】：

解法1：直接将第二个数组放入第一个数组中然后排序。

解法2：从两个数组的最后一个元素开始比起，谁大就往后面移，当然不要忘记有种情况是第一个数组的所有数都比第二个大，所以退出循环后记得把第二个数组的元素放进去。

【代码】：

C++（解法1）：

class Solution {
public:
    void merge(vector<int>& A, int m, vector<int>& B, int n) {
        int len = A.size() - B.size();
        for(int i = 0; i < B.size(); i++)
            A[len + i] = B[i];
        sort(A.begin(), A.end());
    }
};

Python3（解法2）：

class Solution:
    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
        i = m - 1
        j = n - 1
        while(i >= 0 and j >= 0):
            if A[i] >= B[j]:
                A[i + j + 1] = A[i]
                i -= 1
            else:
                A[i + j + 1] = B[j]
                j -= 1
        while(j >= 0):
            A[i + j + 1] = B[j]
            j -= 1

 

面试题 17.16. 按摩师（简单）

【分类】：动态规划

【题解】：我不明白这题为什么简单！！我觉得所有dp都是难的！！

设dp[i]为0-i这个区间内的最大值。那么可以分类讨论：

（1）如果取nums[i]，那么nums[i-1]就不能取，也就是说状态得从dp[i-2]传过来，所以dp[i] = dp[i-2] + nums[i]

（2）如果不取nums[i]，那么状态就可以从ddp[i-1]传过来，所以dp[i] = dp[i - 1]

最后取这两种情况的最大值即可。

【代码】：

C++（解法1）：

class Solution {
public:
    int dp[10005];
    int massage(vector<int>& nums) {
        int len = nums.size();
        if (len == 0)return 0;
        else if (len == 1)return nums[0];
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < len; i++)
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        return dp[len - 1];
    }
};

Python3（解法2）：

class Solution:
    def massage(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0: return 0
        elif n == 1: return nums[0]
        dp = [0] * (n + 1)
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])       
        for i in range(2, n):
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
        return dp[n - 1]

 

面试题40. 最小的k个数（简单）

【分类】：排序

【题解】：

解法1：直接用内置sort排序然后输出即可。

解法2：很经典的堆排序题，用大顶堆做。

【代码】：

C++（解法1）：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        sort(arr.begin(), arr.end());
        vector<int>ans;
        for (int i = 0; i < k; i++)
            ans.push_back(arr[i]);
        return ans;
    }
};

 Python3（解法2）：

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if (k == 0): return list()
        # 由于python里的heapq是小根堆，所以需要取相反数
        hp = [-x for x in arr[:k]]
        # 让列表具备堆特性
        heapq.heapify(hp)
        for i in range(k, len(arr)):
            if -hp[0] > arr[i]:
                heapq.heappop(hp)
                heapq.heappush(hp, -arr[i])
        ans = [-x for x in hp]
        return ans

 

面试题57 - II. 和为s的连续正数序列（简单）

【分类】：思维

【题解】：滑动窗口法，虽然n的范围在10^5但是实际上易得枚举数字只要到n/2 + 1即可，然后我们就可以设置一个左右边界l，r，将l到r-1所有的数加起来，如果超过target那么l 就向右移，也就是减去了l，同理如果小于target那r就向右移。

【代码】：

C++：

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        int h = (target / 2) + 1;
        int l = 1, r = 1, sum = 0;
        vector<vector<int> >ans;
        while(l<=h)
        {
            if (sum > target)
            {
                sum -= l;
                l++;
            }
            else if (sum < target)
            {
                sum += r;
                r++;
            }
            else
            {
                vector<int>v;
                for (int i = l; i < r; i++)
                    v.push_back(i);
                ans.push_back(v);
                sum -= l;
                l++;
            }
        }
        return ans;
    }
};

Python3：

class Solution:
    def findContinuousSequence(self, target: int) -> List[List[int]]:
        h = (target / 2) + 1
        ans = []
        l = 1
        r = 1
        s = 0
        while l <= h:
            if s < target:
                s += r
                r += 1
            elif s > target:
                s -= l
                l += 1
            else:
                a = []
                for i in range(l, r):
                    a.append(i)
                ans.append(a)
                s -= l 
                l += 1
        return ans

 

面试题62. 圆圈中最后剩下的数字（简单）

【分类】：数学

【题解】：约瑟夫环问题。可以看这篇题解，感觉我以前也是一知半解，看完这个豁然开朗。

f(n,m) = 0, n = 1

f(n,m) = [ f(n-1, m) +m ] %n, n > 1

【代码】：

C++：

class Solution {
public:
    int lastRemaining(int n, int m) {
        int pos = 0;
        for (int i = 2; i <= n; i++)
            pos = (pos + m) % i;
        return pos;
    }
};

Python3：

class Solution:
    def lastRemaining(self, n: int, m: int) -> int:
        pos = 0
        for i in range(2, n + 1):
            pos = (pos + m) % i
        return pos

 

 

------------恢复内容开始------------

121. 买卖股票的最佳时机（简单）

【分类】：模拟、思维

【题解】：可以用O(n)的复杂度完成，只需要在遍历的时候记录到当前位置为止买入股票的最小价格minn，再维护一个当前卖出股票价(a-minn)的最大值即可。

【代码】：

C++：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int minn = 0x3f3f3f3f;
        int ans = 0;
        for(int i = 0; i < prices.size(); i++)
        {
            minn = min(prices[i], minn);
            ans = max(ans, prices[i] - minn);
        }
        return ans;
    }
};

Python3：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        ans = 0
        minn = float(inf)
        for a in prices:
            minn = min(minn, a)
            ans = max(ans, a - minn)
        return ans

 

169. 多数元素（简单）

【分类】：模拟、思维

【题解】：

解法1：找到一个出现次数大于n/2向下取整，其实稍微想一下就知道只要排序一下取中位数即可。

解法2：当然也可以直接做，用map存键值对，键为每个数字，值为每个数字出现的次数，然后遍历map找到出现次数大于n/2的键即可。

【代码】：

C++（解法1）：

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        return nums[n / 2];
    }
};

Python3（解法2）：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        dict1 = {}
        for a in nums:
            if a in dict1:
                dict1[a] = dict1[a] + 1
            else:
                dict1[a] = 1
        for k, v in dict1.items():
            if v > (len(nums) / 2):
                return k

 

206. 反转链表（简单）

【分类】：链表、递归

【题解】：

解法1：遍历的思想。其实就是把1->2->3->4变为1<-2<-3<-4。然后就很好理解了，假如说当前head在3，那么需要将head后面的链表保存下来，由于newList已经是1<-2，所以只需要把head指向这个newList就变成1<-2<-3了。当然这种解法也可以携程递归形式。

解法2：递归地思想，还蛮难理解的。假设原理表为1->2->3->4，3和4已经反转那么链表变为1->2->3<-4，此时需要将2->3进行反转，head指向2，那么只需head-->next->nextt = head即可变成2<-3，但是此时head->next也指向3，为了不形成环需要将head->next = NULL，可以看看这个博主的图解，看了就懂的那种。

【代码】

C++（解法1递归形式）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* pre = NULL;
    ListNode* tmp = NULL;
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)return pre;
        tmp = head->next;
        head->next = pre;
        pre = head;
        head = tmp;
        return reverseList(head);
    }
};

C++（解法2）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL || head->next == NULL)return head;
        ListNode* now = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return now;
    }
};

Python3（解法1遍历形式）：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        newList = None
        while(head != None):
            tmp = head.next
            head.next = newList
            newList = head
            head = tmp
        return newList

 

225. 用队列实现栈（简单）

【分类】：队列、模拟

【题解】：

解法1：直接用deque做即可，因为是双端队列，栈该有的操作它都有。

解法2：由于栈是先进后出，队列是先进先出，所以每次有元素进入队列的时候只需要把底下的元素抽上来放到上面，让本次进的元素压在最下面，那么每次取队首元素即是栈顶元素。

【代码】：

C++（解法1）：

class MyStack {
public:
    /** Initialize your data structure here. */
    deque<int>dq;
    MyStack() {

    }
    
    /** Push element x onto stack. */
    void push(int x) {
        dq.push_back(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int x = dq.back();
        dq.pop_back();
        return x;
    }
    
    /** Get the top element. */
    int top() {
        return dq.back();
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        return dq.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

Python3（解法2）：

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.ls = []

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.ls.append(x)
        l = len(self.ls)
        while l > 1:
            self.ls.append(self.ls[0])
            self.ls.pop(0)
            l = l - 1


    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        return self.ls.pop(0)



    def top(self) -> int:
        """
        Get the top element.
        """
        return self.ls[0]


    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        if len(self.ls) > 0:
            return False
        else:
            return True




# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

 

300. 最长上升子序列（中等）

【分类】：动态规划、二分

【题解】：

解法1：设dp[i]为以nums[i]结尾的最长上升子序列长度。

解法2：维护一个数组v即最终的最优数列，v[i]代表当长度为i+1时最后一个元素的最小值。可能这么讲不太明白，我以样例为例。

原数组a：[10,9,2,5,3,7,101,18]，每当我们遍历到一个元素时，我们找到能在v中插入的最佳位置，哪个是最佳位置呢？

当i = 0时，a[i] = 10，直接插入v数组中，v = [10]

当i = 1时，a[i] = 9，那么显然9不可能插在10的后面，但是又要维护这个序列的序号是递增的所以也不可能插在10的前面，很显然9比10小，也就是说后面遇到比9大的数字的可能性比10大，比如后面遇到一个10，那么如果v中是9的话还能再插入，如果是10的话就不能了，所以我们现在要把10替换成9，那么v = [9]

当i = 2时，a[i] = 2，同理v = [2]

当i = 3时，a[i] = 5，此时5比2大，所以可以插在后面v = [2, 5]

以此类推

v = [2, 5,7, 18]

那么问题来了怎样快速确定v中有没有比当前a[i]大的数呢，因为v是有序的，所以显然可以用二分，这个二分可以自己写当然也可以直接用函数lower_bound()。

【代码】：

C++（解法2）：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int>v;
        if (nums.size() == 0)return 0;
        v.push_back(nums[0]);
        for (int i = 1; i < nums.size(); i++)
        {
            int pos = lower_bound(v.begin(), v.end(), nums[i]) - v.begin();
            if (pos == v.size())v.push_back(nums[i]);
            else if (pos < v.size())v[pos] = nums[i];
        }
        return v.size();
    }
};

Python3（解法1）：

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        l = len(nums)
        dp = [0] * l
        ans = 0
        for i in range(l):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j])
            dp[i] += 1
            ans = max(ans, dp[i])
        return ans;

 

409. 最长回文串（简单）

【分类】：思维、模拟

【题解】：刚开始没看清题目，还以为是让我求该字符串中最大回文串的长度。其实是通过字符串提供的字母组合一个最大回文串，这样就简单多了，如果该字符有偶数个那么肯定能构成回文串，如果是奇数个只能就只能是某个字符有奇数个，其他都必须是偶数个。

【代码】：

C++：

class Solution {
public:
    map<char, int>mp;
    int longestPalindrome(string s) {
        int len = s.size(), sum = 0, f = 0;
        for (int i = 0; i < len; i++)
            mp[s[i]]++;
        map<char, int>::iterator it;
        for (it = mp.begin(); it != mp.end(); it++)
        {
            if (it->second % 2 != 0)
            {
                if (!f)
                {
                    f = 1;
                    sum += it->second;
                }
                else sum += it->second - 1;
            }
            else sum += it->second;
        }
        return sum;
    }
};

Python3：

class Solution:
    def longestPalindrome(self, s: str) -> int:
        l = len(s)
        mp = {}
        ans = 0
        f = 0
        for a in s:
            if a in mp:
                mp[a] = mp[a] + 1
            else:
                mp[a] = 1
        for k, v in mp.items():
            if v % 2 != 0:
                if f == 0:
                    f = 1
                    ans += v
                else:
                    ans += v - 1
            else: ans += v
        return ans

 

543. 二叉树的直径（简单）

【分类】：dfs

【题解】：以任意节点为父节点的直径是它的左右子树的最大深度之和，那么我们只要在搜索每个节点的时候维护这样的一个最大值即可。

【代码】：

C++：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int ans = 0;
    int diameterOfBinaryTree(TreeNode* root) {
        int d = dfs(root);
        return ans;

    }
    int dfs(TreeNode *root)
    {
        if (root == NULL)return 0;
        int l = dfs(root->left);
        int r = dfs(root->right);
        ans = max (ans, l + r);
        return max(l, r) + 1;
    }
};

Python3：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def __init__(self):
        self.ans = 0
    def dfs(self, root):
        if not root:
            return 0
        l = self.dfs(root.left)
        r = self.dfs(root.right)
        self.ans = max(self.ans, l + r)
        return max(l, r) + 1
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        d = self.dfs(root)
        return self.ans

 

836. 矩形重叠（简单）

【分类】：思维、分类

【题解】：需要用到逆向思维，因为两个矩形重叠的情况很多，所以我们可以反过来思考不重叠的情况，那么就只有两个矩形平行分开或竖直分开，除去这两种情况就都是重叠了。

【代码】：

C++：

class Solution {
public:
    bool isRectangleOverlap(vector<int>& rec1, vector<int>& rec2) {
        if (rec1[2] <= rec2[0] || rec2[2] <= rec1[0])return false;
        else if (rec1[3] <= rec2[1] || rec2[3] <= rec1[1])return false;
        else return true;
    }
};

Python3：

class Solution:
    def isRectangleOverlap(self, rec1: List[int], rec2: List[int]) -> bool:
        if (rec1[2] <= rec2[0] or rec2[2] <= rec1[0]):
            return False
        elif (rec1[3] <= rec2[1] or rec2[3] <= rec1[1]):
            return False
        else:
            return True

 

876. 链表的中间结点（简单）

【分类】：思维

【题解】：

解法1：按照常规思维只要先遍历一遍链表知道长度，然后再遍历一遍链表即可找到中间位置。

解法2：快慢指针。说实话没看题解真没想到，看到后恍然大悟，其实只要遍历一次即可，即快指针每次走两个单位，慢指针每次走一个单位，当快指针走完链表后慢指针就刚刚到中间位置。

【代码】：

C++（解法1）：

/**
 * 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) {
        int num = 0;
        ListNode *node = head;
        while(node != NULL)
        {
            num++;
            node = node->next;
        }
        num /= 2;
        while(num--)
        {
            head = head->next;
        }
        return head;
    }
};

Python3（解法2）：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = head
        fast = head
        while (fast and fast.next):
            fast = fast.next.next
            slow = slow.next
        return slow

 

892. 三维形体的表面积（简单）

【分类】：数学

【题解】：所有立方体的表面积-重叠面积。关键是重叠面积怎么计算，重叠面积分为两部分，一部分是自身那一列重叠的面积，另一部分是和周围有接触的列的重叠面积。

【代码】：

C++：

class Solution {
public:
    int surfaceArea(vector<vector<int>>& grid) {
        int num = 0;
        int r = 0;
        int row = grid.size(), col = grid[0].size();
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                num += grid[i][j];
                if (grid[i][j] > 0)r += (grid[i][j] - 1) * 2;
                if (i - 1 >= 0)r += min(grid[i - 1][j], grid[i][j]);
                if (i + 1 < row) r += min(grid[i + 1][j], grid[i][j]);
                if (j - 1 >= 0)r += min(grid[i][j - 1], grid[i][j]);
                if (j + 1 < col) r += min(grid[i][j + 1], grid[i][j]);
            }
        }
        return (num * 6 - r);
    }
};

Python3：

class Solution:
    def surfaceArea(self, grid: List[List[int]]) -> int:
        num = 0
        r = 0
        row = len(grid)
        col = len(grid[0])
        for i in range(row):
            for j in range(col):
                num += grid[i][j];
                if (grid[i][j] > 0):
                    r += (grid[i][j] - 1) * 2;
                if (i - 1 >= 0):
                    r += min(grid[i - 1][j], grid[i][j]);
                if (i + 1 < row):
                    r += min(grid[i + 1][j], grid[i][j]);
                if (j - 1 >= 0):
                    r += min(grid[i][j - 1], grid[i][j]);
                if (j + 1 < col):
                    r += min(grid[i][j + 1], grid[i][j]);
        return (num * 6 - r);

 

914. 卡牌分组（简单）

【分类】：数学、gcd

【题解】：理解后即可转换题意为求取这组数据中每个不同的数字的个数的最大公约数，如果最大公约数>1则输出True，反之输出False。这里求取最大公约数记得用辗转相除法哦。

【代码】：

C++：

class Solution {
public:
    int gcd(int a, int b)
    {
        int r;
        while(b > 0)
        {
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }
    bool hasGroupsSizeX(vector<int>& deck) {
        map<int, int>mp;
        for (int i = 0; i < deck.size(); i++)
            mp[deck[i]]++;
        map<int, int>::iterator it = mp.begin();
        int gd = it->second;
        for (;it != mp.end(); it++)
            gd = gcd(gd, it->second);
        if (gd == 1)return false;
        else return true;
    }
};

Python3：

class Solution:
    def gcd(self, a, b):
        while b > 0:
            r = a % b
            a = b
            b = r
        return a
    def hasGroupsSizeX(self, deck: List[int]) -> bool:
        mp = {}
        for x in deck:
            if x not in mp:
                mp[x] = 1
            else:
                mp[x] += 1
        ls = list(mp.values())
        gd = ls[0]
        for x in ls:
            gd = self.gcd(x, gd)
        if gd == 1:
            return False
        else:
            return True

 

994. 腐烂的橘子（简单）

【分类】：bfs

【题解】：很经典的广搜题。

【代码】：

C++：

class Solution {
public:
    struct Node{
        int x, y, v;
    };
    int vis[15][15] = {0};
    int dirx[4] = {0, 0, 1, -1};
    int diry[4] = {1, -1, 0, 0};
    int orangesRotting(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        queue<Node>q;
        int num = 0;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (grid[i][j] == 2)
                {
                    q.push({i, j, 0});
                    vis[i][j] = 1;
                }
                else if (grid[i][j] == 1)num++;
            }
        }
        int ans = 0;
        while(!q.empty())
        {
            Node t = q.front();
            q.pop();
            ans = max(ans, t.v);
            for (int i = 0; i < 4; i++)
            {
                int xx = t.x + dirx[i];
                int yy = t.y + diry[i];
                if (xx >=0 && xx < m && yy >= 0 && yy < n && !vis[xx][yy] && grid[xx][yy] == 1)
                {
                    vis[xx][yy] = 1;
                    q.push({xx, yy, t.v + 1});
                    num--;
                }
            }
        }
        if (num != 0)return -1;
        else return ans;
    }
};

Python3：

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        dirx = [0, 0, 1, -1]
        diry = [1, -1, 0, 0]
        n = len(grid)
        m = len(grid[0])
        ls = []
        ans = 0
        num = 0
        for i in range(n):
            for j in range(m):
                if (grid[i][j] == 2):
                    ls.append([i, j, 0])
                elif (grid[i][j] == 1):
                    num += 1
        while(len(ls) > 0):
            t = ls.pop(0)
            ans = max(ans, t[2])
            for i in range(4):
                xx = t[0] + dirx[i]
                yy = t[1] + diry[i]
                if (xx >=0 and xx < n and yy >=0 and yy < m and grid[xx][yy] == 1):
                    grid[xx][yy] = 2
                    ls.append([xx, yy, t[2] + 1])
                    num -= 1
        if num > 0:
            return -1
        else:
            return ans

 

999. 可以被一步捕获的棋子数（简单）

【分类】：模拟

【题解】：理解题意即可，分别计算R的四个方向，如果碰到边界或B退出循环，如果碰到p那么num+1退出循环（因为抓到一个就会停下）。

【代码】：

C++：

class Solution {
public:
    int numRookCaptures(vector<vector<char>>& board) {
        int n = board.size();
        int m = board[0].size();
        int x, y, num = 0, xx, yy;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                if (board[i][j] == 'R')
                {
                    x = i;
                    y = j;
                    break;
                }
            }
        }
        xx  = x;
        while(xx > 0)
        {
            xx--;
            if (board[xx][y] == 'p')
            {
                num++;
                break;
            }
            else if (board[xx][y] == 'B')break;
        }
        xx = x;
        while(xx + 1 < n)
        {
            xx++;
            if (board[xx][y] == 'p')
            {
                num++;
                break;
            }
            else if (board[xx][y] == 'B')break;
        }
        yy = y;
        while(yy > 0)
        {
            yy--;
            if (board[x][yy] == 'p')
            {
                num++;
                break;
            }
            else if (board[x][yy] == 'B')break;
        }
        yy = y;
        while(yy + 1 < m)
        {
            yy++;
            if (board[x][yy] == 'p')
            {
                num++;
                break;
            }
            else if (board[x][yy] == 'B')break;
        }  
        return num;         
    }
};

Python3：

class Solution:
    def numRookCaptures(self, board: List[List[str]]) -> int:
        n = len(board)
        m = len(board)
        x, y, num = 0, 0, 0
        for i in range(n):
            for j in range(m):
                if board[i][j] == 'R':
                    x = i
                    y = j
                    break
        xx = x
        while xx > 0:
            xx -= 1
            if board[xx][y] == 'B':break
            elif board[xx][y] == 'p':
                num += 1
                break;
        xx = x
        while xx + 1 < n:
            xx += 1
            if board[xx][y] == 'B':break
            elif board[xx][y] == 'p':
                num += 1
                break;
        yy = y
        while yy > 0:
            yy -= 1
            if board[x][yy] == 'B':break
            elif board[x][yy] == 'p':
                num += 1
                break;
        yy = y
        while yy + 1 < m:
            yy += 1
            if board[x][yy] == 'B':break
            elif board[x][yy] == 'p':
                num += 1
                break;  
        return num

 

1013. 将数组分成和相等的三个部分（简单） 

【分类】：思维、模拟

【题解】：直接暴力做就可以啦，首先排除不能分的情况，即所有所有数之和不能被3整除。然后直接找前两组等于和/3的数，如果还有数字被剩下那么久可以分成三个部分。

【代码】：

C++：

class Solution {
public:
    bool canThreePartsEqualSum(vector<int>& A) {
        int len = A.size(), i, sum = 0;
        for (i = 0; i < len; i++)
        {
            sum += A[i];
        }
        if (sum % 3 != 0)return false;
        else
        {
            sum /= 3;
            int t = 0;
            for (i = 0; i < len; i++)
            {
                t += A[i];
                if (t == sum)break;
            }
            if (t != sum)return false;
            t = 0;
            for (i = i + 1; i < len; i++)
            {
                t += A[i];
                if (t == sum)break;
            }
            if (i >= len - 1)return false;
            else return true;
        }
    }
};

Python3：

class Solution:
    def canThreePartsEqualSum(self, A: List[int]) -> bool:
        s = 0
        for x in A:
            s += x
        if (s % 3 != 0):
            return False
        else:
            s /= 3
            t = 0
            l = len(A)
            for i in range(l):
                t += A[i];
                if (t == s):break
            if t != s:
                return False;
            t = 0
            for x in range(i + 1, l):
                t += A[x];
                if (t == s):break
            if (x >= l - 1):
                return False
            else:
                return True

 

1071. 字符串的最大公因子（简单）

【分类】：思维、模拟

【题解】：只要判断两个字符串是否是两字符串最大公因数串的子串即可。

【代码】：

C++：

class Solution {
public:
    string gcdOfStrings(string str1, string str2) {
        int l1 = str1.size(), l2 = str2.size();
        int gd = __gcd(l1, l2), f = 0;
        string s = str1.substr(0, gd), t;
        for (int i = 0; i < l1; i += gd)
        {
            t = "";
            for (int j = i; j < i + gd; j++)
                t += str1[j];
            if (t != s)
            {
                f = 1;
                break;
            }
        }
        if (t != s || f == 1)return "";
        for (int i = 0; i < l2; i += gd)
        {
            t = "";
            for (int j = i; j < i + gd; j++)
                t += str2[j];
            if (t != s)
            {
                f = 1;
                break;
            }
        }
        if (t != s || f == 1)return "";
        else return s;
    }
};

Python3：

class Solution:
    def gcd(self, a, b):
        while b > 0:
            t = a % b
            a = b
            b = t
        return a
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        l1 = len(str1)
        l2 = len(str2)
        gd = self.gcd(l1, l2)
        s = str1[0: gd]
        p = ""
        f = 0
        for i in range(0, l1, gd):
            p = ""
            for j in range(i, i + gd):
                p = p + str1[j]
            if (p != s):
                f = 1
                break
        if (p != s or f == 1):return ""
        for i in range(0, l2, gd):
            p = ""
            for j in range(i, i + gd):
                p = p + str2[j]
            if (p != s):
                f = 1
                break     
        if (p != s or f == 1):return ""
        else: return s
        

 

1103. 分糖果 II（简单）

【分类】：模拟

【题解】：直接根据题意模拟即可。由于编号上存在循环，用到（i + 1）% 人数。当然也可以通过推数学公式来求。

【代码】：

C++：

class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        vector<int>v;
        int i = 0, num = 1;
        for (int i = 0; i < num_people; i++)
            v.push_back(0);
        while(candies > 0)
        {
            v[i] += num;
            candies -= num;
            if (candies > num + 1)num++;
            else num = candies;
            i = (i + 1) % num_people;
        }
        return v;
    }
};

Python3：

class Solution:
    def distributeCandies(self, candies: int, num_people: int) -> List[int]:
        ans = []
        for i in range(num_people):
            ans.append(0)
        num = 1
        i = 0
        while(candies):
            ans[i] += num
            candies -= num
            if (candies > num + 1):
                num += 1
            else: num = candies
            i = (i + 1) % num_people
        return ans

 

1160. 拼写单词（简单）

【分类】：模拟

【题解】：根据题意直接做即可，记录字母表中每个字母的个数，只要统计每个单词出现的字母的个数小于等于字母表就可以啦。不得不说python真是太方便了！！

【代码】：

C++：

class Solution {
public:
    int countCharacters(vector<string>& words, string chars) {
        map<char, int> mp;
        for (int i = 0; i < chars.size(); i++)
            mp[chars[i]]++;
        int ans  = 0;
        for (int i = 0; i < words.size(); i++)
        {
            int f = 0;
            map<char, int>mp2 = mp;
            for (int j = 0; j < words[i].size(); j++)
            {
                if (mp2[words[i][j]] >= 1)
                    mp2[words[i][j]]--;
                else
                {
                    f = 1;
                    break;
                }
            }
            if (!f)
                ans += words[i].size();
        }
        return ans;
    }
};

Python3：

class Solution:
    def countCharacters(self, words: List[str], chars: str) -> int:
        c = collections.Counter(chars)
        ans = 0
        for s in words:
            w = collections.Counter(s)
            if all([c[i] >= w[i] for i in w]):
                ans += len(s)
        return ans

 

1162. 地图分析（中等）

【分类】：bfs

【题解】：

解法1：最普通的bfs，通过遍历地图每遍历到一个0时进入bfs，因为最近的1肯定是最先被搜索到的，所以一旦搜索到了1即可退出，并计算两个位置的距离。

解法2：不需要vis记录，我们可以先记录一个1的队列，通过这个队列去搜索0，因为我们最后要找的是最大距离，每遇到一个0就进队，当队列为空即遍历完整幅图时，返回答案。

【代码】：

C++（解法1）：

class Solution {
public:
    int vis[105][105];
    int dirx[4] = {0, 0, 1, -1};
    int diry[4] = {1, -1, 0, 0};
    int bfs(vector<vector<int>>& grid, int x, int y, int n, int m)
    {
        queue<pair<int, int>>q;
        q.push(make_pair(x, y));
        while(!q.empty())
        {
            pair<int, int> p = q.front();
            int xx = p.first, yy = p.second;
            q.pop();
            if (grid[xx][yy] == 1)
                return (abs(x - xx) + abs(y -yy));
            for(int i = 0; i < 4; i++)
            {
                int tx = xx + dirx[i];
                int ty = yy + diry[i];
                if (tx >= 0 && tx < n && ty >= 0 && ty < m && !vis[tx][ty] )
                {
                    vis[tx][ty] = 1;
                    q.push(make_pair(tx, ty));
                }
            }
        }
        return -1;
    }
    int maxDistance(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int ans = -1;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                if (!grid[i][j])
                {
                    memset(vis, 0, sizeof(vis));
                    ans = max(ans, bfs(grid, i, j, n, m));
                }
            }
        }
        return ans;
    }
};

Python3（解法2）：

class Solution:
    from collections import deque
    def maxDistance(self, grid: List[List[int]]) -> int:
        n = len(grid)
        dire = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        ans = -1
        q = deque((i, j) for i in range(n) for j in range(n) if grid[i][j] == 1)
        if len(q) == 0 or len(q) == n ** 2: return -1
        while q:
            for i in range(len(q)):
                x, y = q.popleft()
                for dx, dy in dire:
                    xx, yy = x + dx, y + dy
                    if xx >= 0 and xx < n and yy >= 0 and yy < n and grid[xx][yy] == 0:
                        grid[xx][yy] -= 1
                        q.append((xx, yy))
            ans += 1
        return ans

 

面试题 01.06. 字符串压缩（简单）

【分类】：模拟

【题解】：不难。根据题意直接做就好啦。

【代码】：

C++：

class Solution {
public:
    string compressString(string S) {
        string ans = "";
        if (S == "")return "";
        int num = 1;
        for (int i = 1; i < S.size(); i++)
        {
            if (S[i] != S[i - 1])
            {
                ans += S[i - 1];
                ans += to_string(num);
                num = 1;
            }
            else num++;
        }
        ans += S[S.size() - 1];
        ans += to_string(num);
        if (ans.size() >= S.size())return S;
        else return ans;
    }
};

Python3：

class Solution:
    def compressString(self, S: str) -> str:
        ans = ""
        if S == "": return ""
        num = 1
        for i in range(1, len(S)):
            if (S[i] != S[i - 1]):
                ans += S[i - 1]
                ans += str(num)
                num = 1
            else: num += 1
        ans += S[len(S) - 1]
        ans += str(num)
        if len(ans) >= len(S): return S
        else: return ans

 

面试题 10.01. 合并排序的数组（简单）

【分类】：排序、思维

【题解】：

解法1：直接将第二个数组放入第一个数组中然后排序。

解法2：从两个数组的最后一个元素开始比起，谁大就往后面移，当然不要忘记有种情况是第一个数组的所有数都比第二个大，所以退出循环后记得把第二个数组的元素放进去。

【代码】：

C++（解法1）：

class Solution {
public:
    void merge(vector<int>& A, int m, vector<int>& B, int n) {
        int len = A.size() - B.size();
        for(int i = 0; i < B.size(); i++)
            A[len + i] = B[i];
        sort(A.begin(), A.end());
    }
};

Python3（解法2）：

class Solution:
    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
        i = m - 1
        j = n - 1
        while(i >= 0 and j >= 0):
            if A[i] >= B[j]:
                A[i + j + 1] = A[i]
                i -= 1
            else:
                A[i + j + 1] = B[j]
                j -= 1
        while(j >= 0):
            A[i + j + 1] = B[j]
            j -= 1

 

面试题 17.16. 按摩师（简单）

【分类】：动态规划

【题解】：我不明白这题为什么简单！！我觉得所有dp都是难的！！

设dp[i]为0-i这个区间内的最大值。那么可以分类讨论：

（1）如果取nums[i]，那么nums[i-1]就不能取，也就是说状态得从dp[i-2]传过来，所以dp[i] = dp[i-2] + nums[i]

（2）如果不取nums[i]，那么状态就可以从ddp[i-1]传过来，所以dp[i] = dp[i - 1]

最后取这两种情况的最大值即可。

【代码】：

C++（解法1）：

class Solution {
public:
    int dp[10005];
    int massage(vector<int>& nums) {
        int len = nums.size();
        if (len == 0)return 0;
        else if (len == 1)return nums[0];
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < len; i++)
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        return dp[len - 1];
    }
};

Python3（解法2）：

class Solution:
    def massage(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0: return 0
        elif n == 1: return nums[0]
        dp = [0] * (n + 1)
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])       
        for i in range(2, n):
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
        return dp[n - 1]

 

面试题40. 最小的k个数（简单）

【分类】：排序

【题解】：

解法1：直接用内置sort排序然后输出即可。

解法2：很经典的堆排序题，用大顶堆做。

【代码】：

C++（解法1）：

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        sort(arr.begin(), arr.end());
        vector<int>ans;
        for (int i = 0; i < k; i++)
            ans.push_back(arr[i]);
        return ans;
    }
};

 Python3（解法2）：

class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        if (k == 0): return list()
        # 由于python里的heapq是小根堆，所以需要取相反数
        hp = [-x for x in arr[:k]]
        # 让列表具备堆特性
        heapq.heapify(hp)
        for i in range(k, len(arr)):
            if -hp[0] > arr[i]:
                heapq.heappop(hp)
                heapq.heappush(hp, -arr[i])
        ans = [-x for x in hp]
        return ans

 

面试题57 - II. 和为s的连续正数序列（简单）

【分类】：思维

【题解】：滑动窗口法，虽然n的范围在10^5但是实际上易得枚举数字只要到n/2 + 1即可，然后我们就可以设置一个左右边界l，r，将l到r-1所有的数加起来，如果超过target那么l 就向右移，也就是减去了l，同理如果小于target那r就向右移。

【代码】：

C++：

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        int h = (target / 2) + 1;
        int l = 1, r = 1, sum = 0;
        vector<vector<int> >ans;
        while(l<=h)
        {
            if (sum > target)
            {
                sum -= l;
                l++;
            }
            else if (sum < target)
            {
                sum += r;
                r++;
            }
            else
            {
                vector<int>v;
                for (int i = l; i < r; i++)
                    v.push_back(i);
                ans.push_back(v);
                sum -= l;
                l++;
            }
        }
        return ans;
    }
};

Python3：

class Solution:
    def findContinuousSequence(self, target: int) -> List[List[int]]:
        h = (target / 2) + 1
        ans = []
        l = 1
        r = 1
        s = 0
        while l <= h:
            if s < target:
                s += r
                r += 1
            elif s > target:
                s -= l
                l += 1
            else:
                a = []
                for i in range(l, r):
                    a.append(i)
                ans.append(a)
                s -= l 
                l += 1
        return ans

 

面试题59 - II. 队列的最大值（中等）

【分类】：队列

【题解】：重新维护一个双端队列d用来维护队列的最大值，保证d的队首元素为当前队列的最大值，每当一个元素进入队列时要与d中的队尾元素比较，如果比它小，那么直接插入，如果比它大那么要弹出d中的元素直到找到比它小的位置。那么为什么要这么操作呢？

首先队列时先进先出的，比如我当前队列是1 2 3 5，只要5不出队列那么最大值就一直是5，此时如果再入队一个6，那么为了保证只要6不出队列最大值就是6就得把5从d中弹出，让d的队首元素时6。此时如果再来个3，我肯定不能把6弹出去，因为此时q为1 2 3 5 6 3最大值仍然是6，那么当前面的1 2 3 5 6都被弹出去了的话最大值就变成了3，所以为了保证能做到这样，3得进入队列d。

【代码】：

C++：

class MaxQueue {
public:
    queue<int>q;
    deque<int>d;
    MaxQueue() {

    }
    
    int max_value() {
        if(d.empty())return -1;
        else return d.front();
    }
    
    void push_back(int value) {
        q.push(value);
        while(!d.empty() && d.back() < value)
            d.pop_back();
        d.push_back(value);
    }
    
    int pop_front() {
        if(q.empty())return -1;
        else
        {
            int t = q.front();
            if (t == d.front())d.pop_front();
            q.pop();
            return t;
        }
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */

Python3： 

import queue
class MaxQueue:

    def __init__(self):
        self.d = queue.deque()
        self.q = queue.Queue()

    def max_value(self) -> int:
        if self.d: return self.d[0]
        else: return -1

    def push_back(self, value: int) -> None:
        while(self.d and self.d[-1] < value):
            self.d.pop()
        self.q.put(value)
        self.d.append(value)

    def pop_front(self) -> int:
        if not self.d: return -1
        ans = self.q.get()
        if ans == self.d[0]:self.d.popleft()
        return ans




# Your MaxQueue object will be instantiated and called as such:
# obj = MaxQueue()
# param_1 = obj.max_value()
# obj.push_back(value)
# param_3 = obj.pop_front()

 

面试题62. 圆圈中最后剩下的数字（简单）

【分类】：数学

【题解】：约瑟夫环问题。可以看这篇题解，感觉我以前也是一知半解，看完这个豁然开朗。

f(n,m) = 0, n = 1

f(n,m) = [ f(n-1, m) +m ] %n, n > 1

【代码】：

C++：

class Solution {
public:
    int lastRemaining(int n, int m) {
        int pos = 0;
        for (int i = 2; i <= n; i++)
            pos = (pos + m) % i;
        return pos;
    }
};

Python3：

class Solution:
    def lastRemaining(self, n: int, m: int) -> int:
        pos = 0
        for i in range(2, n + 1):
            pos = (pos + m) % i
        return pos

 

 

------------恢复内容结束------------

[10,9,2,5,3,7,101,18]