数学题-Offer 39超过一半的数字、66构建乘积数组、14剪绳子i ii、57、62最后剩下的数字

剑指 Offer 39. 数组中出现次数超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
以前做过，这个数没遇到不同它的计数减一，遇到自己加一，如果计数等于0，说明该换另外一个数了。
出现的次数超过数组长度的一半的数，最后肯定是它生存下来。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        count = 0
        cur = None
        for x in nums:
            if x!=cur and count==0:
                cur = x
            elif x!=cur:
                count -= 1
            else:
                count += 1
        return cur

官方题解有三种方法：

官方投票法

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        votes = 0
        for num in nums:
            if votes == 0: x = num
            votes += 1 if num == x else -1
        return x

剑指 Offer 66. 构建乘积数组

给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。

输入: [1,2,3,4,5]
输出: [120,60,40,30,24]

看图才懂，


注意下三角从第二行开始，上三角从倒数第二行开始

class Solution:
    def constructArr(self, a: List[int]) -> List[int]:
        lens = len(a)
        b, c, tmp = [1] * lens, [1] * lens, 1
        for i in range(1, lens):
            b[i] = b[i - 1] * a[i - 1] # 下三角 累积
        # for i in range(len(a) - 2, -1, -1):
        #     tmp *= a[i + 1]            # 上三角
        #     b[i] *= tmp                # 下三角 * 上三角
        for i in range(lens-2, -1, -1):
            c[i] = c[i+1] * a[i+1]
        for i in range(0, lens):
            b[i] *= c[i]

        return b

剑指 Offer 14- I. 剪绳子

给你一根长度为 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。

假设动态规划能解决，应该有怎样的转移方程？

没绕过去，当减去j长度后，后面的怎么算，其实没有前后关系，只有数值关系。长度为x的绳子的最大成绩已经从前面得到了。前面减去j，到底后面的x怎么分，不用管。（容易漏掉，后面的x不分的情况。）
当6 = 3+3 = 2+2+2，所以存在不是越多段越好。

题解-动态规划

class Solution:
    def cuttingRope(self, n: int) -> int:
        dp = [0] * (n+1)
        dp[2] = 1
        for i in range(3, n+1):
            temp = 0
            for j in range(2,i): # 不同位置分割，dp[i]不一样
                res = max(j * (i-j), j * dp[i-j])
                if res>temp: temp=res
            dp[i] = temp
        return dp[n]

题解-贪心算法
涉及到数学推导得到的结论

1. 将绳子 以相等的长度等分为多段 ，得到的乘积最大。
2. 尽可能将绳子以长度 3 等分为多段时，乘积最大。
   
   

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)

特殊情况：
2=1+1 max=1
3=1+2 max=2
4=2+2=1+3 max=4

class Solution:
    def cuttingRope(self, n: int) -> int:
        if n < 4:
            return n - 1
        res = 1
        # 对3求余，有0,1,2的情况。
        # 这里n最后只能为4,3,2
        while n > 4: 
            res *=3
            n -= 3
        return res * n

剑指 Offer 14- II. 剪绳子 II

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

该题不能用动态规划，求余后数值会变，不符合状态转移。
其实切法是一样的，因为也是要得到最大值，只不过最大值要求余后返回，在切的过程中，可能会大于模。

贪心算法，上一题解法一样

class Solution:
    def cuttingRope(self, n: int) -> int:
        if n < 4:
            return n - 1
        res = 1
        p = int(1e9 + 7) # 需要int
        while n > 4:
            res = res * 3 % p
            n -= 3
        return res * n % p

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

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

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

class Solution:
    def findContinuousSequence(self, target: int) -> List[List[int]]:
        end = target // 2
        out = []
        for i in range(1, end+1):
            temp = [i]
            count = i
            for j in range(i+1, end+2): # 9,end=4,但4+5=9
                temp.append(j)
                count += j
                if count == target:
                    out.append(temp)
                    break
                if count >target:
                    break
        return out

题解=滑动窗口（双指针）

跳出条件为什么是i>=j，假设i，j相邻，如果此时i还有向右移，说明i+j已经大于target，移动之后j+j更加大于target。

class Solution:
    def findContinuousSequence(self, target: int) -> List[List[int]]:
        i, j, s, res = 1, 2, 3, []
        while i < j:
            if s == target:
                res.append(list(range(i, j + 1)))
                s -= i
                i += 1
            elif s > target:
                s -= i
                i += 1
            else:
                j += 1
                s += j
        return res

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

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

list列表中有pop函数。

动态规划和递归：

只看文字，把我绕了很久才懂它的逻辑在哪。

现在有n,m问题，删除一个之后，它要从m作为第一个元素，所以index改变。原本0号，变成t号索引。刚刚删除了m-1号索引，
变成n-1，m问题，它也会删除一个索引变成n-2，m的问题，其中要重新调整位置，index会经过变换，
最后变成1，m问题，它肯定删除0号索引，它也是最后一个要删除的元素，就是我们想要的解，但是它在1，m问题中是0号索引，但是它是通过2，m问题变换来的，
现在我们可以通过递推索引的变换，求得1，m问题中的0号索引，在n，m问题中到底是哪个索引。

因为索引从0开始，第m个元素，其实是m-1索引，所以从m索引开始。 t = m % n

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