旋轉圖像 - leetcode

Question

如果我問一些愚蠢的問題（我對編碼很陌生），我深表歉意，但我沒有找到明確的解釋來解決我的疑問。 我在 leetcode 上遇到了以下問題：

給定一個表示圖像的 nxn 2D 矩陣，將圖像旋轉 90 度（順時針）。 您必須就地旋轉圖像，這意味着您必須直接修改輸入的 2D 矩陣。 不要分配另一個二維矩陣並進行旋轉。 示例：輸入：matrix = [[1,2,3],[4,5,6],[7,8,9]] 輸出：[[7,4,1],[8,5,2], [9,6,3]]

我的解決方案是：

class Solution:
    def rotate(self, matrix):
        l = len(matrix)

        clockwise_nums = [matrix[j][i] for i in range(l) for j in range(l - 1, -1, -1)]

        final_array = [clockwise_nums[i:i + l] for i in range(0, len(clockwise_nums), l)]

        return final_array

純粹的執行（矩陣旋轉）有效，但這不被接受，因為它不是就地的。 但我真的不明白這意味着什么。 你認為我的方法離這里很遠，我應該嘗試不同的方法嗎？ 或者有沒有辦法調整我的解決方案（很高興我想出了一種旋轉矩陣的方法）？ 此外，任何關於就地算法的提示將不勝感激。 非常感謝！

Answer 1

要理解“就地執行操作”和“返回新數組”之間的區別，請想象一個更簡單的問題：

給你一個清單。 將 1 添加到列表的每個元素。

# returning a new array
def add_one_copy(l):
  return [x + 1 for x in l]

# in-place
def add_one_inplace(l):
  for i in range(len(l)):
    l[i] = l[i] + 1

在 python 交互式解釋器中測試這兩個函數突出了不同之處：

>>> a = [1, 2, 3]
>>> add_one_copy(a)
[2, 3, 4]
>>> a
[1, 2, 3]
>>> add_one_inplace(a)
>>> a
[2, 3, 4]

add_one_copy返回結果，但不a . add_one_inplace不返回結果，但會修改列表。 python 函數sorted和list.sort之間有相同的區別：

>>> a = [3,4,2,1]
>>> sorted(a)
[1, 2, 3, 4]
>>> a
[3, 4, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]

sorted返回結果，但不修改列表。 .sort修改列表並且不返回結果。

現在，您要解決的問題比僅向每個元素添加 1 稍微復雜一些。 就地解決旋轉問題的困難在於您在矩陣中移動元素； 這樣做時，您必須小心不要覆蓋您仍然需要的元素的值。 想象一個稍微難一點的問題：

給你一個清單。 顛倒列表中元素的順序。

# returning a copy
def reverse_copy(l):
  return [l[len(l) - i - 1] for i in range(len(l))]

# in-place attempt, fall head-first in the trap, this is not working
def reverse_inplace_wrong(l):
  for i in range(len(l)):
    l[i] = l[len(l) - i - 1]

# in-place, correct
def reverse_inplace(l):
  for i in range(len(l)//2):
    tmp = l[len(l) - i - 1]
    l[len(l) - i - 1] = l[i]
    l[i] = tmp

測試：

>>> a = [1,2,3,4,5,6,7]
>>> reverse_copy(a)
[7, 6, 5, 4, 3, 2, 1]
>>> a
[1, 2, 3, 4, 5, 6, 7]
>>> reverse_inplace_wrong(a)
>>> a
[7, 6, 5, 4, 5, 6, 7]
>>> a = [1,2,3,4,5,6,7]
>>> reverse_inplace(a)
>>> a
[7, 6, 5, 4, 3, 2, 1]

反轉列表時，我發現位置i的元素應該轉到位置len(l) - i - 1 。 旋轉矩陣時，您必須弄清楚位置(i,j)處的元素應該去哪里。 而且你必須小心不要重復我在reverse_inplace_wrong中犯的錯誤。

Answer 2

為了解決這個問題，我們還可以使用 Python 內置的reverse() ，不會破壞交易：

class Solution:
    def rotate(self, A):
        A.reverse()
        for row in range(len(A)):
            for col in range(row):
                A[row][col], A[col][row] = A[col][row], A[row][col]

Answer 3

如果你知道 C++，你可以看看我的解決方案。

我使用矩陣轉置的邏輯解決了它。 在轉置之后，我將第一列的值與同一行中的最后一列交換。 然后第二列與倒數第二列，依此類推。

void swapValues(int &valueOne, int &valueTwo) {
    int tempValue = valueOne;
    valueOne = valueTwo;
    valueTwo = tempValue;
}
    
void rotate(vector<vector<int> >& matrix) {
    int n = matrix.size();
    int halfN = n / 2;

    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            if(i != j && j > i) {
                swapValues(matrix[i][j], matrix[j][i]);
            }
        }

        for (int j=0; j<halfN; j++) {
            swapValues(matrix[i][j], matrix[i][n-1-j]);
        }
    }
}

Answer 4

class Solution:
    def rotate(self, matrix):
        rotate_mat = []
        for l in range(len(matrix)):
            mat = [i[l] for i in matrix][::-1]
            rotate_mat.append(mat)
        return rotate_mat