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] 。

??视频题解

code:

vid:

uuid:

requestId:

播放时间:

提示信息

技术图片
字幕
    倍速
      清晰度
        音轨
          倍速正常
          字幕Off
          音轨
          清晰度

          ??文字题解

          前言

          本题的方法被称为「快速幂算法」,有递归和迭代两个版本。这篇题解会从递归版本的开始讲起,再逐步引出迭代的版本。

          当指数 nn 为负数时,我们可以计算 x?nx^{-n} 再取倒数得到结果,因此我们只需要考虑 nn 为自然数的情况。

          方法一:快速幂 + 递归

          「快速幂算法」的本质是分治算法。举个例子,如果我们要计算 x64x^{64},我们可以按照:

          xx2x4x8x16x32x64x o x^2 o x^4 o x^8 o x^{16} o x^{32} o x^{64}

          的顺序,从 xx 开始,每次直接把上一次的结果进行平方,计算 66 次就可以得到 x64x^{64} 的值,而不需要对 xx6363xx

          再举一个例子,如果我们要计算 x77x^{77},我们可以按照:

          xx2x4x9x19x38x77x o x^2 o x^4 o x^9 o x^{19} o x^{38} o x^{77}

          的顺序,在 xx2x o x^2x2x4x^2 o x^4x19x38x^{19} o x^{38} 这些步骤中,我们直接把上一次的结果进行平方,而在 x4x9x^4 o x^9x9x19x^9 o x^{19}x38x77x^{38} o x^{77} 这些步骤中,我们把上一次的结果进行平方后,还要额外乘一个 xx

          直接从左到右进行推导看上去很困难,因为在每一步中,我们不知道在将上一次的结果平方之后,还需不需要额外乘 xx。但如果我们从右往左看,分治的思想就十分明显了:

          • 当我们要计算 xnx^n 时,我们可以先递归地计算出 y=x?n/2?y = x^{lfloor n/2 floor},其中 ?a?lfloor a floor 表示对 aa 进行下取整;

          • 根据递归计算的结果,如果 nn 为偶数,那么 xn=y2x^n = y^2;如果 nn 为奇数,那么 xn=y2?xx^n = y^2 * x

          • 递归的边界为 n=0n = 0,任意数的 00 次方均为 11

          由于每次递归都会使得指数减少一半,因此递归的层数为 O(log?n)O(log n),算法可以在很快的时间内得到结果。

          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 &gt;= <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 &gt;= <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 &gt;= <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
          }

          复杂度分析

          • 时间复杂度:O(log?n)O(log n),即为递归的层数。

          • 空间复杂度:O(log?n)O(log n),即为递归的层数。这是由于递归的函数调用会使用栈空间。

          方法二:快速幂 + 迭代

          由于递归需要使用额外的栈空间,我们试着将递归转写为迭代。在方法一中,我们也提到过,从左到右进行推导是不容易的,因为我们不知道是否需要额外乘 xx。但我们不妨找一找规律,看看哪些地方额外乘了 xx,并且它们对答案产生了什么影响。

          我们还是以 x77x^{77} 作为例子:

          xx2x4+x9+x19x38+x77x o x^2 o x^4 o^+ x^9 o^+ x^{19} o x^{38} o^+ x^{77}

          并且把需要额外乘 xx 的步骤打上了 ++ 标记。可以发现:

          • x38+x77x^{38} o^+ x^{77} 中额外乘的 xxx77x^{77} 中贡献了 xx

          • x9+x19x^9 o^+ x^{19} 中额外乘的 xx 在之后被平方了 22 次,因此在 x77x^{77} 中贡献了 x22=x4x^{2^2} = x^4

          • x4+x9x^4 o^+ x^9 中额外乘的 xx 在之后被平方了 33 次,因此在 x77x^{77} 中贡献了 x23=x8x^{2^3} = x^8

          • 最初的 xx 在之后被平方了 66 次,因此在 x77x^{77} 中贡献了 x26=x64x^{2^6} = x^{64}

          我们把这些贡献相乘,x?x4?x8?x64x * x^4 * x^8 * x^{64} 恰好等于 x77x^{77}。而这些贡献的指数部分又是什么呢?它们都是 22 的幂次,这是因为每个额外乘的 xx 在之后都会被平方若干次。而这些指数 1144886464恰好就对应了 7777 的二进制表示 (1001101)2(1001101)_2 中的每个 11

          因此我们借助整数的二进制拆分,就可以得到迭代计算的方法,一般地,如果整数 nn 的二进制拆分为

          n=2i0+2i1+?+2ikn = 2^{i_0} + 2^{i_1} + cdots + 2^{i_k}

          那么

          xn=x2i0?x2i1???x2ikx^n = x^{2^{i_0}} * x^{2^{i_1}} * cdots * x^{2^{i_k}}

          这样以来,我们从 xx 开始不断地进行平方,得到 x2,x4,x8,x16,?x^2, x^4, x^8, x^{16}, cdots,如果 nn 的第 kk 个(从右往左,从 00 开始计数)二进制位为 11,那么我们就将对应的贡献 x2kx^{2^k}计入答案。

          下面的代码给出了详细的注释。

          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 &gt;= <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 &gt;= <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 &gt;= <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
          }

          复杂度分析

          • 时间复杂度:O(log?n)O(log n),即为对 nn 进行二进制拆分的时间复杂度。

          • 空间复杂度:O(1)O(1)





























































































          以上是关于leetcode题解之50. Pow(x, n)的主要内容,如果未能解决你的问题,请参考以下文章

          leetcode 50 Pow(x,n) 快速幂

          《LeetCode之每日一题》:43.Pow(x, n)

          LeetCode50. Pow(x, n)

          [LeetCode] 50. Pow(x, n)

          leetcode || 50Pow(x, n)

          LeetCode 50. Pow(x, n)