【每日一题补】18-20??

第一题 最大人工岛

                

给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。

返回执行此操作后，grid 中最大的岛屿面积是多少？

岛屿 由一组上、下、左、右四个方向相连的 1 形成。

        对哪一个零格进行操作，能得到最大到域面积

        解题思路：1.所有相连的格子能组成一个岛屿，遍历所有岛屿，给其编号并且计算面积

                                保存到map中

                        2.遍历每个0格子，计算与其相邻的岛屿面积加上格子变为1以后的总面积

                         3.可以将遍历的格子编号设置成所在岛屿编号，避免重复遍历

class Solution:
    def largestIsland(self, grid: List[List[int]]) -> int:

        n = len(grid)  #记录表格长度
        if n == 0: return 1

        # 从2开始计数
        idx, area_dic = 2, dict()   #0,1已经被占用

        def dfs(idx, x, y):  #深度遍历
            
            if 0 <= x < n and 0 <= y < n and grid[x][y] == 1:

                grid[x][y] = idx
                a = dfs(idx, x - 1, y)
                b = dfs(idx, x + 1, y)
                c = dfs(idx, x, y - 1)
                d = dfs(idx, x, y + 1)
                
                return a + b + c + d + 1
            else:
                return 0

        # 给岛屿编号，只计算未编号的岛屿
        for i in range(n):
            for j in range(n):
                if grid[i][j] == 1:
                    area_dic[idx] = dfs(idx, i, j)
                    idx += 1

        # 无岛屿，全是海洋
        if len(area_dic) == 0: return 1

        res, sea = 0, False

        for i in range(n):
            for j in range(n):
                # area面积，cover避免重复计算
                area, cover = 0, []
                if grid[i][j] == 0:
                    area += 1
                    for ni, nj in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)]:
                        if 0 <= ni < n and 0 <= nj < n and grid[ni][nj] != 0 and grid[ni][nj] not in cover:
                            area += area_dic[grid[ni][nj]]
                            cover.append(grid[ni][nj])
                    sea = True
                    res = max(res, area)
        
        # 如果没有海洋
        if not sea: return n * n

        return res

题目二：按照频率数组升序排序

                题目描述：

给你一个整数数组 nums ，请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同，请你按照数值本身将它们 降序 排序。 

请你返回排序后的数组。

class Solution:
    def frequencySort(self, nums: List[int]) -> List[int]:
        cnt = Counter(nums)  #count()统计每个数字出现的次数
        nums.sort(key=lambda x: (cnt[x], -x))  #？ 
        return nums

题目三：划分为K个相等的子集

                题目描述：

                

                        给定一个整数数组  nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。

                解法一：

题目给定长度为 nn 的数组 \textit{nums}nums，和整数 kk，我们需要判断是否能将数组分成 kk 个总和相等的非空子集。首先计算数组的和 \textit{all}all，如果 \textit{all}all 不是 kk 的倍数，那么不可能能有合法方案，此时直接返回 \text{False}False。否则我们需要得到 kk 个和为 per= 
k/all的集合，那么我们每次尝试选择一个还在数组中的数，若选择后当前已选数字和等于 \textit{per}per 则说明得到了一个集合，而已选数字和大于 \textit{per}per 时，不可能形成一个集合从而停止继续往下选择新的数字。又因为 nn 满足 1 \le n \le 161≤n≤16，所以我们可以用一个整数 SS 来表示当前可用的数字集合：从低位到高位，第 ii 位为 11 则表示数字 \textit{nums}[i]nums[i] 可以使用，否则表示 \textit{nums}[i]nums[i] 已被使用。为了避免相同状态的重复计算，我们用 \textit{dp}[S]dp[S] 来表示在可用的数字状态为 SS 的情况下是否可行，初始全部状态为记录为可行状态 \text{True}True。这样我们就可以通过记忆化搜索这种「自顶向下」的方式来进行求解原始状态的可行性，而当状态集合中不存在任何数字时，即 S = 0S=0 时，表示原始数组可以按照题目要求来进行分配，此时返回 \text{True}True 即可。

class Solution:
    def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:
        all = sum(nums)
        if all % k:
            return False
        per = all // k
        nums.sort()  # 方便下面剪枝
        if nums[-1] > per:
            return False
        n = len(nums)

        @cache
        def dfs(s, p):
            if s == 0:
                return True
            for i in range(n):
                if nums[i] + p > per:
                    break
                if s >> i & 1 and dfs(s ^ (1 << i), (p + nums[i]) % per):  # p + nums[i] 等于 per 时置为 0
                    return True
            return False
        return dfs((1 << n) - 1, 0)