LeetCode 50 题解 -- 分治算法

两种方式都为通过，很奇怪，超时

/**
 * 类说明 实现 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
 * 
 * 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/powx-n
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 * 
 * 
 * Modify Information:
 * Author        Date          Description
 * ============ =========== ============================
 * wangm          2020年5月14日    Create this file
 * 
 * 
 */

public class LeetCode50 {

    
    public double myPow(double x, int n) {
        if(x == 1|| x== -1 ){
            return x;
        }
        if(n == 0){
            return 1;
        }
        if (n < 0) {
            x = 1 / x;
            n = -n;
        }
        double pow = 1.0;
        while (n != 0) {
            if ((n & 1) == 1) {
                pow *= x;
            }
            x *= x;
            n >>= 1;
        }
        return pow;
    }
    public double myPow1(double x, int n) {
        if (n == 0) {
            return 1;
        }
        if(x == 1){
            return 1;
        }
        if (n < 0) {
            return 1.0 / myPow1(x, -n);
        }
        if (n % 2 == 0) {
//            return myPow(x, n >> 1)*myPow(x, n >> 1); 会超时
            return myPow1(x*x, n >> 1);
        }
//        return x * myPow(x, n >> 1)*myPow(x, n >> 1);
        return x * myPow1(x*x, n >> 1);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(new LeetCode50().myPow(2, 10));
        System.out.println(new LeetCode50().myPow(2, -2));
        System.out.println(new LeetCode50().myPow(2.1, 3));
    }

}

分治算法模板

def divide_comquer(problem, param1， parana, ... )

#recursion terminator 
if problem is None：
    print result
return 
# prepare data 
data =  prepare_data(problem)
spLit_problems = split_problem(problem_data)
# conquer subproblems
subresult1 = self.divide_conquer(subproblems[0],p1,...)
subresult2 self.divide_conquer（subproblems[l], pl,...）
subresult3= self.divide_conquer（subproblems[2]， pl,...）
... 
# proress anmd generate the FInal nesult 
result = process_ result(subresultl, subresult2， subresult3, ...)