2022牛客多校（六）

最新推荐文章于 2024-08-18 08:31:43 发布
最新推荐文章于 2024-08-18 08:31:43 发布
阅读量543 收藏
点赞数
分类专栏： 2022多校 文章标签： 深度优先 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54646258/article/details/126977401
版权

2022牛客多校（六）

文章目录

一、比赛小结

比赛链接： "蔚来杯"2022牛客暑期多校训练营6

二、题目分析及解法（进阶题）

A、Array

题目链接：A-Array

题意：

给出序列 a i a_i ai​ ，满足： ∑ i = 1 n 1 a i ≤ 1 2 \displaystyle \sum_{i=1}^n \frac1{a_i}\leq \frac12 i=1∑n​ai​1​≤21​ ，要求你构造出 c i , i = 0 , . . . , m − 1 c_i, i=0, ..., m-1 ci​,i=0,...,m−1 。使得， c i c_i ci​ 所对应的无限序列 b i b_i bi​ ，有： 任意连续的 a i a_i ai​ 个元素中，一定存在一个元素为 i i i

题解：

考虑条件倒数和小于等于 1/2 怎么用，每个 a_i 改成小于他最大的 2 的幂，显然倒数和小于等于 1，按照哈夫曼树合并即可

代码：

#include <bits/stdc++.h>
using namespace std;
bool Mbe;
constexpr int N = 1 << 18;
int n, a[N], b[N];
pair<int, int> p[N];
bool Med;
int main() {
  fprintf(stderr, "%.4lf MB\n", (&Mbe - &Med) / 1048576.0);
  ios::sync_with_stdio(0);
  cin >> n;
  for (int i = 1; i <= n; i++)
    cin >> a[i], p[i] = make_pair(1 << 31 - __builtin_clz(a[i]), i);
  sort(p + 1, p + n + 1);
  int f = 0;
  for (int i = 1; i <= n; i++) {
    while (b[f]) f++;
    for (int P = f; P < N; P += p[i].first) b[P] = p[i].second;
  }
  cout << N << "\n";
  for (int i = 0; i < N; i++) cout << max(1, b[i]) << "\n";
  cerr << 1e3 * clock() / CLOCKS_PER_SEC << " ms\n";
  return 0;
}

B、Eezie and Pie

题目链接：B-Eezie and Pie

题意：

给定一棵有根树，每个节点可以为它的 0 ~ 𝑑[𝑖] 级祖先贡献 1 的价值。求最终每个点的价值。

题解：

树剖裸题

代码：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 2e6 + 5;
int n;
int pre[maxn], deep[maxn], num[maxn], son[maxn];  // 第一次dfs的变量
int dfn[maxn], top[maxn], rk[maxn], id;  // 第二次dfs的时候用到的变量
int val[maxn];  //, dfnval[maxn];             // 建树时用dfn序下的val
struct e {
    int to, next;
} edge[maxn << 1];
int head[maxn], cnt;
void init() {
    cnt = 1, id = 0;
    memset(head, -1, sizeof(head));
    for (int i = 0; i < maxn; i++) edge[i].next = -1;
}
struct segtree {
    int l, r;
    int val, add;
} t[maxn << 2];
void addedge(int u, int v) {
    edge[cnt] = e{ v, head[u] };
    head[u] = cnt++;
}
void predfs(int u, int fa, int d) {
    deep[u] = d, num[u] = 1, pre[u] = fa;
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].to;
        if (v == fa) continue;
        predfs(v, u, d + 1);
        num[u] += num[v];                      // 子树的节点数
        if (num[son[u]] < num[v]) son[u] = v;  // 重链子树的根节点
    }
}
void dfs(int u, int t) {
    dfn[u] = ++id, top[u] = t, rk[id] = u;
    if (!son[u]) return;  // 按重链顺序进行dfs
    dfs(son[u], t);
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].to;
        if (v == pre[u] || v == son[u]) continue;
        dfs(v, v);  // 更新链首值top为v
    }
}
void build(int root, int l, int r) {
    t[root].l = l, t[root].r = r;
    if (l == r) {
        t[root].val = 0;
        return;
    }
    int mid = (l + r) >> 1;
    build(root * 2, l, mid);
    build(root * 2 + 1, mid + 1, r);
    t[root].val = (t[root * 2].val + t[root * 2 + 1].val);
}
void spread(int p) {
    int l = t[p].l, r = t[p].r;
    if (t[p].add) {
        t[p * 2].add = (t[p * 2].add + t[p].add);
        t[p * 2 + 1].add = (t[p * 2 + 1].add + t[p].add);
        t[p * 2].val = (t[p * 2].val + (t[p * 2].r - t[p * 2].l + 1) * t[p].add);
        t[p * 2 + 1].val =
            (t[p * 2 + 1].val + (t[p * 2 + 1].r - t[p * 2 + 1].l + 1) * t[p].add);
        t[p].add = 0;
    }
}
void update(int root, int l, int r, int x) {
    if (l <= t[root].l && t[root].r <= r) {
        t[root].add = (t[root].add + x);
        t[root].val = (t[root].val + (t[root].r - t[root].l + 1) * x);
        return;
    }
    spread(root);
    int mid = (t[root].r + t[root].l) >> 1;
    if (l <= mid) update(root * 2, l, r, x);
    if (mid < r) update(root * 2 + 1, l, r, x);
    t[root].val = (t[root * 2].val + t[root * 2 + 1].val);
}
int query(int root, int l, int r) {
    if (l <= t[root].l && t[root].r <= r) return t[root].val;
    spread(root);
    int res = 0;
    int mid = (t[root].l + t[root].r) >> 1;
    if (l <= mid) res = (res + query(root * 2, l, r));
    if (mid < r) res = (res + query(root * 2 + 1, l, r));
    return res;
}
void updatepath(int u, int v, int x) {
    while (top[u] != top[v]) {  // 更新不同链上的节点
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        update(1, dfn[top[u]], dfn[u], x);
        u = pre[top[u]];  // 优先更新链首深度大的节点，更快迭代
    }
    if (deep[u] < deep[v]) swap(u, v);  // 更新相同链上的节点
    update(1, dfn[v], dfn[u], x);
}
int querypath(int u, int v) {
    int res = 0;
    while (top[u] != top[v]) {  // 查询不同链上的节点
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        res = (res + query(1, dfn[top[u]], dfn[u]));
        u = pre[top[u]];  // 优先查询链首深度大的节点，更快迭代
    }
    if (deep[u] < deep[v]) swap(u, v);  // 查询相同链上的节点
    res = (res + query(1, dfn[v], dfn[u]));
    return res;
}
int find(int u, int d) {
    // 查询u的第d个前驱节点
    // d = 0 代表本身
    int res = u;
    int dfn1, dfn2;
    while (d) {
        dfn1 = dfn[res], dfn2 = dfn[top[res]];
        if (dfn1 == dfn2) {
            d--;
            res = pre[res];
        }
        else if (d >= dfn1 - dfn2) {
            d -= (dfn1 - dfn2);
            res = top[res];
        }
        else {
            res = rk[dfn1 - d];
            d = 0;
        }
        if (res == 0) return res = 1;
    }
    return res;
}
signed main() {
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    init();
    cin >> n;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        addedge(u, v), addedge(v, u);
    }
    for (int i = 1; i <= n; i++) cin >> val[i];
    predfs(1, 0, 1);
    dfs(1, 1);
    build(1, 1, n);
    for (int i = 1; i <= n; i++) {
        int fi = find(i, val[i]);
        updatepath(i, fi, 1);
    }
    for (int i = 1; i <= n; i++) cout << querypath(i, i) << " ";
    cout << endl;
    return 0;
}

G、Icon Design

题目链接：G-Icon Design

题意：

画图

题解：

按题意画图即可

代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 5;
int n, cnt;
char res[maxn][maxn];
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  int h = 4 * n + 5, w = 13 * n + 19;
  for (int i = 1; i <= h; i++) {
    for (int j = 1; j <= w; j++) {
      if (i == 1 || j == 1 || i == h || j == w)
        res[i][j] = '*';
      else
        res[i][j] = '.';
    }
  }
  int x = n + 2, y = n + 3, len = 2 * n + 3;
  for (int i = x; i <= x + len - 1; i++) {
    for (int j = y; j <= y + len - 1; j++) {
      if (i == j - 1 || j == y || j == y + len - 1) res[i][j] = '@';
    }
  }
  y += len + n + 1;
  for (int i = x; i <= x + len - 1; i++) {
    for (int j = y; j <= y + len - 1; j++) {
      if (i == x || i == x + n + 1 || j == y) res[i][j] = '@';
    }
  }
  y += len + n + 1;
  for (int i = x; i <= x + len - 1; i++) {
    for (int j = y; j <= y + len - 1; j++) {
      if (i == x + len - 1 || j == y) res[i][j] = '@';
    }
  }
  y += len + n + 1;
  for (int i = x; i <= x + len - 1; i++) {
    for (int j = y; j <= y + len - 1; j++) {
      if (i == x || i == x + n + 1 || i == x + len - 1 ||
          (j == y && i <= x + n + 1) || (j == y + len - 1 && i >= x + n + 1))
        res[i][j] = '@';
    }
  }
  for (int i = 1; i <= h; i++) {
    for (int j = 1; j <= w; j++) cout << res[i][j];
    cout << endl;
  }
  return 0;
}

I、Line

题目链接：I-Line

题意：

给定 n n n 个向量，构造一个点集，使得点集中的任意一个点 ( a i , b i ) (a_i,b_i) (ai​,bi​) ，对于任意向量 ( x j , y j ) (x_j,y_j) (xj​,yj​) ，均有直线 ( a i + t x j , b i + t y j ) (a_i+tx_j,b_i+ty_j) (ai​+txj​,bi​+tyj​) 恰好经过 d d d 个点

1 ≤ n , d ≤ 6 ,   0 ≤ x i , y i ≤ 6 , x i + y i > 0 1\leq n, d \leq 6, \ 0\leq x_i, y_i \leq 6, x_i + y_i >0 1≤n,d≤6, 0≤xi​,yi​≤6,xi​+yi​>0

题解：

数据范围很小，手玩题

•手玩 n=2 发现是平行四边形

•考虑更高维的情况

•发现平移复制 k 次

•本质是高维立方体在平面上的投影

代码：

#include <bits/stdc++.h>
using namespace std;
int n, k, x[11], y[11];
int main() {
  cin >> n >> k;
  set<pair<int, int> > all;
  for (int i = 1; i <= n; i++) {
    cin >> x[i] >> y[i];
    int G = __gcd(x[i], y[i]);
    x[i] /= G;
    y[i] /= G;
    all.insert(make_pair(x[i], y[i]));
  }
  n = 0;
  for (auto p : all) {
    n++;
    x[n] = p.first;
    y[n] = p.second;
  }
  for (int i = 1; i <= n; i++)
    for (int j = i + 1; j <= n; j++) {
      x[j] *= 37;
      y[j] *= 37;
    }
  set<pair<int, int> > P;
  P.insert(make_pair(0, 0));
  for (int i = 1; i <= n; i++) {
    set<pair<int, int> > NP;
    for (auto p : P) {
      for (int j = 0; j < k; j++) {
        NP.insert(make_pair(p.first + j * x[i], p.second + j * y[i]));
      }
    }
    P = NP;
  }
  cout << P.size() << endl;
  for (auto p : P) cout << p.first << " " << p.second << endl;
  return 0;
}

J、Number Game

题目链接：J-Number Game

题意：

给出一个三元数组 ( A , B , C ) (A, B, C) (A,B,C) ，可以执行如下操作：

B → A − B B \rarr A-B B→A−B 和 C → B − C C \rarr B-C C→B−C ，问 C C C 最后可以取到哪些至

题解：

其实这些操作转换为数学问题的话，其就是在做轴对称变换，两个轴对称组合意味着周期函数，进而这题就做完了

若两个操作使用次数相等，则 C 可以成为的集合 S={x∣x=C+k×(A-2×B)}，若次数不等，则 S={x∣x=B-C+k×(A-2×B)}，注意特判 A=2×B 的情况。

代码：

#include <bits/stdc++.h>
#define int long long
using namespace std;
int a, b, c, x;
signed main() {
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int _;
  cin >> _;
  while (_--) {
    cin >> a >> b >> c >> x;
    bool flag = false;
    // int T = (a - 2 * b) / 2;
    int T2 = abs(a - 2 * b);
    if (T2 == 0ll) {
      if (x == c || x == b - c)
        cout << "Yes\n";
      else
        cout << "No\n";
      continue;
    }
    if (2ll * (x - (b - c)) % T2 == 0ll) flag = true;
    if (2ll * (x - c) % T2 == 0ll) flag = true;
    if (flag)
      cout << "Yes\n";
    else
      cout << "No\n";
  }
  return 0;
}

M、Z-Game on grid

题目链接：M-Z-Game on grid

题意：

两个人在 N ∗ M N∗M N∗M 的网格上轮流移动一个棋子。棋子初始位为 (1,1) ，每次只能向某一维的正方向移动一格。网格上有一些特殊点，移到标 ’A’ 的点先手胜，移到标 ‘B’ 的点先手败，没有移到特殊点且不能再移动棋子则为平局。问先手是否有必胜、必平局、必败的策略。

题解：

简单的博弈，配合 dp 即可

代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 600;
int n, m;
char chess[maxn][maxn];
char ans1[maxn][maxn], ans3[maxn][maxn], ans2[maxn][maxn];
int main() {
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int _;
  cin >> _;
  while (_--) {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> chess[i] + 1;
    for (int i = 1; i <= n; i++) {
      strcpy(ans1[i] + 1, chess[i] + 1);
      strcpy(ans2[i] + 1, chess[i] + 1);
      strcpy(ans3[i] + 1, chess[i] + 1);
    }
    // win
    if (ans1[n][m] == '.') ans1[n][m] = 'B';
    for (int j = m - 1; j >= 1; j--) {
      if (ans1[n][j] != '.') continue;
      ans1[n][j] = ans1[n][j + 1];
    }
    for (int i = n - 1; i >= 1; i--) {
      if (ans1[i][m] != '.') continue;
      ans1[i][m] = ans1[i + 1][m];
    }
    for (int i = n - 1; i >= 1; i--)
      for (int j = m - 1; j >= 1; j--) {
        if (ans1[i][j] != '.') continue;
        if ((i + j) % 2 == 0) {  // A 抉择
          if (ans1[i + 1][j] == 'B' && ans1[i][j + 1] == 'B')
            ans1[i][j] = 'B';
          else if (ans1[i + 1][j] == 'A' || ans1[i][j + 1] == 'A')
            ans1[i][j] = 'A';
        } else {  // B 抉择
          if (ans1[i + 1][j] == 'A' && ans1[i][j + 1] == 'A')
            ans1[i][j] = 'A';
          else if (ans1[i + 1][j] == 'B' || ans1[i][j + 1] == 'B')
            ans1[i][j] = 'B';
        }
      }
    // lose
    if (ans2[n][m] == '.') ans2[n][m] = 'A';
    for (int j = m - 1; j >= 1; j--) {
      if (ans2[n][j] != '.') continue;
      ans2[n][j] = ans2[n][j + 1];
    }
    for (int i = n - 1; i >= 1; i--) {
      if (ans2[i][m] != '.') continue;
      ans2[i][m] = ans2[i + 1][m];
    }
    for (int i = n - 1; i >= 1; i--)
      for (int j = m - 1; j >= 1; j--) {
        if (ans2[i][j] != '.') continue;
        if ((i + j) % 2 == 0) {  // A 抉择
          if (ans2[i + 1][j] == 'A' && ans2[i][j + 1] == 'A')
            ans2[i][j] = 'A';
          else if (ans2[i + 1][j] == 'B' || ans2[i][j + 1] == 'B')
            ans2[i][j] = 'B';
        } else {  // B 抉择
          if (ans2[i + 1][j] == 'B' && ans2[i][j + 1] == 'B')
            ans2[i][j] = 'B';
          else if (ans2[i + 1][j] == 'A' || ans2[i][j + 1] == 'A')
            ans2[i][j] = 'A';
        }
      }
    // equal
    for (int j = m - 1; j >= 1; j--) {
      if (ans3[n][j] != '.') continue;
      ans3[n][j] = ans3[n][j + 1];
    }
    for (int i = n - 1; i >= 1; i--) {
      if (ans3[i][m] != '.') continue;
      ans3[i][m] = ans3[i + 1][m];
    }
    for (int i = n - 1; i >= 1; i--)
      for (int j = m - 1; j >= 1; j--) {
        if (ans3[i][j] != '.') continue;
        if ((i + j) % 2 == 0) {  // A 抉择
          if (ans3[i + 1][j] == '.' || ans3[i][j + 1] == '.')
            ans3[i][j] = '.';
          else
            ans3[i][j] = 'A';
        } else {  // B 抉择
          if (ans3[i + 1][j] == '.' && ans3[i][j + 1] == '.')
            ans3[i][j] = '.';
          else
            ans3[i][j] = 'A';
        }
      }

    if (ans1[1][1] == 'A')
      cout << "yes ";
    else
      cout << "no ";
    if (ans3[1][1] == '.')
      cout << "yes ";
    else
      cout << "no ";
    if (ans2[1][1] == 'B')
      cout << "yes" << endl;
    else
      cout << "no" << endl;

    // for (int i = 1; i <= n; i++) cout << ans1[i] + 1 << endl;
    // for (int i = 1; i <= n; i++) cout << ans2[i] + 1 << endl;
    // for (int i = 1; i <= n; i++) cout << ans3[i] + 1 << endl;
  }
  return 0;
}

三、题目分析及解法（进阶题）

不会做X

C、Forest

D、Fourier and Theory for the Universe

E、From AtCoder

F、Hash

H、Jumping Steps

K、SolarPea and Inversion

L、Striking String Problem

Lusfiee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020牛客多校暑期集训营第一场题解.pdf
01-20
### 2020牛客多校暑期集训营第一场题解 #### B-SuffixArray 在构建**B-SuffixArray**时，首先要理解**C_i**的定义：对于字符串**s**中的每一个位置**i**，找到第一个与**s_i**相同且位置大于**i**的位置**j**，...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2022牛客暑期多校训练营6（ABGIJM）
Tan_Yuu的博客
08-08 664
A Array B Eezie and Pie G Icon Design I Line J Number Game M Game on grid
2022牛客暑期多校训练营6 个人题解
SC_Linno的博客
09-22 419
title :2022牛客暑期多校训练营6 题解tags : ACM,练习记录。
2022牛客多校联赛第六场 题解
weixin_51937688的博客
08-06 1017
牛客6
2022牛客多校六 J-Number Game（简单推理）
AC__dream的博客
08-06 211
给定a，b，c，x，我们可以对a和b和c这三个数进行操作，我们可以把b变成a-b，也可以把c变成b-c，操作次数不受限制，问我们能不能把c变成x。
2022牛客多校六 A-Array（构造+哈夫曼）
AC__dream的博客
08-07 119
给定一个长度为n的数组，满足∑ai​^(-1)​≤1/2。求长度为m的序列c0,c1,……,cm-1。其中以c序列作为循环节可以生成一个无限长的b数组，其中bi=c(i%m)。b数组必须要满足任意连续ai个数中要有一个值为i的数。​...
2022牛客多校六 B-Eezie and Pie (dfs)
AC__dream的博客
08-06 131
给定一棵有根树，根为1，每个节点可以为它的 0 ~ 𝑑[𝑖] 级祖先贡献 1 的价值。求最终每个点的价值。
2022牛客多校六 M-Z-Game on grid（动态规划）
AC__dream的博客
08-06 187
两个人在𝑁∗𝑀 N∗M 的网格上轮流移动一个棋子。棋子初始位为(1,1) (1,1) ，每次只能向某一维的正方向移动一格。网格上有一些特殊点，移到标 ’A’ 的点先手胜，移到标 ‘B’ 的点先手败，没有移到特殊点且不能再移动棋子则为平局。问先手是否有必胜、必平局、必败的策略。...
2022牛客多校1
行码棋
08-21 415
题解有六题。题解纯属自己玩，更多详细解释还请看官方题解。
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5146
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
利用Matlab实现【图论】中的图
wxhdvd的博客
08-15 626
本文将讲解如何使用matlab中的函数实现最短路径算法，所提供代码仅供参考，严禁用于数模比赛中使用！
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 325
基于Pygame和PIL的迷宫生成器
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 770
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
最新发布
2302_78914800的博客
08-18 508
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
2024牛客多校05
07-31
抱歉，关于"2024牛客多校05"的信息我没有找到具体的上下文。牛客网（LeetCode-OJ）是一家提供算法题库和技术面试准备服务的网站，他们经常会组织一些技术比赛，包括编程挑战赛。如果你提到的是某一次特定的比赛，通常会包含题目描述、时间安排、竞赛规则等信息。 如果这是即将到来的一场在线编程比赛，它可能会涉及到数据结构、算法、计算机科学基础知识的测试，旨在考察参赛者的编程能力、问题解决能力和对复杂问题的分析能力。对于这类比赛，通常会在比赛前公布相关信息，如比赛开始日期、报名入口、赛题类型等。 如果你想了解更多信息，建议访问牛客网官方平台查看最新的活动公告，或者直接搜索相关的比赛名称获取详细情况。同时，如果你需要帮助理解算法题目的解法，也可以告诉我具体题目，我会尽力为你解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值