AcWing 844. 走迷宫(数组模拟，C++STL， python、打印路径)    原题链接    简单

作者： 作者的头像   Ker ,  2020-03-16 18:50:01 ,  所有人可见 ,  阅读 19712

207


101

题目描述

给定一个n*m的二维整数数组，用来表示一个迷宫，数组中只包含0或1，其中0表示可以走的路，1表示不可通过的墙壁。

最初，有一个人位于左上角(1, 1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角(n, m)处，至少需要移动多少次。

数据保证(1, 1)处和(n, m)处的数字为0，且一定至少存在一条通路。

输入格式
第一行包含两个整数n和m。

接下来n行，每行包含m个整数（0或1），表示完整的二维数组迷宫。

输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围
1≤n,m≤100

样例

输入样例：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
8

数组模拟队列

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110; 
typedef pair<int, int> PII;
int n, m;
int g[N][N];//存放地图
int d[N][N];//存 每一个点到起点的距离
PII q[N * N];//手写队列
int bfs()
{
    int hh = 0, tt = 0;
    q[0] = {0, 0};

    memset(d, - 1, sizeof d);//距离初始化为- 1表示没有走过

    d[0][0] = 0;//表示起点走过了

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};//x 方向的向量和 y 方向的向量组成的上、右、下、左

    while(hh <= tt)//队列不空
    {
        PII t = q[hh ++ ];//取队头元素

        for(int i = 0; i < 4; i ++ )//枚举4个方向
        {
            int x = t.first + dx[i], y = t.second + dy[i];//x表示沿着此方向走会走到哪个点
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)//在边界内 并且是空地可以走 且之前没有走过
            {
                d[x][y] = d[t.first][t.second] + 1;//到起点的距离
                q[ ++ tt ] = {x, y};//新坐标入队
            }
        }
    }
    return d[n - 1][m - 1]; //输出右下角点距起点的距离即可
}
int main() 
{
    cin >> n >> m;
    for(int i = 0; i < n; i ++ )
        for(int j = 0; j < m; j ++ )
            cin >> g[i][j];

    cout << bfs() << endl;

    return 0;
}

C++ queue

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int N = 110;

typedef pair<int, int> PII;

int n, m;
int g[N][N], d[N][N];

int bfs()
{
    queue< pair<int, int> > q;

    q.push({0, 0});

    memset(d, -1, sizeof(d));

    d[0][0] = 0;


    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

    while (q.size())//队列不为空
    {
        PII t = q.front();//取队头元素

        q.pop();//出队

        for (int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i], y = t.second + dy[i];

            if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;//当前点到起点的距离
                q.push({x, y});//将新坐标入队
            }
        }
    }

    return d[n - 1][m -1];
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> g[i][j];

    cout << bfs() << endl;

    return 0;
}

打印路径

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
typedef pair<int, int> PII;
PII q[N*N],Prev[N][N];
int g[N][N], d[N][N];
int n, m;
int bfs()
{
    int hh = 0, tt = 0;
    q[0] = {0, 0};
    memset(d, -1, sizeof d);

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    d[0][0] = 0;
    while(hh <= tt)
    {
        PII t = q[hh ++ ];
        for(int i = 0; i < 4; i ++ )
        {
            int x = dx[i] + t.first, y = t.second + dy[i];

            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                Prev[x][y] = t;
                q[++ tt] = {x, y};
            }
        }
    }
    int x = n - 1, y = m - 1;
    while(x || y)//有一个不d等于0
    {
        cout << x << ' ' << y << endl;
        PII t = Prev[x][y];
        x = t.first, y = t.second;
    }

    return d[n - 1][m - 1];
}
int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i ++ )
        for(int j = 0; j < m;j ++)
            cin >> g[i][j];

    cout << bfs() << endl;

    return 0;
}

python

def bfs():
    d[0][0] = 0
    queue = [(0, 0)]
    dx = [-1, 0, 1, 0]
    dy = [0, 1, 0, -1]

    while queue : #队列不为空
        x, y = queue.pop(0)
        for i in range(4):
            a = x + dx[i];
            b = y + dy[i];
            if a >= 0 and a < n and b >= 0 and b < m and g[a][b] == 0 and d[a][b] == -1:
                queue.append((a,b))#入队
                d[a][b] = d[x][y] + 1
    print(d[n - 1][m - 1])
#main
n, m = map(int, input().split())#map函数对分割输入后的字符列表转换成整型
g = [[-1 for j in range(m)] for i in range(n)] # 存储地图

for i in range(n):
    in_li = list(map(int, input().split()))
    for j in range(m):
        g[i][j] = in_li[j];
d = [[-1 for i in range(m)] for j in range(n)]#初始化为 - 1
bfs()

62 评论

用户头像
thebeatles   9个月前      21    踩      回复

附上打印路径的代码，如果对你有帮助，请留个评论或者点个赞，谢谢。

#include<bits/stdc++.h>
using namespace std;
const int N = 200;
int n,m;
int d[N][N];//存储从起点到各点的最短距离，初始化为-1，表示未访问过。
int g[N][N];//存储地图信息，0表示可以通过的点，非0表示有障碍物的点。
queue<pair<int,int>> q; //用于BFS搜索的队列，存储点的坐标。
pair<int, int> prevNode[N][N]; //存储每个点的前一个点的坐标，用于追踪路径

int bfs(){
    memset(d,-1,sizeof d);// 初始化所有点的最短距离为-1
    d[1][1] = 0; //首先将起点(1, 1)的最短距离设置为0，表示从起点到起点的距离为0，
    q.push({1,1}); //把起点放入队列中。

    int dx[4] ={0,0,-1,1},dy[4] = {1,-1,0,0};//上下左右

    while(q.size()){//当队列中还有坐标
        auto t = q.front();  // 获取队列前端元素，即当前处理的点
        q.pop(); // 弹出当前处理的点
        for(int i = 0;i < 4;i++){
            int x = t.first + dx[i],y = t.second + dy[i];//遍历四个方向
            //如果这个相邻点有效（在网格范围内）、未被访问过（d[x][y] == -1）、且没有障碍物（g[x][y] == 0），
            if(x >= 1 && y >= 1 && x <= n && y <= m && d[x][y] == - 1 && g[x][y] == 0){//记住是y <= m不是y <= n
                d[x][y] = d[t.first][t.second] + 1; //更新这个点的最短距离为d[t.first][t.second] + 1
                prevNode[x][y] = t; // 记录前驱点，是由t来到(x,y)的。
                q.push({x,y}); //将其坐标加入队列中。
            }
        }
    }
    //循环结束后，d[n][m]中存储的就是从起点(1, 1)到终点(n, m)的最短距离。
    //如果终点不可达，结果将保持为初始化时的-1。
    return d[n][m];
}

void print_path() {
    if (d[n][m] == -1) {
        cout << "终点不可达。" << endl;
        return;
    }
    vector<pair<int, int>> path;
    // 从终点开始逆向追踪到起点

    //这里为什么逆向追踪呢？因为我们储存的是前驱节点，我们只知道到达了终点(n,m)，所以要先找(n,m)的前驱节点a，
        //再找a的前驱节点b，直到到达(1,1)
    //这个过程就像是沿着一条线索，从故事的结局逐步回溯到开头一样。
    //make_pair(1, 1) 创建了一个包含两个整数的 pair
    for (pair<int, int> at = {n, m}; at != make_pair(1, 1); at = prevNode[at.first][at.second]) {
        path.push_back(at);
    }

    path.push_back({1, 1}); // 加入起点
    reverse(path.begin(), path.end()); // 将路径逆序，因为我们是逆向追踪的

    for (auto p : path) {
        cout << "(" << p.first << ", " << p.second << ")" << " -> ";
    }
    cout << "End" << endl;
}

int main() {
    cin >> n >> m;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            cin >> g[i][j];
        }
    }

    cout << bfs() << endl; // 执行BFS搜索并输出从起点到终点的最短距离
    print_path(); // 打印找到的路径

    return 0;
}
用户头像
查克靠近   9个月前      1    踩      回复

打印路径写的很清楚

用户头像
thebeatles   9个月前    回复了 查克靠近 的评论         踩      回复

就是因为评论区翻了翻没找到详细解释打印路径的，才发了这个评论哈哈哈

用户头像
knighz   9个月前    回复了 thebeatles 的评论         踩      回复

是不是GPT写的哈哈哈我今天也生成了差不多的代码

用户头像
thebeatles   9个月前    回复了 knighz 的评论      2    踩      回复

用GPT4写的，解释的很清楚，这就是科技的力量哈哈哈

用户头像
h闵   8个月前      1    踩      回复 
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
// #include <vector>

#define x first
#define y second

using namespace std;

typedef pair<int,int> PII;

const int N = 110;

int g[N][N];
int d[N][N];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};
int n,m;

// vector<PII> q;
PII q[N * N];

int dfs()
{
    int hh = 0,tt = 0;
    q[hh] = {0,0};
    memset(d,-1,sizeof d);
    d[0][0] = 0;

    while(hh <= tt)
    {
        PII t = q[hh];
        hh++;

        for(int i = 0;i < 4;i++)
        {
            int x = t.first + dx[i],y = t.second + dy[i];
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                q[++tt] = {x,y};
            }
        }
    }

    return d[n - 1][m - 1];
}

int main()
{
    scanf("%d%d",&n,&m);

    for(int i = 0;i < n;i++)
    {
        for(int j = 0;j < m;j++)
        {
            scanf("%d",&g[i][j]);
        }
    }

    printf("%d\n",dfs());

    return 0;
}

为什么vector[HTML_REMOVED] q;就会报错
PII q[N * N];这样才可以啊，我不理解这个是为什么，原则上不都是可以的吗?

用户头像
喜欢吃葡萄-爱谁回笼觉   2023-10-25 21:32      1    踩      回复 
#include<iostream>
#include<queue>
#include<utility>
using namespace std;

const int N=110;
int map[N][N];  // map记录一个地图的点 
bool vis[N][N];     // vis记录每个点是否被走过 
int m,n;
const int dx[] = {-1,0,1,0};  // dx dy 记录每个方向上的变化量 
const int dy[] = {0,-1,0,1};
int res;
typedef pair<int,int> PII;

void bfs(){

    queue<PII> q;
    q.push({1,1});
    vis[1][1]=1;
    int flag=0;

    while(!q.empty()){
        int size = q.size();
        res++;
        cout<<"res is"<<res<<endl;
        for(int t=1;t<=size;t++){
            PII k = q.front();
            q.pop();
            int x = k.first;
            int y = k.second;
            cout<<"x is "<<x<<"y is "<<y<<endl; 
            if(x==n&&y==m){
                flag=1;
                break;
            } 
            for(int i=1;i<=4;i++){
                int xx = x + dx[i];
                int yy = y + dy[i];
                if(yy >= 1&&yy<=n&&xx>=1&&xx<=m&& map[xx][yy]==0 && !vis[xx][yy]){
                    vis[xx][yy]=1;
                    map[xx][yy]=2;
                    q.push({xx,yy});
                }
            }
        }
        if(flag) break;
    }
}



int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            // cout<<"!!!"<<endl;
            cin>>map[i][j];
        }
    }
    // cout<<"!!!"<<endl;
    bfs();
    cout<<res-1<<endl;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++) 
            cout<<map[i][j]<<" "; 
        cout<<endl;
    }
    return 0;
}

兄弟们 我想用res 代表走过的长度 没走一次不是都会离终点只进一格吗? 那么我在每个while循环当中 res++ 为什么答案不对???
样例能过

用户头像
第九片海_2   2023-09-18 19:54      1    踩      回复

为什么我这个答案一直不对


#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N=110;
int n,m,g[N][N],d[N][N];


int bfs()
{
    queue<pair<int,int>>p;
    p.push({0,0});

    memset(d,-1,sizeof(d));
    d[0][0]=0;

    int dx[4]={1,0-1,0},dy[4]={0,1,0,-1};

    while(p.size())
    {
        PII t=p.front();
        p.pop();

        for(int i=0;i<4;i++)
        {
            int x=t.first+dx[i],y=t.second+dy[i];
            if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1)
            {
                d[x][y]=d[t.first][t.second]+1;
                p.push({x,y});
            }
        }
    }
    return d[n-1][m-1];
}
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
       for(int j=0;j<m;j++)
          cin>>g[i][j];

    cout<<bfs();
    return 0;
}
用户头像
sca   2023-10-25 11:16         踩      回复

你不会是dx[4]={1,0-1,0}这句里漏了个逗号吧…

用户头像
acwing_63468   2023-10-26 12:40    回复了 sca 的评论         踩      回复

确实

用户头像
li2022   2023-08-04 16:20      1    踩      回复

为什么初始化队列hh=0，tt=0？
我记得以前y总代码tt是等于-1的，hh和tt初始化有什么原理吗

用户头像
佐助   2023-10-06 16:42      1    踩      回复

tt是初始-1,y总也习惯-1,但是这里是从起点开始q[0] = {0,0}; //此时默认将起点加入队列了
由于q[++ tt] = x;
所以tt变成了 -1 + 1 = 0 ，所以初始化的时候hh = 0, tt = 0; //队列中已经有一个元素了hh~

用户头像
li2022   2023-10-09 12:37    回复了 佐助 的评论         踩      回复

原来如此，要根据题目来初始化是吧？hhh感谢大佬答惑

用户头像
佐助   2023-10-10 20:52    回复了 li2022 的评论         踩      回复

因为队伍里有一个点了，根据需求来吧…我也刚开始学习加油hh~

用户头像
狐行千里   2022-03-26 19:31      1    踩      回复

一个很奇怪的问题。Y总讲输出路径的时候用的代码如下

int x = n - 1, y = m - 1;
    while(x || y)
    {
        cout << x << ' ' << y << endl;
        auto t = pre[x][y];
        x = t.first, y = t.second;
    }

但如果不定义临时变量t，变成

int x = n - 1, y = m - 1;
    while(x || y)
    {
        cout << x << ' ' << y << endl;
        x = pre[x][y].first, y = pre[x][y].second;
    }

就会少输出（2，4）这个点。实在想不明白，求解

用户头像
不会算法的小菜鸡   2022-04-01 19:21      5    踩      回复

y = pre[x][y].second;里的x 会根据x = pre[x][y].first,改变所肯定会少几个点

用户头像
狐行千里   2022-04-02 01:26    回复了 不会算法的小菜鸡 的评论         踩      回复

确实如此，感谢

用户头像
胡歌-此生不换   2023-04-03 19:53         踩      回复

不是都一样吗，我等下回去试一试

用户头像
HanhanH   2023-04-05 15:03         踩      回复

啊啊啊啊啊你的问题解决了我找了好久好久的bug!!!Orz

用户头像
_chouchou_   2023-07-19 22:16    回复了 胡歌-此生不换 的评论      1    踩      回复

不一样，下面那个，先改变了x，相当于后面的第一个下标变了

用户头像
vanBo   2023-11-22 18:37    回复了 不会算法的小菜鸡 的评论         踩      回复

原来如此啊，出现了覆盖的问题😁

用户头像
烟波   9个月前         踩      回复

我爱你!!! ┭┮﹏┭┮,这注释救大命

用户头像
Thoudam   9个月前         踩      回复 
有没有大佬知道为什么我这个TLE呢
#include <iostream>
#include <string.h>
#include <queue>
using namespace std;
const int N = 105;
int maze[N][N];
int dx[] = { 1, 0, -1, 0};
int dy[] = { 0, 1, 0, -1};
int n,m;

typedef struct Node{
    int x,y;
    int min_step;
}Node;
Node node;

int BFS(){
    queue<Node> q;
    Node first = {1,1,0};
    q.push(first);
    while(!q.empty()){
        Node top = q.front();
        q.pop();
        maze[top.x][top.y] = 1;
        for(int i = 0;i < 4;i ++){
            int next_x = top.x + dx[i];
            int next_y = top.y + dy[i];
            if(maze[next_x][next_y] == 0){
                Node next = {next_x, next_y, top.min_step + 1};
                maze[next_x][next_y] = 1;
                if(next_x == n && next_y == m)return next.min_step;
                q.push(next);
            }
        }
    }
    cout << "wrong";
    return -1;
}

int main(){
    memset(maze, 1, sizeof(maze));
    cin >> m >> n;
    for(int i = 1;i <= m;i ++){
        for(int j = 1;j <= n;j ++){
            cin >> maze[i][j];
        }
    }
    cout << BFS();
    return 0;
}
用户头像
jack2012   11个月前         踩      回复

写得太好了

用户头像
Wd_8   2023-11-16 09:28         踩      回复

ORZ

用户头像
zhangqiwei   2023-10-18 15:23         踩      回复

求大佬援助，这个代码为何不对？
#include [HTML_REMOVED]
using namespace std;
long long int n,sum=100000000,m,cup,equ[110][110],ans,ok[110][110],px[4]={0,-1,0,1},py[4]={1,0,-1,0};
bool edge(int x,int y){
return x>=1&&x<=n&&y>=1&&y<=m;
}
void bfs(int x,int y){
if(x==n&&y==m) sum=min(ans,sum);
ok[1][1]=-1;
for(int i=0;i<4;i){
if(edge(x+px[i],y+py[i])&&ok[x+px[i]][y+py[i]]==0){
cup=ans;
// cout<[HTML_REMOVED]>equ[i][j];
if(equ[i][j]==1) ok[i][j]=-5;
}
}
bfs(1,1);
cout<<sum;
return 0;
}

用户头像
嘉然今天不吃饭   2023-07-08 12:10         踩      回复

%%%%

用户头像
ACwe   2023-06-07 23:35         踩      回复

请问为什么我这个代码不行呢？

include[HTML_REMOVED]
using namespace std;

const int N=105;
typedef pair[HTML_REMOVED] pii;
int tt,hh;
int n,m;
pii q[N*N];
bool g[N][N];//表示地图
int d[N][N];//表示距离
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};

int bfs()
{
q[0]={0,0};//队头
memset(d,-1,sizeof(d));//距离都初始化成-1，表示没有走过。
d[0][0]=0;//从00点开始走
while(hh<=tt)//队列非空
{
auto t=q[hh];//拿出对头
for(int i=0;i<4;i)
{
int x=t.first+dx[i];
int y=t.second+dy[i];
if(x>=0&&x[HTML_REMOVED]=0&&y<m&&d[x][y]==-1&&g[x][y]==false)
//新的xy坐标没有出地图边界，且是第一次遍历到该点（d[x][u]==-1），且地图上是可以走的点
{
d[x][y]=d[t.first][t.second]+1;//更新距离，注意这里不能用
q[tt]={x,y};//插入队列
}
}
}
return d[n-1][m-1];
}

int main()
{
cin>>n>>m;
cout<<bfs()<<endl;
}

当输入是：
10 10
0 0 0 0 0 0 1 0 0 1
0 0 1 0 0 1 0 0 0 1
0 0 1 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 1 1 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 1
0 0 0 1 1 1 0 1 1 1
0 0 0 0 0 0 0 0 0 1
0 0 0 0 1 0 1 0 0 0
0 0 0 0 1 0 1 1 1 0
我输入18，正确答案20

用户头像
linshengxuan   2023-07-19 15:30      1    踩      回复

我只能说你小子很强， i也不 h也不 tt也不++

用户头像
AINLL   2023-09-07 13:41         踩      回复

写的很好但是但凡你设置一下断点，就能看出大错误哥们

用户头像
shenkai   2023-02-11 15:45         踩      回复

为什么pair数组(模拟队列的那个数组）要是N*N的长度呢

用户头像
DDR   2023-02-20 21:06      1    踩      回复

因为有数组维度NN，一共有NN 个元素啊

用户头像
shenkai   2023-02-21 08:16    回复了 DDR 的评论         踩      回复

啊哦哦哦懂了谢谢

用户头像
_cabbage_   2023-01-06 19:34         踩      回复

为什么每一次都要取走队头元素？？？是因为这个点已经走过了吗？

用户头像
星光下的舞蹈   2023-01-08 09:46      2    踩      回复

因为要一层层遍历啊，取队头元素能够保证在遍历下一层的时候把这一层已经走完了，这一层能够走到的点都入队了

用户头像
南岸以南南岸哀   2022-06-30 21:33         踩      回复

为什么d要初始成-1，既然是bfs距离肯定是上一个+1的距离，所以只要初始化第一个点的距离为0就行了吧，剩下的点都是从0点开始+

用户头像
JunieXD   2022-10-02 17:29      2    踩      回复 
if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)

中的

 d[x][y] == -1

可以用来判断那个位置是不是第一次走

用户头像
Hi_5   2022-05-24 20:09         踩      回复

为什么用BFS找出的路径一定是最短的？

用户头像
Horace   2022-06-09 21:48      1    踩      回复

权值都一样，一层一层找肯定BFS最短

用户头像
Hi_5   2022-06-10 12:00    回复了 Horace 的评论         踩      回复

谢谢~

用户头像
枯木逢春i   2023-06-02 22:41      1    踩      回复

其实可以这样理解，如果有几条线路都可以到终点得话，这几条线路都是同样的速度，如果某条路线最先到达了，其他线路就不让到达了，相同的速度，先到的是不是距离最短。

用户头像
无奈和生活对线了   2023-08-02 21:11      1    踩      回复

因为每个位置在d数组也就是距离数组中能且只能被赋一次值，d数组中对应位置的值就是第一次找到这个元素所走的步数

用户头像
无奈和生活对线了   2023-08-02 21:12    回复了 无奈和生活对线了 的评论      1    踩      回复

既然是第一次找到这个点，肯定就是最短路径

用户头像
rayyy310   2022-03-20 13:37         踩      回复

现在输出路径是倒着输出的，那路径如果想正着输出该怎么办呢？

用户头像
菜得过于均匀   2022-04-11 15:49         踩      回复

加个栈，先进后出，重新输出保存路径的栈就行。

用户头像
胡歌-此生不换   2023-04-03 19:49    回复了 菜得过于均匀 的评论         踩      回复

用栈也可以，reverse 反转一下数组也可以

用户头像
pdsuacm10   2022-01-07 22:08         踩      回复

大哥写的最好

用户头像
我要上大学   2022-03-07 17:15      1    踩      回复

怎么好多人都是你这个头像呢

用户头像
牛马阳msun   2022-03-17 12:00    回复了 我要上大学 的评论         踩      回复

这是acwing网站初始的头像

用户头像
我要上大学   2022-03-17 17:49    回复了 牛马阳msun 的评论         踩      回复

soga

用户头像
Critic   2022-01-06 20:44         踩      回复

赞，您写得最清晰。