剑指offer 刷题 二十四 数学（14-I 57-II 62）

剑指 Offer 14- I. 剪绳子

直接不会。看2个大佬的思路和代码吧：






下面是我根据大佬思路，自己写的代码：

def cuttingRope(self, n: int) -> int:
        if n <=3: return n - 1
        else:
            a = n // 3
            b = n % (3 * a)
            if b == 0: return int(math.pow(3, a))
            elif b == 1: return int(math.pow(3, a-1) * 4)
            elif b == 2: return int(math.pow(3, a) * 2)

每次根据大佬的思路，都可以写出代码，所以关键还是思路问题。

大佬代码：

class Solution:
    def cuttingRope(self, n: int) -> int:
        if n <= 3: return n - 1
        a, b = n // 3, n % 3
        if b == 0: return int(math.pow(3, a))
        if b == 1: return int(math.pow(3, a - 1) * 4)
        return int(math.pow(3, a) * 2)

贪心算法：

class Solution {
    public int cuttingRope(int n) {
        if(n == 2)return 1;
        if(n == 3)return 2;
        if(n == 4)return 4;
        int res = 1;
        while(n > 4){
            res *= 3;
            n -= 3;
        }
        return res*n;
    }
}

动态规划的代码如下，我没看太懂：

class Solution {
    public int cuttingRope(int n) {
        //定义dp数组，dp[i]表示长度为i的绳子剪成m端后长度的最大乘积(m>1)
        int dp[] = new int[n+1];
        //初始化
        dp[2] = 1;
        //目标：求出dp[n]
        //dp[2]已知，从dp[3]开始求，直到求出dp[n]
        for(int i = 3;i <= n;i++){
            //首先对绳子剪长度为j的一段,其中取值范围为 2 <= j < i
            for(int j = 2;j < i;j++){
                
                //转移方程如下
                dp[i] = Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j]));
                //Math.max(j*(i-j),j*dp[i-j]是由于减去第一段长度为j的绳子后，可以继续剪也可以不剪
                //Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j]))是当j不同时，求出最大的dp[i]
            }
        }
        //现在已经求出每个长度i对应的最大乘积，返回dp[n]
        return dp[n];
    }
}

剑指 Offer 57 - II. 和为s的连续正数序列

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

写了一个冗长的暴力法：

def findContinuousSequence(self, target: int) -> List[List[int]]:
        res, temp,  = [], []
        cur, flag = 0, 0
        target_li = list(range(1, target + 1))
        while True:
            temp.append(target_li[cur])
            if sum(temp) >= target:
                if sum(temp) == target: res.append(temp)
                flag += 1
                cur = flag
                temp = []
                continue
            cur += 1
            if cur == target // 2 + 1:
                break
        return res

下面是我根据答案说可以用滑动窗口，自己写的滑动窗口：

def findContinuousSequence(self, target: int) -> List[List[int]]:
        left, right = 0, 0
        target_li = list(range(1, target + 1))
        res, temp = [], []
        while True:
            temp = target_li[left:right + 1]
            if sum(temp) < target: right += 1
            elif sum(temp) == target:
                left += 1
                res.append(temp)
            else: 
                left += 1
            if right > (target // 2) + 1: break
        return res

下面是大佬的思路和代码：




代码：

def findContinuousSequence(self, target: int) -> List[List[int]]:
    i = 1 # 滑动窗口的左边界
    j = 1 # 滑动窗口的右边界
    sum = 0 # 滑动窗口中数字的和
    res = []

    while i <= target // 2:
        if sum < target:
            # 右边界向右移动
            sum += j
            j += 1
        elif sum > target:
            # 左边界向右移动
            sum -= i
            i += 1
        else:
            # 记录结果
            arr = list(range(i, j))
            res.append(arr)
            # 左边界向右移动
            sum -= i
            i += 1

    return res

他用了sum这个变量，来进行加减，比我在速度上要快。我应该想到。

剑指 Offer 62. 圆圈中最后剩下的数字

写了半天，由于li是动态的，最后放弃了。
这道题根本不是简单题。







答案我都没看懂，回头翻过来再看一遍吧。

class Solution:
    def lastRemaining(self, n: int, m: int) -> int:
        x = 0
        for i in range(2, n + 1):
            x = (x + m) % i
        return x