view code 1 #include <bits/stdc++.h> 
 2 int ans[10][10];
 3 int m1,n1,m2,n2;
 4 int core[10][10],matrix[10][10];
 5 void Convolution();
 6 void print();
 7 int main() {
 8     scanf("%d %d %d %d",&m1,&n1,&m2,&n2);
 9     for(int i=0;i<m1;i++){
10         for(int j=0;j<n1;j++){
11             scanf("%d",&matrix[i][j]);
12         }
13     }
14     for(int i=0;i<m2;i++){
15         for(int j=0;j<n2;j++){
16             scanf("%d",&core[i][j]);
17         }
18     }
19     Convolution();
20     print();
21     return 0;
22 }
23 //本题不需要翻转，也不需要填充 
24 //下面用变量i,j控制卷积核的移动，k,l作为数据运算时的卷积核中元素行列标号
25 //分析可知:0<=i<=m1-m2   0<=j<=n1-n2    
26 //分析可知:0<=k<m2       0<=l<n2    
27 //计算规则:ans[i][j]+=core[k][l]*matrix[i+k][j+l]
28 void Convolution(){
29     for(int i=0;i<=m1-m2;i++){
30         for(int j=0;j<=n1-n2;j++){
31             for(int k=0;k<m2;k++){
32                 for(int l=0;l<n2;l++){
33                     ans[i][j]+=core[k][l]*matrix[i+k][j+l];
34                 }
35             }
36         }
37     }
38 }
39 void print(){
40     for(int i=0;i<=m1-m2;i++){
41         for(int j=0;j<=n1-n2;j++){
42             printf("%d ",ans[i][j]);
43         }
44         printf("
");
45     }
46 }

view code  1 .data
  2 matrix:    .space 400
  3 .macro readint(%ans) #常用简单操作写成宏比较方便
  4     li    $v0,5
  5     syscall
  6     move    %ans,$v0
  7 .end_macro
  8 .macro save(%a)        #入栈
  9     sw    %a,($sp)
 10     addi    $sp,$sp,-4
 11 .end_macro
 12 .macro load(%a)        #出栈
 13     addi    $sp,$sp,4
 14     lw    %a,($sp)
 15 .end_macro
 16 .text
 17     readint($s0)        #s0是n
 18     readint($s1)        #s1是m
 19     li    $s7,0        #s7是方案数
 20     li    $t0,1        #t0是i
 21 read_matrix:
 22     bgt    $t0,$s0,read_matrix_end
 23     li    $t1,1
 24 read:
 25     bgt    $t1,$s1,read_end
 26     addi    $t2,$t0,-1
 27     mult    $t2,$s1
 28     mflo    $t2        #t2=(i-1)*m
 29     add    $t2,$t2,$t1    #t2=(i-1)*m+j
 30     sll    $t2,$t2,2
 31     la    $s2,matrix
 32     add    $t2,$s2,$t2    #t2是在矩阵中的位置
 33     li    $v0,5
 34     syscall    
 35     sw    $v0,($t2)    #数据存储进入矩阵
 36     addi    $t1,$t1,1
 37     j    read
 38 read_end:
 39     addi    $t0,$t0,1
 40     j    read_matrix
 41 read_matrix_end:
 42     readint($s2)        #s2,s3,s4,s5分别是起始行列，终点行列
 43     readint($s3)
 44     readint($s4)
 45     readint($s5)
 46     
 47     addi    $t0,$s2,-1
 48     mult    $t0,$s1
 49     mflo    $t0
 50     add    $t0,$t0,$s3
 51     sll    $t0,$t0,2
 52     la    $t1,matrix
 53     add    $t0,$t0,$t1
 54     li    $t2,1
 55     sw    $t2,($t0)    #把出发点的位置标记为1，然后再dfs（最开始忘了，所以最终得到的方案数比预计的多）
 56     
 57     move    $a0,$s2
 58     move    $a1,$s3        #dfs参数，即目前的行和列
 59     jal    dfs    
 60     
 61     li    $v0,1
 62     move    $a0,$s7
 63     syscall
 64     li    $v0,10
 65     syscall
 66     
 67     
 68 dfs:                #dfs写的是返回条件，dfswork里面才写了递归调用        
 69     beq    $a0,$s4,hope
 70     j    dfswork
 71 hope:
 72     beq    $a1,$s5,ansadd
 73     j    dfswork
 74 ansadd:
 75     addi    $s7,$s7,1
 76     jr    $31
 77     
 78 #多个if语句的跳转的一种写法:为了能让多个if语句都能执行，并不能直接使用beq等指令，一种实现方法是用jal连接下一步并跳转到一个专门用于判断的过程judge中去
 79 #由于jal跳转，所以需要维护栈，如果用宏来封装维护栈的过程的话，这里就特别容易写（推荐把读入数据，维护栈这种常用简单操作封装，至于其他用到额外寄存器的操作，请谨慎封装）
 80 dfswork:                
 81     save($a0)
 82     save($a1)
 83     save($31)        #第一次进时，这里存的是回主函数的地址
 84     addi    $a0,$a0,0
 85     addi    $a1,$a1,-1
 86     jal    judge
 87     load($31)
 88     load($a1)
 89     load($a0)         #完成对于一个方向的判断
 90     
 91     save($a0)
 92     save($a1)
 93     save($31)
 94     addi    $a0,$a0,0
 95     addi    $a1,$a1,1
 96     jal    judge
 97     load($31)
 98     load($a1)
 99     load($a0)
100     
101     save($a0)
102     save($a1)
103     save($31)
104     addi    $a0,$a0,-1
105     addi    $a1,$a1,0
106     jal    judge
107     load($31)
108     load($a1)
109     load($a0)
110     
111     save($a0)
112     save($a1)
113     save($31)
114     addi    $a0,$a0,1
115     addi    $a1,$a1,0
116     jal    judge
117     load($31)
118     load($a1)
119     load($a0)
120     
121     jr    $31        #返回上一个dfs
122     
123 judge:
124     bgt    $a0,$s0,back    #如果行严格大于行数，返回
125     ble    $a0,$0,back    #如果行号小于等于0，返回
126     bgt    $a1,$s1,back    #同理
127     ble    $a1,$0,back
128     addi    $t0,$a0,-1    #由于存的时候就是这样的，所以此处也先减一
129     mult    $t0,$s1
130     mflo    $t1
131     add    $t1,$t1,$a1
132     sll    $t1,$t1,2
133     la    $t2,matrix
134     add    $t1,$t1,$t2    
135     lw    $t3,($t1)    #t3是矩阵中该位置的值，表示是否能走
136     bne    $t3,$0,back    #如果t3不能走，回退一次
137     li    $t4,1
138     sw    $t4,($t1)    #标记为不能走了
139     save($31)        #第一次进时，这里存的是judge下一条的地址
140     save($t1)
141     save($t2)
142     save($t3)
143     save($t4)        #不管哪些需要存哪些不需要存了，xjb存就完事了（其实这里只需要$t1存起来），最开始我$t1忘了存了
144     jal    dfs
145     load($t4)
146     load($t3)
147     load($t2)
148     load($t1)
149     load($31)
150     sw    $0,($t1)        #把值修改回去，以后又可以走了
151     jr    $31        #回judge的下一条指令，即判断另一个方向
152     
153     
154 back:
155     jr    $31

view code#include <bits/stdc++.h> 
#define ll    long long 
//矩阵快速幂的快速之处不在于加速两个矩阵相乘时内部的计算速度
//而是减少矩阵之间做乘法的次数 
ll mod=1000000007;
typedef struct{
    ll    a[200][200];
}Matrix;
Matrix m,ans;
void power(ll n,ll k);
Matrix mult(Matrix ans,Matrix base,ll n);
int main() {
    ll n,k;
    scanf("%lld %lld",&n,&k);
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            scanf("%lld",&m.a[i][j]);
        }
    }
    power(n,k);
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            printf("%lld ",ans.a[i][j]);
        }
        printf("
");
    }
    return 0;
}
void power(ll n,ll k){
    Matrix base=m;
    for(ll i=0;i<n;i++){
        ans.a[i][i]=1; //构造单位矩阵 
    }
    while(k>0){
        if(k&1){
            ans=mult(ans,base,n);
        }
        base=mult(base,base,n);
        k>>=1;
    }
}
Matrix mult(Matrix ans,Matrix base,ll n){
    Matrix result;
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            result.a[i][j]=0;
        }
    }
    for(ll i=0;i<n;i++){
        for(ll j=0;j<n;j++){
            for(ll k=0;k<n;k++){
                result.a[i][j]+=(((ans.a[i][k])*(base.a[k][j]))%mod);
//              result.a[i][j]+=((ans.a[i][k]%mod)*(base.a[k][j]%mod)%mod);会慢，超时 
                result.a[i][j]%=mod;
            }
        }
    }
    return result;
}

view code#include <stdio.h>
#include <stdlib.h>
void dfs(int n,char from,char tmp,char to);
int main() {
    int n;
    char from='A',tmp='B',to='C';
    scanf("%d",&n);
    dfs(n,from,tmp,to);
    
    return 0;
}
void dfs(int n,char from,char tmp,char to){
    if(n==1){
        printf("%c --> %c
",from,to);
        return;
    }
    dfs(n-1,from,to,tmp);
    dfs(1,from,tmp,to);
    dfs(n-1,tmp,from,to);
    return;
}

view code 1 .data
 2 connect:    .asciiz " --> "
 3 enter:    .asciiz "
"
 4 _a:    .asciiz "A"
 5 _b:    .asciiz "B"
 6 _c:    .asciiz "C"
 7 .macro save(%a)
 8     sw    %a,($sp)
 9     addi    $sp,$sp,-4
10 .end_macro
11 
12 .macro swap(%a,%b)
13     move    $t0,%a
14     move    %a,%b
15     move    %b,$t0
16 .end_macro
17 
18 .macro load(%a)
19     addi    $sp,$sp,4
20     lw    %a,($sp)
21 .end_macro
22 
23 .text
24     li    $v0,5
25     syscall
26     move    $s0,$v0        #s0是n
27     move    $a0,$v0
28     la    $a1,_a
29     la    $a2,_b
30     la    $a3,_c        #配置四个参数：盘子数，from,tmp,to
31     jal     dfs
32     
33     li    $v0,10
34     syscall
35 
36 dfs:
37     bgt    $a0,1,dfs_work
38     move    $a0,$a1
39     li    $v0,4
40     syscall
41     la    $a0,connect
42     li    $v0,4
43     syscall
44     move    $a0,$a3
45     li    $v0,4
46     syscall
47     la    $a0,enter
48     li    $v0,4
49     syscall
50     jr    $31
51     
52 dfs_work:
53     save($31)
54     save($a0)
55     save($a1)
56     save($a2)
57     save($a3)
58     addi    $a0,$a0,-1
59     swap($a2,$a3)
60     jal    dfs
61     load($a3)
62     load($a2)
63     load($a1)
64     load($a0)
65     load($31)
66     
67     save($31)
68     save($a0)
69     save($a1)
70     save($a2)
71     save($a3)
72     li    $a0,1
73     jal    dfs
74     load($a3)
75     load($a2)
76     load($a1)
77     load($a0)
78     load($31)
79     
80     save($31)
81     save($a0)
82     save($a1)
83     save($a2)
84     save($a3)
85     addi    $a0,$a0,-1
86     swap($a1,$a2)
87     jal    dfs
88     load($a3)
89     load($a2)
90     load($a1)
91     load($a0)
92     load($31)
93     
94     jr    $31
95