剑指Offer(leetcode版)

剑指Offer-03 数组中重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内,数组中某些数字是重复的,但不知道有几个数字重复了,也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：
2 或 3

代码a

class Solution {
   
public:
    int findRepeatNumber(vector<int>& a) {
   
        int n=a.size();
        if(!n) return -1;
        
        for(int i=0;i<n;i++)
        {
   
            while(a[i]!=a[a[i]]) 
            swap(a[i],a[a[i]]);
        
            if(i!=a[i]) return a[i];
        }
        return -1;
    }
};

代码b

class Solution {
   
public:
    int findRepeatNumber(vector<int>& nums) {
   
        int c[100010]={
   0};
        for(auto e:nums)
            c[e]++;
        for(int i=0;i<nums.size();i++)
            if(c[i]>1)        
                return i;
                
        return 0;
    }
};

---

剑指Offer-04 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。

class Solution {
   
public:
    bool findNumberIn2DArray(vector<vector<int>>& a, int target) {
   
        if(a.empty())   return 0;
        int i=0,j=a[0].size()-1;
        while(i<a.size()&&j>=0)
        {
   
            if(a[i][j]==target) return 1;
            if(a[i][j]>target) j--;
            else i++;
        }
        return 0;
    }
};

---

剑指Offer-05 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”

class Solution {
   
public:
    string replaceSpace(string s) {
   
        string res;
        for(auto ch:s)
            if(ch==' ')
                res+="%20";
            else 
                res+=ch;
        return res;
    }
};

---

剑指Offer-06 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]

class Solution {
   
public:
    vector<int> reversePrint(ListNode* head) {
   
        vector<int> res;
        while(head)
        {
   
            res.push_back(head->val);
            head=head->next;
        }
        for(int i=0,j=res.size()-1;i<j;i++,j--)
            swap(res[i],res[j]);
        
        return res;
    }
};

---

剑指Offer-07 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/  \
9 20
     / \
   15 7

class Solution {
   
public:
    unordered_map<int,int> pos;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
   
        int n = preorder.size();
        for (int i = 0; i < n; i ++ )
            pos[inorder[i]] = i;
        return dfs(preorder, inorder, 0, n - 1, 0, n - 1);
    }

    TreeNode* dfs(vector<int>&pre, vector<int>&in, int pl, int pr, int il, int ir)
     {
   
        if (pl > pr) return NULL;
        int k = pos[pre[pl]] - il;
        TreeNode* root = new TreeNode(pre[pl]);
        root->left = dfs(pre, in, pl + 1, pl + k, il, il + k - 1);
        root->right = dfs(pre, in, pl + k + 1, pr, il + k + 1, ir);
        return root;
    }
};

---

剑指Offer-09 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

输入：
[“CQueue”,“appendTail”,“deleteHead”,“deleteHead”]
[[],[3],[],[]]
输出：
[null,null,3,-1]

class CQueue {
   
public:
    stack<int> A,B;

    CQueue() {
   }
    
    void appendTail(int value) {
   
        A.push(value);
    }
    
    int deleteHead() {
   
        if(B.size())
        {
   
            int t=B.top();
            B.pop();
            return t;
        }
        
        if(A.empty()) return -1;

        while(A.size())
        {
   
            int t=A.top(); A.pop();
            B.push(t);
        }

        int t=B.top();
        B.pop();
        return t;
    }
};

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

---

剑指Offer-10-I 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：1
示例 2：
输入：n = 5
输出：5

代码a

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

代码b

class Solution {
   
public:
    int fib(int n) {
   
        if(n<2) return n;
        const int mod=1e9+7;
        int a=0,b=1,c;
        for(int i=2;i<=n;i++)
        {
   
            c=(a+b)%mod;
            a=b;
            b=c;
        }
        return b;
    }
};

---

剑指Offer-10-II 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：2
示例 2：
输入：n = 7
输出：21
示例 3：
输入：n = 0
输出：1
提示：
0 <= n <= 100

class Solution {
   
public:
    int numWays(int n) {
   
        const int mod=1e9+7;
        int a=1,b=1,c;
        for(int i=0;i<n;i++)
        {
   
            c=(a+b)%mod;
            a=b;
            b=c;
        }
        return a;
    }
};

剑指Offer-11 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
示例 1：
输入：[3,4,5,1,2]
输出：1
示例 2：
输入：[2,2,2,0,1]
输出：0

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

剑指Offer-12 矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]
但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。
示例 1：
输入：
board =
[[“A”,“B”,“C”,“E”],
[“S”,“F”,“C”,“S”],
[“A”,“D”,“E”,“E”]],
word = “ABCCED”
输出：true
示例 2：
输入：
board =
[[“a”,“b”],
[“c”,“d”]],
word = “abcd”
输出：false
提示：
1 <= board.length <= 200
1 <= board[i].length <= 200

class Solution {
   
public:
    bool exist(vector<vector<char>>& a, string &str) {
   
        for(int i=0;i<a.size();i++)
            for(int j=0;j<a[i].size();j++)
                if(dfs(a,str,0,i,j))    
                    return true;
        return false;
    }
    bool dfs(vector<vector<char>>& a,string &str,int u,int x,int y)
    {
   
        if(a[x][y]!=str[u]) return false;
        if(u==str.size()-1) return true;
        int dx[4]={
   0,0,-1,1},dy[4]={
   -1,1,0,0};
        char ch=a[x][y];
        a[x][y]='+';
        
        for(int i=0;i<4;i++)
        {
   
            int xx=x+dx[i],yy=y+dy[i];
            if(xx>=0 && xx<a.size() && yy>=0 && yy<a[0].size())
                if(dfs(a,str,u+1,xx,yy))
                    return true;
        }
        
        a[x][y]=ch;
        return false;
    }
};

剑指Offer-13 机器人的运动范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
示例 1：
输入：m = 2, n = 3, k = 1
输出：3
示例 2：
输入：m = 3, n = 1, k = 0
输出：1
提示：
1 <= n,m <= 100
0 <= k <= 20

class Solution {
   
public:
    int f(int x)
    {
   
        int s=0;
        while(x) s+=x%10,x/=10;
        return s;
    }
    int get_sum(pair<int,int> t)
    {
   
        return f(t.first)+f(t.second);
    }
    int movingCount(int threshold, int rows, int cols)
    {
   
        if(!rows || !cols) return 0;
        queue<pair<int,int>> q;
        vector<vector<bool>> st(rows,vector<bool> (cols));
        int dx[4]={
   0,0,1,-1},dy[4]={
   -1,1,0,0};
        int res=0;
        q.push({
   0,0});
        while(q.size())
        {
   
            auto t=q.front();q.pop();
            if(st[t.first][t.second] || get_sum(t)>threshold) continue;
            res++;
            st[t.first][t.second]=true;
            for(int i=0;i<4;i++)
            {
   
                int x=t.first+dx[i],y=t.second+dy[i];
                if(x<0 ||x>=rows ||y<0 ||y>=cols) continue;
                q.push({
   x,y});
            }
        }
        return res;
    }
};

剑指Offer-14-I 剪绳子

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m-1] 。请问 k[0]k[1]…*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
示例 1：
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示：
2 <= n <= 58

class Solution {
   
public:
    int cuttingRope(int n) {
   
        if(n==2) return 1;
        if(n==3) return 2;
        
        int res=1;
        if(n%3==1) res*=4,n-=4;
        if(n%3==2) res*=2,n-=2;
        while(n) res*=3,n-=3;
        return res;
    }
};

剑指Offer-14-II 剪绳子II

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m - 1] 。请问 k[0]k[1]…*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
提示：
2 <= n <= 1000

class Solution {
   
    public:
        int cuttingRope(int n) {
   
        if(n <= 3) return n - 1;
        long res=1L;
        int p=(int)1e9+7;    //贪心算法，优先切三，其次切二
        while(n>4){
   
            res=res*3%p;
            n-=3;
        }        		 	//出来循环只有三种情况，分别是n=2、3、4
        return (int)(res*n%p);
    }
};

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

请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
示例 1：
输入：00000000000000000000000000