剑指offer（1/6）

矩形覆盖

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
假设：n块矩形有f(n)种覆盖方法。进行逆向分析，要完成最后的搭建有两种可能。

第一种情况等价于情形1中阴影部分的n-1块矩形有多少种覆盖方法，为f(n-1);

第二种情况等价于情形2中阴影部分的n-2块矩形有多少种覆盖方法，为f(n-2);

故f(n) = f(n-1) + f(n-2)，还是一个斐波那契数列。。。。

public class Solution {
    public int rectCover(int target) {
        if(target == 1 || target == 0 || target == 2)
            return target;
        int [] dp = new int [target+1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3;i <= target; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[target];
    }
}

class Solution {
public:
    int rectCover(int number) {
        if (number <= 0) {
            return number;
        }
        int f1 = 1;
        int f2 = 2;
        int f3;
         
        for (int i = 3; i <= number; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
};

二进制中1的个数

输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。

public class Solution {
    public int NumberOf1(int n) {
        int count = 0;
        while(n != 0){
            count++;
            n &= n-1;
        }
        return count;
    }
}

class Solution {
public:
     int  NumberOf1(int n) {
         int count = 0;
        while(n!= 0){
            count++;
            n = n & (n - 1);
         }
        return count;
     }
};

数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

public class Solution {
    public double Power(double b, int n) {
        if(b == 0 && n==0)
            return 0;
        if(n < 0){
            b = 1 / b;
            n = -n;
        }
        return Fib(b,n);
  }
    public double Fib(double b,int n){
        if(n == 0)
            return 1;
        double res = Fib(b,n/2);
        if((n&1) != 0)
            res = res * res * b;
        else
            res = res * res;
        return res;
    }
}
// public class Solution {
//     public double Power(double b, int n) {
//         //非递归快速幂法
//         //遍历n的二进制位，是1就乘进结果
//         if(b==0&&n==0){
//             return 0;
//         }
//         if(n<0){
//             b = 1/b;
//             n = -n;
//         }
//         double res = 1;
//         double x = b;//x是b的替身
//         while(n!=0){
//             if((n&1)!=0){//说明这一位有1，将x乘进结果
//                 res *= x;
//             }
//             x *=x;
//             n>>=1;
//         }
//         return res;
         
//     }
// }

class Solution {
        double power(double base, int exp) {
        if (exp == 1) return base;
        if ((exp % 2) == 0) {
            int tmp = power(base, exp / 2);
            return tmp * tmp;
        } else {
            int tmp = power(base, (exp - 1) / 2);
            return tmp * tmp * base;
        }
    }
public:
    double Power(double base, int exp) {
        if (base == 0) {
            if (exp > 0) return 0;
            else if (exp == 0) return 0;
            else throw invalid_argument("Invalid input!");
        } else {
            if (exp > 0) return power(base, exp);
            else if (exp == 0) return 1;
            else return 1 / power(base, -exp);
        }
    }
};
    /**
     * 1.全面考察指数的正负、底数是否为零等情况。
     * 2.写出指数的二进制表达，例如13表达为二进制1101。
     * 3.举例:10^1101 = 10^0001*10^0100*10^1000。
     * 4.通过&1和>>1来逐位读取1101，为1时将该位代表的乘数累乘到最终结果。
     */
//     public double Power(double base, int n) {
//     	double res = 1,curr = base;
//     	int exponent;
//     	if(n>0){
//     		exponent = n;
//     	}else if(n<0){
//     		if(base==0)
//     			throw new RuntimeException("分母不能为0");  
//     		exponent = -n;
//     	}else{// n==0
//     		return 1;// 0的0次方
//     	}
//     	while(exponent!=0){
// 			if((exponent&1)==1)
// 				res*=curr;
// 			curr*=curr;// 翻倍
// 			exponent>>=1;// 右移一位
// 		}
// 		return n>=0?res:(1/res);        
//   	}