leetcode5619.最小不兼容性

1. 元素按个数排序，再依次分配

class Solution:
    def minimumIncompatibility(self, nums: List[int], k: int) -> int:
        if len(nums)%k!=0:
            return -1
        dicta = {}
        for s in nums:
            if s not in dicta:
                dicta[s] =1
            else:
                dicta[s] +=1 
        flag = True          
        for key in dicta.keys():
            if dicta[key]>k:
                flag = False
                break  
        if not flag:
            return -1
        key_set = sorted(dicta.items(),key=lambda dicta:dicta[1],reverse=True)
        count = 0
        n = len(nums)//k
        min_sum=0
        result = []
        for m in range(k):
            res = []
            for i in range(len(key_set)):
                if dicta[key_set[i][0]]<=0:
                    continue
                res.append(key_set[i][0])
                dicta[key_set[i][0]] -=1
                if len(res)==n:
                    if res in result:
                        dicta[res[-1]] +=1
                        res.pop(-1)
                        continue
                    min_sum += max(res) - min(res) 
                    break 
            result.append(res)                       
        return min_sum

部分通过。。。。

2. 深度搜索：

class Solution:
    def minimumIncompatibility(self, nums: List[int], k: int) -> int:
        if len(nums)%k!=0:
            return -1
        dicta = {}
        for s in nums:
            if s not in dicta:
                dicta[s] =1
            else:
                dicta[s] +=1 
        flag = True          
        for key in dicta.keys():
            if dicta[key]>k:
                flag = False
                break  
        if not flag:
            return -1
        count = 0
        n = len(nums)//k
        min_sum=sum(nums)
        sets=[]
        for i in range(k):
            sets.append([])
        def dfs(i,sets):
            nonlocal n
            nonlocal min_sum
            if i ==len(nums):
                sum_val = 0
                for j in range(k):
                    sum_val += max(sets[j])- min(sets[j])
                min_sum = min(min_sum, sum_val)   
                return
            sum_val = sum([max(sub)- min(sub) if len(sub)>0 else 0 for sub in sets])
            if min_sum < sum_val:
                return     
            for sub_set in sets:
                if len(sub_set)==n:
                    continue
                if len(sub_set) <n and nums[i] not in sub_set:
                    sub_set.append(nums[i])
                    dfs(i+1,sets)
                    sub_set.remove(nums[i])
        dfs(0,sets)                        
        return min_sum

超时了，，，，

3.动态规划：

下一步更新。。。