好题

题意：

 

 

 

 只有前四个很好操作。记录一个偏移量即可。

对于Inverse操作，

考虑每个“点“的变化路径。

发现：一个点：$(i,j,a[i][j])$，

通过$I$变化，变为$(i,a[i][j],j)$

通过$C$变化，变为$(a[i][j],j,i)$

（这个就是所谓的逆映射，想一下就可以明白）

 

对于每个点，都是这样的变换。

根据高等代数知识，这玩意可以用矩阵乘法来处理。

6个操作， 每个操作对应一个矩阵，从开始的$(i,j,a[i][j],1)$行向量左乘这串矩阵即可。

用矩阵结合律优化一下就可。

（题解有线性做法，，，但是看不懂）

（矩乘非常容易理解，但是常数多了64.。。）

Code：

#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
    char ch;x=0;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*10+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/10)output(x/10);putchar(x%10+'0');}
template<class T>il void ot(T x){if(x<0) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=998244353;
il int ad(int x,int y){return x+y>=mod?x+y-mod:x+y;}
il int sub(int x,int y){return ad(x,mod-y);}
il int mul(int x,int y){return (ll)x*y%mod;}
il void inc(int &x,int y){x=ad(x,y);}
il void inc2(int &x,int y){x=mul(x,y);}
il int qm(int x,int y=mod-2){int ret=1;while(y){if(y&1) ret=mul(x,ret);x=mul(x,x);y>>=1;}return ret;}
template<class ...Args>il int ad(const int a,const int b,const Args &...args) {return ad(ad(a,b),args...);}
template<class ...Args>il int mul(const int a,const int b,const Args &...args) {return mul(mul(a,b),args...);}
}
//using namespace Modulo;
namespace Miracle{
const int N=1000+5;
const int M=1e5+5;
int a[N][N];
int b[N][N];
struct tr{
    int a[4][4];
    void init(){
        for(int i=0;i<4;++i) a[i][i]=1;
    }
    void clear(){
        memset(a,0,sizeof a);
    }
    tr friend operator *(const tr &A,const tr &B){
        tr C;C.clear();
        for(int i=0;i<4;++i){
            for(int j=0;j<4;++j){
                for(int k=0;k<4;++k){
                    C.a[i][j]+=A.a[i][k]*B.a[k][j];
                }
            }
        }
        return C;
    }
    void ot(){
        for(int i=0;i<4;++i){
            for(int j=0;j<4;++j){
                cout<<a[i][j]<<" ";
            }cout<<endl;
        }
    }
}O,B,C;
int T,n,m;
char s[M];
int con(int t){
    return (t%n+n)%n;
}
int main(){
    
    rd(T);
    while(T--){
        rd(n);rd(m);
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                rd(a[i][j]);
            }
        }
        B.clear();B.init();O.clear();O.init();
        scanf("%s",s);
        for(int i=0;i<m;++i){
            switch(s[i]){
                case 'L':B.a[3][1]=-1;O=O*B;B.a[3][1]=0;break;
                case 'R':B.a[3][1]=1;O=O*B;B.a[3][1]=0;break;
                case 'U':B.a[3][0]=-1;O=O*B;B.a[3][0]=0;break;
                case 'D':B.a[3][0]=1;O=O*B;B.a[3][0]=0;break;
                case 'I':swap(B.a[1][1],B.a[2][1]);swap(B.a[1][2],B.a[2][2]);O=O*B;swap(B.a[1][1],B.a[2][1]);swap(B.a[1][2],B.a[2][2]);break;
                case 'C':swap(B.a[0][0],B.a[2][0]);swap(B.a[0][2],B.a[2][2]);O=O*B;swap(B.a[0][0],B.a[2][0]);swap(B.a[0][2],B.a[2][2]);break;
            }
        }
        //O.ot();
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                C.clear();
                C.a[0][0]=i,C.a[0][1]=j,C.a[0][2]=a[i][j]-1;C.a[0][3]=1;
                C=C*O;
                //cout<<" i "<<i<<" "<<j<<" "<<"-------------------------"<<endl;
                //C.ot();
                b[con(C.a[0][0])][con(C.a[0][1])]=con(C.a[0][2])+1;
            }
        }
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                ot(b[i][j]);
            }puts("");
        }
    }
    return 0;
}

}
signed main(){
    Miracle::main();
    return 0;
}

/*
   Author: *Miracle*
*/

 把整体变换，拆成每个点的变换。

最后每个点得到的变换，点和点直接不会冲突。

拼起来就是整个矩阵最后的结果。