Question

当我遇到HackerRank时，我正在解决问题。

问题陈述

您将获得一个二维矩阵，a，维度为MxN，正整数为R.您必须将矩阵旋转R次并打印结果矩阵。旋转应沿逆时针方向旋转。

4x5矩阵的旋转由下图表示。请注意，在一次旋转中，您必须仅将元素移动一步（请参阅样本测试以获得更清晰）。

保证M和N的最小值均匀。

输入

第一行包含三个空格分隔的整数，M，N和R，其中M是行数，N是矩阵中的列数，R是矩阵必须旋转的次数。然后是M行，其中每行包含N个空格分隔的正整数。这些M行代表矩阵。

输出

打印旋转的矩阵。

约束

2 <= M, N <= 300 
1 <= R <= 10^9 
min(M, N) % 2 == 0 
1 <= aij <= 108, where i ∈ [1..M] & j ∈ [1..N]'

我尝试做的是将圆圈存储在一维数组中。这样的事情。

 while(true)
    {
        k = 0;
        for(int j = left; j <= right; ++j) {temp[k] = a[top][j]; ++k;}
        top++;
        if(top > down || left > right) break;

        for(int i = top; i <= down; ++i) {temp[k] = a[i][right]; ++k;}
        right--;
        if(top > down || left > right) break;

        for(int j = right; j >= left; --j) {temp[k] = a[down][j] ; ++k;}
        down--;
        if(top > down || left > right) break;

        for(int i = down; i >= top; --i) {temp[k] = a[i][left]; ++k;}
        left++;
        if(top > down || left > right) break;
    }

然后我可以通过计算其模数为R的长度来轻松旋转1D矩阵。但是，我如何将其重新放回矩阵形式？再次使用循环可能会导致超时。

请不要提供代码，但只提供建议。我想自己做。

解决方案创建：

#include <iostream>
using namespace std;



int main() {
int m,n,r;
cin>>m>>n>>r;
int a[300][300];
for(int i = 0 ; i < m ; ++i){
    for(int j = 0; j < n ; ++j)
        cin>>a[i][j];
}

int left = 0;
int right = n-1;
int top = 0;
int down = m-1;
int tleft = 0;
int tright = n-1;
int ttop = 0;
int tdown = m-1;
int b[300][300];
int k,size;
int temp[1200];

while(true){
    k=0;
    for(int i = left; i <= right ; ++i)
    {
        temp[k] = a[top][i];
      //  cout<<temp[k]<<" ";
        ++k;
    }
    ++top;

    if(top > down || left > right) 
        break;

    for(int i = top; i <= down ; ++i)
    {
        temp[k]=a[i][right];
       // cout<<temp[k]<<" ";
        ++k;
    }
    --right;
    if(top > down || left > right) 
        break;

    for(int i = right; i >= left ; --i)
    {
        temp[k] = a[down][i];
      //  cout<<temp[k]<<" ";
        ++k;
    }
    --down;

    if(top > down || left > right) 
        break;

    for(int i = down; i >= top ; --i)
    {   
        temp[k] = a[i][left];
       // cout<<temp[k]<<" ";
        ++k;
    }

    ++left;
    if(top > down || left > right) 
        break;

    //________________________________\\

    size = k;
    k=0;
   // cout<<size<<endl;
    for(int i = tleft; i <= tright ; ++i)
    {
        b[ttop][i] = temp[(k + (r%size))%size];
     //   cout<<(k + (r%size))%size<<" ";
     //   int index = (k + (r%size))%size;
       // cout<<index;
        ++k;
    }
    ++ttop;

    for(int i = ttop; i <= tdown ; ++i)
    {
        b[i][tright]=temp[(k + (r%size))%size];
        ++k;
    }
    --tright;

    for(int i = tright; i >= tleft ; --i)
    {
        b[tdown][i] = temp[(k + (r%size))%size];
        ++k;
    }
    --tdown;

    for(int i = tdown; i >= ttop ; --i)
    {   
        b[i][tleft] = temp[(k + (r%size))%size];
        ++k;
    }

    ++tleft;
}

size=k;
k=0;
if(top != ttop){
    for(int i = tleft; i <= tright ; ++i)
    {
        b[ttop][i] = temp[(k + (r%size))%size];
        ++k;
    }
    ++ttop;
}
if(right!=tright){
    for(int i = ttop; i <= tdown ; ++i)
    {
        b[i][tright]=temp[(k + (r%size))%size];
        ++k;
    }
    --tright;
}
if(down!=tdown){
    for(int i = tright; i >= tleft ; --i)
    {
        b[tdown][i] = temp[(k + (r%size))%size];
        ++k;
    }
    --tdown;
}
if(left!=tleft){
    for(int i = tdown; i >= ttop ; --i)
    {   
        b[i][tleft] = temp[(k + (r%size))%size];
        ++k;
    }

    ++tleft;
}
for(int i = 0 ; i < m ;++i){
    for(int j = 0 ; j < n ;++j)
        cout<<b[i][j]<<" ";
    cout<<endl;
}

return 0;
}

Answer 1

我将从一个简化的假设开始：M小于或等于N.因此，您可以保证偶数行。（如果M> N？那么如何转置矩阵，执行算法，并再次转置矩阵。）

因为您有偶数行，所以您可以轻松找到矩阵中每个循环的角点。最外面的周期有这些角落：

a _1,1→a _M，1→a _M，N→a _1，N

要查找下一个循环，请向内移动每个角，这意味着在适当的时候递增或递减每个角的索引。

了解角的序列允许您迭代每个循环并将值存储在一维向量中。在每个这样的向量a中，从索引R % a.size()开始并递增索引a.size() - 1次以迭代循环的旋转元素。将每个元素a[i % a.size()]复制回循环。

请注意，我们实际上并没有旋转矢量。当我们将元素复制回矩阵时，我们通过从偏移索引开始来完成旋转。因此，算法的总运行时间是O（MN），这是最优的，因为仅仅为了读取输入矩阵而花费O（MN）。

Answer 2

我会将此视为将矩阵划分为子矩阵的问题。您可以编写一个函数，每次调用它时，将矩阵（和子矩阵）的外部行和列移动一个。注意适当处理矩阵的四个角。

检查this以获取有关如何移动列的建议。

修改（更详细）：

将每个矩阵圆作为向量读取，使用std :: rotate对它进行R％length.vector次，回写。最多150次操作。

Answer 3

你需要打破这个问题（让我想起gg和fb的采访问题）：

首先解决序列一个单一位置的问题
然后解决旋转序列N次
模拟每个＆＃34;圈＆＃34;或作为一个数组响。您实际上可能需要或可能不需要存储在单独的数据中
迭代每个环并应用旋转算法

让我们考虑一个长度为<!DOCTYPE html> <html lang="en" ng-app="mcw"> <head> <meta charset="utf-8"> <title>title spec</title> <script src="js/angular1.3.0/angular.js"></script> <script src="js/angular1.3.0/angular-route.js"></script> <script src="js/angular1.3.0/angular-animate.js"></script> <script src="js/app.js"></script> <script src="js/commonFunc.js"></script> <script src="js/controllers.js"></script> <script src="js/directives.js"></script> <script src="js/filters.js"></script> <script src="js/server.js"></script> <script src="js/services.js"></script> </head> <body> <ng-view></ng-view> </body> </html>的数组，需要轮换L时间。请注意，如果R是R的倍数，则数组将保持不变。另请注意，向右旋转L次与向左旋转x相同（反之亦然）。

因此，您可以首先设计一种能够向左或向右旋转一个位置的算法
减少向左旋转L - x次以向左旋转R的问题
如果您想进一步减少向左旋转R modulo L以向左旋转R modulo L或向右旋转R modulo L的问题。这意味着如果你有100个元素并且你必须做99次旋转，你最好做一次旋转并完成它。

因此复杂性将为O（圆圈数×圆长x单旋转成本）

就地使用数组意味着L - R modulo L

如果使用双向链接列表作为临时存储，则通过移除前面并将其放在尾部（或反之亦然向右旋转）来完成单个旋转序列。因此，您可以做的是首先将所有数据复制到链接列表。运行单次旋转算法O( min(N,m) * (N * M)^2 )次，复制环位置上的链表，然后向右移动直到处理完所有环。

将R modulo L数据复制到列表ring
单次轮换费用为O（1）
所有轮换O(L), L <= N*M均为R modulo L
重复所有O(L)

使用备用双链表，这意味着min(N,m) rings

Answer 4

每个元素根据四个公式中的一个进行唯一移动，添加五个已知大小的移动（我将把大小计算留出来，因为你想弄明白）：

formula (one of these four):

left + down + right + up + left
down + right + up + left + down
right + up + left + down + right
up + left + down + right + up

由于矩阵的最小边是偶数，我们知道没有剩余的元素。在R轮换后，元素已绕floor (R / formula)次圈出，但仍需要进行extra = R % formula次轮换。知道extra后，只需计算元素的适当位置即可。

旋转矩阵n次

4 个答案: