leetcode题解之50. Pow(x, n)
Posted 刷题之路1
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了leetcode题解之50. Pow(x, n)相关的知识,希望对你有一定的参考价值。
实现 pow(x, n) ,即计算 x 的 n 次幂函数。
示例 1:
输入: 2.00000, 10 输出: 1024.00000
示例 2:
输入: 2.10000, 3 输出: 9.26100
示例 3:
输入: 2.00000, -2 输出: 0.25000 解释: 2-2 = 1/22 = 1/4 = 0.25
说明:
- -100.0 < x < 100.0
- n 是 32 位有符号整数,其数值范围是 [?231, 231 ? 1] 。
??视频题解
??文字题解
前言
本题的方法被称为「快速幂算法」,有递归和迭代两个版本。这篇题解会从递归版本的开始讲起,再逐步引出迭代的版本。
当指数 为负数时,我们可以计算 再取倒数得到结果,因此我们只需要考虑 为自然数的情况。
方法一:快速幂 + 递归
「快速幂算法」的本质是分治算法。举个例子,如果我们要计算 ,我们可以按照:
的顺序,从 开始,每次直接把上一次的结果进行平方,计算 次就可以得到 的值,而不需要对 乘 次 。
再举一个例子,如果我们要计算 ,我们可以按照:
的顺序,在 ,, 这些步骤中,我们直接把上一次的结果进行平方,而在 ,, 这些步骤中,我们把上一次的结果进行平方后,还要额外乘一个 。
直接从左到右进行推导看上去很困难,因为在每一步中,我们不知道在将上一次的结果平方之后,还需不需要额外乘 。但如果我们从右往左看,分治的思想就十分明显了:
-
当我们要计算 时,我们可以先递归地计算出 ,其中 表示对 进行下取整;
-
根据递归计算的结果,如果 为偶数,那么 ;如果 为奇数,那么 ;
-
递归的边界为 ,任意数的 次方均为 。
由于每次递归都会使得指数减少一半,因此递归的层数为 ,算法可以在很快的时间内得到结果。
class Solution {
public:
double quickMul(double x, long long N) {
if (N == 0) {
return 1.0;
}
double y = quickMul(x, N / 2);
return N % 2 == 0 ? y * y : y * y * x;
}
<span class="hljs-function"><span class="hljs-keyword">double</span> <span class="hljs-title">myPow</span><span class="hljs-params">(<span class="hljs-keyword">double</span> x, <span class="hljs-keyword">int</span> n)</span> </span>{
<span class="hljs-keyword">long</span> <span class="hljs-keyword">long</span> N = n;
<span class="hljs-keyword">return</span> N >= <span class="hljs-number">0</span> ? quickMul(x, N) : <span class="hljs-number">1.0</span> / quickMul(x, -N);
}
};
class Solution {
public double quickMul(double x, long N) {
if (N == 0) {
return 1.0;
}
double y = quickMul(x, N / 2);
return N % 2 == 0 ? y * y : y * y * x;
}
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">double</span> <span class="hljs-title">myPow</span><span class="hljs-params">(<span class="hljs-keyword">double</span> x, <span class="hljs-keyword">int</span> n)</span> </span>{
<span class="hljs-keyword">long</span> N = n;
<span class="hljs-keyword">return</span> N >= <span class="hljs-number">0</span> ? quickMul(x, N) : <span class="hljs-number">1.0</span> / quickMul(x, -N);
}
}
class Solution:
def myPow(self, x: float, n: int) -> float:
def quickMul(N):
if N == 0:
return 1.0
y = quickMul(N // 2)
return y * y if N % 2 == 0 else y * y * x
<span class="hljs-keyword">return</span> quickMul(n) <span class="hljs-keyword">if</span> n >= <span class="hljs-number">0</span> <span class="hljs-keyword">else</span> <span class="hljs-number">1.0</span> / quickMul(-n)
func myPow(x float64, n int) float64 {
if n >= 0 {
return quickMul(x, n)
}
return 1.0 / quickMul(x, -n)
}
func quickMul(x float64, n int) float64 {
if n == 0 {
return 1
}
y := quickMul(x, n/2)
if n%2 == 0 {
return y * y
}
return y * y * x
}
复杂度分析
-
时间复杂度:,即为递归的层数。
-
空间复杂度:,即为递归的层数。这是由于递归的函数调用会使用栈空间。
方法二:快速幂 + 迭代
由于递归需要使用额外的栈空间,我们试着将递归转写为迭代。在方法一中,我们也提到过,从左到右进行推导是不容易的,因为我们不知道是否需要额外乘 。但我们不妨找一找规律,看看哪些地方额外乘了 ,并且它们对答案产生了什么影响。
我们还是以 作为例子:
并且把需要额外乘 的步骤打上了 标记。可以发现:
-
中额外乘的 在 中贡献了 ;
-
中额外乘的 在之后被平方了 次,因此在 中贡献了 ;
-
中额外乘的 在之后被平方了 次,因此在 中贡献了 ;
-
最初的 在之后被平方了 次,因此在 中贡献了 。
我们把这些贡献相乘, 恰好等于 。而这些贡献的指数部分又是什么呢?它们都是 的幂次,这是因为每个额外乘的 在之后都会被平方若干次。而这些指数 ,, 和 ,恰好就对应了 的二进制表示 中的每个 !
因此我们借助整数的二进制拆分,就可以得到迭代计算的方法,一般地,如果整数 的二进制拆分为
那么
这样以来,我们从 开始不断地进行平方,得到 ,如果 的第 个(从右往左,从 开始计数)二进制位为 ,那么我们就将对应的贡献 计入答案。
下面的代码给出了详细的注释。
class Solution {
public:
double quickMul(double x, long long N) {
double ans = 1.0;
// 贡献的初始值为 x
double x_contribute = x;
// 在对 N 进行二进制拆分的同时计算答案
while (N > 0) {
if (N % 2 == 1) {
// 如果 N 二进制表示的最低位为 1,那么需要计入贡献
ans *= x_contribute;
}
// 将贡献不断地平方
x_contribute *= x_contribute;
// 舍弃 N 二进制表示的最低位,这样我们每次只要判断最低位即可
N /= 2;
}
return ans;
}
<span class="hljs-function"><span class="hljs-keyword">double</span> <span class="hljs-title">myPow</span><span class="hljs-params">(<span class="hljs-keyword">double</span> x, <span class="hljs-keyword">int</span> n)</span> </span>{
<span class="hljs-keyword">long</span> <span class="hljs-keyword">long</span> N = n;
<span class="hljs-keyword">return</span> N >= <span class="hljs-number">0</span> ? quickMul(x, N) : <span class="hljs-number">1.0</span> / quickMul(x, -N);
}
};
class Solution {
double quickMul(double x, long N) {
double ans = 1.0;
// 贡献的初始值为 x
double x_contribute = x;
// 在对 N 进行二进制拆分的同时计算答案
while (N > 0) {
if (N % 2 == 1) {
// 如果 N 二进制表示的最低位为 1,那么需要计入贡献
ans *= x_contribute;
}
// 将贡献不断地平方
x_contribute *= x_contribute;
// 舍弃 N 二进制表示的最低位,这样我们每次只要判断最低位即可
N /= 2;
}
return ans;
}
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">double</span> <span class="hljs-title">myPow</span><span class="hljs-params">(<span class="hljs-keyword">double</span> x, <span class="hljs-keyword">int</span> n)</span> </span>{
<span class="hljs-keyword">long</span> N = n;
<span class="hljs-keyword">return</span> N >= <span class="hljs-number">0</span> ? quickMul(x, N) : <span class="hljs-number">1.0</span> / quickMul(x, -N);
}
}
class Solution:
def myPow(self, x: float, n: int) -> float:
def quickMul(N):
ans = 1.0
# 贡献的初始值为 x
x_contribute = x
# 在对 N 进行二进制拆分的同时计算答案
while N > 0:
if N % 2 == 1:
# 如果 N 二进制表示的最低位为 1,那么需要计入贡献
ans *= x_contribute
# 将贡献不断地平方
x_contribute *= x_contribute
# 舍弃 N 二进制表示的最低位,这样我们每次只要判断最低位即可
N //= 2
return ans
<span class="hljs-keyword">return</span> quickMul(n) <span class="hljs-keyword">if</span> n >= <span class="hljs-number">0</span> <span class="hljs-keyword">else</span> <span class="hljs-number">1.0</span> / quickMul(-n)
func myPow(x float64, n int) float64 {
if n >= 0 {
return quickMul(x, n)
}
return 1.0 / quickMul(x, -n)
}
https://www.jianshu.com/p/b9f5d5dbfb2c
func quickMul(x float64, N int) float64 {
ans := 1.0
// 贡献的初始值为 x
x_contribute := x
// 在对 N 进行二进制拆分的同时计算答案
for N > 0 {
if N % 2 == 1 {
// 如果 N 二进制表示的最低位为 1,那么需要计入贡献
ans *= x_contribute
}
// 将贡献不断地平方
x_contribute *= x_contribute
// 舍弃 N 二进制表示的最低位,这样我们每次只要判断最低位即可
N /= 2
}
return ans
}
复杂度分析
-
时间复杂度:,即为对 进行二进制拆分的时间复杂度。
-
空间复杂度:。
以上是关于leetcode题解之50. Pow(x, n)的主要内容,如果未能解决你的问题,请参考以下文章