leetcode题目 总共四题

11. 盛最多水的容器

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。画 n 条垂直线，使得垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

注意：你不能倾斜容器，n 至少是2。

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        start=0
        end=len(height)-1
        max_area=0
        temp_area=0
        min_height=0
        while start<end:
            height_min =( height[start] if (height[start] < height[end]) else height[end])
            temp_area=(end-start) * height_min
            if temp_area>max_area:
                max_area=temp_area
            if height[end] > height[start]:
                start += 1
            else:
                end -=1
        return max_area
            

主要从两边往中间遍历，更换长度短的长度

1. 两数之和

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for k in range(0, (len(nums) - 1)):
            a=target-nums[k]
            if a in nums[k+1:len(nums) ]:
                for i in range(k+1,(len(nums))):
                    if a==nums[i]:
                        new_=[k,i]
                        return new_
            

2. 两数相加

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        val_sum = l1.val + l2.val  
        new_list = ListNode(val_sum%10)  
        a = val_sum // 10
        node = new_list
        while True:
            try:  
                l1 = l1.next  
            except:  
                pass  
            try:  
                l2 = l2.next  
            except:  
                pass  
            if not l1 and not l2:  
                break  
            elif not l1:  
                l1_val = 0  
                l2_val = l2.val  
            elif not l2:  
                l2_val = 0  
                l1_val = l1.val  
            else:  
                l1_val = l1.val  
                l2_val = l2.val  
            val_sum = l1_val + l2_val + a  
            temp_node = ListNode(val_sum % 10)  
            node.next = temp_node  
            node = temp_node  
            a = val_sum // 10  
        if a != 0:  
            node.next = ListNode(a)  
        return new_list  

3. 无重复字符的最长子串

给定一个字符串，找出不含有重复字符的最长子串的长度。

示例：

给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。

给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。

给定 "pwwkew" ，最长子串是 "wke" ，长度是3。请注意答案必须是一个子串，"pwke" 是 子序列  而不是子串。

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        res = 0
        if s is None or len(s) == 0:
            return res
        d = {}    #d这个字典用来记录s中出现的不重复的字母的最新位置
        tmp = 0
        start = 0
        for i in range(len(s)):
            if s[i] in d and d[s[i]] >= start:
                start = d[s[i]] + 1
            tmp = i - start + 1
            d[s[i]] = i
            res = max(res, tmp)
        return res

主要是字典d的作用