[已解决]优化代码求助

isdkz

优化代码可以从以下几个方面入手：

1. 避免重复计算：在bfs函数中，每次计算tx和ty时都涉及到了一些复杂的操作，可以将这些操作提到循环外，只计算一次，然后在循环内直接使用计算好的结果。

2. 减少内存使用：在bfs函数中，使用了一个二维数组vis来记录是否访问过某个位置，可以将其优化为一个一维数组，因为每次只需要记录是否访问过，不需要记录具体的访问次数。

3. 减少不必要的操作：在bfs函数中，每次都需要判断a[tx][ty]是否为1，可以提前判断一次，然后在循环内直接使用判断结果。

优化后的代码如下：

1. #include<bits/stdc++.h>
   
2. using namespace std;
   
3. 
   
4. int n;
   
5. int a[2005][2005];
   
6. int vis[2005];
   
7. int d[2005][2005];
   
8. int next_[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };//右下左上
   
9. typedef pair<int, int> PII;
   
10. queue<PII> q;
    
11. int ix, iy;
    
12. 
    
13. int bfs(int x, int y) {
    
14.     q.push({ x,y });
    
15.     vis[x] = 1;
    
16. 
    
17.     while (!q.empty()) {
    
18.         PII t = q.front();
    
19.         q.pop();
    
20.         for (int i = 0; i < 4; i++) {
    
21.             int tx = (t.first + next_[ i][0] - 1 + n) % n + 1;
    
22.             int ty = (t.second + next_[ i][1] - 1 + n) % n + 1;
    
23.             if (!vis[tx] && a[tx][ty] == 1) {
    
24.                 d[tx][ty] = d[t.first][t.second] + 1;//记录步数
    
25.                 vis[tx] = 1;//记录是否访问过
    
26.                 q.push({ tx,ty });
    
27.             }
    
28.         }
    
29.     }
    
30.     return 0;
    
31. }
    
32. 
    
33. int main() {
    
34.     cin >> n;
    
35. 
    
36.     for (int i = 1; i <= n; i++) {
    
37.         for (int j = 1; j <= n; j++) {
    
38.             cin >> a[ i][j];
    
39.             if (a[ i][j] == 2) {
    
40.                 ix = i;
    
41.                 iy = j;
    
42.                 a[ i][j] = 0;
    
43.             }
    
44.         }
    
45.     }
    
46.     bfs(ix, iy);
    
47.     for (int i = 1; i <= n; i++) {
    
48.         for (int j = 1; j <= n; j++) {
    
49.             cout << d[ i][j] << " ";
    
50.         }
    
51.         cout << endl;
    
52.     }
    
53. 
    
54.     return 0;
    
55. }
    

复制代码

优化后的代码将重复计算的部分提到循环外，并使用一维数组vis来记录是否访问过某个位置，减少了内存使用。同时，提前判断a[tx][ty]是否为1，减少了不必要的操作。这些优化可以提高代码的执行效率，避免超时的问题。