校招算法笔面试 | 数值的整数次方

原创于 2025-04-10 09:36:23 发布 · 460 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #面试 #职场和发展 #算法力扣 #算法力扣面试

题目## 题目

题目链接

题目的主要信息：

求一个浮点数的整数次方
整数有正有负
不可以使用库函数，也不需要判断大数问题

举一反三：

学习完本题的思路你可以解决如下题目：

JZ83. 剪绳子（进阶版）

方法一：直接运算（推荐使用）

思路：

既然是求次方，那我们做不断累乘就可以了，重点是处理负的次方数，因为 $x^{-n}=(\frac{1}{x})^n$ ，因此我们将底数转换为相应分数，就可以将次方数变回正数。

if(exponent < 0){
    base = 1 / base;
    exponent = -exponent;
}

具体做法：

step 1：先处理次方数为负数的情况，将底数化为分数解决。
step 2：遍历次方数的次数，不断累乘底数。

Java实现代码：

public class Solution {
    public double Power(double base, int exponent) {
        //处理负数次方
        if(exponent < 0){
            base = 1 / base;
            exponent = -exponent;
        }
        double res = 1.0;
        //累乘
        for(int i = 0; i < exponent; i++)
            res *= base;
        return res;
  }
}

C++实现代码：

class Solution {
public:
    double Power(double base, int exponent) {
        //处理负数次方
        if(exponent < 0){
            base = 1 / base;
            exponent = -exponent;
        }
        double res = 1.0;
        //累乘
        for(int i = 0; i < exponent; i++)
            res *= base;
        return res;
    }
};

Python实现代码：

class Solution:
    def Power(self , base: float, exponent: int) -> float:
        #处理负数次方
        if exponent < 0:
            base = 1 / base
            exponent = -exponent
        res = 1.0
        #累乘
        for i in range(exponent):
            res *= base
        return res

复杂度分析：

时间复杂度： $O (n)$ ，其中 $n$ 为所求的次方数，一共需要乘 $n$ 次
空间复杂度： $O (1)$ ，常数级变量，无额外辅助空间

方法二：快速幂（扩展思路）

知识点：分治：

分治即“分而治之”，“分”指的是将一个大而复杂的问题划分成多个性质相同但是规模更小的子问题，子问题继续按照这样划分，直到问题可以被轻易解决；“治”指的是将子问题单独进行处理。经过分治后的子问题，需要将解进行合并才能得到原问题的解，因此整个分治过程经常用递归来实现。

思路：

计算幂运算，我们还可以使用快速幂快速计算。如果我们要计算 $5^{10}$ ，常规的算法是 $5 * 5 = 25$ ，然后再 $25 * 5 = 125$ ，如此往下，一共是 $9$ 次运算，即 $n - 1$ 次。但是我们可以考虑这样： $5 * 5 = 25$ (二次）、 $25 * 25 = 625$ （四次）、 $625 * 625 = ...$ （八次），这是一个二分的思维，运算次数缩减到了 $log_2n$ 次，公式如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

具体做法：

step 1：先处理次方数为负数的情况，将底数化为分数解决。
step 2：使用快速幂计算次方：将已乘出来的部分求次方，可以每次缩小一半要求的次方数。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

public class Solution {
    //快速幂
    private double Pow(double x, int y){ 
        double res = 1;
        while(y != 0){
            //可以再往上乘一个
            if((y & 1) != 0) 
                res *= x;
            //叠加
            x *= x; 
            //减少乘次数
            y = y >> 1; 
        }
        return res;
    }
    public double Power(double base, int exponent) {
        //处理负数次方
        if(exponent < 0){
            base = 1 / base;
            exponent = -exponent;
        }
        return Pow(base, exponent);
  }
}

C++实现代码：

class Solution {
public:
    //快速幂
    double Pow(double x, int y){ 
        double res = 1;
        while(y){
            //可以再往上乘一个
            if(y & 1) 
                res *= x;
            //叠加
            x *= x; 
            //减少乘次数
            y = y >> 1; 
        }
        return res;
    }
    double Power(double base, int exponent) {
        //处理负数次方
        if(exponent < 0){
            base = 1 / base;
            exponent = -exponent;
        }
        return Pow(base, exponent);
    }
};

Python实现代码：

class Solution:
    #快速幂
    def Pow(self, x: float, y: int) -> float:
        res = 1
        while y:
            #可以再往上乘一个
            if y & 1: 
                res *= x
            #叠加
            x *= x 
            #减少乘次数
            y = y >> 1 
        return res
        
    def Power(self , base: float, exponent: int) -> float:
        #处理负数次方
        if exponent < 0:
            base = 1 / base
            exponent = -exponent
        res = 1.0
        return self.Pow(base, exponent)

复杂度分析：

时间复杂度： $O(log_2n)$ ，其中 $n$ 为所求的次方数，快速幂相当于对求幂使用二分法
空间复杂度： $O (1)$ ，常数级变量，无额外辅助空间

题目链接

题目主要信息:

给定一个整型数组，数组每个元素表示下图所示的每列灰色柱子高度，数值都是非负数
在雨水（图中蓝色部分）不超过边界的情况下，问最多能有多少蓝色的格子
数组以外的区域高度视为0

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

举一反三：

BM93. 盛水最多的容器

方法：双指针(推荐使用)

知识点：双指针

双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个），两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。

思路：

我们都知道水桶的短板问题，控制水桶水量的是最短的一条板子。这道题也是类似，我们可以将整个图看成一个水桶，两边就是水桶的板，中间比较低的部分就是水桶的底，由较短的边控制水桶的最高水量。但是水桶中可能出现更高的边，比如上图第四列，它比水桶边还要高，那这种情况下它是不是将一个水桶分割成了两个水桶，而中间的那条边就是两个水桶的边。

有了这个思想，解决这道题就容易了，因为我们这里的水桶有两个边，因此可以考虑使用对撞双指针往中间靠。

具体做法：

step 1：检查数组是否为空的特殊情况
step 2：准备双指针，分别指向数组首尾元素，代表最初的两个边界
step 3：指针往中间遍历，遇到更低柱子就是底，用较短的边界减去底就是这一列的接水量，遇到更高的柱子就是新的边界，更新边界大小。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java代码实现:

import java.util.*;
public class Solution {
    public long maxWater (int[] arr) {
        //排除空数组
        if(arr.length == 0) 
            return 0;
        long res = 0;
        //左右双指针
        int left = 0; 
        int right = arr.length - 1; 
        //中间区域的边界高度
        int maxL = 0; 
        int maxR = 0;
        //直到左右指针相遇
        while(left < right){ 
            //每次维护往中间的最大边界
            maxL = Math.max(maxL, arr[left]); 
            maxR = Math.max(maxR, arr[right]);
            //较短的边界确定该格子的水量
            if(maxR > maxL) 
                res += maxL - arr[left++]; 
            else
                res += maxR - arr[right--];
        }
        return res;
    }
}

C++代码实现:

class Solution {
public:
    long long maxWater(vector<int>& arr) {
        //排除空数组
        if(arr.size() == 0) 
            return 0;
        long long res = 0;
        //左右双指针
        int left = 0; 
        int right = arr.size() - 1; 
        //中间区域的边界高度
        int maxL = 0; 
        int maxR = 0;
        //直到左右指针相遇
        while(left < right){ 
            //每次维护往中间的最大边界
            maxL = max(maxL, arr[left]); 
            maxR = max(maxR, arr[right]);
            //较短的边界确定该格子的水量
            if(maxR > maxL) 
                res += maxL - arr[left++]; 
            else
                res += maxR - arr[right--];
        }
        return res;
    }
};

Python实现代码：

class Solution:
    def maxWater(self , arr: List[int]) -> int:
        #排除空数组
        if len(arr) == 0: 
            return 0
        res = 0
        #左右双指针
        left = 0 
        right = len(arr) - 1
        #中间区域的边界高度
        maxL = 0 
        maxR = 0
        #直到左右指针相遇
        while left < right:
            #每次维护往中间的最大边界 
            maxL = max(maxL, arr[left]) 
            maxR = max(maxR, arr[right])
            #较短的边界确定该格子的水量
            if maxR > maxL: 
                res += maxL - arr[left]
                left += 1
            else:
                res += maxR - arr[right]
                right -= 1
        return res