LeetCode每周记录-8

给出一个无序数组，找出缺失的最小正整数。思路是先对数组进行排序，然后遍历数组，从第一个正整数开始与currNum=1对比，相同则currNum加1继续遍历，不相同则返回currNum为答案。代码：

class Solution(object):
    def firstMissingPositive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return 1
        nums = list(set(nums))
        nums.sort()
        currNum = 1
        for num in nums:
            if num > 0:
                if num != currNum:
                    return currNum
                else:
                    currNum += 1
        return currNum

给出一个数组，代表如图黑色方格所示的“砖块”，求这些“砖块”组成的凹槽能盛的水量（蓝色方格所示）。联想到之前做过的一个水桶最大容量问题，采取相似的办法：两个指针q、p从首尾分别开始向中间进行遍历，并由两个变量maxLeft、maxRight记录当前左边的最高“砖块”和右边的最高“砖块”，比较q、p所指的高度，高度低的那一方向中间移动一格；每次进行移动的指针，获取其当前代表的高度h，若 h < maxLeft 并且 h < maxRight ，则水量v增加 min(maxLeft, maxRight) - h ；然后再由q、p所指的高度判断是否要更新maxLeft和maxRight。代码：

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        if not height:
            return 0
        q = 0
        p = len(height) - 1
        maxLeft = height[q]
        maxRight = height[p]
        v = 0
        while(p > q):
            _p = height[p]
            _q = height[q]
            if _p < _q:
                if _p < maxRight and _p < maxLeft:
                    v += (min(maxRight, maxLeft) - _p)
                p -= 1
            else:
                if _q < maxLeft and _q < maxRight:
                    v += (min(maxRight, maxLeft) - _q)
                q += 1
            if _p > maxRight:
                maxRight = _p
            if _q > maxLeft:
                maxLeft = _q
        return v

给出两个字符串，算出这两个字符串代表的数字相乘的结果（不能直接使用内置的字符串转数字功能）。思路是先把两个字符串转换为数字：从个位开始，i = 1，通过建立的转换表map得到数字num，总数字加上num * i，然后i *= 10，进入十位…… 转换完成之后将两个数相乘即可。代码：

class Solution(object):
    def multiply(self, num1, num2):
        """
        :type num1: str
        :type num2: str
        :rtype: str
        """
        str_num_map = {str(i): i for i in range(10)}
        def convertToNum(str_input):
            i, currNum = 1, 0
            for letter in reversed(str_input):
                currNum += str_num_map[letter] * i
                i *= 10
            return currNum
        return str(convertToNum(num1) * convertToNum(num2))

跳跃游戏，给出一个数组，数组的每个数代表从当前位置可以向后跳跃的步数，求出最少需要多少步即可跳跃至数组最后一位。思路是将这个问题拆分成一个一个的跳跃小游戏，假设数组是nums，先找出离终点最远并且可以一步跳跃至终点的位置index，然后对nums[0:index + 1]进行再跳跃问题求解即可；并且在遍历的时候可以将当前位置可以到达的位置进行存储，记录下每个位置 - 能一步到达该位置的最小index。这样当进行再跳跃时，如果目标已经有存储的最优解，便可以直接返回。代码：

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) <= 1:
            return 0
        best = [None for i in range(len(nums))]
        steps = 0
        while(1):          
            totalLength = len(nums) - 1
            if best[totalLength] != None:
                currIndex = best[totalLength]
            else:
                for index, num in enumerate(nums):
                    if index + num >= totalLength:
                        currIndex = index
                        break
                    else:
                        for i in range(index + 1, index + num + 1):
                            if best[i] == None or index < best[i]:
                                best[i] = index
            steps += 1
            if currIndex == 0:
                return steps
            else:
                nums = nums[0:currIndex + 1]