Leetcode简单题41~60

Posted 2020-11-26 xhw19950606

41.思路：分别在列表中存放两个单词的索引，再用两次遍历求距离
# 给定一个单词列表和两个单词 word1 和 word2，返回列表中这两个单词之间的最短距离。
# 示例:
# 假设 words = ["practice", "makes", "perfect", "coding", "makes"]
# 输入: word1 = “coding”, word2 = “practice”
# 输出: 3
# 输入: word1 = "makes", word2 = "coding"
# 输出: 1
#me
class Solution0(object):
    def shortestDistance(self, words, word1, word2):
        result = []
        idwords1 = [id_ for id_,word in enumerate(words) if word == word1]
        idwords2 = [id_ for id_,word in enumerate(words) if word == word2]
        for id1 in idwords1:
            for id2 in idwords2:
                result.append(abs(id1-id2))
        return min(result)
#other 复杂度O(n)
class Solution1(object):
    def shortestDistance(self, words, word1, word2):
        n = m = min_distance = size = len(words)
        for i in range(size):
            if words[i] == word1:
                n = i
            elif words[i] == word2:
                m = i
            if m != size and m != size:
                min_distance = min(min_distance, abs(m - n))
        return min_distance

*42.思路：奇数移动到奇数、偶数移动到偶数是无消耗的，意思是算奇数和偶数的个数。
# 数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
# 你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
# 将第 i 个筹码向左或者右移动 2 个单位，代价为 0。
# 将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
# 最开始的时候，同一位置上也可能放着两个或者更多的筹码。
# 返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
# 示例 1：
# 输入：chips = [1,2,3]
# 输出：1
# 解释：第二个筹码移动到位置三的代价是 1，第一个筹码移动到位置三的代价是 0，总代价为 1。
# 示例 2：
# 输入：chips = [2,2,2,3,3]
# 输出：2
# 解释：第四和第五个筹码移动到位置二的代价都是 1，所以最小总代价为 2。
#me
class Solution(object):
    def minCostToMoveChips(self, chips):
        jiShuNum = len([i for i in chips if i%2 == 1])
        ouShuNum = len([j for j in chips if j%2 == 0])
        return min([jiShuNum,ouShuNum])

43.思路：直述题意
# 给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。
# 你可以按任意顺序返回答案。
# 示例 1：
# 输入：["bella","label","roller"]
# 输出：["e","l","l"]
# 示例 2：
# 输入：["cool","lock","cook"]
# 输出：["c","o"]
#me
class Solution0(object):
    def commonChars(self, A):
        allSigWord = []
        for word in A:
            for sigword in word:
                allSigWord.append(str(sigword))
        allReWord = [i for i in allSigWord if allSigWord.count(i)>=len(A)]
        result = []
        for sigReWord in set(allReWord):
            allnum = []
            for word in A:
                allnum.append(word.count(sigReWord))
            for i in range(min(allnum)):
                result.append(sigReWord)
        return(result)
#other
#思路：使用Counter得到每个字符串的字典，字典相交，然后转换为list输出
#counter是 colletions内的一个类,可以理解为一个简单的计数器，可以统计字符出现的个数
from collections import Counter
class Solution1(object):
    def commonChars(self, A):
        ans = Counter(A[0])
        for i in range(1, len(A)):
            ans &= Counter(A[i])
        return list(ans.elements())
#other
class Solution:
    def commonChars(self, A):
        return [i for c in set(A[0]) for i in c * min(w.count(c) for w in A)] if A else []

44.思路：直述题意
# 给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。
# 示例 1:
# 输入: S = "loveleetcode", C = ‘e‘
# 输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]
#me
class Solution0(object):
    def shortestToChar(self, S, C):
        C_ids = [Id for Id,s in enumerate(S) if s==C]
        result = []
        for Id,s in enumerate(S):
            mid = []
            for C_id in C_ids:
                mid.append(abs(Id-C_id))
            result.append(min(mid))
        return result
#other
class Solution1(object):
    def shortestToChar(self, S, C):
        return [min([abs(i - j) for j in [k for k, c in enumerate(S) if c == C]]) for i in range(len(S))]

45.思路：1.使用列表存放最后两个数的和，2.递归算法
# 斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
# F(0) = 0,   F(1) = 1
# F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
# 给定 N，计算 F(N)。
# 示例 1：
# 输入：2
# 输出：1
# 解释：F(2) = F(1) + F(0) = 1 + 0 = 1.
# 示例 2：
# 输入：3
# 输出：2
# 解释：F(3) = F(2) + F(1) = 1 + 1 = 2.
# 示例 3：
# 输入：4
# 输出：3
# 解释：F(4) = F(3) + F(2) = 2 + 1 = 3.
#me
class Solution0(object):
    def fib(self, N):
        resultList = [0,1]
        if N == 2:
            return 1
        else:
            while(N):
                resultList.append(resultList[-1]+resultList[-2])
                N-=1
            return resultList[-2]
#other
class Solution1(object):
    def fib(N):
        if N in [0, 1]:
            return N
        a, b = 0, 1
        while N > 1:
            a, b = b, a + b
            N -= 1
        return b
class Solution2(object):
    class Solution():
        def Fibnacci(self, n):
            if n <= 0:
                return 0
            if n == 1:
                return 1
            return self.Fibnacci(n - 1) + self.Fibnacci(n - 2)

46.思路：while循环，直到各个位数相加之和为一位数。
# 给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
# 示例:
# 输入: 38
# 输出: 2
# 解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
#me
class Solution0(object):
    def addDigits(self, num):
        while(len(str(num))-1):
            num = sum([int(i) for i in list(str(num))])
        return str(num)[-1]
#other
class Solution1(object):
    def addDigits(self, num):
        while len(str(num)) > 1:
            num = eval("+".join(list(str(num))))
        return num

47.思路：1.直述题意，2.模拟法（动态规划）
#给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
#在杨辉三角中，每个数是它左上方和右上方的数的和
#示例:
# 输入: 5
# 输出:
# [
#      [1],
#     [1,1],
#    [1,2,1],
#   [1,3,3,1],
#  [1,4,6,4,1]
# ]
#me
class Solution0(object):
    def generate(self, numRows):
        Result = [(i+1)*[1] for i in range(numRows)]
        if numRows <=2:
            return Result
        else:
            for i in range(2,numRows):
                for j in range(1,len(Result[i])-1):
                    Result[i][j] = Result[i-1][j-1]+Result[i-1][j]
            return Result
#other
# 1.初始化结果数组，numRowsnumRows表示结果数组dpdp的行数，每一行的元素个数等于所处第几行。全部初始化为0
# 2.将边界全部初始化为1
# 3.遍历dpdp，将为00的位置使用动态规划填入，公式：dp[i][j]=dp[i-1][j-1]+dp[i-1][j]dp[i][j]=dp[i−1][j−1]+dp[i−1][j]
class Solution:
    def generate(self, numRows):
        dp=[[0]*n for n in range(1,numRows+1)]
        for i in range(numRows):
            dp[i][0]=dp[i][-1]=1
        for i in range(0,numRows):
            for j in range(i+1):
                if(dp[i][j]==0):
                    dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
        return dp

48.思路：直述题意
# 给出一个按 非递减 顺序排列的数组 nums，和一个目标数值 target。假如数组 nums 中绝大多数元素的数值都等于 target，则返回 True，否则请返回 False。
# 所谓占绝大多数，是指在长度为 N 的数组中出现必须 超过 N/2 次。
#me
class Solution(object):
    def isMajorityElement(self, nums, target):
        return bool(nums.count(target)>len(nums)//2)

49.思路：先处理"C"操作，再进行其他操作
# 你现在是棒球比赛记录员。
# 给定一个字符串列表，每个字符串可以是以下四种类型之一：
# 1.整数（一轮的得分）：直接表示您在本轮中获得的积分数。
# 2. "+"（一轮的得分）：表示本轮获得的得分是前两轮有效 回合得分的总和。
# 3. "D"（一轮的得分）：表示本轮获得的得分是前一轮有效 回合得分的两倍。
# 4. "C"（一个操作，这不是一个回合的分数）：表示您获得的最后一个有效 回合的分数是无效的，应该被移除。
# 每一轮的操作都是永久性的，可能会对前一轮和后一轮产生影响。
# 你需要返回你在所有回合中得分的总和。
# 示例 1:
# 输入: ["5","2","C","D","+"]
# 输出: 30
# 解释:
# 第1轮：你可以得到5分。总和是：5。
# 第2轮：你可以得到2分。总和是：7。
# 操作1：第2轮的数据无效。总和是：5。
# 第3轮：你可以得到10分（第2轮的数据已被删除）。总数是：15。
# 第4轮：你可以得到5 + 10 = 15分。总数是：30。
# 示例 2:
# 输入: ["5","-2","4","C","D","9","+","+"]
# 输出: 27
# 解释:
# 第1轮：你可以得到5分。总和是：5。
# 第2轮：你可以得到-2分。总数是：3。
# 第3轮：你可以得到4分。总和是：7。
# 操作1：第3轮的数据无效。总数是：3。
# 第4轮：你可以得到-4分（第三轮的数据已被删除）。总和是：-1。
# 第5轮：你可以得到9分。总数是：8。
# 第6轮：你可以得到-4 + 9 = 5分。总数是13。
# 第7轮：你可以得到9 + 5 = 14分。总数是27。
#me
class Solution0(object):
    def calPoints(self, ops):
        for ele in ops:
            if ele == ‘C‘:
                ops = ops[:ops.index(ele) - 1] + ops[ops.index(ele) + 1:]
        result = 0
        for i in ops:
            if i == ‘D‘:
                result += int(ops[ops.index(i) - 1]) * 2
                ops[ops.index(i)] = int(ops[ops.index(i) - 1]) * 2
            elif i == ‘+‘:
                result += (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))
                ops[ops.index(i)] = (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))
            else:
                result += int(i)
        return result
#other
class Solution1(object):
    def calPoints(self, ops):
        stack = []
        for op in ops:
            if op == ‘+‘:
                stack.append(stack[-1] + stack[-2])
            elif op == ‘C‘:
                stack.pop()
            elif op == ‘D‘:
                stack.append(2 * stack[-1])
            else:
                stack.append(int(op))
        return sum(stack)

50.思路：转换思想，找出最长的字符串
# 给定两个字符串，你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
# 子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
# 输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。
# 示例 :
# 输入: "aba", "cdc"
# 输出: 3
# 解析: 最长特殊序列可为 "aba" (或 "cdc")
#me
class Solution0(object):
    def findLUSlength(self, a, b):
        na = a if len(a)>len(b) else b
        nb = b if len(b)<len(a) else a
        result = []
        for i in range(len(na)-1):
            for j in range(1,len(na)+1):
                sub = na[i:j]
                print(sub)
                if sub not in nb:
                    result.append(len(sub))
        if result != []:
            return max(result)
        else:
            return -1
#other
class Solution1(object):
    def findLUSlength(self, a, b):
        if a == b:
            return -1
        elif len(a) > len(b):
            return len(a)
        else:
            return len(b)

51.思路：转换思想，求差值
# 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
# 说明：
# 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
# 示例 1:
# 输入: [2,2,1]
# 输出: 1
# 示例 2:
# 输入: [4,1,2,1,2]
# 输出: 4
#other
class Solution1(object):
    def singleNumber(self, nums):
        return sum(set(nums))*2-sum(nums)

52.思路：用集合来判断糖果的种类个数，因为弟弟和妹妹两个人糖果数一样，所以总个数的一半为界
# 给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。
# 示例 1:
# 输入: candies = [1,1,2,2,3,3]
# 输出: 3
# 解析: 一共有三种种类的糖果，每一种都有两个。
# 最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
# 示例 2 :
# 输入: candies = [1,1,2,3]
# 输出: 2
# 解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
#me
class Solution(object):
    def distributeCandies(self, candies):
        return len(set(candies)) if len(set(candies))<=len(candies)//2 else len(candies)//2

*53.思路：通过栈来实现
# 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
# 在 S 上反复执行重复项删除操作，直到无法继续删除。
# 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
# 示例：
# 输入："abbaca"
# 输出："ca"
# 解释：
# 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
#me
#栈的思想
class Solution(object):
    def removeDuplicates(self, S):
        Stack = []
        for s in S:
            if Stack == []:
                Stack.append(s)
            elif s!= Stack[-1]:
                Stack.append(s)
            else:
                Stack.pop()
        return ‘‘.join(Stack)

54.思路：直述题意
# 给你两个数组，arr1 和 arr2，
# arr2 中的元素各不相同
# arr2 中的每个元素都出现在 arr1 中
# 对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
# 示例：
# 输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
# 输出：[2,2,2,1,4,3,3,9,6,7,19]
#me
class Solution(object):
    def relativeSortArray(self, arr1, arr2):
        orgarr2 = list(arr2)
        containList = [i for i in arr1 if i in arr2]
        notContainList = sorted([i for i in arr1 if i not in arr2])
        for i in containList:
            arr2.insert(arr2.index(i),i)
        midResult = arr2+notContainList
        for i in orgarr2:
            midResult.remove(i)
        return midResult
#other
class Solution1(object):
    def relativeSortArray(self, arr1, arr2):
        arr3 = []
        set_2 = set(arr2)
        for i in arr1[::-1]:
            if i not in set_2:
                arr1.remove(i)
                arr3.append(i)
        arr3.sort(reverse = True)
        for i in arr2[::-1]:
            num = arr1.count(i)
            arr3.extend([i for j in range(num)])
        return arr3[::-1]

55.思路：直述题意
# 给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
# 假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
# 注意：每次拼写时，chars 中的每个字母都只能用一次。
# 返回词汇表 words 中你掌握的所有单词的 长度之和。
# 示例 1：
# 输入：words = ["cat","bt","hat","tree"], chars = "atach"
# 输出：6
# 解释：
# 可以形成字符串 "cat" 和 "hat"，所以答案是 3 + 3 = 6。
# 示例 2：
# 输入：words = ["hello","world","leetcode"], chars = "welldonehoneyr"
# 输出：10
# 解释：
# 可以形成字符串 "hello" 和 "world"，所以答案是 5 + 5 = 10。
#me
class Solution(object):
    def countCharacters(self, words, chars):
        mid = []
        for word in words:
            flag = True
            for sigWord in word:
                if word.count(sigWord)>chars.count(sigWord):
                    flag = False
                    break
            if flag:
                mid.append(word)
        return len(‘‘.join(mid))
#other
import collections
class Solution1(object):
    def countCharacters(self, words, chars):
        ans = 0
        cnt = collections.Counter(chars)
        for w in words:
            c = collections.Counter(w)
            if all([c[i] <= cnt[i] for i in c]):
                ans += len(w)
        return ans

56.思路：先排序，再计算相邻两个元素的最小绝对差
# 给你个整数数组 arr，其中每个元素都 不相同。
# 请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
# 示例 1：
# 输入：arr = [4,2,1,3]
# 输出：[[1,2],[2,3],[3,4]]
# 示例 2：
# 输入：arr = [1,3,6,10,15]
# 输出：[[1,3]]
# 示例 3：
# 输入：arr = [3,8,-10,23,19,-4,-14,27]
# 输出：[[-14,-10],[19,23],[23,27]]
#me
class Solution(object):
    def minimumAbsDifference(self, arr):
        abslist = sorted(arr)
        midresult = []
        lastresult = []
        for i in range(1, len(abslist)):
            midresult.append(abslist[i]-abslist[i-1])
        min_abstract = min(midresult)
        for Id, result in enumerate(midresult):
            mid = []
            if result == min_abstract:
                mid.append(abslist[Id])
                mid.append(abslist[Id+1])
                lastresult.append(mid)
        return lastresult

57.思路：直述题意
# 我们要把给定的字符串 S 从左到右写到每一行上，每一行的最大宽度为100个单位，如果我们在写某个字母的时候会使这行超过了100 个单位，那么我们应该把这个字母写到下一行。我们给定了一个数组 widths ，这个数组 widths[0] 代表 ‘a‘ 需要的单位， widths[1] 代表 ‘b‘ 需要的单位，...， widths[25] 代表 ‘z‘ 需要的单位。
# 现在回答两个问题：至少多少行能放下S，以及最后一行使用的宽度是多少个单位？将你的答案作为长度为2的整数列表返回。
# 示例 1:
# 输入:
# widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
# S = "abcdefghijklmnopqrstuvwxyz"
# 输出: [3, 60]
# 解释:
# 所有的字符拥有相同的占用单位10。所以书写所有的26个字母，
# 我们需要2个整行和占用60个单位的一行。
# 示例 2:
# 输入:
# widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
# S = "bbbcccdddaaa"
# 输出: [2, 4]
# 解释:
# 除去字母‘a‘所有的字符都是相同的单位10，并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
# 最后一个字母 ‘a‘ 将会被写到第二行，因为第一行只剩下2个单位了。
# 所以，这个答案是2行，第二行有4个单位宽度。
#other
class Solution(object):
    def numberOfLines(self, widths, S):
        line = 1
        result = 0
        for i in S:
            num = ord(i) - 97
            result += widths[num]
            if result > 100:
                result = 0 + widths[num]
                line += 1
            if result == 100:
                result = 0
                line += 1
        return [line, result]

58.思路：先变为一维向量，再按照列元素个数取值存放
# 在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。
# 给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。
# 重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
# 如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
# 示例 1:
# 输入:
# nums =
# [[1,2],
#  [3,4]]
# r = 1, c = 4
# 输出:
# [[1,2,3,4]]
# 解释:
# 行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
# 示例 2:
# 输入:
# nums =
# [[1,2],
#  [3,4]]
# r = 2, c = 4
# 输出:
# [[1,2],
#  [3,4]]
#me
class Solution0(object):
    def matrixReshape(self, nums, r, c):
        allNum = []
        for i in nums:
            allNum += i
        result = []
        if len(allNum)%r==0:
            for sub1 in range(r):
                j = len(allNum)//r
                subNum = allNum[sub1*j:(sub1+1)*j]
                result.append(subNum)
            return result
        else:
            return nums
#other
class Solution1(object):
    def matrixReshape(self, nums, r, c):
        if len(nums) == 0:
            return nums
        c0 = len(nums[0])
        r0 = len(nums)
        if r*c != r0*c0:
            return nums
        result = [[0]*c for _ in range(r)]
        for i in range(r):
            for j in range(c):
                t = i*c+j
                result[i][j] = nums[t//c0][t%c0]
        return result

59.思路：将当前元素索引以后的元素存放在列表中，然后查找
# 给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。
# nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。
# 示例 1:
# 输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
# 输出: [-1,3,-1]
# 解释:
#     对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
#     对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
#     对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
# 示例 2:
# 输入: nums1 = [2,4], nums2 = [1,2,3,4].
# 输出: [3,-1]
# 解释:
#    对于num1中的数字2，第二个数组中的下一个较大数字是3。
#     对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。
#me
class Solution0(object):
    def nextGreaterElement(self, nums1, nums2):
        result = []
        for i in nums1:
            sub = []
            subList = nums2[nums2.index(i):]
            for j in subList:
                if j > i:
                    sub.append(j)
            sub1 = [-1] if sub==[] else sub
            mid = sub1[0]
            result.append(mid)
        return result
#other
# 思路
# 遍历nums2，维护一个递减栈
# 当得到一个更大的数的时候，将栈里小于它的数都放到哈希表当中
# 举例来说，如果nums2里是3,2,1,4，那么栈前三位都是3,2,1，当遍历到4的时候，发现4比1大，这时候，哈希表里要添加hashmap[1] = 4,hashmap[2] = 4,hashmap[3] = 4。含义是，对于1这个数字而言，右边第一个比它大的数字是4。后面几个同理。
# 遍历nums1，对每一项查找哈希表，找到第一个比它大的数，并返回一个列表作为答案。如果在哈希表中不存在则返回默认值-1。
class Solution1(object):
    def nextGreaterElement(self, nums1, nums2):
        stack, hashmap = list(), dict()
        for i in nums2:
            while len(stack) != 0 and stack[-1] < i:hashmap[stack.pop()] = i
            stack.append(i)
        return [hashmap.get(i,-1) for i in nums1]

60.思路：用两个栈实现，一个栈负责压入，另一个负责弹出
# 使用栈实现队列的下列操作：
# push(x) -- 将一个元素放入队列的尾部。
# pop() -- 从队列首部移除元素。
# peek() -- 返回队列首部的元素。
# empty() -- 返回队列是否为空。
# 示例:
# MyQuque queue = new MyQueue();
# queue.push(1);
# queue.push(2);
# queue.peek();  // 返回 1
# queue.pop();   // 返回 1
# queue.empty(); // 返回 false
#me
class MyQueue(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stack1 = []
        self.stack2 = []
    def push(self, x):
        """
        Push element x to the back of queue.
        :type x: int
        :rtype: None
        """
        self.stack1.append(x)
    def pop(self):
        """
        Removes the element from in front of queue and returns that element.
        :rtype: int
        """
        if self.stack2:
            return self.stack2.pop()
        else:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()
    def peek(self):
        """
        Get the front element.
        :rtype: int
        """
        if self.stack1:
            return self.stack1[0]
        else:
            return self.stack2[-1]
    def empty(self):
        """
        Returns whether the queue is empty.
        :rtype: bool
        """
        if self.stack1 == [] and self.stack2 == []:
            return True
        else:
            return False