剑指Offer刷题小结--二(7~12)

最新推荐文章于 2023-07-04 13:54:07 发布
最新推荐文章于 2023-07-04 13:54:07 发布
阅读量209 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxzxzx0119/article/details/79774798
版权

目录

  1. 第一题：斐波那契数列
  2. 第二题：跳台阶
  3. 第三题：变态跳台阶
  4. 第四题：矩形覆盖
  5. 第五题：二进制中1的个数
  6. 第六题：数值的整数次方

第一题：斐波那契数列

题目链接
题目：

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39

解析：

四种方法:

  • 递归 ，时间O(2^n)；
  • 一维dp，空间O(n)，时间O(n)；
  • 滚动优化，空间O(1)，时间O(n)；
  • 矩阵快速幂；
递归(很慢 O(2^n)):
    public int Fibonacci(int n) {
        if(n  < 1)
            return 0;
        if(n == 1 || n == 2)
            return 1; 
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
记忆化
    public int[] m;
    public int Fibonacci(int n) {
        m = new int[n + 1];
        return process(n);
    }
    public int process(int n){
        if(n < 1)
            return 0;
        if(n == 1 || n == 2)
            return 1;
        if(m[n] != 0)
            return m[n];
        m[n] = process(n-1) + process(n-2);
        return m[n];
    }
一维dp(O(n)空间):
 public int Fibonacci(int n) {
        if(n  < 1)
            return 0;
        if(n == 1 || n == 2)
            return 1; 
        
        int[] dp = new int[n + 1];
        dp[1] = dp[2] = 1;
        
        for(int i = 2 ; i <= n; i++)
            dp[i] = dp[i-1] + dp[i-2];
        
        return dp[n];   
    }
滚动优化:
    public int Fibonacci(int n) {
        if(n  < 1)
            return 0;
        if(n == 1 || n == 2)
            return 1; 
        
        int f1 = 1;
        int f2 = 1;
        int res = 0;
        for(int i = 3; i <= n; i++){
            res = f1 + f2;
            f1 = f2;
            f2 = res;
        }
        return res;
    }
矩阵快速幂:

具体的过程可以看一下这篇博客和这篇博客。
在这里插入图片描述

  private static class Matrix{
        public int row;
        public int col;
        public int[][] m;

        public Matrix(int row, int col) {
            this.row = row;
            this.col = col;
            m = new int[row][col];
        }
    }
    
    public static Matrix mul(Matrix a,Matrix b){
        Matrix c = new Matrix(a.row,b.col); //注意这里

        for(int i = 0; i < a.row; i++){
            for(int j = 0; j < b.col; j++){
                for(int k = 0; k < a.col; k++)
                    c.m[i][j] = c.m[i][j] + a.m[i][k]*b.m[k][j];
            }
        }
        return c;
    }

    public static Matrix pow(Matrix a,int k){
        Matrix res = new Matrix(a.row,a.col); // 方阵
        for(int i = 0; i < a.row; i++)
            res.m[i][i] = 1;
        while(k > 0){
            if( (k&1) != 0)
                res = mul(res,a);
            a = mul(a,a);
            k >>= 1;
        }
        return res;
    }
    
    public int Fibonacci(int n) {
        if(n  < 1)
            return 0;
        if(n == 1 || n == 2)
            return 1; 
        
        Matrix a = new Matrix(2,2);
        a.m[0][0] = a.m[0][1] = a.m[1][0] = 1;
        a.m[1][1] = 0;
        
        Matrix res = pow(a,n-2); //此时列向量是 F1 = 1, F2 = 1
        
        return res.m[0][0] + res.m[0][1];
    }

第二题：跳台阶

题目链接
题目：

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

解析：

这个题目考察的还是斐波那契数列:

  • 唯一的不同在于n = 2时不是返回1而是返回2，因为2级台阶可以有两种跳法；
  • 为什么是fn = fn-1 + fn-2呢，如果台阶有N级，最后跳上第N级的情况，要么是从N-2级台阶直接跨2级台阶，要么是从N-1级台阶跨1级台阶，所以台阶有N级的方法数为跨到N-2级台阶的方法数加上跨到N-1级台阶的方法数；
递归:
     public int JumpFloor(int target) {
         if(target < 1)
             return 0;
        if(target == 1 || target == 2) //这里和上面的不同
            return target;
        return JumpFloor(target - 1) + JumpFloor(target - 2);
    }
记忆化
    public int[] m;
    public int JumpFloor(int target) {
        m = new int[target + 1];
        return process(target);
    }
    public int process(int n){
        if(n < 1)
            return 0;
        if(n == 1 || n == 2)
            return n;
        if(m[n] != 0)
            return m[n];
        m[n] = process(n-1) + process(n-2);
        return m[n];
    }
一维dp:
    public int JumpFloor(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        
        int[] dp = new int[target + 1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3; i <= target; i++)
            dp[i] = dp[i-1] + dp[i-2];
        return dp[target];
    }
滚动优化
    public int JumpFloor(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
             return target;
        int f1 = 1;
        int f2 = 2;
        int res = 0;
        for(int i = 3; i <= target; i++){
            res = f1 + f2;
            f1 = f2;
            f2 = res;
        }
        return res;
    }
矩阵快速幂

在这里插入图片描述

public class Solution {
    
    private static class Matrix{
        public int row;
        public int col;
        public int[][] m;

        public Matrix(int row, int col) {
            this.row = row;
            this.col = col;
            m = new int[row][col];
        }
    }
    
    public static Matrix mul(Matrix a,Matrix b){
        Matrix c = new Matrix(a.row,b.col); //注意这里

        for(int i = 0; i < a.row; i++){
            for(int j = 0; j < b.col; j++){
                for(int k = 0; k < a.col; k++)
                    c.m[i][j] = c.m[i][j] + a.m[i][k]*b.m[k][j];
            }
        }
        return c;
    }

    public static Matrix pow(Matrix a,int k){
        Matrix res = new Matrix(a.row,a.col); // 方阵
        for(int i = 0; i < a.row; i++)
            res.m[i][i] = 1;
        while(k > 0){
            if( (k&1) != 0)
                res = mul(res,a);
            a = mul(a,a);
            k >>= 1;
        }
        return res;
    }
  
    public int JumpFloor(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        Matrix a = new Matrix(2,2);
        a.m[0][0] = a.m[0][1] = a.m[1][0] = 1;
        a.m[1][1] = 0;
        
        Matrix res = pow(a,target-2);
        
        return res.m[0][0] * 2 + res.m[0][1]; //注意这里F2 = 2 ,所以乘以2
    }
}

第三题：变态跳台阶

题目链接
题目：

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

解析：

分析一下这个题目:

  • 第n个台阶可以由前面所有的台阶跳过来即f[n] = f[n-1] + f[n-2] + … f[1]；
  • 然后加上直接跳到自己这个台阶(+1)；

递归:

    public int JumpFloorII(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        int sum = 1; //加上自己一步直接跳到自己的台阶
        for(int i = 1; i < target; i++)
            sum += JumpFloorII(i);
        return sum; 
    }

一维dp:

    public int JumpFloorII(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        int[] dp = new int[target + 1];
        dp[1] = 1;
        for(int i = 2; i <= target; i++){
            dp[i] = 0;
            for(int j = 1; j < i; j++) //前面的和
                dp[i] += dp[j];
            dp[i] += 1;//加上自己的
        }  
        return dp[target];
    }

一维dp稍微优化:

    public int JumpFloorII(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        int[] dp = new int[target + 1];
        
        dp[1] = 1;  dp[2] = 2;
        int preSum = 3; 
        for(int i = 3; i <= target; i++){
            dp[i] = preSum + 1;
            preSum += dp[i];
        }  
        return dp[target];
    }

滚动优化:

    public int JumpFloorII(int target) {
        if(target < 1)
            return 0;
        if(target == 1 || target == 2)
            return target;
        int preSum = 3, res = 0;//一开始  preSum = f1 + f2的值
        for(int i = 3; i <= target; i++){
            res = preSum + 1;  //之前的和　加上自己的
            preSum += res;
        }  
        return res;
    }
规律

推出前面几项也可以看出其实就是一个等比数列求和 ，也就是2n-1, so :

    public int JumpFloorII(int target) {
         return (int)Math.pow(2,target - 1);
    }

   public int JumpFloorII(int target){
        return 1 << (target - 1);
    }

第四题：矩形覆盖

题目链接
题目：

我们可以用2 * 1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2 * 1的小矩形无重叠地覆盖一个2 * n的大矩形，总共有多少种方法？

解析：

覆盖2 * n(2代表行，n代表列)的时候，先看看假设前面已经覆盖2 * (n-2)之后，到2 * n之间还有多少种覆盖法：

  • 后面两个只有两种覆盖方法，一种是全部竖着放(实际上是从2 * (n-1)来的)，这里注意不要认为还有一种情况是放置两个竖的，实际上放好n-1的情况中已经包含了那种情况；
  • 另一种就是全部横着放，也就是n-2到n之间横着放两块 1 * 2的矩形，如图(2)；
  • 所以fn= fn-1 + fn-2 ，和跳台阶问题(第二题)完全一样。
  • 由于代码和跳台阶一模一样，就不放重复的代码了；
    在这里插入图片描述

第五题：二进制中1的个数

题目链接
题目：

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

解析：

先看一下左移和右移的基本操作:
在这里插入图片描述
(1). 简单的想法，就是使用位运算，直接将n每次右移一位，并且和最后一位和1做与运算，然后统计1的个数:

    // 右移 不能处理负数
    public int NumberOf1(int n) {
        int sum = 0;
        while(n > 0){
            if(  (n&1) != 0)
                sum++;
            n >>= 1;
        }
        return sum;
    }

但是这种做法不能解决负数的问题，负数右移在左边补1，稍有不同。
(2). 为了解决死循环的问题，使用另一个变量another，初始化为1，然后每次和n做与运算，也可以判断n的每一位是不是1；这种做法another左移32次，终止条件为another = 0；

    public int NumberOf1(int n) {
        int sum = 0;
        int another = 1;
        while(another != 0){
            if( (n & another) != 0)
                sum++;
            another <<= 1;
        }
        return sum;
    }

至于another终止条件测试:

   public void test(){
        int a = 1;
        for(int i = 0; i < 32; i++){
            a <<= 1;
            System.out.print("左移第 ");
            System.out.printf("%2d",(i+1));
            System.out.print("次     ---->     ");
            System.out.print("十进制 :  ");
            System.out.printf("%11d",a);
            System.out.print("   |||  二进制 : ");
            System.out.printf("%33s",Integer.toBinaryString(a));
            System.out.println();
        }
    }

输出 ，也就是a = 1 ，左移32次，就变成了0；
在这里插入图片描述
(3). 更优的做法: 第二个做法是一个数和比自己小1的数做于运算，会把这个数最右边的1变成0，然后看能做几次这样的运算，这个数就有多少个1，代码如下：
这个方法有多少个1，就只需要循环多少次。
在这里插入图片描述

   public int NumberOf1(int n) {
        int sum = 0;
        while( n != 0){
            sum++;
            n = n & (n-1);
        }
        return sum;
    }

这个方法和这个题第三种解法很类似。

第六题：数值的整数次方

题目链接
题目：

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

解析：

这个题目和LeetCode50 Pow(x, n)是一样的，完整解析可以看这篇博客。

两种思路: 递归和非递归

递归:
     public double Power(double base, int exponent) {
         return myPow(base,exponent);
     }
     public double myPow(double x,int n){
         if(n > 0){
             return pow(x,n);
         }else {
             if(n == Integer.MIN_VALUE){
                 return 1.0 / (pow(x,-(Integer.MIN_VALUE+1)) * x); // MAX_VALUE = -(Integer.MIN_VALUE + 1)
             }
             return 1.0 / pow(x,-n);
         }
     }    
     public double pow(double x,int n){
         if(n == 0)
             return 1;
         double half = pow(x,n/2);
         if(n % 2 == 0)
             return half * half;
         else 
             return x * half * half;
     }

     public double Power(double base, int exponent) {
         return myPow(base,exponent);
     }
     public double myPow(double x,int n){
         if(n == 0)
            return 1.0;
         if(n < 0){
             if(n == Integer.MIN_VALUE){
                 // return 1.0 / (myPow(x,-(Integer.MIN_VALUE+1)) * x);
                 return 1.0 / (myPow(x,Integer.MAX_VALUE) * x);
             }
             return 1.0 / myPow(x,-n);
          }
          double half = myPow(x,n/2);
          if(n % 2 == 0)
              return half * half;
          else 
              return x * half * half;
      }
非递归:
     public double Power(double base, int exponent) {
         return myPow(base,exponent);
     }
     public double myPow(double x,int n){
        if(n == 0)
             return 1.0;
         if(n < 0){
             if(n == Integer.MIN_VALUE){
                 return 1.0 / (myPow(x,Integer.MAX_VALUE) * x);
             }else {
                 return 1.0 / myPow(x,-n);
             }
         }
         double res = 1.0;
         while(n > 0){
             if( (n&1) != 0)
                 res *= x;
             x = x*x;
             n >>= 1;
         }
         return res;
     }

     public double Power(double base, int exponent) {
         return myPow(base,exponent);
     }
     public double myPow(double x,int n){
          if(n == 0)
              return 1.0;
          
          double res = 1.0;
          if(n < 0){
              x = 1/x;
              n = -(1+n);  // for Integer.MIN_VALUE   
              res *= x ;  // x is 1/x   because n is -(n+1) so should do this 
          }
          
          while(n > 0){
              if( (n&1) != 0)
                  res *= x;
              x = x*x;
              n >>= 1;
          }
          
          return res;
      }

     public double Power(double base, int exponent) {
         return myPow(base,exponent);
     }
      public double myPow(double x,int n){
        if(n == 0)
            return 1.0;
        
        long abs = Math.abs((long)n); // also for Integer.MIN_VALUE
        
        double res = 1.0;
        while(abs > 0){
            if( (abs&1) != 0)
                res *= x;
            x = x*x;
            abs >>= 1;
        }
        if(n < 0)
            return 1.0/res;
        return res;
    }
zxzxin
关注
专栏目录
剑指Offer刷题小结--一(1~6)
zxzxin的博客~
03-31 465
原题链接 第一题：二维数组中的查找 第二题：替换空格 第三题：从尾到头打印链表 第四题：重建二叉树 第五题：用两个栈实现队列 第六题：旋转数组的最小数字 第一题：二维数组的查找 题目: 在一个二维数组中，每一行都按照从左到右递增的顺序排序， 每一列都按照从上到下递增的顺序排序。请完成一个函数，输入 这样的一个二维数组和一个整数，判断数组中是否含有该整数。 解析...
剑指Offer刷题小结--六(31~36)
zxzxin的博客~
04-16 244
原题链接： 第一题：整数中1出现的次数（从1到n整数中1出现的次数） 第二题：把数组排成最小的数 第三题：丑数 第四题：第一个只出现一次的字符 第五题：数组中的逆序对 第六题：两个链表的第一个公共结点 第一题：整数中1出现的次数（从1到n整数中1出现的次数） 题目： 求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~1...
剑指Offer刷题小结--五(25~30)
zxzxin的博客~
04-05 333
原题链接 第一题：复杂链表的复制 第二题：二叉搜索树与双向链表 第三题：字符串的排列 第四题：数组中出现次数超过一半的数字 第五题：最小的K个数 第六题：连续子数组的最大和 第一题：复杂链表的复制 题目： 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不...
剑指Offer刷题小结--四(19~24)
zxzxin的博客~
04-02 237
原题链接 第一题：顺时针打印矩阵 第二题：包含min函数的栈 第三题：栈的压入、弹出序列 第四题：从上往下打印二叉树 第五题：二叉搜索树的后序遍历序列 第六题：二叉树中和为某一值的路径 第一题：顺时针打印矩阵 题目： 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14...
剑指Offer刷题小结--三(13~18)
zxzxin的博客~
04-01 553
原题链接 第一题：调整数组顺序使奇数位于偶数前面 第二题：链表中倒数第k个结点 第三题：反转链表 第四题：合并两个排序的链表 第五题：树的子结构 第六题：二叉树的镜像 第一题：调整数组顺序使奇数位于偶数前面 题目： 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之...
剑指offer刷题记录--算法--搜索算法
qq_37746927的博客
05-12 186
剑指offer刷题记录--算法--搜索算法
剑指offer刷题笔记--Num31-40
最新发布
牵一只蜗牛去散步
07-04 603
直观思路：用两个指针 i 和 j 指向压入和弹出的 vector，终止条件是：所有元素都压入了辅助栈（i > len），且辅助栈当前的栈顶元素与弹出的元素 popped[j] 不相等；模拟栈的压入顺序，依次压入 pushed 里的所有元素，用一个指针 j 指向需要弹出的元素，当符合弹出要求时就弹出对应的元素；二叉搜索树的定义：左子树的结点均小于根节点，右子树的结点均大于根结点；，不同的是为了打印每一层的结点，需要循环当前层的结点数次，每一次。，因此只需要循环队列的长度次，并记录对应的结点值即可；
剑指offer刷题记录--树
qq_37746927的博客
05-03 1653
剑指offer刷题记录--树
剑指offer刷题记录--队列&栈
qq_37746927的博客
05-09 1012
剑指offer刷题记录--队列&栈
【LeetCode & 剑指offer 刷题笔记】汇总（已完成）
热门推荐
技术改变世界
01-11 6万+
前言   不知不觉就结束了自己的秋招之路，虽感觉有些艰辛但是收获很多。找工作那段时间做了很多学习笔记，这是数据结构与算法相关的一部分笔记，这一块除了复习相关教科书，还有就是刷leetcode和《剑指offer》了。这段时间稍微空闲些，打算把自己之前在印象笔记上做的笔记迁移到CSDN上（CSDN解析html源码的功能还没加上去，已经反馈了这个问题，我要再等等这个功能，免得要过多的二次编辑），供大家学...
刷题笔记（剑指offer-67题，Java版）
晋青杨
08-25 958
本文包括刷题的总体思想要义、以及剑指offer67题的全部题解
【java】leetcode刷题记录+简单思路（hot100+剑指offer 简单\中等难度）
昂萨哈凯尔可真难记啊
08-14 1255
避免重复刷题每次都两眼一抹黑咩都不记得，简单记一下思路。 1. 两数之和（简单） 2. 两数相加（中等） 3. 无重复字符的最长子串（中等） 4. 寻找两个正序数组的中位数（困难） 5. 最长回文子串（中等） 10. 正则表达式匹配（困难） 11. 盛最多水的容器（中等） 15. 三数之和（中等） 17. 电话号码的字母组合（中等） 19. 删除链表的倒数第 N 个结点（中等） ...
剑指offer_edition2刷题记录
jiandandian_的博客
04-21 1418
剑指offer_edition2刷题记录
【LeetCode & 剑指offer刷题】树题1：二叉树的遍历总结（前序、中序、后序、层序、 之字形层序、垂直遍历）...
技术改变世界
01-05 2462
【LeetCode &amp; 剑指offer刷题】树题1：二叉树的遍历总结（前序、中序、后序、层序、 之字形层序、垂直遍历） 【LeetCode &amp; 剑指offer 刷题笔记】目录（持续更新中...）   二叉树的遍历总结 （前序、中序、后序、层序、 之字形层序、垂直遍历）   三种递归遍历 //前序遍历（根-左-右） void ...
各种排序算法总结(全面)
zxzxin的博客~
04-05 2万+
目录 冒泡排序 改进的冒泡排序(鸡尾酒排序) 选择排序 插入排序 二分插入排序 希尔排序 快速排序 归并排序 堆排序 计数排序 基数排序 桶排序 基本概要 排序算法大体可分为两种： 一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 另一种是非比较排序，时间复杂度可以达到O(...
ACM常用模板(+模板题)(基础)
zxzxin的博客~
04-08 2万+
目录 大数 二分 枚举排列 子集生成 n皇后回溯 并查集 树状数组 KMP，Sunday，BM 01背包，完全背包 最长(不)上升或下降子序列 最长公共子序列 拓扑排序 欧拉路径和回路 搜索 最小生成树 最短路 GCD和LCM 埃拉托斯特尼筛法 唯一分定理 扩展欧几里得 欧拉函数 快速幂 矩阵快速幂 说明 虽然只打了一年的ACM，现在已经离开ACM赛场了，但是在ACM中一些...
分支限界法总结--例题(01背包，最大团，单源最短路径，装载问题，布线问题)
zxzxin的博客~
04-28 1万+
目录 分支限界法剪枝搜索策略(广度搜索)与算法框架 01背包问题 最大团 单源最短路径 装载问题 布线问题 分支限界法剪枝搜索策略(广度搜索)与算法框架 基本思想 分支限界法与回溯法求解目标不同，回溯法的求解目标是找出解空间中满足约束条件的所有解，而分支限界法的求解目标是找出满足约束条件的一个解，或者是在满足约束条件的解中找出使某一个目标函数值达到极大或者极...
二分查找的总结(6种变形)
zxzxin的博客~
09-13 4749
二分查找的总结 普通的二分查找 普通二分查找的另一种写法 第一个 = key 的，不存在返回 -1 第一个 &amp;amp;amp;amp;amp;amp;gt;= key 的 第一个 &amp;amp;amp;amp;amp;amp;gt; key 的 最后一个 = key 的 ，不存在返回 - 1 最后一个 &amp;amp;amp;amp;amp;amp;lt;= key 的 最后一个 &amp;amp;amp;amp;amp;amp;lt; key 的 完
"剑指Offer刷题：二维数组中查找问题解析
而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维数组的特点是每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值