Weekly Contest 114

最新推荐文章于 2021-07-18 20:07:17 发布

Briwisdom

最新推荐文章于 2021-07-18 20:07:17 发布

阅读量231

点赞数

分类专栏： LeetCode/竞赛/算法分析

本文链接：https://blog.csdn.net/u010420283/article/details/84925816

版权

LeetCode/竞赛/算法分析专栏收录该内容

57 篇文章 0 订阅

订阅专栏

1675 / 3198,(1/5)

953. 验证外星语词典

题目描述（简单）

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例 1：

输入：words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出：true
解释：在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。

示例 2：

输入：words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出：false
解释：在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：

输入：words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出：false
解释：当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小（更多信息）。

提示：

1 <= words.length <= 100
1 <= words[i].length <= 20
order.length == 26
在 words[i] 和 order 中的所有字符都是英文小写字母。

代码

我的代码：

class Solution:
    def judgeOrder(self,c1,c2,order):
        if order.index(c1)<=order.index(c2):
            return True
        else:
            return False
    def isAlienSorted(self, words, order):
        """
        :type words: List[str]
        :type order: str
        :rtype: bool
        """
        for i in range(len(words)-1):
            w1=words[i]
            w2=words[i+1]
            j=0
            while j<min(len(w1),len(w2)):
                if w1[j]==w2[j] and j!=min(len(w1),len(w2))-1:
                    j+=1
                elif w1[j]==w2[j] and j==min(len(w1),len(w2))-1:
                    if len(w1) > len(w2):
                        return False
                    else:
                        break
                else:
                    boo=self.judgeOrder(w1[j],w2[j],order)
                    if boo==False:
                        return boo
                    else:
                        break
        return True

牛人代码：

代码1和代码11,都是先将words里面所有单词按照给定order排序，然后如果和原始words相等则返回True，否则False，代码11更简单明了，易于读懂。而代码1使用python内置的ord()和chr()函数，没太理解……

class Solution:
    def isAlienSorted(self, words, order):
        """
        :type words: List[str]
        :type order: str
        :rtype: bool
        """
        rep = ['a'] * 26
        for i, c in enumerate(order):
            rep[ord(c) - ord('a')] = chr(i + ord('a'))
        for i in range(len(words)):
            words[i] = ''.join([rep[ord(c) - ord('a')] for c in words[i]])

        return words == sorted(words)

代码11

class Solution(object):
    def isAlienSorted(self, words, order):
        """
        :type words: List[str]
        :type order: str
        :rtype: bool
        """
        o = {v: k for k, v in enumerate(order)}
        W = words[:]
        W.sort(key=lambda x: [o[c] for c in x])
        return W == words

代码2，首先将每一个单词字符用其在order的排序位置替代，然后直接用内置new_words[i] > new_words[i+1]直接判断。

class Solution:
    def isAlienSorted(self, words, order):
        """
        :type words: List[str]
        :type order: str
        :rtype: bool
        """    
        new_words = [[order.index(char) for char in word] for word in words]
        for i in range(len(new_words)-1):
            if new_words[i] > new_words[i+1]:
                return False
        return True

954. 二倍数对数组

题目描述

给定一个长度为偶数的整数数组 A，只有对 A 进行重组后可以满足 “对于每个 0 <= i < len(A) / 2，都有 A[2 * i + 1] = 2 * A[2 * i]” 时，返回 true；否则，返回 false。

示例 1：

输入：[3,1,3,6]
输出：false

示例 2：

输入：[2,1,2,6]
输出：false

示例 3：

输入：[4,-2,2,-4]
输出：true
解释：我们可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]

示例 4：

输入：[1,2,4,16,8,4]
输出：false

提示：

0 <= A.length <= 30000
A.length 为偶数
-100000 <= A[i] <= 100000

代码

我的代码（超时）：

思想：先数组排序，将正负数分开。遍历 i，如果发现A[2 * i + 1] != 2 * A[2 * i],返回false。

class Solution:
    def judge(self,A):
        if len(A)==0:
            return True
        new_A=[i for i in A if i >0]
        if (len(A)-len(new_A))%2 !=0:
            return False
        else:
            while len(A):
                f=A[0]
                if 2*f in A:
                    A.remove(2*f)
                    A.remove(f)
                else:
                    return False
            return True

    def canReorderDoubled(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        if len(A)==0:
            return True
        A.sort()
        AA=[]
        B=[]
        for i in range(len(A)):
            if A[i]>=0:
                B=A[i:]
                break
            else:
                AA.append(-A[i])
        if len(AA)%2!=0:
            return False
        AA.sort()
        j1=self.judge(AA)
        j2=self.judge(B)
        if j1 and j2:
            return True
        else:
            return False

牛人代码：

解法1，使用了字典序

class Solution:
    def canReorderDoubled1(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        from collections import Counter
        cnt = Counter(A)
        nums = sorted(cnt.keys(), key=abs)
        num_ptr = 0
        while num_ptr < len(nums):
            if cnt[nums[num_ptr]] <= 0:
                num_ptr += 1
            else:
                num = nums[num_ptr]
                cnt[num] -= 1
                if cnt[num * 2] <= 0:
                    return False
                else:
                    cnt[num * 2] -= 1
        return True

解法2，将从0-200010代替A的数值，类似字典序

class Solution:
    def canReorderDoubled2(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        def check(A):
            A.sort()
            cnts = [0] * 200010
            for x in A: cnts[x] += 1
            while A:
                x = A.pop()
                if cnts[x] == 0: continue
                cnts[x] -= 1
                if x % 2: return False
                hf = x // 2
                if cnts[hf] == 0: return False
                cnts[hf] -= 1
            return True

        pos, neg = [], []
        for x in A:
            if x >= 0:
                pos.append(x)
            else:
                neg.append(-x)
        return check(pos) and check(neg)

955. 删列造序 ||

题目描述

给定由 N 个小写字母字符串组成的数组 A，其中每个字符串长度相等。

选取一个删除索引序列，对于 A 中的每个字符串，删除对应每个索引处的字符。

比如，有 A = ["abcdef", "uvwxyz"]，删除索引序列 {0, 2, 3}，删除后 A 为["bef", "vyz"]。

假设，我们选择了一组删除索引 D，那么在执行删除操作之后，最终得到的数组的元素是按 字典序（A[0] <= A[1] <= A[2] ... <= A[A.length - 1]）排列的，然后请你返回 D.length 的最小可能值。

例 1：

输入：["ca","bb","ac"]
输出：1
解释： 
删除第一列后，A = ["a", "b", "c"]。
现在 A 中元素是按字典排列的 (即，A[0] <= A[1] <= A[2])。
我们至少需要进行 1 次删除，因为最初 A 不是按字典序排列的，所以答案是 1。

示例 2：

输入：["xc","yb","za"]
输出：0
解释：
A 的列已经是按字典序排列了，所以我们不需要删除任何东西。
注意 A 的行不需要按字典序排列。
也就是说，A[0][0] <= A[0][1] <= ... 不一定成立。

示例 3：

输入：["zyx","wvu","tsr"]
输出：3
解释：
我们必须删掉每一列。

提示：

1 <= A.length <= 100
1 <= A[i].length <= 100

代码

未完待续……

956. 最高的广告牌（困难）

题目描述

你正在安装一个广告牌，并希望它高度最大。这块广告牌将有两个钢制支架，两边各一个。每个钢支架的高度必须相等。你有一堆可以焊接在一起的钢筋 rods。举个例子，如果钢筋的长度为 1、2 和 3，则可以将它们焊接在一起形成长度为 6 的支架。返回广告牌的最大可能安装高度。如果没法安装广告牌，请返回 0。

示例 1：

输入：[1,2,3,6]
输出：6
解释：我们有两个不相交的子集 {1,2,3} 和 {6}，它们具有相同的和 sum = 6。

示例 2：

输入：[1,2,3,4,5,6]
输出：10
解释：我们有两个不相交的子集 {2,3,5} 和 {4,6}，它们具有相同的和 sum = 10。

示例 3：

输入：[1,2]
输出：0
解释：没法安装广告牌，所以返回 0。

提示：

0 <= rods.length <= 20
1 <= rods[i] <= 1000
钢筋的总数最多为 5000 根

代码

未完待续……

Briwisdom

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录