Leetcode从双倍数组中还原原数组

最新推荐文章于 2024-05-22 18:44:11 发布

梦想闹钟

最新推荐文章于 2024-05-22 18:44:11 发布

阅读量84

点赞数

分类专栏： Leetcode中等题文章标签： leetcode 算法 python

本文链接：https://blog.csdn.net/qq_43199509/article/details/129886301

版权

Leetcode中等题专栏收录该内容

43 篇文章 0 订阅

订阅专栏

在这里插入图片描述
我的想法：
首先判断长度是否是偶数，奇数长度的数组必然不可能
然后奇数一定是在返回答案里的，需要考虑的是偶数，还有就是0这个2倍是自身的情况

class Solution:
    def findOriginalArray(self, changed: List[int]) -> List[int]:
        from sortedcontainers import SortedList
        list_len=len(changed)
        if list_len%2==1:
           return []
        even_list=SortedList()
        odd_list=[]
        ans=[]
        for each_num in changed:
            if each_num%2==1:
               odd_list.append(each_num)
               ans.append(each_num)
            else:
               even_list.add(each_num)
        for each_num in ans:
            if each_num*2 in even_list:
               even_list.remove(each_num*2)
            else:
               return []  
        if len(even_list)%2==1:
           return []                  
        while(len(even_list)>1):
            temp=even_list[-1]
            even_list.remove(even_list[-1])
            if temp//2 in even_list:
              ans.append(temp//2)
              even_list.remove(temp//2)
        if len(even_list)>0:
           return []
        return ans

标准解法：
用了collections.counter这个python内置库，还有列表的sort直接排序代替了我之前的操作，速度提升了很多，最后只要遍历一遍即可（python的一些自带库底层是c写的所以快）

class Solution:
    def findOriginalArray(self, changed: List[int]) -> List[int]:
        if len(changed) % 2 != 0:
            return []
        
        dic = collections.Counter(changed)
        a = list(set(changed))
        a.sort()
        ans = []

        for each in a:
            if each == 0:
                if dic[each] % 2 != 0:
                    return []
                else:
                    ans.extend([0] * int(dic[each]/2))
            elif dic[each]:
                b = int(each*2)
                if b not in dic:
                    return []
                else:
                    if dic[b] < dic[each]:
                        return []
                    else:
                        ans.extend([each] * dic[each])
                        dic[b] -= dic[each]

        if len(ans) == int(len(changed)/2):
            return ans
        else:
            return []