蓝桥杯 3.搜索

news2025/2/24 10:05:37

蓝桥杯 3.搜索

文章目录

  • 蓝桥杯 3.搜索
    • DFS回溯
    • DFS剪枝
    • 记忆化搜索
    • 编程66-75

DFS回溯

回溯法简介

  • 使用**DFS(深度优先搜索)**实现, DFS是一种遍历或搜索图, 树或者图像等数据结构的算法, 当然这个图, 树未必要存储下来(隐式处理就是回溯法)
  • 搜索树一般是排列型搜索树 (总节点个数n!)和子集型搜索树(总结点个数2^n)
  • DFS从起始点开始, 沿着一条路径尽可能深入的搜索, 直到无法继续为止, 然后回溯到前一个结点, 继续探索其他路径, 直到遍历完整个图或树
  • DFS一般使用递归来管理节点的遍历顺序

image-20250218162557042

image-20250218162806703

回溯法模板

// 求1~n的全排列
int a[N];
bool vis[N];

void dfs(int dep){ // 深度
    if(dep == n + 1){ // n层
        for(int i = 1; i <= n; i++){
            cout << a[i] << "\n";
        }
        cout << "\n";
        return; // 出口
    }
    for(int i = 1; i <= n; i++){ // 向下搜索
        // 排除不合法的路径(vis[i]是否使用过)
        if(vis[i]) continue;
        
        // 修改状态
        vis[i] = true;
        a[dep] = i;
        
        // 下一层
        dfs(dep + 1);
        
        // 恢复现场
        vis[i] = false;
        // a[dep] = 0 可以省略
    }
}

// 这是一个排列型搜索树, 子集型搜索树跟这个类似, 就是在往下走的时候只有两条, 表示"选或不选当前的元素"

例题讲解

image-20250218165942338

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 15;
ll n, ans; 
// 求1~n的全排列
ll a[N];
ll vis[N][N];

void dfs(int dep){ // 深度
    if(dep == n + 1){ // n层
        ans++;
        return; // 出口
    }
    for(int i = 1; i <= n; i++){ // 向下搜索
        // 排除不合法的路径
        if(vis[dep][i]) continue;
        
        // 修改状态
        for(int _i = 1; _i <= n; _i++) vis[_i][i]++;
        for(int _i = dep, _j = i; _i >= 1 && _j >= 1; _i--, _j--) vis[_i][_j]++;
        for(int _i = dep, _j = i; _i <= n && _j >= 1; _i++, _j--) vis[_i][_j]++;
        for(int _i = dep, _j = i; _i >= 1 && _j <= n; _i--, _j++) vis[_i][_j]++;
        for(int _i = dep, _j = i; _i <= n && _j <= n; _i++, _j++) vis[_i][_j]++;
        
        // 下一层
        dfs(dep + 1);
        
        // 恢复现场
        for(int _i = 1; _i <= n; _i++) vis[_i][i]--;
        for(int _i = dep, _j = i; _i >= 1 && _j >= 1; _i--, _j--) vis[_i][_j]--;
        for(int _i = dep, _j = i; _i <= n && _j >= 1; _i++, _j--) vis[_i][_j]--;
        for(int _i = dep, _j = i; _i >= 1 && _j <= n; _i--, _j++) vis[_i][_j]--;
        for(int _i = dep, _j = i; _i <= n && _j <= n; _i++, _j++) vis[_i][_j]--;
    }
}

int main(){
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  cin >> n;
  dfs(1);
  cout << ans << "\n";
  return 0;
}

image-20250218171830882

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e5+9;
ll n, a[N], dfn[N], idx, mindfn; // dfn表示时间戳

int dfs(int x){
    dfn[x] = ++idx;
    if(dfn[a[x]]){
        if(dfn[a[x]] >= mindfn) return dfn[x] - dfn[a[x]] + 1;
        return 0;
    }
    return dfs(a[x]);
}

int main(){
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  cin >> n;
  for(int i = 1; i <= n; i++){
    cin >> a[i];
  }
  int ans = 0;
  for(int i = 1; i <= n; i++){
    if(!dfn[i]){
      mindfn = idx + 1;
      ans = max(ans, dfs(i));
    }
  }
  cout << ans << "\n";
  return 0;
}

DFS剪枝

简介

  • 将搜索过程中一些不必要的部分直接剔除掉
  • 剪枝是回溯法的一种重要的优化手段

例题讲解

image-20250219211905581

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e5 + 9;
ll n, a[N];
vector<int> v[N];

// cnt表示队伍数量, dfs返回在cnt个队伍的情况下是否可以成功分组
bool dfs(int cnt, int dep){
  if(dep == n + 1){
    return true;
  }
  // 枚举每个人所属的队伍
  for(int i = 1; i <= cnt; i++){
    bool tag = true;
    for(const auto &j : v[i]){
      if(a[dep] % j == 0){
        tag = false;
        break;
      }
    }
    if(!tag) continue;

    v[i].push_back(a[dep]);
    if(dfs(cnt, dep + 1)) return true;

    // 恢复现场
    v[i].pop_back();
  }
  return false;
}

int main(){
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  cin >> n;
  for(int i = 1; i <= n; i++){
    cin >> a[i];
  }
  sort(a + 1, a + 1 + n);
  int ans = 0;
  for(int i = 1; i <= n; i++){
    if(dfs(i, 1)){
      cout << i << "\n";    
      break;
    }
  }
  
  return 0;
}

image-20250219214259308

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 9;
ll n, a[5], cnt[N], prefix[N];

// cnt表示队伍数量, dfs返回在cnt个队伍的情况下是否可以成功分组
void dfs(int dep, int st, int mul, int sum){
  // 剪枝
  if(mul > 1e6) return;
  if(dep == 4){
    cnt[mul]++;
    return;
  }

  int up = pow(1e6 / mul, 1.0 / (4 - dep)) + 3;

  for(int i = st + 1; i < (dep == 3 ? sum : up); i++){
    dfs(dep + 1, i, mul * i, sum + i);
  }
}

int main(){
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  dfs(1, 0, 1, 0);

  for(int i = 1; i <= 1e6; i++){
    prefix[i] = prefix[i - 1] + cnt[i];
  }
  ll t; cin >> t;
  while(t--){
    ll l, r; cin >> l >> r;
    cout << prefix[r] - prefix[l - 1] << "\n";
  }
    
  return 0;
}

image-20250219214844893

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 9;
ll n, a[5], cnt[N], prefix[N];

// cnt表示队伍数量, dfs返回在cnt个队伍的情况下是否可以成功分组
void dfs(int dep, int st, int mul, int sum){
  // 剪枝1
  if(mul > 1e5) return;
  if(dep == n + 1){
    cnt[mul]++;
    return;
  }
  // 剪枝2
  int up = pow(1e5 / mul, 1.0 / (n - dep + 1)) + 3;
  // 剪枝3
  for(int i = st + 1; i < (dep == n ? min(sum , up) : up); i++){
    dfs(dep + 1, i, mul * i, sum + i);
  }
}

int main(){
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  ll t; cin >> t >> n;
  dfs(1, 0, 1, 0);

  for(int i = 1; i <= 1e5; i++){
    prefix[i] = prefix[i - 1] + cnt[i];
  }

  while(t--){
    ll l, r; cin >> l >> r;
    cout << prefix[r] - prefix[l - 1] << "\n";
  }
    
  return 0;
}

记忆化搜索

简介

  • 将搜索过程中会重复计算且结果相同的部分保存下来
  • 通常使用数组或者map来进行记忆化, 下标一般和dfs的参数表对应

例题讲解

  • 斐波那契数列
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 9;
const ll p = 1e9 + 7;
ll n, a[N], dp[N];

ll f(ll n){
    if(n == 1 || n == 2){
        return 1;
    }
    if(dp[n] != -1){
        return dp[n];
    }
    return dp[n] = (f(n - 1) + f(n - 2)) % p;
}

int main(){
  	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	memset(dp, -1, sizeof(dp)); // 初始化为-1, 表示这个状态还没有被算过
    cin >> n;
    cout << f(n) << "\n";
    
  	return 0;
}

image-20250221164605428

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e3 + 9;
const ll p = 1e9 + 7;
ll n, m, k, a, b, c, d, h[N][N];
ll dx[] = {0, 0, 1, -1};
ll dy[] = {1, -1, 0, 0};

int dp[N][N][2];

ll inmp(int x, int y){
  return 1 <= x && x <= n && 1 <= y && y <= m;
}

bool dfs(int x, int y, int t){
  if(x == c && y == d){
    return true;
  }
  if(dp[x][y][t] != -1){
    return dp[x][y][t];
  }
  for(int i = 0; i < 4; i++){
    int nx = x + dx[i], ny = y + dy[i];
    if(!inmp(nx, ny)) continue;

    if(!t){ // 没用过背包
      // 不用
      if(h[x][y] > h[nx][ny] && dfs(nx, ny, 0)) return dp[x][y][t] = true;
      // 用
      if(h[x][y] + k > h[nx][ny] && dfs(nx, ny, 1)) return dp[x][y][t] = true;
    } else { // 已经用过一次背包了
      // 不用
      if(h[x][y] > h[nx][ny] && dfs(nx, ny, 1)) return dp[x][y][t] = true;
    }
  }
  return dp[x][y][t] = false;
}

int main(){
  	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    memset(dp, -1, sizeof(dp));
    cin >> n >> m >> k;
    cin >> a >> b >> c >> d;
    for(int i = 1; i <= n; i++){
      for(int j = 1; j <= m; j++){
        cin >> h[i][j];
      }
    }

    cout << (dfs(a, b, 0) ? "Yes" : "No") << "\n";
    
  	return 0;
}

编程66-75

image-20250221171522028

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 9;
ll n, d;
pair<ll, ll> a[N];
bool vis[N];
ll dist2(ll x1, ll y1, ll x2, ll y2){
  return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2); // 两点之间的距离的平方
}

void dfs(ll x){
  vis[x] = 1; // 第一个人肯定传染
  for(int i = 1; i <= n; i++){ // 枚举n个人
    if(dist2(a[i].first, a[i].second, a[x].first, a[x].second) > d * d) continue; // 距离大于d的平方不会被传染
    if(vis[i]) continue; // 标记过的不传染
    dfs(i); // 继续dfs
  }
}

int main(){
  	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cin >> n;
    for(int i = 1; i <= n; i++){
      cin >> a[i].first >> a[i].second;
    }
    cin >> d;
    dfs(1);
    for(int i = 1; i <= n; i++){
      cout << vis[i] << "\n";
    }
  	return 0;
}

image-20250221174827235

image-20250221172825029

// dfs大概模板(对于二维)
ll dx[...] = ...
ll dy[...] = ...
ll dfs(ll x, ll y){
  ll sum = a[x][y];
  for(int i = 0; i < 4; i++){
    ll xx = x + dx[i];
    ll yy = y + dy[i];
    if(xx < 1 || xx > n || yy < 1 || yy > m) continue; // 超出边界
    if(vis[xx][yy]) continue; // 已经被访问过
    if(...) // 其他限制条件
    // 剩下的就是满足的
    vis[xx][yy] = 1;
  }
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 105;
ll n, m, a[N][N], vis[N][N];
ll dx[4] = {1, 0, 0, -1}; // 下左上右
ll dy[4] = {0, 1, -1, 0};

ll dfs(ll x, ll y){ // 求(x, y)整个连通块的和
  ll sum = a[x][y];
  for(int i = 0; i < 4; i++){
    ll xx = x + dx[i];
    ll yy = y + dy[i];
    if(xx < 1 || xx > n || yy < 1 || yy > m) continue; // 超出边界
    if(vis[xx][yy]) continue; // 已经被访问过
    if(a[xx][yy] == 0) continue; // 0
    vis[xx][yy] = 1;
    sum += dfs(xx, yy);
  }
  return sum;
}

int main(){
  	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cin >> n >> m;
    for(int i = 1; i <= n; i++){
      for(int j = 1; j <= m; j++){
        cin >> a[i][j];
      }
    }
    ll ans = 0;
    for(int i = 1; i <= n; i++){
      for(int j = 1; j <= m; j++){
        if(a[i][j] && !vis[i][j]){ // a[i][j]不为0, 并且没有被访问, 那么就dfs
          vis[i][j] = 1;
          ans = max(ans, dfs(i, j));
        }
      }
    }
    cout << ans << "\n";
  	return 0;
}

image-20250223212457696

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 105;
ll n, m, f[N];
string a, b;
struct node{
  ll id, x, y;
}opt[N];

int main(){
  	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cin >> n >> a >> b >> m;
    for(int i = 1; i <= m; i++){
      cin >> opt[i].id >> opt[i].x >> opt[i].y;
    }
    for(int i = 1; i <= m; i++){
      f[i] = i;
    }
    do{
      string qwq = a;
      for(int i = 1; i <= m; i++){
        if(opt[f[i]].id == 1){
          qwq[opt[f[i]].x] = ((qwq[opt[f[i]].x] - '0' +  opt[f[i]].y) % 10) + '0';
        } else {
          swap(qwq[opt[f[i]].x], qwq[opt[f[i]].y]);
        }
        if(qwq == b){
          cout << "Yes\n";
          return 0;
        }
      }
    }while(next_permutation(f + 1, f + m + 1));
    cout << "No" << "\n";
  	return 0;
}

69-75没写

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2304334.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

STM32的“Unique device ID“能否修改？

STM32的“Unique device ID“能否修改？

STM32F1系列的"Unique device ID"寄存器的地址为0x1FFFF7E8。 这个寄存器是只读的。 "Unique device ID"寄存器位于“System memory”中。“System memory”地址范围为“0x1FFF F000- 0x1FFF F7FF”。 所有STM32 MCU上都存在系统引导加载程序。顾名思义&a…
阅读更多...
[内网基础] 内网基础知识 —— Windows 工作组

[内网基础] 内网基础知识 —— Windows 工作组

关注这个专栏的其他相关笔记&#xff1a;[内网安全] 内网渗透 - 学习手册-CSDN博客 0x01&#xff1a;Windows 工作组介绍 在一个大型单位里&#xff0c;可能有成百上千台计算机互相连接组成局域网&#xff0c;如果不对这些计算机进行分组&#xff0c;网络的混乱程度是可想而知…
阅读更多...
【新手初学】SQL注入之二次注入、中转注入、伪静态注入

【新手初学】SQL注入之二次注入、中转注入、伪静态注入

二次注入 一、概念 二次注入可以理解为&#xff0c;攻击者构造的恶意数据存储在数据库后&#xff0c;恶意数据被读取并进入到SQL查询语句所导致的注入。 二、原理 防御者可能在用户输入恶意数据时对其中的特殊字符进行了转义处理&#xff0c;但在恶意数据插入到数据库时被处…
阅读更多...
Deepseek存算分离安全部署手册

Deepseek存算分离安全部署手册

Deepseek大火后&#xff0c;很多文章教大家部署Dfiy和ollamadeepseek&#xff0c;但是大部分都忽略了数据安全问题&#xff0c;本文重点介绍Deepseek存算分裂安全架设&#xff0c;GPU云主机只负责计算、CPU本地主机负责数据存储&#xff0c;确保数据不上云&#xff0c;保证私有…
阅读更多...
单页图床HTML源码+本地API接口图床系统修复版源码

单页图床HTML源码+本地API接口图床系统修复版源码

源码介绍 图床系统是一种用于存储和管理图片文件的在线服务。它允许用户上传图片文件&#xff0c;并生成相应的图片链接&#xff0c;从而方便用户在网页、社交媒体或其他平台上分享图片。 PS:源码压缩包分为两个版本&#xff0c;一个是调用360第三方api接口&#xff0c;另外一…
阅读更多...
IDEA使用Maven方式构建SpringBoot项目

IDEA使用Maven方式构建SpringBoot项目

1、环境准备 确保你已经安装了以下工具&#xff1a; Java JDK&#xff08;推荐 JDK 8 或更高版本&#xff09; IntelliJ IDEA&#xff08;推荐使用最新版本&#xff09; 2、创建 Spring Boot 项目 &#xff08;1&#xff09; 打开 IntelliJ IDEA。 &#xff08;2&#xff09…
阅读更多...
【SPIE出版，见刊快速，EI检索稳定，浙江水利水电学院主办】2025年物理学与量子计算国际学术会议（ICPQC 2025）

【SPIE出版，见刊快速，EI检索稳定，浙江水利水电学院主办】2025年物理学与量子计算国际学术会议（ICPQC 2025）

2025年物理学与量子计算国际学术会议&#xff08;ICPQC 2025&#xff09;将于2025年4月18-20日在中国杭州举行。本次会议旨在汇聚全球的研究人员、学者和业界专家&#xff0c;共同探讨物理学与量子计算领域的最新进展与前沿挑战。随着量子技术的快速发展&#xff0c;其在信息处…
阅读更多...
查看cmd下python的安装路径 + Windows 命令行添加环境变量和不重启刷新环境变量

查看cmd下python的安装路径 + Windows 命令行添加环境变量和不重启刷新环境变量

1、查看cmd下python的安装路径 cmd ----》输入“python” 命令 ---》输入 import sys; print(sys.executable) 即可看到当前系统python的安装路径&#xff1a; 注&#xff1a;系统所使用的python实际上就是在系统环境变量下配置的python目录。 2、刷新path命令&#xff1a;在c…
阅读更多...
C/C++跳动的爱心

C/C++跳动的爱心

系列文章 序号直达链接1C/C李峋同款跳动的爱心2C/C跳动的爱心3C/C经典爱心4C/C满屏飘字5C/C大雪纷飞6C/C炫酷烟花7C/C黑客帝国同款字母雨8C/C樱花树9C/C奥特曼10C/C精美圣诞树11C/C俄罗斯方块小游戏12C/C贪吃蛇小游戏13C/C孤单又灿烂的神14C/C闪烁的爱心15C/C哆啦A梦16C/C简单…
阅读更多...
Cannot deserialize instance of java.lang.String out of START_ARRAY token

Cannot deserialize instance of java.lang.String out of START_ARRAY token

这个错误 Cannot deserialize instance of java.lang.String out of START_ARRAY token 表示 Jackson 正在尝试将一个 JSON 数组反序列化成一个 String 类型的字段&#xff0c;但是 JSON 中传递的是一个数组而不是单一的字符串。 具体来说&#xff0c;这段堆栈信息&#xff1a…
阅读更多...
一、初始爬虫

一、初始爬虫

1.爬虫的相关概念 1.1 什么是爬虫 网络爬虫&#xff08;又被称为网页蜘蛛&#xff0c;网络机器人&#xff09;就是模拟浏览器发送网络请求&#xff0c;接收请求响应&#xff0c;一种按照一定的规则&#xff0c;自动地爬取互联网信息的程序。 原则上&#xff0c;只要是浏览器…
阅读更多...
在低功耗MCU上实现人工智能和机器学习

在低功耗MCU上实现人工智能和机器学习

作者&#xff1a;Silicon Labs 人工智能&#xff08;AI&#xff09;和机器学习&#xff08;ML&#xff09;技术不仅正在快速发展&#xff0c;还逐渐被创新性地应用于低功耗的微控制器&#xff08;MCU&#xff09;中&#xff0c;从而实现边缘AI/ML解决方案。这些MCU是许多嵌入式…
阅读更多...
QQ登录测试用例报告

QQ登录测试用例报告

QQ登录测试用例思维导图 一、安全性测试用例 1. 加密传输与存储验证 测试场景&#xff1a;输入账号密码并提交登录请求。预期结果&#xff1a;账号密码通过加密传输&#xff08;如HTTPS&#xff09;与存储&#xff08;如哈希加盐&#xff09;&#xff0c;无明文暴露。 2. 二…
阅读更多...
细说STM32F407单片机2个ADC使用DMA同步采集各自的1个输入通道的方法

细说STM32F407单片机2个ADC使用DMA同步采集各自的1个输入通道的方法

目录 一、示例说明 二、工程配置 1、RCC、DEBUG、CodeGenerator 2、USART6 3、TIM3 &#xff08;1&#xff09;Mode &#xff08;2&#xff09;参数设置 &#xff08;3&#xff09; TRGO &#xff08;4&#xff09;ADC1_IN0 1&#xff09;ADCs_Common_Settings 2&a…
阅读更多...
[python脚本]论文1.（一）CPU/内存数据分析和分组

[python脚本]论文1.（一）CPU/内存数据分析和分组

CPU 收集到的CPU数据&#xff0c;格式如下&#xff1a; 由于这里6个数据为一组来收集latency的数据以及各个分位值的数据&#xff0c;而本质上每一行都是一次完整的测试&#xff0c;因此这里将这个csv文件分为两个文件&#xff0c;第一个是和latency相关的&#xff0c;将6条数…
阅读更多...
一周学会Flask3 Python Web开发-Jinja2模板基本使用

一周学会Flask3 Python Web开发-Jinja2模板基本使用

锋哥原创的Flask3 Python Web开发 Flask3视频教程&#xff1a; 2025版 Flask3 Python web开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili 我们平台开发web系统&#xff0c;必须用到网页&#xff0c;单纯的静态网页无法满足我们的需求。我们可以使用模版引擎技术&am…
阅读更多...
《操作系统 - 清华大学》8 -3：进程管理：进程特点

《操作系统 - 清华大学》8 -3：进程管理：进程特点

深入剖析进程的特点、实现及进程控制块 一、进程的特点 &#xff08;一&#xff09;动态性 进程具有明显的动态性。它可以被动态创建&#xff0c;在执行过程中会发生状态切换&#xff0c;从一个状态转变为另一个状态。当所有任务执行完毕后&#xff0c;进程还会结束运行。整…
阅读更多...
Java 大视界 -- 总结与展望：Java 大数据领域的新征程与无限可能（96）

Java 大视界 -- 总结与展望：Java 大数据领域的新征程与无限可能（96）

&#x1f496;亲爱的朋友们&#xff0c;热烈欢迎来到 青云交的博客&#xff01;能与诸位在此相逢&#xff0c;我倍感荣幸。在这飞速更迭的时代&#xff0c;我们都渴望一方心灵净土&#xff0c;而 我的博客 正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识&#xff0c;也…
阅读更多...
【微服务】深入解析spring aop原理

【微服务】深入解析spring aop原理

目录 一、前言 二、AOP 概述 2.1 什么是AOP 2.2 AOP中的一些概念 2.2.1 aop通知类型 2.3 AOP实现原理 2.3.1 aop中的代理实现 2.4 静态代理与动态代理 2.4.1 静态代理实现 三、 jdk动态代理与cglib代理 3.1 jdk动态代理 3.1.1 jdk动态代理模拟实现 3.2 CGLIB 代理…
阅读更多...
pikachu靶场搭建教程

pikachu靶场搭建教程

需要的东西 phpStudy&#xff1a; 链接&#xff1a; https://pan.baidu.com/s/1fJ-5TNtdDZGUf5FhTm245g 提取码&#xff1a;0278 pikachu-master&#xff1a; Github链接&#xff1a;https://github.com/zhuifengshaonianhanlu/pikachu 链接&#xff1a; https://pan.baidu.c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023