【leetcode刷题】410、1025、329、392、面试题 08.03

410. 分割数组的最大值

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        '''
        二分法
        时间复杂度：(N log Sum)
        空间复杂度：O(1)
        '''
        left , right = max(nums), sum(nums)
        while left < right:
            mid = (left + right) // 2
            sums, count = 0, 1
            for i in nums:
                if sums + i > mid:
                    count += 1
                    sums = i
                else:
                    sums += i
            if count <= m:
                right = mid 
            else:
                left = mid + 1
        return left 

1025. 除数博弈
1.数字N如果是奇数，它的约数（因子）必然都是奇数；若为偶数，则其约数可奇可偶。
2. 无论N初始为多大的值，游戏最终只会进行到N=2时结束，那么谁轮到N=2时谁就会赢。
3. 因为爱丽丝先手，N初始若为偶数，爱丽丝则只需一直选1，使鲍勃一直面临N为奇数的情况，这样爱丽丝稳赢；
N初始若为奇数，那么爱丽丝第一次选完之后N必为偶数，那么鲍勃只需一直选1就会稳赢。
综述，判断N是奇数还是偶数，即可得出最终结果！

from functools import lru_cache
class Solution:
    @lru_cache(maxsize = None)    #  加缓存
    def divisorGame(self, N: int) -> bool:
        # 方法一：数学找规律
        # return not N % 2
        # 方法二：DP
        # if N <= 1:
        #     return False 
        # elif N == 2:
        #     return True 
        # elif N == 3:
        #     return False 
        # return any([self.divisorGame(x) for x in range(1, (N)) if N % x == 0])
        # 方法三：位运算
        return not N & 1

329 .329. 矩阵中的最长递增路径

排序+动态规划

def longestIncreasingPath( matrix):
   # 对 matrix 里面的每个元素看，在上、下、左、右四个方向上，matrix[i][j[ 的值有几个大于四周的值的，、
   # 若有，记录1
    def dfs(i, j):
        if not dp[i][j]:
            val = matrix[i][j]
            dp[i][j] = 1 + max(
                dfs(i - 1, j) if i and val > matrix[i - 1][j] else 0,
                dfs(i + 1, j) if i < M - 1 and val > matrix[i + 1][j] else 0,
                dfs(i, j - 1) if j and val > matrix[i][j - 1] else 0,
                dfs(i, j + 1) if j < N - 1 and val > matrix[i][j + 1] else 0)
        print(dp[i][j])
        return dp[i][j]

    if not matrix : return 0
    M, N = len(matrix), len(matrix[0])
    dp = [[0] * N for i in range(M)]  # 定义与 matrix大小相同的 dp 列表，并且用 0 来填充
    #   那我在能选的选项里选哪个？选上、下、左、右中可选方向值最大的
    return max(dfs(x, y) for x in range(M) for y in range(N)) 

392. 判断子序列

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        t = iter(t)
        return all(c in t for c in s)

322. 零钱兑换

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        max_ = float('inf')
        dp = [0] + [max_] * amount
        for i in range(1, amount + 1):
            dp[i] = 1 + min(dp[i - c] if i - c >= 0 else max_ for c in coins)
        return [dp[amount], -1][dp[amount] == max_]

343. 整数拆分

# 数学的方法
class Solution:
    def integerBreak(self, n: int) -> int:
        if n <= 3:return n - 1
        q, r = n // 3, n % 3
        if r == 0:return int(math.pow(3, q))
        elif r == 1:return int(math.pow(3, q - 1) * 4)
        else: return int(math.pow(3, q) * 2)

# 递归的方法
class Solution:
    @lru_cache(maxsize = None)
    def integerBreak(self, n: int) -> int:
        if n==2:
            return 1
        if n == 3:
            return 2
        def IB(n):
            if n<=4:
                return n
            else:
                return 3*IB(n-3)
        return IB(n)

参考
面试题 08.03. 魔术索引

class Solution:
    def findMagicIndex(self, nums: List[int]) -> int:
        # 因为有序，本题采用二分的思想
        if not nums:
            return -1 
        i, n = 0, len(nums)
        while i < n:
            if nums[i] == i:
                return i 
            if nums[i] > i:  # 此时我们可以排除索引i到nums[i-1]这一整段
                i = nums[i]  # 由于数组可以保持平稳，所以nums[i]这一元素不可排除
            else:
                i += 1
        return -1 

class Solution:
    def findMagicIndex(self, nums: List[int]) -> int:
        for i, num in enumerate(nums):
            if i == num:
                return i 
        return -1