leetcode剑指offer_leedcode剑指offer怎么打开

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof

c++栈的方法的基本用法：

push(): 向栈内压入一个成员；
pop(): 从栈顶弹出一个成员；
empty(): 如果栈为空返回true，否则返回false；
top(): 返回栈顶，但不删除成员；
size(): 返回栈内元素的大小；

class CQueue {
public:
    stack<int> s1;
    stack<int> s2;
    CQueue() {
    }
    
    void appendTail(int value) {
        s1.push(value);
    }
    
    int deleteHead() {
        if(s2.empty()){
                while(!s1.empty()){
                int val=s1.top();
                s1.pop();
                s2.push(val);
            }
        }
        
        if(!s2.empty()){
            int val = s2.top();
            s2.pop();
            return val;
        }
        return -1;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

注意细节即可。

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

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof

class Solution {
public:
    int f0=0, f1=1, f2;
    int mod = 1e9+7;
    int fib(int n) {
        for(int i=2; i<=n; i++){
            f2=(f0+f1)%mod;
            f0=f1;
            f1=f2;
        }
        if(n==0)return f0;
        if(n==1)return f1;
        return f2;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1. 不要忘记余1e9+7
2. 采用的是从0加到n，而不是从n到0，因为那样复杂度很高

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

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof

class Solution {
public:
    int f0=1, f1=1, f2;
    int mod = 1e9+7;
    int numWays(int n) {
        for(int i=2; i<=n; i++){
            f2=(f0+f1)%mod;
            f0=f1;
            f1=f2;
        }
        if(n==0)return f0;
        if(n==1)return f1;
        return f2;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1. 动态规划，f(n)为n阶台阶的解法数，因为只能跳1阶或者2阶，所以f(n)=f(n-1)+f(n-2)
2. 自底向上，时间复杂度O(n)

矩阵快速幂的解法，时间复杂度为O(logn):

typedef long long ll;

class Solution {
private:
    struct Matrix{
        const static int N=2;
        const static ll MOD=1e9+7;
        ll a[N][N];
        Matrix(bool x){for(int i=0;i<N;i++)for(int j=0;j<N;j++)a[i][j]=x?i==j:0;}
        Matrix operator*(Matrix&b){
            Matrix C=Matrix(0);
            for(int k=0;k<N;k++)
                for(int i=0;i<N;i++)
                    for(int j=0;j<N;j++)
                        C.a[i][j]=(C.a[i][j]+a[i][k]*b.a[k][j])%MOD;
            return C;
        }
        Matrix operator^(int n){
            Matrix C=Matrix(1);
            Matrix A=Matrix(0);
            for(int i=0;i<N;i++)for(int j=0;j<N;j++)A.a[i][j]=a[i][j];
            for(;n;n>>=1,A=A*A)if(n&1)C=C*A;
            return C;
        }

        void show(){puts("");for(int i=0;i<N;i++){for(int j=0;j<N;j++)cout<<a[i][j]<<" ";puts("");}}
    };


public:
    int numWays(int n) {
        Matrix A0=Matrix(0);
        A0.a[0][0]=1,A0.a[0][1]=1;
        A0.a[1][0]=0,A0.a[1][1]=0;
        //A0.show();
        Matrix B=Matrix(0);
        B.a[0][0]=0,B.a[0][1]=1;
        B.a[1][0]=1,B.a[1][1]=1;
        //B.show();
        Matrix C=B^n;
        //C=A0*C;
        //C.show();        
        return (A0*C).a[0][0];
    }
};

作者：moao
链接：https://leetcode-cn.com/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/solution/mo-ao-shu-xue-ologn-ju-zhen-kuai-su-mi-j-ejp7/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof

使用vector注意事项：

1、如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；

2、Vector 作为函数的参数或者返回值时，需要注意它的写法：

double Distance(vector&a, vector&b)
其中的“&”绝对不能少！！！

C++ vector的用法（整理）https://www.cnblogs.com/Nonono-nw/p/3462183.html

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int l=0, r=numbers.size()-1,mid;
        if(numbers[l]<numbers[r])return numbers[l];
        while(l<=r){
            mid=l+(r-l)/2;
            if(mid!=0&&numbers[mid-1]>numbers[mid])return numbers[mid];
            else if(numbers[mid]>numbers[r])l=mid+1;
            else if(numbers[mid]<numbers[r])r=mid-1;
            else r--;
        }
        return numbers[l];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1. 暴力时间复杂度为O(n)
2. 二分时间复杂度为O(logn)，由于两段都是递增，且num[r]<=num[l]，所以中间小于右边，说明最小数在mid左边，中间大于右边，最小数在mid右边，如果相等，则缩小范围，r–
3. 注意细节