[LeetCode]75. Pow(x,n)幂运算

Implement pow(xn).

Subscribe to see which companies asked this question

解法1:最简单的即是n个x直接相乘,毫无疑问会超时Time Limit Exceeded

class Solution {
public:
    double myPow(double x, int n) {
        if(x < 0.000001) return 0;
        if(n == 0) return 1;
        if(n < 0) return 1.0 / myPow(x, -n);

        double res = 1.0;
        for(int i = 0; i < n; ++i)
            res *= x;
        return res;
    }
};

解法2:考虑pow(4,12),可以这样计算:pow(4,12)=pow(4,8)*pow(4,4),而pow(4,8)可以通过pow(4,1)-->pow(4,2)-->pow(4,4)-->pow(4,8)这样计算,pow(4,4)同样可以通过可以通过pow(4,1)-->pow(4,2)-->pow(4,4)计算得到。即在计算到某次幂pow(x,k)的时候,若当前幂次的平方pow(x,2k)不会大于结果(通过2k<=n来判断),则直接平方。因此可以写出如下代码:

class Solution {
public:
    double myPow(double x, int n) {
        if (x < 0.000001) return 0;
        if (n == 0) return 1;
        if (n < 0) return 1.0 / myPow(x, -n);

        double res = 1.0;
        while (n > 0) {
            double f = x;
            int loop = 1;
            while ((loop << 1) <= n) {
                f *= f;
                loop <<= 1;
            }
            n -= loop;
            res *= f;
        }
        return res;
    }
};

这样虽然一定程度上减少了运算次数,但是正如上面例子展现的,仍然会有不少的冗余计算。同样在LeetCode中提交后会超时Time Limit Exceeded。可以使用map<double,int>记录下计算过的幂值,第一次循环后后面的所有值都可以通过查表得到,这样可以减少重复计算。

class Solution {
public:
    double myPow(double x, int n) {
        if (x == 0) return 0;
        if (n == 0) return 1;
        if (n < 0) return 1.0 / myPow(x, -n);
        vector<double> power;

        double res = 1.0;
        double f = x;
        int loop = 1;
        power.push_back(f);
        while ((loop << 1) <= n) {
            f *= f;
            power.push_back(f);
            loop <<= 1;
        }
        n -= loop;
        res *= f;
        bitset<sizeof(int) * 8> powb(n);
        for (int i = 0; i < 32; ++i) {
            if (powb[i] == 1)
                res *= power[i];
        }
        return res;
    }
};

但是这种方法会出现 Memory Limit Exceeded。因为输入指数为int型,实际vector<double>最大长度为32,是常数复杂度。时间复杂度也在常数级别。不知题目限定空间复杂度在什么级别。

解法3:考虑使用二分搜索。如果n为偶数,则pow(x,n)=pow(x,n/2)*pow(x,n/2),如果n是奇数则再乘个x。这样递归下去,直到n==0。

class Solution {
public:
    double myPow(double x, int n) {
        if (x == 0) return 0;
        if (n == 0) return 1;
        if (n < 0) return 1.0 / power(x, -n);
        return power(x, n);
    }
private:
    double power(double x, int n) {
        if (n == 0) return 1;
        double half = power(x, n / 2);
        double res = half * half;
        return n % 2 == 0 ? res : res * x;
    }
};
时间: 2024-10-07 06:02:08

[LeetCode]75. Pow(x,n)幂运算的相关文章

LeetCode OJ:Pow(x, n) (幂运算)

Implement pow(x, n). 幂运算,简单的方法snag然很好实现,直接循环相乘就可以了,但是这里应该不是那种那么简单,我的做法使用到了一点递归: 1 class Solution { 2 public: 3 double myPow(double x, int n) { 4 if(n == INT_MIN) 5 return 1.0* x/myPow(x, INT_MAX); 6 if(n < 0) 7 return 1.0/myPow(x, -n); 8 else if(n ==

LeetCode:Pow(x, n)

1.题目名称 Pow(x, n)(求指定数字x的整数次幂) 2.题目地址 https://leetcode.com/problems/powx-n/ 3.题目内容 英文:Implement pow(x, n) 中文:给定底数x和指数n,求x的n次幂 4.解题方法1 在Java中,有一个偷懒的办法是这样实现的: /**  * 功能说明:LeetCode 50 - Pow(x, n)   * 开发人员:Tsybius2014  * 开发时间:2015年8月8日  */ public class So

【LeetCode】Pow(x, n)

Implement pow(x, n). 思路:快速幂运算,需要考虑指数为负数,同时底数为0的情况,这种属于异常数据,代码里没有体现. class Solution { public: double pow_abs(double x, unsigned int n) { if (n == 0) { return 1; } if (n == 1) { return x; } double res = pow(x, n>>1); res *= res; if (n & 0x1 == 1)

斐波那契加求幂运算

斐波那契博大精深啊,还有求幂的迭代也有点意思 1 //斐波那契有好多中方法 2 #include <iostream> 3 #include <deque> 4 using namespace std; 5 6 //注意普通斐波那契,在太大数时就会发生越界,比如long long 只能存表示第92个数,这些都是小的斐波那契,当要大时,就得用大数方法了 7 //用int ,只能到第46个,47就不行了,unsighed int 只能到92 8 int fibnaq(int n) //

求幂运算、多项式乘法及Horner法则的应用

一,两种不同的求幂运算 求解x^n(x 的 n 次方) ①使用递归,代码如下: 1 private static long pow(int x, int n){ 2 if(n == 0) 3 return 1; 4 if(n == 1) 5 return x; 6 if(n % 2 == 0) 7 return pow(x * x, n / 2); 8 else 9 return pow(x * x, n / 2) * x; 10 } 分析: 每次递归,使得问题的规模减半.2到6行操作的复杂度为

快速求幂运算笔记

如何快速求x得n次方呢? 首先C++里面有个pow如何实现呢?自己查查,里面使用double,肯定更麻烦,还有jianzhi 我们会顺手写下 int res=1; for(int i=1;i<=n;i++) { res*=x; } 学习一下快速幂,logn内计算出来,使用N的二进制,只需要logN就可以计算. 正要的就是计算每个为1对应的基数.列入: 11是多少?是二进制的话,就是1*2^1+1 那么x^(11)呢,两个1对应的基数是多少呢?低位1对应的是X,高位1对应的是X^2,因此,就是位于

高效率的取幂运算,递归解法跟非递归解法

long int Pow( long int x, unsigned int n ) { // 求幂运算 if( n == 0 ) return 1; if( n == 1 ) return x; if( n % 2 == 0 ) return Pow( x * x, n / 2 ); else return Pow( x, n - 1 ) * x; // 可以用下列的注释行替换 //return Pow( x * x, n / 2 ) * x; } 上面的是递归解法,时间复杂度为 O(logN

高效求幂运算

//说明: //高效求幂运算(递归) //输入:整数X,幂次N //输出:X^N //时间复杂度:O(logN) #include<iostream> using namespace std; int Pow(int X,int N) { if(N==0) return 1; else if(N==1) return X; else if(N%2==0) return Pow(X*X,N/2); else return Pow(X*X,N/2)*X; } void main() { cout&

[ACM] hdu 3923 Invoker (Poyla计数,高速幂运算,扩展欧几里得或费马小定理)

Invoker Problem Description On of Vance's favourite hero is Invoker, Kael. As many people knows Kael can control the elements and combine them to invoke a powerful skill. Vance like Kael very much so he changes the map to make Kael more powerful. In