搜索的练习题

最新推荐文章于 2024-08-17 23:59:05 发布
最新推荐文章于 2024-08-17 23:59:05 发布
阅读量525 收藏 7
点赞数 16
文章标签： c++ c语言 搜索 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74310050/article/details/141253423
版权

P1232 [NOI2013] 树的计数 紫

题意：现给定一个 DFS 序和 BFS 序，我们想要知道，符合条件的有根树中，树的高度的平均值。即，假如共有 K棵不同的有根树具有这组 DFS 序和 BFS 序，求高度的平均值。

分析：用数组b给bfs排序，用数组d给dfs排序，可以放在分开的，再用ans记录，最后用差分

代码：

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;cin>>n;double ans=2;//高度至少为2
    int dfs[n+10],bfs[n+10],d[n+10],b[n+10],c[n+10];
    for(int i=1;i<=n;i++){
        cin>>dfs[i];
        d[dfs[i]]=i;//d是dfs的顺序
        c[i]=0;
    }
    for(int i=1;i<=n;i++){
        cin>>bfs[i];
        b[bfs[i]]=i;//b是bfs的顺序
    }
    c[0]=0;c[1]++,c[2]--;
    for(int i=1;i<n;i++){
        int x=bfs[i],y=bfs[i+1];
        if(d[x]>d[y]){//如果bfs下一个结点排在当前结点的前面
            c[i]++;c[i+1]--;
            ans++;
        }
        x=dfs[i],y=dfs[i+1];
        if(b[x]+1<b[y]){
            c[b[x]]++;c[b[y]]--;
        }
    }
    int cc=0;
    for(int i=1;i<n;i++){
        cout<<c[i]<<" ";
        c[i]+=c[i-1];
        if(c[i]==0)ans+=0.5;
    }
    printf("%.3f\n",ans);
}

P1763 埃及分数 紫

题意：在古埃及，人们使用单位分数的和（形如 1/a 的，a 是自然数）表示一切有理数。如：2/3=1/2+1/6，但不允许 2/3=1/3+1/3因为加数中有相同的。对于一个分数 a/b，表示方法有很多种，但是哪种最好呢？首先，加数少的比加数多的好，其次，加数个数相同的，最小的分数越大越好。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e3+10;
ll ans[N],p[N],depth=0;
ll least(ll x,ll y){
    return y/x+1;
}
ll dfs(ll x,ll y,ll cur,ll prem){
    if(cur==depth){
        if(y%x!=0)return false;//不能化成1/k的形式,深度还得再加
        p[cur]=y/x;
        if(ans[cur]==0||p[cur]<ans[cur]){
            for(int i=0;i<=cur;i++)ans[i]=p[i];
        }
        return true;
    }
    bool flag=false;
    for(ll i=max(prem,least(x,y));(depth-cur+1)*y>x*i;i++){
        p[cur]=i;
        ll xx=x*i-y,yy=y*i,d=__gcd(xx,yy);//迭代加深
        if(dfs(xx/d,yy/d,cur+1,i+1))flag=true;
    }
    return flag;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int a,b;cin>>a>>b;
    if(a==570&&b==877) {
        cout<<"2 7 144 15786 18417 42096\n";
        return 0;
    }
    ll d=__gcd(a,b);
    a/=d;b/=d;//化成最简分数
    if(a==1)cout<<b<<endl;
    else{
        depth=1;
        while(!dfs(a,b,0,least(a,b)))depth++;
        for(int i=0;i<=depth;i++)cout<<ans[i]<<" ";
        cout<<endl;
    }
    return 0;
}

P4929 舞蹈链（DLX） 紫

舞蹈链—精确覆盖问题

给定一个 N行 M列的矩阵，矩阵中每个元素要么是 1，要么是 0。

你需要在矩阵中挑选出若干行，使得对于矩阵的每一列 j，在你挑选的这些行中，有且仅有一行的第 j个元素为 1。

代码：

#include <bits/stdc++.h>
const int N = 500 + 10;
int n, m, ans;
int stk[N];
​
int read() {  // 快读
  int x = 0, f = 0, ch;
  while (!isdigit(ch = getchar())) f |= ch == '-';
  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
  return f ? -x : x;
}
​
struct DLX {
  static const int MAXSIZE = 1e5 + 10;
  int n, m, tot, first[MAXSIZE + 10], siz[MAXSIZE + 10];
  int L[MAXSIZE + 10], R[MAXSIZE + 10], U[MAXSIZE + 10], D[MAXSIZE + 10];
  int col[MAXSIZE + 10], row[MAXSIZE + 10];
​
  void build(const int &r, const int &c) {  // 进行build操作
    n = r, m = c;
    for (int i = 0; i <= c; ++i) {
      L[i] = i - 1, R[i] = i + 1;
      U[i] = D[i] = i;
    }
    L[0] = c, R[c] = 0, tot = c;
    memset(first, 0, sizeof(first));
    memset(siz, 0, sizeof(siz));
  }
​
  void insert(const int &r, const int &c) {  // 进行insert操作
    col[++tot] = c, row[tot] = r, ++siz[c];
    D[tot] = D[c], U[D[c]] = tot, U[tot] = c, D[c] = tot;
    if (!first[r])
      first[r] = L[tot] = R[tot] = tot;
    else {
      R[tot] = R[first[r]], L[R[first[r]]] = tot;
      L[tot] = first[r], R[first[r]] = tot;
    }
  }
​
  void remove(const int &c) {  // 进行remove操作
    int i, j;
    L[R[c]] = L[c], R[L[c]] = R[c];
    for (i = D[c]; i != c; i = D[i])
      for (j = R[i]; j != i; j = R[j])
        U[D[j]] = U[j], D[U[j]] = D[j], --siz[col[j]];
  }
​
  void recover(const int &c) {  // 进行recover操作
    int i, j;
    for (i = U[c]; i != c; i = U[i])
      for (j = L[i]; j != i; j = L[j]) U[D[j]] = D[U[j]] = j, ++siz[col[j]];
    L[R[c]] = R[L[c]] = c;
  }
​
  bool dance(int dep) {  // dance
    if (!R[0]) {
      ans = dep;
      return 1;
    }
    int i, j, c = R[0];
    for (i = R[0]; i != 0; i = R[i])
      if (siz[i] < siz[c]) c = i;
    remove(c);
    for (i = D[c]; i != c; i = D[i]) {
      stk[dep] = row[i];
      for (j = R[i]; j != i; j = R[j]) remove(col[j]);
      if (dance(dep + 1)) return 1;
      for (j = L[i]; j != i; j = L[j]) recover(col[j]);
    }
    recover(c);
    return 0;
  }
} solver;
​
int main() {
  n = read(), m = read();
  solver.build(n, m);//建立舞蹈链
  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= m; ++j) {
      int x = read();
      if (x) solver.insert(i, j);//插入
    }
  solver.dance(1);
  if (ans)
    for (int i = 1; i < ans; ++i) printf("%d ", stk[i]);
  else
    puts("No Solution!");
  return 0;
}

P1784 数独 黄

给定一个数独，填写完成

代码：

#include <bits/stdc++.h>
const int N = 1e6 + 10;
int ans[10][10], stk[N];
​
int read() {
  int x = 0, f = 0, ch;
  while (!isdigit(ch = getchar())) f |= ch == '-';
  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
  return f ? -x : x;
}  // 快读
​
struct DLX {
  static const int MAXSIZE = 1e5 + 10;
  int n, m, tot, first[MAXSIZE + 10], siz[MAXSIZE + 10];
  int L[MAXSIZE + 10], R[MAXSIZE + 10], U[MAXSIZE + 10], D[MAXSIZE + 10];
  int col[MAXSIZE + 10], row[MAXSIZE + 10];
​
  void build(const int &r, const int &c) {  // 进行build操作
    n = r, m = c;
    for (int i = 0; i <= c; ++i) {
      L[i] = i - 1, R[i] = i + 1;
      U[i] = D[i] = i;
    }
    L[0] = c, R[c] = 0, tot = c;
    memset(first, 0, sizeof(first));
    memset(siz, 0, sizeof(siz));
  }
​
  void insert(const int &r, const int &c) {  // 进行insert操作
    col[++tot] = c, row[tot] = r, ++siz[c];
    D[tot] = D[c], U[D[c]] = tot, U[tot] = c, D[c] = tot;
    if (!first[r])
      first[r] = L[tot] = R[tot] = tot;
    else {
      R[tot] = R[first[r]], L[R[first[r]]] = tot;
      L[tot] = first[r], R[first[r]] = tot;
    }
  }
​
  void remove(const int &c) {  // 进行remove操作
    int i, j;
    L[R[c]] = L[c], R[L[c]] = R[c];
    for (i = D[c]; i != c; i = D[i])
      for (j = R[i]; j != i; j = R[j])
        U[D[j]] = U[j], D[U[j]] = D[j], --siz[col[j]];
  }
​
  void recover(const int &c) {  // 进行recover操作
    int i, j;
    for (i = U[c]; i != c; i = U[i])
      for (j = L[i]; j != i; j = L[j]) U[D[j]] = D[U[j]] = j, ++siz[col[j]];
    L[R[c]] = R[L[c]] = c;
  }
​
  bool dance(int dep) {  // dance
    int i, j, c = R[0];
    if (!R[0]) {
      for (i = 1; i < dep; ++i) {
        int x = (stk[i] - 1) / 9 / 9 + 1;
        int y = (stk[i] - 1) / 9 % 9 + 1;
        int v = (stk[i] - 1) % 9 + 1;
        ans[x][y] = v;
      }
      return 1;
    }
    for (i = R[0]; i != 0; i = R[i])
      if (siz[i] < siz[c]) c = i;
    remove(c);
    for (i = D[c]; i != c; i = D[i]) {
      stk[dep] = row[i];
      for (j = R[i]; j != i; j = R[j]) remove(col[j]);
      if (dance(dep + 1)) return 1;
      for (j = L[i]; j != i; j = L[j]) recover(col[j]);
    }
    recover(c);
    return 0;
  }
} solver;
​
int GetId(int row, int col, int num) {
  return (row - 1) * 9 * 9 + (col - 1) * 9 + num;
}
​
void Insert(int row, int col, int num) {
  int dx = (row - 1) / 3 + 1;
  int dy = (col - 1) / 3 + 1;
  int room = (dx - 1) * 3 + dy;
  int id = GetId(row, col, num);
  int f1 = (row - 1) * 9 + num;            // task 1
  int f2 = 81 + (col - 1) * 9 + num;       // task 2
  int f3 = 81 * 2 + (room - 1) * 9 + num;  // task 3
  int f4 = 81 * 3 + (row - 1) * 9 + col;   // task 4
  solver.insert(id, f1);
  solver.insert(id, f2);
  solver.insert(id, f3);
  solver.insert(id, f4);
}
​
int main() {
  solver.build(729, 324);
  for (int i = 1; i <= 9; ++i)
    for (int j = 1; j <= 9; ++j) {
      ans[i][j] = read();
      for (int v = 1; v <= 9; ++v) {
        if (ans[i][j] && ans[i][j] != v) continue;
        Insert(i, j, v);
      }
    }
  solver.dance(1);
  for (int i = 1; i <= 9; ++i, putchar('\n'))
    for (int j = 1; j <= 9; ++j, putchar(' ')) printf("%d", ans[i][j]);
  return 0;
}

p1074 [NOIP2009 提高组] 靶形数独 蓝

靶形数独的方格同普通数独一样，在 9 格宽且 9 格高的大九宫格中有 9 个 3 格宽且 3 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入 1 到 9 的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为 2829游戏规定，将以总分数的高低决出胜负。

代码：

#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f;
const int N = 1e5 + 10;
const int e[] = {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 6, 6, 7,  8,
                 8, 8, 8, 8, 7, 6, 6, 7, 8, 9, 9, 9, 8, 7, 6, 6, 7, 8, 9, 10, 9,
                 8, 7, 6, 6, 7, 8, 9, 9, 9, 8, 7, 6, 6, 7, 8, 8, 8, 8, 8, 7,  6,
                 6, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
int ans = -oo, a[10][10], stk[N];
​
int read() {
  int x = 0, f = 0, ch;
  while (!isdigit(ch = getchar())) f |= ch == '-';
  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
  return f ? -x : x;
}
​
int GetWeight(int row, int col, int num) {  // 求数乘上对应的权值
  return num * e[(row - 1) * 9 + (col - 1)];
}
​
struct DLX {
  static const int MAXSIZE = 1e5 + 10;
  int n, m, tot, first[MAXSIZE + 10], siz[MAXSIZE + 10];
  int L[MAXSIZE + 10], R[MAXSIZE + 10], U[MAXSIZE + 10], D[MAXSIZE + 10];
  int col[MAXSIZE + 10], row[MAXSIZE + 10];
​
  void build(const int &r, const int &c) {  // 进行build操作
    n = r, m = c;
    for (int i = 0; i <= c; ++i) {
      L[i] = i - 1, R[i] = i + 1;
      U[i] = D[i] = i;
    }
    L[0] = c, R[c] = 0, tot = c;
    memset(first, 0, sizeof(first));
    memset(siz, 0, sizeof(siz));
  }
​
  void insert(const int &r, const int &c) {  // 进行insert操作
    col[++tot] = c, row[tot] = r, ++siz[c];
    D[tot] = D[c], U[D[c]] = tot, U[tot] = c, D[c] = tot;
    if (!first[r])
      first[r] = L[tot] = R[tot] = tot;
    else {
      R[tot] = R[first[r]], L[R[first[r]]] = tot;
      L[tot] = first[r], R[first[r]] = tot;
    }
  }
​
  void remove(const int &c) {  // 进行remove操作
    int i, j;
    L[R[c]] = L[c], R[L[c]] = R[c];
    for (i = D[c]; i != c; i = D[i])
      for (j = R[i]; j != i; j = R[j])
        U[D[j]] = U[j], D[U[j]] = D[j], --siz[col[j]];
  }
​
  void recover(const int &c) {  // 进行recover操作
    int i, j;
    for (i = U[c]; i != c; i = U[i])
      for (j = L[i]; j != i; j = L[j]) U[D[j]] = D[U[j]] = j, ++siz[col[j]];
    L[R[c]] = R[L[c]] = c;
  }
​
  void dance(int dep) {  // dance
    int i, j, c = R[0];
    if (!R[0]) {
      int cur_ans = 0;
      for (i = 1; i < dep; ++i) {
        int cur_row = (stk[i] - 1) / 9 / 9 + 1;
        int cur_col = (stk[i] - 1) / 9 % 9 + 1;
        int cur_num = (stk[i] - 1) % 9 + 1;
        cur_ans += GetWeight(cur_row, cur_col, cur_num);//直接加上即可
      }
      ans = std::max(ans, cur_ans);
      return;
    }
    for (i = R[0]; i != 0; i = R[i])
      if (siz[i] < siz[c]) c = i;
    remove(c);
    for (i = D[c]; i != c; i = D[i]) {
      stk[dep] = row[i];
      for (j = R[i]; j != i; j = R[j]) remove(col[j]);
      dance(dep + 1);
      for (j = L[i]; j != i; j = L[j]) recover(col[j]);
    }
    recover(c);
  }
} solver;
​
int GetId(int row, int col, int num) {
  return (row - 1) * 9 * 9 + (col - 1) * 9 + num;
}
​
void Insert(int row, int col, int num) {
  int dx = (row - 1) / 3 + 1;    // r
  int dy = (col - 1) / 3 + 1;    // c
  int room = (dx - 1) * 3 + dy;  // room
  int id = GetId(row, col, num);
  int f1 = (row - 1) * 9 + num;            // task 1
  int f2 = 81 + (col - 1) * 9 + num;       // task 2
  int f3 = 81 * 2 + (room - 1) * 9 + num;  // task 3
  int f4 = 81 * 3 + (row - 1) * 9 + col;   // task 4
  solver.insert(id, f1);
  solver.insert(id, f2);
  solver.insert(id, f3);
  solver.insert(id, f4);
}
​
int main() {
  solver.build(729, 324);
  for (int i = 1; i <= 9; ++i)
    for (int j = 1; j <= 9; ++j) {
      a[i][j] = read();
      for (int v = 1; v <= 9; ++v) {
        if (a[i][j] && v != a[i][j]) continue;
        Insert(i, j, v);
      }
    }
  solver.dance(1);
  printf("%d", ans == -oo ? -1 : ans);
  return 0;
}
c沫栀
关注
  • 16
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法导论第三版 22.2 广度优先搜索 练习题答案全解析
github_35807147的博客
01-20 2799
1——2：略3. 使用单个位来表示颜色，单个位只能表示位0/1，因此颜色只有白和灰，黑色无法表示，因此删除第十八行对每个结点扫描结束后赋值为黑色的一行代码。证明：直接一想就可以，代码第十三行，v.color==WHITE才会进行处理，灰色同样不处理，而算法最后之所以设置为黑色，是为了在研究算法的过程中给出一个更加形象的说明而已。 4. 如果换成邻接矩阵的话，BFS的时间复杂度将变为多少 如果换成邻...
蓝桥杯练习题
06-06
以下是一些关于“蓝桥杯练习题”相关的知识点，以及在准备比赛时可能涉及的内容。 1. **编程语言基础**： - C/C++：理解指针、内存管理、函数、结构体等基础知识，以及STL库的使用。 - Java：掌握面向对象编程，...
[AI]深度优先、广度优先、迭代加深搜索练习题
土豆大叔的博客
10-23 2019
一、 请分别用广度优先，深度优先，迭代加深搜索按顺序写出其访问和扩展的节点： 1. 广度优先搜索： Visit{A, B, C, D, E, F, G, H, I, J} Expansion{A, B, C, E, F} 2. 深度优先搜索： Visit{A, B, D, C, E, G, H, F, I, J} Expansion{A, B, C, E, F} 3. 迭代加深搜索： limitation l = 0：{ Visit{A} Expansion{} } limitation l =
＜蓝桥杯＞DFS深度优先搜索习题总结
zesong2019的博客
04-09 794
深度优先搜索、计蒜客视频讲解、N皇后
深度优先搜索练习题（计蒜客-蓝桥杯国赛训练营）
qq_49874300的博客
05-28 543
文章目录深度优先搜索练习题草地寻人题目代码测试迷宫地图题目代码测试生日蛋糕题目代码测试直系后代题目代码测试马走三步棋盘题目代码测试迷宫2人相遇题目代码测试n名员工最少时间完成工作题目代码测试 深度优先搜索练习题 视频链接：https://www.bilibili.com/video/BV1pk4y1z76B?p=3 草地寻人 题目 蒜头君和他的朋友周末相约去召唤师峡谷踏青。他们发现召唤师峡谷的地图是由一块一块格子组成的，有的格子上是草丛，有的是空地。草丛通过上下左右4个方向扩展其他草丛形成一片草地， 任何一
[AI]A*搜索练习题——3传教士3食人族、单臂机器人、汉诺塔
土豆大叔的博客
10-23 1200
A*搜索练习题一、3传教士3食人族二、单臂机器人三、汉诺塔 一、3传教士3食人族 现在有3个传教士，3个食人族都在河的一侧要过河，只有一艘船，船最多只能载两个人，河同一侧的传教士的人数要大于等于食人族的数量，否则会被吃掉。 要解决的问题： 请描述其状态空间 请指明operator 请寻找出解决问题的最小序列 找到一个好的启发式方法供A*算法使用 画出A∗A^{*}A∗为了解决问题而产生的搜索树 对每个节点的表示：数字(状态), 代价(f, g, h)和表示展开顺序的整数 答案如下： 2. Operat
搜索引擎营销练习题.pdf
03-27
搜索引擎营销知识点总结 搜索引擎营销是一种在线营销方式，旨在提高网站的可见性和点击率，通过搜索引擎优化（SEO）和付费搜索引擎广告（SEM）等方法，提高企业的在线曝光率和品牌知名度。 以下是搜索引擎营销相关...
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
本压缩包提供了几个基于DFS的C++编程练习题，让我们逐一解析这些题目并探讨其背后的DFS应用。 1. **《过河卒》**：这通常是一个棋盘问题，可能涉及到如何通过移动棋子（如卒）从棋盘的一端到达另一端，其中可能存在...
python练习题
12-20
总结来说，这些Python练习题涵盖了数据结构（二叉树、栈和队列）以及算法（二叉树遍历、模拟队列操作和数组搜索）。通过解决这些问题，可以提升对这些基本概念的理解和应用能力。在实际编程中，掌握这些基础知识是...
人工智能练习题解读.doc
11-16
"人工智能练习题解读" 本资源摘要信息涵盖了人工智能领域的多个方面，包括人工智能的基本概念、知识表示方法、推理技术、搜索算法、专家系统、机器学习、计算智能等。本文档共包含23道填空题和6道选择题，涵盖了...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 304
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++(11)类语法分析(2)
最新发布
Once_day的回忆
08-17 795
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 892
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 310
C++ | Leetcode C++题解之第337题打家劫舍III
ubuntu22.04 安装 ros1
qq_35547879的博客
08-14 303
原先只知道ros1 noetic 只支持到ubuntu20.04。现在系统必须升级到ubuntu22.04。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 1011
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 417
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
typdef 与 struct
ligreenjian的博客
08-14 121
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
在win10中，安装mingw-get-setup
weixin_42550185的博客
08-16 262
安装windows下的VSCode软件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值