旋转矩阵

Question

我有 matrixA 之类的

[0][1]
[2][3]
[4][5]

在我的自定义轮换（不同的编号）变为 matrixB 之后：

[0][1][2]
[3][4][5]

当我从左侧＆gt;右侧查看matrixA时，我想要的是映射矩阵A到B的编号。 要解释一下： matrixA 从左边看＆gt;右边看起来像这样。

[1][3][5]
[0][2][4]

matrixB 就是这样

[0][1][2]
[3][4][5]

所以我想映射，最好用方程式映射这些值

1->0
3->1
5->2
0->3
2->4
4->5

真实矩阵要大得多，所以请不要专注于此矩阵的大小

如果有人有任何建议可以找到这个映射的等式或其他一些方法来进行描述？我很感激

Answer 1

以下是我有时会使用的一些代码。这使矩阵旋转90或-90度。这可能是您的问题的开始：

public int[][] rotateMatrixRight(int[][] matrix)
{
    /* W and H are already swapped */
    int w = matrix.length;
    int h = matrix[0].length;
    int[][] ret = new int[h][w];
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            ret[i][j] = matrix[w - j - 1][i];
        }
    }
    return ret;
}


public int[][] rotateMatrixLeft(int[][] matrix)
{
    /* W and H are already swapped */
    int w = matrix.length;
    int h = matrix[0].length;   
    int[][] ret = new int[h][w];
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            ret[i][j] = matrix[j][h - i - 1];
        }
    }
    return ret;
}

Answer 2

Here您可以为序列3,0,4,1,5,2找到十种不同的公式。

当您需要整数序列时，请务必咨询OEIS！

Answer 3

也许是这样的：

map(matrixA,x,y)
  w=width of matrix A
  h=height of matrix A
  n=y*w+x
  from=matrixA(x,y)
  to=matrixA(n mod h, n / h)
  return (from, to)

要制作地图，只需遍历所有x和y并对所有这些变量进行映射。

Answer 4

int height = 2, width = 3;  // of matrix B
int [][] a = {{0,1}, {2, 3}, {4, 5}};
int [][] b = {{0,1,2}, {3,4,5}};
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < height; ++i) {
    for (int j = 0; j < width; ++j) {
        int b_val = b[i][j];
        int a_val = a[j][height - i - 1];
        map.put(a_val, b_val);
    }
}

Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
Iterator<Map.Entry<Integer, Integer>> it = entries.iterator();
while(it.hasNext()) {
    Map.Entry<Integer, Integer> e = it.next();
    System.out.println(e.getKey() + " -> " + e.getValue());
}

请参阅here in action。

Answer 5

到位C解决方案如下

void rotateRight(int matrix[][SIZE], int length) {

    int layer = 0;

    for (int layer = 0; layer < length / 2; ++layer) {

        int first = layer;
        int last = length - 1 - layer;

        for (int i = first; i < last; ++i) {

            int topline = matrix[first][i];
            int rightcol = matrix[i][last];
            int bottomline = matrix[last][length - layer - 1 - i];
            int leftcol = matrix[length - layer - 1 - i][first];

            matrix[first][i] = leftcol;
            matrix[i][last] = topline;
            matrix[last][length - layer - 1 - i] = rightcol;
            matrix[length - layer - 1 - i][first] = bottomline;
        }
    }
}