剑指Offer

剑指Offer

面试题14- I. 剪绳子

代码1 dp

集合:f[i]表示 绳子长度为i时所有方案集合中 最大乘积

集合划分:考虑f[i]可以由哪些变过来, f[i-1] * f[1] , f[i-2] *f[2] ...

f[i-k] * f[k];

O(n)枚举k,总复杂度O(n^2)

class Solution {
public:
    int f[105];
    int cutRope(int number) {
        //必须分成两段
        if(number == 2) return 1; 
        else if(number == 3) return 2;
        //f[i] 长度为i的升子的最大乘积
        f[1] = 1;
        f[2] = 2; //1和2和3特例
        f[3] = 3;
        for(int i=4;i<=number;i++){
            f[i] = max(f[i],f[i-1]);
            for(int j=2;j

代码2 贪心

贪心,分成2和3最佳,能分成3就不分成2

class Solution {
public:
    int cutRope(int number) {
        //必须分成两段
        if(number == 2) return 1;
        else if(number == 3) return 2;
        int thirdNum = number / 3;
        int thirdOther = number % 3;
        if(thirdOther == 0){
            return pow(3,thirdNum);
        }else if(thirdOther == 1){
            return pow(3,thirdNum-1) * 4;
        }else{
            return pow(3,thirdNum) * 2;
        }
    }
};

剑指 Offer 14- II. 剪绳子 II

这道题再用dp，取mod后又取max就不准确了，一定要用dp的话只能使用java大数

思路：贪心 + 快速幂(普通求幂的方法也可以的)

划分成2和3的乘积，结果值最大。先计算能分成3的最大个数，再取余计算2的数量，不够2的整数倍就减去一个3分给2。

class Solution {
public:
    int mod = 1e9+7;
    int cuttingRope(int n) {
        if(n == 0) return 0;
        if(n == 1) return 0;
        if(n == 2) return 1;
        if(n == 3) return 2;
        //分成2和3最佳 3的数量尽量多
        int a = n/3;
        int b = n%3;
        if(b == 2){
            return (int) (quickPow(3,a) * b) % mod;
        }else if(b == 0){
            return (int) quickPow(3,a) % mod;
        }else{
            //取模注意 要在int转型前取模
            return (int) ((quickPow(3,a-1) * 4) % mod);
        }
    }

    //快速幂
    long long quickPow(long long a,long long n){
        long long ans = 1;
        while(n){
            if(n&1){
                ans = (ans * a) % mod;
            }
            a = (a * a) % mod;
            n >>= 1;
        }
        return ans;
    }
};

面试题13. 机器人的运动范围

坐标dfs，判满足条件。

注意走不到的要直接退出递归，防止走到其它序列，导致结果不正确了。

class Solution {
public:
    int cnt = 0;
    int dr[4][2] = {{0,1},{1,0},{-1,0},{0,-1}};
    int vis[1000][1000];

    void dfs(int x ,int y,int m,int n,int k){
        if(x >= m || y >= n || x < 0 || y < 0) return ;
        if(vis[x][y]) return ;
        vis[x][y] = 1;
        if(x / 10 + x % 10 + y / 10 + y % 10 <= k) {
            cnt++;
        }else return; //走不到的要退出不能继续往下
        for(int i=0;i<4;i++){
            int nx = x + dr[i][0];
            int ny = y + dr[i][1];
            dfs(nx,ny,m,n,k);
        }
    }

    int movingCount(int m,int n,int k){
        dfs(0,0,m,n,k);
        return cnt;
    }
};

面试题03. 数组中重复的数字

哈希表判重

class Solution {
public:
    int findRepeatNumber(vector& nums) {
        map mp;
        for(int i=0;i

面试题04. 二维数组中的查找 / 240. 搜索二维矩阵 II

二分lower_bound

class Solution {
public:
    bool findNumberIn2DArray(vector>& matrix, int target) {
        //nlogn二分
        if(matrix.size() == 0) return false;
        int n = matrix.size();
        int m = matrix[0].size();
        for(int i=0;i= 0 && matrix[i][index] == target) 
                return true;
        }
        return false;
    }
};

方法2：根据题目性质，从右上角开始

具体可看题解

class Solution {
public:
    bool searchMatrix(vector>& matrix, int target) {
        //nlogn二分
        if(matrix.size() == 0) return false;
        int n = matrix.size() - 1;
        int m = matrix[0].size() - 1;
        if(n < 0 || m < 0) return false;
        int row = 0,col = m;
        while(row <= n && col >= 0){
            if(matrix[row][col] == target){
                return true;
            }else if(matrix[row][col] < target){
                row++;
            }else if(matrix[row][col] > target){
                col--;
            }
        }
        return false;
    }
};

面试题05. 替换空格

这题用java写吧，StringBuilder减少开销，用C++和Java的String，字符串+拼接都会拷贝原字符串形成新的字符串。

class Solution {
    public String replaceSpace(String s) {
        StringBuilder sb = new StringBuilder();
        for(int i=0;i

面试题06. 从尾到头打印链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector reversePrint(ListNode* head) {
        vector results;
        ListNode *p = head;
        while(p){
            results.push_back(p->val);
            p = p->next;
        }
        reverse(results.begin(),results.end());
        return results;
    }
};

面试题10- I. 斐波那契数列

dp

class Solution {
public:
    int fib(int n) {
        if(n == 0) return 0;
        int dp[110];
        int mod = 1e9+7;
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;
        for(int i=3;i<=n;i++){
            dp[i] = (dp[i-1] + dp[i-2])%mod;
        }
        return dp[n];
    }
};

面试题10- II. 青蛙跳台阶问题

这道题注意特判，台阶是0的时候默认一种方案，1的时候也是1种方案

dp 滚动一维

class Solution {
    public int numWays(int n) {
        if(n == 0) return 1; //特判
        if(n == 1) return 1; //特判
        //从2开始  第二阶可以由第0个跳1次2或者第1个跳2次1
        int f0 = 1,f1 = 1,f2 = f1 + f0;
        int mod = 1000000007;
        for(int i=2;i<=n;i++){
            f2 = (f1 + f0)%mod;;
            f0 = f1;
            f1 = f2;
        }
        return f2%mod;
    }
}

面试题07. 重建二叉树

前序中序序列建树

前序确定根，中序划分左右子树

/**
 * 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:
    map mp;
    TreeNode* buildTree(vector& preorder, vector& inorder) {
        if(preorder.size() == 0 || inorder.size() == 0) return NULL;
        for(int i=0;i& preorder,vector& inorder,
    int il,int ir,int rootIndex){
        if(il > ir) return NULL;
        TreeNode* Root = new TreeNode();
        Root->val = preorder[rootIndex];
        //在中序数组中找到根所在的位置 划分左右子树
        int pos = mp[preorder[rootIndex]];
        Root->left = build(preorder,inorder,il,pos-1,rootIndex+1);
        Root->right = build(preorder,inorder,pos+1,ir,(pos-il+1)+rootIndex);
        return Root;
    }
};

面试题09. 用两个栈实现队列

第一个栈push就可以

要删除时，需要将第一个栈的除第一个元素外的所有元素移动到临时栈中，再弹出栈首，并返回栈首值。再将临时栈所有元素移动到第一个栈中。

class CQueue {
public:
    stack stk,stkTemp;
    CQueue() {

    }
    
    void appendTail(int value) {
        stk.push(value);
    }
    
    int deleteHead() {
        if(stk.size() == 0) return -1;
        while(stk.size() > 1){
            stkTemp.push(stk.top());
            stk.pop();
        }
        int front = stk.top();
        stk.pop();
        while(stkTemp.size()){
            stk.push(stkTemp.top());
            stkTemp.pop();
        }
        return front;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

优化，插入都查到stk栈中。删除时，当stkTemp有值的时候返回stkTemp的首元素；当stkTemp没有值时，将stk栈中元素全部移动到stkTemp(FIFO就是倒序进栈了，先进的后出，后出即到了stkTemp栈顶)，栈顶就是本轮删除的队首，pop它。

class CQueue {
public:
    stack stk,stkTemp;
    CQueue() {

    }
    
    void appendTail(int value) {
        stk.push(value);
    }
    
    int deleteHead() {
        if(stkTemp.size()==0 && stk.size() == 0) return -1;
        int front;
        if(stkTemp.size()){
            front = stkTemp.top();
            stkTemp.pop();
            return front;
        }
        while(stk.size()){
            stkTemp.push(stk.top());
            stk.pop();
        }
        front = stkTemp.top();
        stkTemp.pop();
        return front;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

面试题11. 旋转数组的最小数字

同leetCode154

不同于leetCode153

本题数组中可能有相等的元素，需要特判nums[mid] == nums[r]时，让r -= 1

class Solution {
public:
    int minArray(vector& nums) {
        if(nums.size() == 0) return 0;
        int l = 0,r = nums.size()-1;
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums[mid] < nums[r]) r = mid;
            else if(nums[mid] > nums[r]) l = mid + 1;
            else r = r - 1; //特判相等
        }
        return nums[r];
    }
};

面试题12. 矩阵中的路径

dfs+回溯

坐标上搜索和回溯，搜索到正解返回true，非正解继续搜索

class Solution {
public:
    int dr[4][2] = {{0,1},{1,0},{-1,0},{0,-1}};
    int length;
    bool vis[210][210];
    int n,m;
    bool exist(vector>& board, string word) {
        length = word.size();
        n = board.size();
        m = board[0].size();
        for(int i=0;i>& board,
    string word){
        if(index == length-1){
            return true;
        }
        if(vis[x][y]) return false;
        vis[x][y] = 1;
        for(int i=0;i<4;i++){
            int nx = x + dr[i][0];
            int ny = y + dr[i][1];
            if(vaild(nx,ny) && !vis[nx][ny] && 
            board[nx][ny] == word[index+1]){
                if(dfs(nx,ny,index+1,board,word))
                	return true;
            }
        }
        vis[x][y] = 0;
        return false;
    }

    bool vaild(int x,int y){
        if(x < 0 || y < 0 || x >= n || y >=m) return false;
        return true;
    }
};

剑指 Offer 15. 二进制中1的个数

位运算，与1作&运算，如果结果值为1，表示当前为数字是1，计数器+1；右移一位。

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt = 0;
        while(n){
            if(n & 1) cnt++;
            n >>= 1;
        }
        return cnt;
    }
};

剑指 Offer 16. 数值的整数次方

首先看到n的范围，枚举肯定不行

分治，每次计算一半，递归往下，最大32层。

class Solution {
public:
    double myPow(double x, int n) {
        if(n == 0) return 1;
        if(n == 1) return x;
        if(n == -1) return 1.0/x;
        double half = myPow(x,n/2);
        double mod = myPow(x,n%2);
        return half*half*mod;
    }
};

方法二：快速幂

先将幂为负数的转成整数 x也要变成分数

二分快速幂O(logn)

class Solution {
public:
    double myPow(double x, int n) {
        if(n == 0) return 1;
        if(n == 1) return x;
        if(x == 1) return 1;
        //快速幂 先将幂为负数的转成整数 x也要变成分数 
        long num = n;
        if(num < 0){
            num = -num;
            x = 1/x;
        }
        double ans = 1;
        while(num){
            if(num&1) ans*=x;
            x *= x;
            num >>= 1;
        }
        return ans;
    }
};

剑指 Offer 17. 打印从1到最大的n位数

class Solution {
public:
    vector printNumbers(int n) {
        vector result;
        if(n == 0) return result;
        int num = 1;
        for(int i=1;i<=n;i++) num = num*10; 
        for(int i=1;i

剑指 Offer 18. 删除链表的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        //建立虚拟头节点 使得首尾结点删除更方便
        ListNode *Head = new ListNode(-1);
        Head->next = head;
        ListNode *p = Head;
        //如果最后1个是要被删除的
        //那么只会遍历到倒数第二个 所以无bug
        while(p->next){
            if(p->next->val == val){
                p->next = p->next->next;
                break;
            }
            p = p->next;
        }
        return Head->next;
    }
};

剑指 Offer 20. 表示数值的字符串

条件大模拟

首先要删除字符串首尾空格

1..前面不能出现.和e

2.e前面不能出现e，也不能没有数字

3.1e-3 是正确的，+和-只能出现在首部，或者e后

4.不能出现 - + e 数字 外的字符

class Solution {
public:
    bool isNumber(string str) {
        if(str.length() == 0) return false;
        bool numSeen = false;
        bool dotSeen = false;
        bool eSeen = false;
        string s = str;
        s.erase(0,s.find_first_not_of(" "));
        s.erase(s.find_last_not_of(" ") + 1);
        for(int i=0;i= '0' && s[i] <= '9') numSeen = true;
            else if(s[i] == '.'){
                //.前面不能出现.和e
                if(dotSeen || eSeen) return false;
                dotSeen = true;
            }else if(s[i] == 'e' || s[i] == 'E'){
                //e前面不能出现e 不能没有数字
                if(eSeen || !numSeen) return false;
                eSeen = true;
                numSeen = false; //重置e后面的num了
            }else if(s[i] == '-' || s[i] == '+'){
                //1e-3 是正确的
                if(i != 0 && s[i-1] != 'e' && s[i-1] != 'E') return false;
            }else return false;
        }
        return numSeen;
    }
};

方法二，DFA自动机转移，读入字符转移，看最终能否到达终态

参考题解

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

class Solution {
public:
    vector exchange(vector& nums) {
        if(nums.size() == 0) return nums;
        int n = nums.size();
        vector result,temp;
        for(int i = 0;i

剑指 Offer 22. 链表中倒数第k个节点

建立虚拟头节点

建立两个指针，第二个指针提前移动k个距离，即两个指针最后相距k

同时移动两个指针，当第二个指针为空时(到了链表末尾)，次数第一个指针指向的位置就是倒数第k个节点，返回第一个指针即可

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* list, int k) {
        ListNode *head = new ListNode(-1);
        head->next = list;
        ListNode* p = head;
        ListNode* q = head;
        int pos = 0;
        while(pos < k){
            q = q->next;
            pos++;
        }
        while(q){
            q = q->next;
            p = p->next;
        }
        return p;
    }
};

剑指 Offer 24. 反转链表

/**
 * 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) return head;
        ListNode* a = head;
        ListNode* b = a->next;
        while(b){
            ListNode* c = b->next;
            b->next = a;
            a = b,b = c;
        }
        head->next = NULL;
        head = a;
        return head;
    }
};

剑指 Offer 25. 合并两个排序的链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *p = l1;
        ListNode *q = l2;
        ListNode *head = new ListNode(-1);
        ListNode *dummy = head;
        while(p && q){
            if(p->val <= q->val){
                head->next = p;
                head = head->next;
                p = p->next;
            }else{
                head->next = q;
                head = head->next;
                q = q->next;
            }
        }
        if(p) head ->next = p,p = p->next;
        if(q) head ->next = q,q = q->next;
        return dummy->next;
    }
};

剑指 Offer 27. 二叉树的镜像

交换左右节点，递归子树

/**
 * 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* mirrorTree(TreeNode* root) {
        dfs(root);
        return root;
    }
    void dfs(TreeNode* root){
        if(root == NULL) return;
        swap(root->left,root->right);
        if(root->left) dfs(root->left);
        if(root->right) dfs(root->right);
    }
};

剑指 Offer 28. 对称的二叉树

一个空一个不同，false

两个都空，true

1.比较当前两结点的值 是否相等

2.比较p结点左子树和q结点右子树

3.比较p结点右子树和q结点左子树

/**
 * 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 isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return dfs(root->left,root->right);
    }
    bool dfs(TreeNode* p,TreeNode* q){
        if(p && !q || q && !p) return false;
        if(!p && !q) return true;
        return p->val == q->val && dfs(p->left,q->right) && dfs(p->right,q->left);
    }
};

剑指 Offer 29. 顺时针打印矩阵

按右下左上到底的顺序模拟

class Solution {
public:
    vector spiralOrder(vector>& matrix) {
        bool vis[110][110];
        memset(vis,false,sizeof(vis));
        vector ans;
        int n = matrix.size();
        if(n == 0) return ans;
        int m = matrix[0].size();
        int x = 0,y = 0;
        vis[x][y] = 1;
        ans.push_back(matrix[x][y]);
        while(1){
            //右 下 左 上
            //右
            bool flag = false;
            while(y+1 < m && vis[x][y+1] == 0) {
                y++;
                vis[x][y] = 1;
                ans.push_back(matrix[x][y]);
                flag = true;
            }
            //下
            while(x+1 < n && vis[x+1][y] == 0){
                x++;
                vis[x][y] = 1;
                ans.push_back(matrix[x][y]);
                flag = true;
            }
            //左
            while(y-1>=0 && vis[x][y-1] == 0){
                y--;
                vis[x][y] = 1;
                ans.push_back(matrix[x][y]);
                flag = true;
            }
            //上
            while(x-1>=0 && vis[x-1][y] == 0){
                x--;
                vis[x][y] = 1;
                ans.push_back(matrix[x][y]);
                flag = true;
            }
            if(!flag) break;
        }
        return ans;
    }
};

剑指 Offer 30. 包含min函数的栈

两个栈模拟，维护栈顶最小的栈push的时候，让x与栈顶(最小)比较，插入小的

class MinStack {
public:
    stack stk;
    stack minStk;
    /** initialize your data structure here. */
    MinStack() {

    }
    
    void push(int x) {
        stk.push(x);
        if(minStk.size() && minStk.top() < x){
            minStk.push(minStk.top());
        }else minStk.push(x);
    }
    
    void pop() {
        if(stk.size()){
            stk.pop();
            minStk.pop();
        }
    }
    
    int top() {
        return stk.top();
    }
    
    int min() {
        if(minStk.size())
            return minStk.top();
        else return -1;
    }
};

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

剑指 Offer 31. 栈的压入、弹出序列

​ 辅助栈 用于模拟后进先出的pushed栈

​ 遍历pushed 每次加入i值

​ 当stk栈顶与popped栈顶值匹配时 while循环pop匹配

​ 最后比较pos下标到达m 表示完全匹配上

class Solution {
public:
    bool validateStackSequences(vector& pushed, vector& popped) {
        int pos = 0;
        int n = pushed.size(),m = popped.size();
        //辅助栈 后进先出
        stack stk; 
        if(n != m) return false;
        //遍历pushed 每次加入i值
        //当stk栈顶与popped栈顶值匹配时 while循环pop匹配
        //最后比较pos下标到达m 表示完全匹配上
        for(int i = 0;i

剑指 Offer 26. 树的子结构

思路：

先bfs搜索到所有与B树的根节点值相同的节点。

然后遍历所有与B根相同的根节点，dfs递归判断是否有子结构与B相同的子树。

dfs成立条件见代码

/**
 * 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 isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL || B==NULL) return false;
        queue q;
        vector roots; 
        q.push(A);
        while(!q.empty()){
            TreeNode* top = q.front();
            if(top->val == B->val) roots.push_back(top);
            q.pop();
            if(top->left) q.push(top->left);
            if(top->right) q.push(top->right);
        }
        for(int i=0;ival == q->val && 
        dfs(p->left,q->left) && dfs(p->right,q->right);
    }
};

思路二

把思路一中的bfs找子树，换成递归判断A的左右子树与B比较

class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if (A == nullptr || B == nullptr) {
            return false;
        }
        if(A->val != B->val) return false;
        return hasSubStructure(A, B) 
        || isSubStructure(A->left, B) 
        || isSubStructure(A->right, B);
    }
    bool hasSubStructure(TreeNode* A, TreeNode* B) {
        if (B == nullptr) {
            return true;
        }
        if (A == nullptr) {
            return false;//在不满足b为nullptr但是A变成了空
        }
        if (A->val != B->val) {
            return false;
        }
        return hasSubStructure(A->left, B->left) 
        && hasSubStructure(A->right, B->right);
    }
};

剑指 Offer 32 - I. 从上到下打印二叉树

bfs层序遍历

class Solution {
public:
    vector levelOrder(TreeNode* root) {
        vector result;
        if(root == NULL) return result;
        queueq;
        q.push(root);
        while(!q.empty()){
            TreeNode* top = q.front();
            q.pop();
            result.push_back(top->val);
            if(top->left) q.push(top->left);
            if(top->right) q.push(top->right);
        }
        return result;
    }
};

剑指 Offer 32 - II. 从上到下打印二叉树 II

dfs深度优先遍历，以深度depth为参数

class Solution {
public:
    
    vector> levelOrder(TreeNode* root) {
        vector> result(1001,vector(0));
        vector> ans;
        if(!root) return ans;
        dfs(root,0,result);
        for(int i=0;i>& result){
        if(!root) return;
        result[depth].push_back(root->val);
        dfs(root->left,depth+1,result);
        dfs(root->right,depth+1,result);
    }
};

bfs层序也行，但与32-I题区别是，bfs每次要把上一层队列的值出队完。以保证能把下一层的节点都入队

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        vector> ans;
        if(root == nullptr)     return ans;
        queue myQue;
        myQue.push(root);
        while(!myQue.empty()){
            vector tmp;
            int size = myQue.size();
            for(;size--;myQue.pop()){
                auto node = myQue.front();
                if(node->left)  myQue.push(node->left);
                if(node->right) myQue.push(node->right);               
                tmp.push_back(node->val);
            }
            ans.push_back(tmp);
        }
        return ans;
    }
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

比32-II多一次奇数层，反转

class Solution {
public:
    vector> levelOrder(TreeNode* root) {
        vector> ans;
        if(root == nullptr)     return ans;
        queue myQue;
        myQue.push(root);
        while(!myQue.empty()){
            vector tmp;
            int size = myQue.size();
            for(;size--;myQue.pop()){
                auto node = myQue.front();
                if(node->left)  myQue.push(node->left);
                if(node->right) myQue.push(node->right);               
                tmp.push_back(node->val);
            }
            ans.push_back(tmp);
        }
        for(int i=0;i

思路二，用java的ArrayList，偶数层尾插，奇数层头插

原作者：麦宇恒

class Solution {
    List> res = new ArrayList<>();
    public List> levelOrder(TreeNode root) {
        helper(root,0);
        return res;
    }

    private void helper(TreeNode root,int level){
        if(root==null)
            return;
        if(res.size()==level){
        	//加入新的一层 初始化 这个if直得学习
            res.add(new ArrayList<>());
        }
        if(level%2==0){
            res.get(level).add(root.val);
        }else{
            res.get(level).add(0,root.val);
        }
        helper(root.left,level+1);
        helper(root.right,level+1);
    }
}

同样也可以用C++的deque双端队列

push_back 尾插

push_front 头插

明天要把32-II的dfs vector >的初始化给优化一下啊

剑指 Offer 34. 二叉树中和为某一值的路径

class Solution {
public:
    vector> results;
    int cnt;
    vector> pathSum(TreeNode* root, int sum) {
        if(root==NULL) return results;
        cnt = sum;
        vector result;
        dfs(root,0,result);
        return results;
    }
    void dfs(TreeNode* root,int sum,vector result){
        if(root == NULL) 
            return;
        result.push_back(root->val);
        sum += root->val;
        if(sum == cnt){
            if(!root->left && !root->right){
                results.push_back(result);
                result.pop_back();
                return;
            }
        }
        if(root->left){
            dfs(root->left,sum,result);
        }
        if(root->right){
            dfs(root->right,sum,result);
        }
        result.pop_back();
    }
};

*剑指 Offer 33. 二叉搜索树的后序遍历序列

方法一：递归、分治。

后序遍历序列的倒数第一个元素尾根。

二叉搜索树的根，能把子树 划分为两部分，一部分的值都小于根，另一部分的值都大于根，否则就不满足二叉搜索树的定义(即序列不能划分为左边一端小于根的、右边一端都大于根的两部分)

参考题解

class Solution {
public:
    bool verifyPostorder(vector& postorder) {
        return dfs(postorder,0,postorder.size()-1);
    }

    bool dfs(vector& postorder,int l,int r){
        //子树 只有1个节点 说明到了叶结点 返回true
        if(l >= r) return true;
        int pos = l;
        //左子树 都比根小 
        //根就是后序序列的r右编辑postorder[r]) pos++;
        int mid = pos - 1;
        //右子树 都比根大
        while(pos<=r && 
        postorder[pos] > postorder[r]) pos++;
        //最终pos一定要等于r  否则说明pos~r之间还有小于根对应值的
        //即根能划分成左右两部分 一份小于根 一份大于根
        //否则就不满足 二叉搜索树 右子树
        return pos == r 
        && dfs(postorder,l,mid) && dfs(postorder,mid+1,r-1);
    }
};

方法二：单调栈

参考地址

class Solution {
public:
    bool verifyPostorder(vector& postorder) {
        stack stk;
        int pre = INT_MAX;
        for(int i=postorder.size()-1;i>=0;i--){
            //pre表示当前i的根 左子树必须要小于
            if(postorder[i] > pre) return false;
            //满足while 就进入左子树了 要找到根 就要把之前比i大的都弹出
            while(stk.size() && postorder[i] < stk.top()){
                pre = stk.top();
                stk.pop();//弹出右边的树
            }
            stk.push(postorder[i]);
        }
        return true;
    }
};

剑指 Offer 39. 数组中出现次数超过一半的数字

哈希表

class Solution {
public:
    int majorityElement(vector& nums) {
        int n = nums.size();
        map mp;
        for(int i = 0; i< nums.size();i++){
            mp[nums[i]]++;
            if(mp[nums[i]] > n/2) return nums[i];
        }
        return -1;
    }
};

学习摩尔投票法

class Solution {
public:
    vector getLeastNumbers(vector& arr, int k) {
        sort(arr.begin(),arr.end());
        return vector(arr.begin(),arr.begin()+k);
    }
};

学习topK大根堆

//升序队列，小顶堆
priority_queue ,greater > q;
//降序队列，大顶堆
priority_queue ,less >q;

//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

控制大根堆的size始终保持k，如果新进入堆中一个元素，并且队头(最大值)比当前元素小，就pop队头，即始终保持k个最小

class Solution {
public:
    vector getLeastNumbers(vector& arr, int k) {
        vector result;
        if(k == 0) return result;
        //大根堆
        priority_queue heap;
        for(int i=0;i arr[i]){
                    heap.pop();
                    heap.push(arr[i]);
                }
            }
        }
        while(!heap.empty()){
            result.push_back(heap.top());
            heap.pop();
        }
        return result;
    }
};

剑指 Offer 42. 连续子数组的最大和

dp[i]: 数组中前i个连续子数组的最大和

dp[i] 只可以由 dp[i-1]转移 所以思考得出状态转移方程

dp[i] = max(dp[i-1] + nums[i] , nums[i]);

class Solution {
public:
    int maxSubArray(vector& nums) {

        int n = nums.size();
        if(n == 0) return 0;
        vectordp(n);
        dp[0] = nums[0];//初始化
        int ans = nums[0];
        for(int i=1;i

剑指 Offer 35. 复杂链表的复制

哈希表存储旧节点----新节点的映射

遍历一原链表，查map找到映射的新节点，建立新的链表

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL) return head;
        map mp;
        //存储新旧节点映射 node 映射 node'
        for(Node* cur = head;cur != NULL;cur = cur->next)
            mp[cur] = new Node(cur->val);
        //拷贝节点
        for(Node* cur = head;cur != NULL;cur = cur->next){
            mp[cur]->next = mp[cur->next];
            mp[cur]->random = mp[cur->random];
        }
        //返回新节点的头部
        return mp[head];
    }
};

剑指 Offer 50. 第一个只出现一次的字符

哈希表

class Solution {
public:
    char firstUniqChar(string s) {
        char ans = ' ';
        map mp;
        for(char c : s){
            mp[c]++;
        }
        for(char c : s){
            if(mp[c] == 1){
                return c;
            }
        }
        return ans;
    }
};

剑指 Offer 51. 数组中的逆序对

思路：树状数组 + 离散化

逆序: 前i-1个中比nums[i]小的数的个数

树状数组维护每个数字出现的次数

当前这个时间点i下的逆序数个数 = 已经有的个数i - 前面出现过的数字中比nums[i]小的个数getsum(nums[i])

因为出现了负值，所以要对原数据离散化

class Solution {
public:
    int c[50010];

    int lowbit(int x){
        return x & -x;
    }

    void update(int x,int v,int n){
        while(x <= 50000){
            c[x] += v;
            x += lowbit(x);
        }
    }

    int getSum(int x){
        int res = 0;
        while(x>=1){
            res += c[x];
            x -= lowbit(x);
        }
        return res;
    }

    long long getSum(long long x){
        long long res = 0;
        while(x){
            res += c[x];
            x -= lowbit(x);
        }
        return res;
    }

    int reversePairs(vector& nums) {
        int n = nums.size();
        vector temp(nums);
        //离散化开始
        sort(temp.begin(),temp.end());
        int num = unique(temp.begin(),temp.end()) - temp.begin();
        for(int i=0;i

160. 相交链表

两个链表头指针都走完，公共部分 + A的非公共部分 + B的非公共部分 时会重合

1当头节点到末尾时，把指针指向另一个链表的头节点。

2跑到公共部分 + A的非公共部分 + B的非公共部分 时会重合

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //当快的链表先到达时末尾 移动到另一个链表开头 交换重新开始移动
        ListNode* p = headA;
        ListNode* q = headB;
        while(p && q){
            p = p->next;
            q = q->next;
        }
        //都跑a+b+c段距离会重合
        if(!p){
            p = headB;
            while(q){
                q = q->next;
                p = p->next;
            }
            q = headA;
        }else{
            q = headA;
            while(p){
                p = p->next;
                q = q->next;
            }
            p = headB;
        }
        while(p && q && p!=q){
            p = p->next;
            q = q->next;
        }
        return p;
    }
};

简单写法

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto tempHeadA = headA;
        auto tempHeadB = headB;
        while(tempHeadA != tempHeadB){
            if(tempHeadA) tempHeadA = tempHeadA->next;
            else tempHeadA = headB;
            if(tempHeadB) tempHeadB = tempHeadB->next;
            else tempHeadB = headA;
        }
        return tempHeadB;
    }
};

剑指 Offer 53 - I. 在排序数组中查找数字 I

STL二分

class Solution {
public:
    int search(vector& nums, int target) {
        return upper_bound(nums.begin(),nums.end(),target) 
        - lower_bound(nums.begin(),nums.end(),target);
    }
};

手写二分

找满足(==target)最大值最小的下标

找满足(>target)最大值最小的下标

二者相减

class Solution {
public:
    int search(vector& nums, int target) {
        int n = nums.size();
        if(n == 0) return 0;
        if(n == 1) {
            if(nums[0] == target) return 1;
            return 0;
        }
        //找满足(==target)最大值最小的下标
        int l = 0, r = n;
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums[mid] >= target){
                r = mid;
            }else{
                l = mid + 1;
            }
        }
        int lowPos = r;
        //找满足(>target)最大值最小的下标
        l = 0,r = n;
        while(l < r){
            int mid = (l + r) >> 1;
            if(nums[mid] > target){
                r = mid;
            }else{
                l = mid + 1;
            }
        }
        int highPos = r;
        return highPos - lowPos;
    }
};

剑指 Offer 53 - II. 0～n-1中缺失的数字

class Solution {
public:
    int missingNumber(vector& nums) {
        for(int i=0;i

二分

左半段mid都等于nums[mid]，右半段都不等于

所以二分最大的最小满足的点

class Solution {
public:
    int missingNumber(vector& nums) {
        int left = 0, right = nums.size();
        while(left < right){
            int mid = (left + right)/2;
            if(mid == nums[mid]) left = mid + 1;
            else right = mid;
        }
        return left;
    }
};

剑指 Offer 55 - I. 二叉树的深度

递归max(左右子树的深度) + 1

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

剑指 Offer 54. 二叉搜索树的第k大节点

思路：二叉搜索树的中序遍历就是有序的递增序列，所以只要中序遍历得出序列，并且统计出节点个数cnt，返回第k大也就是下标为cnt-k小的数

class Solution {
public:
    int cnt = 0;
    int kthLargest(TreeNode* root, int k) {
        if(root == NULL) return 0;
        if(k == 0) return root->val;
        vector inOrder;
        dfs(root,inOrder);
        return inOrder[cnt - k];
    }

    void dfs(TreeNode* root,vector& inOrder){
        if(root == NULL) return;
        if(root->left) dfs(root->left,inOrder);
        cnt++;
        inOrder.push_back(root->val);
        if(root->right) dfs(root->right,inOrder);
    }
};

剑指 Offer 55 - II. 平衡二叉树

判断当前节点是否满足，左子树深度 与 右子树深度差为1

递归判断左右子树是否满足

中序遍历，时间复杂度O(n)

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(root == NULL) return true;
        if(abs(dfs(root->left) - dfs(root->right) ) <= 1){
            return isBalanced(root->left)
            && isBalanced(root->right);
        }
        return false;
    }
    int dfs(TreeNode* root){
        if(root == NULL) return 0;
        return max(dfs(root->left)+1,dfs(root->right)+1);
    }
};

思路二：中序遍历的倒序序列，第k个才是第k大；正序的中序遍历是第k小。所以为了倒序先遍历右子树，再遍历根，再遍历左子树

class Solution {
public:
    int cnt = 0;
    int ans = 0;
    int kthLargest(TreeNode* root, int k) {
        if(root == NULL) return 0;
        if(k == 0) return root->val;
        dfs(root,k);
        return ans;
    }

    void dfs(TreeNode* root,int k){
        if(root == NULL) return;
        if(root->right) dfs(root->right,k);
        if(++cnt == k) {
            ans = root->val;
            return;
        }
        if(root->left) dfs(root->left,k);
    }
};

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

先把中序序列存下来

然后建立双向链表

因为先存下中序序列，然后开辟新结点，所以空间复杂度较高

class Solution {
public:
    Node* treeToDoublyList(Node* root) {
        if(!root) return NULL;
        vector result;
        dfs(root,result);
        Node * head = new Node(result[0]);
        Node * last = head;
        for(int i=1;ileft = last;
            last->right = cur;
            last = last->right;
        }
        last->right = head;
        head->left = last;
        return head;
    }
    void dfs(Node* root,vector& result){
        if(!root) return ;
        if(root->left) dfs(root->left,result);
        result.push_back(root->val);
        if(root->right) dfs(root->right,result);
    }
};

思路二：递归实现，在中序遍历的过程中维护前驱，以及前驱结点的后继，类似于线索二叉树

class Solution {
public:
    Node* head,*pre = NULL;
    Node* treeToDoublyList(Node* root) {
        if(root == NULL) return NULL;
        dfs(root);
        pre->right = head;
        head->left = pre;
        return head;
    }

    void dfs(Node *root){
        if(!root) return;
        if(root->left) dfs(root->left);
        
        if(pre == NULL){
            //中序序列的第一个为头节点
            head = root;
            pre = root;
        }else{
            //1.维护当前结点的前驱
            //2.维护当前结点前驱的后继
            root->left = pre;
            pre->right = root;
            pre = root;
        }
        if(root->right) dfs(root->right);
    }
};

剑指 Offer 57. 和为s的两个数字

二分查找

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        int n = nums.size();
        int ans = 0;
        for(int i=0;i target) break;
            int pos = lower_bound(nums.begin(),
            nums.end(),target-nums[i]) - nums.begin();
            if(pos < n && nums[i] + nums[pos] == target){
                ans = nums[i];
                break;
            }
        }
        return {ans,target-ans};
    }
};

剑指 Offer 58 - I. 翻转单词顺序

class Solution {
public:
    string reverseWords(string s) {
        vector result;
        string buffer = "";
        for(int i = 0; i < s.length();i++){
            if(s[i] == ' '){
                if(buffer != ""){
                    result.push_back(buffer);
                    buffer = "";
                }
            }else{
                buffer += s[i];
            }
        }
        if(buffer != "") result.push_back(buffer);
        reverse(result.begin(),result.end());
        string ans = "";
        int n = result.size();
        for(int i=0;i

剑指 Offer 56 - I. 数组中数字出现的次数

二进制运算详细专题

重复的数字进行分组，很简单，只需要有一个统一的规则，就可以把相同的数字分到同一组了。例如：奇偶分组。因为重复的数字，数值都是一样的，所以一定会分到同一组！

对 i & -i 的位进行分组，

class Solution {
public:
    vector singleNumbers(vector& nums) {
        int n = nums.size();
        int sum = 0;
        for(int i=0;i

nums[i] & pos理解不了了啊

剑指 Offer 58 - II. 左旋转字符串

字符串模拟

class Solution {
public:
    string reverseLeftWords(string s, int k) {
        int n = s.length();
        string temp = "";
        for(int i=0;i

库函数

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        return s.substr(n)+s.substr(0,n);
    }
};

剑指 Offer 45. 把数组排成最小的数

to_string 将数字转换为字符串

对字符串组合排序 a+b < b + a 小的排在前面

class Solution {
public:
    string minNumber(vector& nums) {
        vector vec;
        for(int i=0;i

剑指 Offer 46. 把数字翻译成字符串

思路：dp

集合：dp[i] 表示前i个不同的方案数

状态转移：考虑dp[i]可以有哪些字符串转移过来

1.由dp[i-1]转移过来

2.当num[i-1] == 1 时 可以由dp[i-2] 转移过来

3.当num[i-1] == 2 且 num[i] <=5 时 可以由dp[i-2]转移过来

dp[i] = dp[i-1];

if(arr[i-1] == 1 || (arr[i-1] == 2 && arr[i] <= 5) dp[i] += dp[i-2];

判断边界

初始化dp[0] = 1;

class Solution {
public:
    int translateNum(int num) {
        //dp[i] 表示前i个不同的方案数
        //考虑dp[i]可以有哪些字符串转移过来
        //1.由dp[i-1]转移过来
        //2.当num[i-1] == 1 时 可以由dp[i-2] 转移过来
        //3.当num[i-1] == 2 且 num[i] <=5 时 可以由dp[i-2]转移过来
        if(num == 0) return 1;
        int len = 0;
        int temp = num;
        vector arr;
        while(temp){
            arr.push_back(temp%10);
            temp /= 10;
        }
        reverse(arr.begin(),arr.end());
        int n = arr.size();
        vector dp(n,0);
        dp[0] = 1;
        for(int i=1;i= 2){
                    dp[i] += dp[i-2];
                }else{
                    dp[i] += 1;
                }
            }
        }
        return dp[n-1];
    }
};

剑指 Offer 47. 礼物的最大价值

坐标dp

dp(i,j)表示在坐标(i,j)下能拿到礼物的所有集合 中的 礼物的最大价值

dp(i,j)可以由dp(i-1,j) 和 dp(i,j-1)推出来，判边界

初始化dp(0,0) = grid(0,0)

class Solution {
public:
    int maxValue(vector>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        int dp[n][m];
        memset(dp,0,sizeof(dp));
        for(int i=0;i=1) dp[i][j] = 
                    max(dp[i][j],dp[i-1][j] + grid[i][j]);
                    if(j>=1) dp[i][j] = 
                    max(dp[i][j],dp[i][j-1] + grid[i][j]);
                }
            }
        }
        return dp[n-1][m-1];
    }
};

想办法再优化成滚动数组，空间复杂度O(N)的

剑指 Offer 61. 扑克牌中的顺子

0表示可以不连续的间隔+1

统计不连续数字的间隔和，与0比较

class Solution {
public:
    bool isStraight(vector& nums) {
        int cnt = 0;
        vector vec;
        for(int i=0;i 1) 
            	cnt-=(vec[i] - vec[i-1] - 1);
        }
        return cnt >= 0;
    }
};

* 剑指 Offer 67. 把字符串转换成整数

字符串大模拟

我的代码混乱，要改！

class Solution {
public:
    int strToInt(string str) {
        long long ans = 0;
        bool flag = false;
        bool symbol = true;
        int len = str.length();
        for(int i=0;i0 && str[i-1] >= '0' && str[i-1] <= '9' && (str[i] < '0' || str[i] > '9')) break;
            if(str[i] == ' ' && !flag) continue;
            if(str[i] == ' ') return 0;
            if(!flag && (str[i] == '-' || str[i] == '+')){
                flag = true;
                if(str[i] == '-') symbol = false;
                continue;
            }
            if(str[i] < '0' || str[i] > '9') break;
            if(flag && (str[i] < '0' || str[i] >'9')) break;
            if(flag || (str[i] >= '0' && str[i] <='9') ){
                ans = ans * 10 + (str[i]-'0');
                if(symbol){
                    if(ans >= INT_MAX) return INT_MAX;
                }else{
                    if(ans * -1 <= INT_MIN) return INT_MIN;
                }
            }
        }
        return symbol==false?-1*ans:ans;
    }
};

剑指 Offer 38. 字符串的排列

使用next_permutation对字符串全排列，函数将每次返回下一次的字典序。所以需要先对字符串s字符进行字典序排序

class Solution {
public:
    vector permutation(string s) {
        sort(s.begin(),s.end());
        vector ans;
        do{
            ans.push_back(s);
        }while(next_permutation(s.begin(),s.end()));
        return ans;
    }
};

dfs搜索+set去重

class Solution {
public:
    vector res;
    set se;
    vector permutation(string s) {
        sort(s.begin(),s.end());
        vector temp;
        for(int i=0;i& temp,int left){
        if(left == temp.size()-1){
            string ans;
            for(int i=0;i

dfs交换 不需要去重的写法

1.不用&

2.不用回溯

class Solution {
public:
    vector res;
    vector permutation(string s) {
        sort(s.begin(),s.end());
        vector temp;
        for(int i=0;i temp,int left){
        if(left == temp.size()-1){
            string ans;
            for(int i=0;i

去重关键：如果pos和i之间有字符等于s[i]，则跳过。

class Solution {
public:
    vector result;
    vector permutation(string s) {
        dfs(s, 0);
        return result;
    }
    void dfs(string& s, int pos) {
        if (pos >= s.size()) {
            result.push_back(s);
            return;
        }
        for (int i = pos; i < s.size(); ++i) {
        	// 如果pos和i之间有字符等于s[i]，则跳过。
            if (judge(s, pos, i)) continue;   
            swap(s[pos], s[i]);
            dfs(s, pos+1);
            swap(s[pos], s[i]);
        }
    }

    bool judge(string& s, int start, int end) {
        for (int i = start; i < end; ++i) {
            if (s[i] == s[end]) return true;
        }
        return false;
    }
};

作者：yuexiwen
链接：https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof/solution/c-dfs-mian-shi-ti-38-zi-fu-chuan-de-pai-lie-by-yue/

*剑指 Offer 43. 1～n整数中1出现的次数

题解

数位dp思想，模拟出来

int getRest(stack s){
    s.pop();
    int res = 0;
    while(!s.empty()){
        res = res * 10 + s.top();
        s.pop();
    }
    return res + 1;
}

int countDigitOne(int n) {
    // 计算f(1~10)
    vectorhelp = vector(11);
    help[1] = 1;
    for(int i = 2; i < help.size(); i++){
        help[i] = pow(10, i - 1) + 10 * help[i - 1];
    }
    
    //用栈来记录数字的各个位数上的值
    stack s = stack();
    while(n){
        s.push(n % 10);
        n /= 10;
    }
    //res 记录结果
    long res = 0;
    while(!s.empty()){
        int size = s.size();
        int top = s.top();
        //判断个位
        if(size == 1){
            // 如果个位为0则不++  如果个位不为0 则增加一个1个数
            if(top != 0)    res += help[1];
        }
        else{
            //判断除了个位的其他位
            if(top > 1)   res += pow(10, s.size() - 1);
            else if(top == 1)   res += getRest(s);
            res += top * help[size - 1];
        }
        s.pop();
    }
    return res;
}

*剑指 Offer 44. 数字序列中某一位的数字

找规律

题解

    int findNthDigit(int n){
        long int base = 9;
        int p = 1;
        while((n - base * p) > 0){
            n -= base * p;
            base *= 10;
            p += 1;
        }
        int number = 1;
        for(int i = p; i > 1; --i){
            number *= 10;
        }
        number += n / p;
        int re;
        if(n % p == 0){
            re = (number - 1) % 10;
        }
        else {
            for(int i = 0; i < p - n % p; ++i){
                number /= 10;
            }
            re = number % 10;
        }
        return re;
    }

剑指 Offer 48. 最长不含重复字符的子字符串

双指针，保证l~r区间内无重复下移动r++扩大区间，如果有重复值了让左指针l移动到重复的下一个(当重复位置大于L时才移动)，更新区间最大长度答案

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        map mp;
        int ans = 0,l = 0,r = 0;
        while(r < s.length()){
            if(mp.find(s[r]) != mp.end()){
                l = max(l,mp[s[r]] + 1);
            }
            mp[s[r]] = r;
            ans = max(r-l+1,ans);
            r++;
        }
        return ans;
    }
};

剑指 Offer 49. 丑数

优先队列 每次从丑数队列中选出最小的，并分别与2、3、5相乘加入新值到队列，有可能计算会重复所以使用set去重， 第n次从队头出队的就是答案

class Solution {
public:
    int nthUglyNumber(int n) {
        priority_queue,greater > queue;
        set se;
        long long  prime[3] = {2,3,5};
        queue.push(1);
        se.insert(1);
        long long ans = 1;
        for(int i=1;i<=n;i++){
            ans = queue.top();
            queue.pop();
            for(int j=0;j<3;j++){
                if(se.find(ans*prime[j]) == se.end()){
                    se.insert(ans*prime[j]);
                    queue.push(ans*prime[j]);
                }
            }
        } 
        return ans;
    }
};

dp 题解

class Solution {
public:
    int nthUglyNumber(int n) {
        vector dp(n,0);
        dp[0] = 1;
        int p2 = 0,p3 = 0,p5 = 0;
        for(int i=1;i

剑指 Offer 56 - II. 数组中数字出现的次数 II

作者地址

class Solution {
public:
    int singleNumber(vector& nums) {
        int cnt[32];
        for(int i=0;i<32;i++) cnt[i] = 0;
        for(int i=0;i>=1;
            }
        }
        int ans = 0;
        for(int i=0;i<31;i++){
            ans = ans + (cnt[i]%3) * pow(2,i);
        }
        return ans;
    }
};

剑指 Offer 57 - II. 和为s的连续正数序列

每次使用i个数字 target表示这一次最小的是多少

下一次使用i+1个数，各元素相差增加了i，

题解参考作者xuelimin

class Solution {
public:
    vector> findContinuousSequence(int target) {
        vector> result;
        int i = 1;//几个数
        //每次使用i个数字  target表示这一次最小的是多少
        while(target > 0){
            target -= i;
            i++;
            if(target > 0 && target%i == 0){
                vector temp;
                for(int j=0;j

剑指 Offer 59 - I. 滑动窗口的最大值

单调队列，滑动窗口保持窗口大小小于k

class Solution {
public:
    vector maxSlidingWindow(vector& nums, int k) {
        vector result;
        deque queue;
        for(int i=0;i k)   
                queue.pop_front();
            //控制单调性 找到当前元素的合适位置
            while(queue.size() 
            && nums[queue.back()] < nums[i])
                queue.pop_back();
            //把当前元素加入到队尾
            queue.push_back(i);
            //保存这一轮队头 就是最大值答案
            if(queue.size() && i - k + 1 >= 0){
                result.push_back(nums[queue.front()]);
            }
        }
        return result;
    }
};

剑指 Offer 63. 股票的最大利润

如果当前价格i小于前面出现过的最小价格，就更新最小价格；

否则，就更新最大利润

class Solution {
public:
    int maxProfit(vector& prices) {
        if(prices.size() == 0) return 0;
        int n = prices.size();
        int minPrice = prices[0];
        int ans = 0;
        for(int i=0;i

思路二：dp

dp[i] 表示第i天所有方案中的最大利润，注意是第i天，不是前i天

转移方程：

1.当第i天价格比第i-1天大，说明我第i天卖出去能多卖prices[i]-prices[i-1]。

2.否则，只能与前面的minPrice作比较来判断最大利润，且差值不能小于0

每一轮都要更新minPrice

class Solution {
public:
    int maxProfit(vector& prices) {
        if(prices.size() == 0) return 0;
        int n = prices.size();
        int minPrice = prices[0];
        vector dp(n,0);
        int ans = 0;
        for(int i=1;i= prices[i-1]){
                dp[i] = dp[i-1] + prices[i]-prices[i-1];
            }else{
                dp[i] = max(prices[i]-minPrice,0);
            }
            ans = max(ans,dp[i]);
            minPrice = min(minPrice,prices[i]);
        }
        return ans;
    }
};

剑指 Offer 59 - II. 队列的最大值

使用两个队列：一个队列正常入队出队；再用一个双端队列来辅助作为单调队列，维护队头最大值。这样O(1)查询最大值就是队头的值。

入队的时候维护单调性，注意这里是可以有相同元素进入单调队列的。

出队时，如果普通队列的队头元素等于单调队列的队头，那么单调队列队头也出队

class MaxQueue {
public:
    queue queue;
    deque help;
    MaxQueue() {

    }
    
    int max_value() {
        return help.size() ? help.front() : -1;
    }
    
    void push_back(int value) {
        queue.push(value);
        while(help.size() && help.back() < value){
            help.pop_back();
        }
        help.push_back(value);
    }
    
    int pop_front() {
        if(!queue.size()) return -1;
        int topValue = queue.front();
        queue.pop();
        if(help.size() && help.front() == topValue) 
        	help.pop_front();
        return topValue;
    }
};

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

如果两个结点都在左子树上，就递归搜索左子树

如果两个结点都在右子树上，就递归搜索右子树

否则就是一个结点在左子树，另一个结点在右子树，那么root就是它们的公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL) return root;
        if(p->val < root->val && q->val < root->val){
            return lowestCommonAncestor(root->left,p,q);
        }else if(p->val > root->val && q->val > root->val){
            return lowestCommonAncestor(root->right,p,q);
        }
        return root;
    }
};

剑指 Offer 68 - II. 二叉树的最近公共祖先

1.递归出口root==NULL 或则 root == 左右孩子其中一个

2.递归找左子树上有没有两个结点，递归找右子树有没有两个结点，

3.三种情况，左子树null，两个结点都在右子树；右子树null，两个结点都在左子树；左右子树各有一个，root就是最近公共祖先

/**
 * 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* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == NULL) return NULL;
        if(root == p || root == q) return root;
        TreeNode* left = 
        	lowestCommonAncestor(root->left,p,q);
        TreeNode* right = 
        	lowestCommonAncestor(root->right,p,q);
        if(!left) return right;
        if(!right) return left;
        return root;
    }
};

剑指 Offer 62. 圆圈中最后剩下的数字

Java使用ArrayList模拟

pos = (pos + m - 1) % n 表示每一次位置上加上m对新的任务n取余

class Solution {
    public int lastRemaining(int n, int m) {
        ArrayList list = new ArrayList(n);
        for(int i=0;i<=n-1;i++) list.add(i);
        int pos = 0;
        while(n > 1){
            pos = (pos + m - 1) % n;
            list.remove(pos);
            n--;
        }
        return list.get(0);
    }
}

C++使用队列模拟，超时

class Solution {
public:
    int lastRemaining(int n, int m) {
        queue q;
        for(int i=0;i<=n-1;i++) q.push(i);
        int num = 0;
        while(q.size() > 1){
            num++;
            int top = q.front();
            q.pop();
            if(num == m){
                num = 0;
            }else{
                q.push(top);
            }
            n--;
        }
        return q.front();
    }
};

数学方法约瑟夫环

https://blog.csdn.net/u011500062/article/details/72855826

剑指 Offer 66. 构建乘积数组

思路本质是构造一个矩阵，让下三角和上三角相乘。

下三角从0往下推用到i-1；上三角从n往上推用到i+1；

参考题解原作者

class Solution {
public:
    vector constructArr(vector& a) {
        int n = a.size();
        if(n == 0) return a;
        vector result(n);
        vector left(n,0);
        vector right(n,0);
        left[0] = 1;
        right[n-1] = 1;
        for(int i=1;i=0;i--) right[i] = right[i+1]*a[i+1];
        for(int i=0;i