Tema:
Dada una matriz, mueva los elementos de la matriz k posiciones a la derecha, donde k es un número no negativo.
Avanzado:
Piense en tantas soluciones como sea posible Hay al menos tres formas diferentes de resolver este problema.
¿Puede resolver este problema utilizando un algoritmo in situ con una complejidad espacial de O (1)?
Ejemplo 1:
Entrada: nums = [1,2,3,4,5,6,7], k = 3
Salida: [5,6,7,1,2,3,4]
Explicación:
Girar a la derecha 1 paso: [ 7, 1,2,3,4,5,6]
Girar a la derecha 2 pasos: [6,7,1,2,3,4,5]
Girar a la derecha 3 pasos: [5,6,7,1,2, 3,4]
Ejemplo_2:
Entrada: nums = [-1, -100,3,99], k = 2
Salida: [3,99, -1, -100]
Explicación:
Girar a la derecha en 1 paso: [99, -1, -100 , 3]
Girar a la derecha 2 pasos: [3,99, -1, -100]
Solución_1:
No sé por qué no usa la función de rotación
directamente. Puede usar la función de rotación directamente para rotar la matriz.
Al mismo tiempo, debido al resultado de esta pregunta, debe cambiar nums y
finalmente reemplazar cada un poco de números con la función en una después de la rotación.
Al mismo tiempo, la eficiencia de este método no está mal. Cuando es
posible, la función de rotación es relativamente impopular. La
función de rotación es extremadamente eficiente,
por lo que no hay necesidad de considerar la caso donde k es más largo que nums.
Código_1:
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
a = collections.deque(nums)
a.rotate(k)
a = list(a)
for i in range(len(nums)):
nums[i] = a[i]
Respuesta 1:
Solución_2:
Es equivalente a la rotación de atrás hacia adelante nums k desplazados
para evitar nums más largos que el caso donde k
puede ser el último elemento en un número de 0 bits
y luego
se repite borrar el último elemento k veces
cuidado k mayor que la longitud de la matriz donde sea
necesario Tomar el resto de k para
aumentar la eficiencia operativa
Código_2:
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
k %= len(nums)
for i in range(k):
nums.insert(0, nums[-1])
nums.pop()
Respuesta_2:
Solución_3:
El tercer método es asombroso.
También aprendí de
otros. La idea general de los demás es la siguiente
nums = “-----> ->”; k = 3
resultado = “-> ----->”;
invertir “-----> ->” podemos obtener “<- <-----”
invertir “<-” podemos obtener “-> <-----”
invertir “<----- "Podemos obtener" -> -----> "
Código_3:
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
k = k % len(nums)
self.reverse(nums, 0, len(nums) - 1)
self.reverse(nums, 0, k - 1)
self.reverse(nums, k, len(nums) - 1)
def reverse(self, nums, start, end):
while start < end:
nums[start], nums[end] = nums[end], nums[start]
start += 1
end -= 1
