Leetcode每天五题II-06

380. 常数时间插入、删除和获取随机元素

设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构。

• insert(val)：当元素 val 不存在时，向集合中插入该项。
• remove(val)：元素 val 存在时，从集合中移除该项。
• getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。

map+set

class RandomizedSet(object):

    def __init__(self):
        self.element = set()
        self.size = 0

    def insert(self, val):
        if val in self.element:
            return False
        self.element.add(val)
        self.size+=1
        return True

    def remove(self, val):
        if val not in self.element:
            return False
        self.element.remove(val)
        self.size-=1
        return True

    def getRandom(self):
        return list(self.element)[random.randint(0,self.size-1)]

map+list

class RandomizedSet(object):

    def __init__(self):
        self.element = []
        self.map = {}
        self.size = 0
    def insert(self, val):
        if self.map.has_key(val):
            return False
        
        self.element.append(val)

        self.map[val] = self.size
        
        self.size+=1
        return True

    def remove(self, val):
        if not self.map.has_key(val) or self.size==0:
            return False
        #将最后一个元素交换到val所在的位置
        tail = self.element[self.size-1]
        self.element[self.map.get(val)] = tail
        self.map[tail] = self.map.get(val)
        #删除最后一个元素
        self.element.pop()
        self.map.pop(val)

        self.size -=1
        return True

    def getRandom(self):
        import random
        return self.element[random.randint(0,self.size-1)]

384. 打乱数组

打乱一个没有重复元素的数组。

示例:

// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);

// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();

// 重设数组到它的初始状态[1,2,3]。
solution.reset();

// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();

class Solution(object):

    def __init__(self, nums):
        self.origin = nums
        
    def reset(self):
        return self.origin
    
    def shuffle(self):
        new_list = self.origin[:]
        k = len(new_list)
        import random
        for i in range(k,1,-1):
            # 每次将[0..i-1]范围上的数和未shuffle的第一个数交换
            t = random.randint(0,i-1)
            tmp = new_list[t]
            new_list[t] = new_list[i-1]
            new_list[i-1] = tmp
        return new_list

387. 字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

案例:

s = “leetcode”
返回 0.

s = “loveleetcode”,
返回 2.

注意事项：您可以假定该字符串只包含小写字母。

class Solution(object):
    def firstUniqChar(self, s):
        map = {}
        for i in range(len(s)):
            map[s[i]] = map.get(s[i],0)+1
        for i in range(len(s)):
            if map[s[i]] == 1:
                return i
        return -1

412. Fizz Buzz

写一个程序，输出从 1 到 n 数字的字符串表示。

• 如果 n 是3的倍数，输出“Fizz”；

• 如果 n 是5的倍数，输出“Buzz”；

• 如果 n 同时是3和5的倍数，输出 “FizzBuzz”。

class Solution(object):
    def fizzBuzz(self, n):
        res = ['1','2']
        for i in range(3,n+1):
            if i%15==0:
                res.append('FizzBuzz')
            elif i%3==0:
                res.append('Fizz')
            elif i%5==0:
                res.append('Buzz')
            else:
                res.append(str(i))
        return res[:n]

454. 四数相加 II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

输入:

A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:

2

解释:

两个元组如下:

1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

class Solution(object):
    def fourSumCount(self, A, B, C, D):
        map = {}
        for i in A:
            for j in C:
                s = i+j
                map[s] = map.get(s,0)+1
        res = 0
        for i in B:
            for j in D:
                s = -i-j
                res += map.get(s,0)
        return res