【算法题】剪绳子、计算二进制中1的个数、数值的整数次方

news2024/12/28 19:24:38

剪绳子、计算二进制中1的个数、数值的整数次方

一、剪绳子
- 1.1、题目描述
- 1.2、思路
- 1.3、代码实现：
- 1.4、华丽的快速幂取余
- 1.5、小结
二、数值的整数次方
- 2.1、题目描述
- 2.2、思路
- 2.3、代码实现
- 2.4、小结
三、计算二进制中1的个数
- 3.1、题目描述
- 3.2、思路
- 3.3、代码实现
- 3.4、小结
总结

一、剪绳子

1.1、题目描述

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m-1] 。请问 k[0]k[1]…*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

来源：力扣（LeetCode）

1.2、思路

利用数学结论，数学上有个常识：当有一定数量的整数数字，若其总和不变，则每个数字之间的差距越小，其所有数字的乘积越大；所以尽可能把 n 均分之后的数字连乘的积会达到最大。不理解？没事，还有一个相同的结论：多边形边越趋于相等总面积越大。

也就是说，把一个数字，尽可能的均分之后数字连乘的积会达到最大。下面直接给出结论，推导过程就略过了。

当子段长度 len=3 时，可以得到最大乘积。因此，应该将给定的正整数拆分成尽可能多的3。根据 n 除以 3 的余数进行分类讨论：

如果余数为 0，即 n=3m(m≥2)，则将 n 拆分成 m 个 3；
如果余数为 1，即 n=3m+1(m≥1)，由于 2×2>3×1，因此将 n 拆分成 m−1 个 3 和 2 个 2；
如果余数为 2，即 n=3m+2(m≥1)，则将 n 拆分成 m 个 3 和 1 个 2。

上述拆分的适用条件是 n≥4。如果 n≤3，则上述拆分不适用，需要单独处理。

如果 n=2，则唯一的拆分方案是 2=1+1，最大乘积是 1×1=1；
如果 n=3，则拆分方案有 3=1+2=1+1+1，最大乘积对应方案 3=1+2，最大乘积是 1×2=2。

这两种情形可以合并为：当 n≤3 时，最大乘积是 n−1。

1.3、代码实现：

class Solution {
public:
    int cuttingRope(int n) {
        if(n<=3)
            return n-1;
        int q=n/3;
        int r=n%3;
        if(r==0)//3*m
            return (int)pow(3,q);
        else if(r==1)//3*m+1=3*(m-1)+2*2;
            return (int)pow(3,q-1)*2*2;
        else//3*m+2
            return (int)pow(3,q)*2;
    }
};

时间复杂度：O(1)。涉及到的操作包括计算商和余数，以及幂次运算，时间复杂度都是常数。

空间复杂度：O(1)。只需要使用常数复杂度的额外空间。

1.4、华丽的快速幂取余

尽可能切多点3，对于最后的切法，要考虑到整体长度。

起码得切2，切1没有意义。
或者切3，即绳子长度刚好可以被 3 整除。
或者切4，比如一直切3，最后余下1的长度，又因为前述提到不要切1，我们可以把前一段3和这一段1，合并起来，切成4。
不能切5，因为可以将5切成 2*3 ，可以得到乘积6。

总结一句话，一直对这段绳子切3，直到最后一个不大于4。为了防止计算的值超出变量类型的返回值，每次都对值进行1000000007取模（参考leetcode）。

代码实现：

class Solution {
public:
    int cuttingRope(int n) {
        if(n<=3)
            return n-1;
        long res=1;
        while(n>4)
        {
            n-=3;
            res=(res%1000000007)*3;
        }
        return (n*res)%1000000007;
    }
};

1.5、小结

数学公式的好处是时间复杂度低。核心是对3取模：

$n\geq4$ 情况下：

n%3==0，结果为 $3^{n\div2}$ 。
n%3==1，结果为 $3^{n-1}\times4$ 。
n%3==2，结果为 $3^{n\div2}\times2$ 。

否则结果是n-1。

二、数值的整数次方

2.1、题目描述

实现 n class=“nolink”>pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。

2.2、思路

分治算法+递归。如果要计算 $x^{64}$ ，可以按照：x–> $x^{2}$ --> $x^{4}$ --> $x^{16}$ --> $x^{32}$ --> $x^{64}$ 的顺序，从x 开始，每次直接把上一次的结果进行平方，计算6次就可以得到 $x^{64}$ 的值，而不需要对x 乘63 次 x。

再比如，如果要计算 $x^{77}$ ，可以按照：x–> $x^{2}$ --> $x^{4}$ --> $x^{9}$ --> $x^{19}$ --> $x^{38}$ --> $x^{77}$ 的顺序，可以看到把上一次的结果进行平方后，还要额外乘一个x。

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

当要计算 $x^{n}$ 时，先递归地计算出 $y=x^{n /2}$ 。
根据递归计算的结果，如果n 为偶数，那么 $x^{n}=y^2$ ；如果n为奇数，那么 $x^{n}=y^2 \times x$ 。
递归的边界为 0，任意数的0 次方均为 1。

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

2.3、代码实现

class Solution {
public:
    double quikly(double x, long long n)
    {
        if(n==0)
            return 1.0;
        double cnt=quikly(x,n/2);
        return n%2==0?cnt*cnt:cnt*cnt*x;
    }
    double myPow(double x, int n) {
        long long N=n;
        return N<0?1.0/quikly(x,-N):quikly(x,N);
            
    }
};

2.4、小结

快速幂的本质是分治法。

三、计算二进制中1的个数

3.1、题目描述

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量).）。

示例 1：

输入：n = 11 (控制台输入 00000000000000000000000000001011)
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。

示例 2：

输入：n = 128 (控制台输入 00000000000000000000000010000000)
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。

示例 3：

输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

来源：力扣（LeetCode）

3.2、思路

计算二进制中1的个数，首先想到位运算；利用位运算的性质加速我们的检查过程，在实际代码中不断右移一位，同时判断当前的最低位是否为1来统计个数。

3.3、代码实现

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count=0;
        while(n)
        {
            if(n&1)
                count++;
            n>>=1;
        }
        return count;
    }
};