[Leetcode] Notas de cepillado de etiquetas para principiantes: algoritmos simples

1. la suma de dos números

Dado un número de matriz de enteros y un objetivo de valor de destino entero, busque los dos enteros cuya suma es el valor de destino en la matriz y devuelva sus subíndices de matriz.
Puede asumir que cada entrada solo corresponderá a una respuesta. Sin embargo, el mismo elemento de la matriz no se puede repetir en la respuesta.
Puede devolver las respuestas en cualquier orden.

# 方法一
nums = [3,2,4];
print("输入的列表是：",nums);
targe = 6;
print("输入的targe是：",targe);
for i in range(0,3):
    for j in range(i+1,3):
        if (targe == nums[i] + nums[j]):
            print("[%s,%s]"%(i,j));

# 方法二哈希表
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

# 两数之和（twosum）
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        map_a = dict()
        k = len(nums)
        for i in range(0, k):#一边将列表中的数添加到字典中，一边判断两数之差是否存在于字典中
            temp = target - nums[i]  
            if temp in map_a :  # 判断步骤
                return [map_a[temp], i]
            map_a[nums[i]] =  i  # 添加步骤（切记先判断再添加，以免key冲突）

20. Paréntesis válidos

Dada una cadena s que solo incluye '(', ')', '{', '}', '[', ']', juzgue si la cadena es válida.

Una cadena válida debe cumplir:

El paréntesis izquierdo debe cerrarse con el mismo tipo de paréntesis derecho.
El paréntesis de apertura debe cerrarse en el orden correcto.

# 方法一：使用栈，枚举
class Solution:
    def isValid(self, s: str) -> bool:
        n = len(s)
        if n == 0:
            return True
        stack = []
        for i in s:
            if i == '(' or i == '[' or i == '{':
                stack.append(i)
            else:
                if len(stack) == 0:
                    return False
                else:
                    temp = stack.pop()
                    if i == ')':
                        if temp != '(':
                            return False
                    elif i == '[':
                        if temp != ']':
                            return False
                    elif i == '}':
                        if temp != '{':
                            return False
        if len(stack) == 0:
            return True
        else:
            return False

no pila se refiere a la pila vacía

pila [-1] se refiere a la parte superior de la pila

# 方法二：使用栈，字典
class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1:# 如果是单数，则False
            return False
        # 建立一个字典，根据右括号来查找左括号
        pairs = {
    
    
            ")": "(",
            "]": "[",
            "}": "{",
        }
        stack = list()# 建立一个栈
        for ch in s:
            if ch in pairs:
                if not stack or stack[-1] != pairs[ch]:# 如果是空栈或者栈顶不等于左括号
                    return False
                stack.pop()
            else:
                stack.append(ch)
        
        return not stack