leetcode算法题

#第17题
#电话号码中的字母组合
#利用回溯算法（递归）列举出所有答案
class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        alpha = {"2":['a','b','c'],
                 "3":['d','e','f'],
                 "4":['g','h','i'],
                 "5":['j','k','l'],
                 "6":['m','n','o'],
                 "7":['p','q','r','s'],
                 "8":['t','u','v'],
                 "9":['w','x','y','z']}
        def tracback(combanation, next_digits):
            if len(next_digits) == 0:
                output.append(combanation)
            else:
                for letter in alpha[next_digits[0]]:
                    tracback(combanation+letter,next_digits[1:])
        output=[]
        if digits:
            tracback('',digits)
        return output

 

#coding: utf-8

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

class Solution:

    def lengthOfLongestSubstring(self, s):
        sub = []
        mer = []
        for i in range(len(s)):
            if s[i] not in sub:
                sub.append(s[i])
            else:
                maxval = len(sub)
                mer.append(maxval)
                sub = []
        return max(mer)


if __name__ == "__main__":
    s = Solution()
    res = s.lengthOfLongestSubstring('abcabcbb')
    print(res)

 

#第88题
#合并两个有序数组

class Solution:
    def merge(self, nums1, m, nums2, n):
        """
        Do not return anything, modify nums1 in-place instead.
        """
        a, b = m-1, n-1
        k = m+n-1
        if n == 0:
            pass
        if m == 0:
            nums1[:n] = nums2[:n]
        else:
            while a>= 0 and b>=0:
                if nums1[a] <= nums2[b]:
                    nums1[k] = nums2[b]
                    b -= 1
                    k -= 1
                else:
                    nums1[k] = nums1[a]
                    k -= 1
                    a -= 1
            if b >= 0:
                nums1[k-b:k+1] = nums2[:b+1]
            if a >= 0:
                pass

 

​
#第11题
#选取盛最多水的容器

class Solution:
    def maxArea(self, height: List[int]) -> int:
        res, left, right =0, 0, len(height) -1
        while(left < right):
            res = max(res, (right - left) * min(height[right], height[left]))
            if height[right] > height[left]:
                left += 1
            else:
                right -= 1
        return res

​

#第6题

#将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
#比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下：
#L   C   I   R
#E T O E S I I G
#E   D   H   N
#之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。


class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows < 2:
            return s
        res = [[] for _ in range(numRows)]
        dir = -1
        i = 0
        for c in s:
            res[i].append(c)
            if i==0 or i==numRows-1:
                dir = -dir
            i += dir
        ans = ""
        for re in res:
            for j in re:
                ans+=j
        return ans

#第39题 组合总数

from typing import List

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        size = len(candidates)
        if len(candidates) == 0:
            return []
        candidates.sort()

        path=[]
        res=[]
        self.__dfs(candidates, 0, size, path, res, target)
        return res
        

    def __dfs(self, candidates, begin, size, path, res, target):
        if target == 0:
            res.append(path[:])
            return 
        
        for index in range(begin, size):
            residue = target - candidates[index]
            if residue < 0:
                break
            path.append(candidates[index])
            self.__dfs(candidates, index, size, path, res, residue)
            path.pop()

if __name__ == '__main__':
    candidates = [2, 3, 6, 7]
    target = 7
    solution = Solution()
    result = solution.combinationSum(candidates, target)
    print(result)