directorio
Uno de los temas: no orden creciente de la más pequeña sub-secuencia
Ideas de resolución de problemas:
Título II: La representación binaria del número de etapas se reduce a 1
Ideas de resolución de problemas:
Tema tres: Feliz cadena más larga
Ideas de resolución de problemas:
Tema Cuatro: Juego de piedra III
Ideas de resolución de problemas:
Uno de los temas: no orden creciente de la más pequeña sub-secuencia
enlaces a los temas: https://leetcode-cn.com/problems/minimum-subsequence-in-non-increasing-order/
Ideas de resolución de problemas:
Clasificar, desde el prólogo de números, cada uno tome un juicio es mayor que la mitad de la suma
Si es así, se devuelve el resultado
la implementación del código:
class Solution:
def minSubsequence(self, nums: List[int]) -> List[int]:
nums.sort()
total = sum(nums)
res = []
for index in range(len(nums) - 1, -1, -1):
res.append(nums[index])
if sum(res) > total / 2:
break
return res
Título II: La representación binaria del número de etapas se reduce a 1
enlaces a los temas: https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-in-binary-representation-to-one/
Ideas de resolución de problemas:
Método uno:
La cadena binaria convertida a variables int, de conformidad con las normas de cada paso de simulación, y el número de superpuesta
Segundo método:
Transversal de atrás hacia adelante cada uno, añadir una identificación de transporte. Llevar la bandera cuando se atraviesa en conjunto, habrá las siguientes situaciones:
- 0: Descripción es par, el número de los pasos 1 +
- 1: Descripción es impar, la necesidad actual para la adición digital después de 1 + 2, con el fin de eliminar este bit, los pasos 2 +, carry = 1
- 2: Descripción originalmente un número impar, pero después de añadir el acarreo se convierte en número par, el número de paso + 1, llevar a = 1
la implementación del código:
Método uno:
class Solution:
def numSteps(self, s: str) -> int:
num = int(s, 2)
count = 0
while num > 1:
if num % 2 == 0:
num //= 2
else:
num += 1
count += 1
return count
Segundo método:
class Solution:
def numSteps(self, s: str) -> int:
count = 0
add_num = 0
for index in range(len(s) - 1, -1, -1):
num = int(s[index]) + add_num
add_num = 0
if index == 0 and add_num == 0 and num == 1:
break
if 0 == num:
count += 1
elif 1 == num:
count += 2
add_num = 1
else:
count += 1
add_num = 1
return count
Tema tres: Feliz cadena más larga
enlaces a los temas: https://leetcode-cn.com/problems/longest-happy-string/
Ideas de resolución de problemas:
La costura restante puede ser clasificada según el número actual de caracteres, en descendente determina si el empalme de caracteres actual
Si el empalme, el empalme de un solo carácter, actualiza el número restante
Si no empalmado, obtener el siguiente carácter en la secuencia
Hasta que todos los personajes son todos los caracteres no se pueden empalmar o se quedan sin
la implementación del código:
class Solution:
def longestDiverseString(self, a: int, b: int, c: int) -> str:
num_lst = {'a' : a, 'b' : b, 'c' : c}
res = ''
while sum(num_lst.values()) > 0:
stop = False
for a in sorted(num_lst.items(), key = lambda item: item[1], reverse = True):
if res[-2:] == a[0] * 2 or a[1] <= 0:
stop = True
continue
res += a[0]
num_lst[a[0]] -= 1
stop = False
break
if stop:
break
return res
Tema Cuatro: Juego de piedra III
enlaces a los temas: https://leetcode-cn.com/problems/stone-game-iii/
Ideas de resolución de problemas:
Juego tipo teoría de problema, programación dinámica, la recursividad de atrás hacia adelante
matriz de programación dinámica dp posición de primer índice salvado, si durante el montón de piedras restante del índice al último, ser capaz de obtener una puntuación máxima es el número
Cuando el resto de la última vez, porque usted tiene que manejar una gama tan última dp, la matriz original es igual al último bit
Después de la recursión hacia delante, añadir la suma a la posición actual de la última recursividad tiempo, cuando la primera matriz de bits de actualización dinámica de índice de la lógica de programación es el siguiente:
Variables:
- Índice: El índice de recurrencia a la actual
- dp: una matriz de programación dinámica (relación multi-aplicación stoneValue 3, las cifras son 0. Esto no puede ser un tratamiento especial para subíndice)
- curr_sum: Desde el último bit de la suma al índice
- stoneValue: matriz original, se supone que la matriz aquí [1, 2, 3, -1, -2, -3, 7]
Lógica (stoneValue recorrido de atrás hacia adelante):
- 更新 curr_sum = curr_sum + stoneValue [índice] = 0 + 7 = 7
- Inicialización dp [índice] = flotador ( '- inf') infinitesimal
- Actualización de la lógica dp [índice] en cuenta la siguiente tabla, la ecuación de actualización de dp [índice] = curr_sum - min (dp [índice + 1], dp [índice + 2], dp [índice + 3]), el propósito de es capaz de hacer su propio valor lo más rápido posible para conseguir el máximo
Continuando los pasos anteriores hasta dp atravesado [0]
su comportamiento El otro subíndice comenzó El otro lado del valor máximo su máximo tome una índice + 1 dp [índice + 1] curr_sum - dp [índice + 1] tome 2 índice + 2 dp [índice + 2] curr_sum - dp [índice + 2] tomar 3 índice + 3 dp [índice + 3] curr_sum - dp [índice + 3] Debido a que Alice siempre se inicia en primer lugar, por lo que Alice puede obtener el puntaje máximo de dp [0], Bob puede obtener la puntuación máxima de curr_sum - dp [0]
A continuación, la puntuación se determina a Alice y Bob
la implementación del código:
class Solution:
def stoneGameIII(self, stoneValue: List[int]) -> str:
dp = [0] * (len(stoneValue) + 3)
curr_sum = 0
for index in range(len(stoneValue) - 1, -1, -1):
dp[index] = float('-inf')
curr_sum += stoneValue[index]
dp[index] = curr_sum - min([dp[index + 1], dp[index + 2], dp[index + 3]])
alice_score = dp[0]
bob_score = curr_sum - dp[0]
if alice_score > bob_score:
return 'Alice'
elif alice_score < bob_score:
return 'Bob'
return 'Tie'
