本周写题报告

最新推荐文章于 2024-10-01 23:05:47 发布
最新推荐文章于 2024-10-01 23:05:47 发布
阅读量177 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60549559/article/details/125588204
版权

洛谷 P1616 疯狂的采药

思路：

这题是一个标准的完全背包问题，在分析的时候我们就把题目中的背景去掉，体积就是时间，这样更有利于分析此题以及联想其他背包题目

不难得出递推式：dp[j] = max(dp[j - h[i]] + w[i], dp[j]);

#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
typedef long long ll;
int h[N], w[N];
const int M = 1e7 + 10;
ll dp[M];
int main()
{
    int t, m;
    scanf("%d%d", &t, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &h[i], &w[i]);
    }
    for (int i = 1; i <= m; i++)
    {
        for (int j = h[i]; j <= t; j++)
        {
            dp[j] = max(dp[j - h[i]] + w[i], dp[j]);
        }
    }
    printf("%lld\n", dp[t]);
    return 0;
}

洛谷 P1833 樱花

思路：这题是一道混合背包题，判断是完全，01，或是多重，再选择

状态转移方程：dp[j] = max(dp[j - t[i]] + w[i], dp[j]);

#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int t[N], w[N], p[N];
int dp[1008];
int main()
{
    int h1, h2, m1, m2;
    scanf("%d:%d %d:%d", &h1, &m1, &h2, &m2);
    int n;
    scanf("%d", &n);
    int ans = (m2 - m1) + (h2 - h1) * 60;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &t[i], &w[i], &p[i]);
    }
    for (int i = 1; i <= n; i++)
    {
        if (p[i] == 0) //完全背包
        {
            for (int j = t[i]; j <= ans; j++)
            {
                dp[j] = max(dp[j - t[i]] + w[i], dp[j]);
            }
        }
        else //多重背包和01背包
        {
            for (int k = 1; k <= p[i]; k++)
            {
                for (int j = ans; j >= k * t[i]; j--)
                {
                    dp[j] = max(dp[j - t[i]] + w[i], dp[j]);
                }
            }
        }
    }
    printf("%d\n", dp[ans]);
    return 0;
}

洛谷 P1855 榨取kkksc03

思路：这题是一个经典的二维背包题，就是在01背包的基础上加上一层循环即可

状态转移方程：dp[j][k] = max(dp[j][k], dp[j - a[i]][k - b[i]] + 1);

#include <bits/stdc++.h>
using namespace std;
int a[108], b[108];
int dp[300][300];
int main()
{
    int n, m, t;
    scanf("%d%d%d", &n, &m, &t);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a[i], &b[i]);
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= a[i]; j--)
        {
            for (int k = t; k >= b[i]; k--)
            {
                dp[j][k] = max(dp[j][k], dp[j - a[i]][k - b[i]] + 1);
            }
        }
    }
    printf("%d\n", dp[m][t]);
    return 0;
}

洛谷 P1757 通天之分组背包

思路：

正如题目名所说，这是一道分组背包的题

只要在01背包板子上改动一点：求背包的组数（直接在输入时求就行了），然后加层循环就行了

#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int cnt[N];
int dp[N];
int a[N], b[N];
int vis[N][N];
int main()
{
    int m, n;
    scanf("%d%d", &m, &n);
    int ans;
    int maxn = 0;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &a[i], &b[i], &ans);
        ++cnt[ans];
        vis[ans][cnt[ans]] = i;
        maxn = max(maxn, ans);
    }
    for (int i = 1; i <= maxn; i++)
    {
        for (int j = m; j >= 0; j--)
        {
            for (int k = 1; k <= cnt[i]; k++)
            {
                if (j >= a[vis[i][k]])
                {
                    dp[j] = max(dp[j], dp[j - a[vis[i][k]]] + b[vis[i][k]]);
                }
            }
        }
    }
    printf("%d\n", dp[m]);
    return 0;
}

洛谷 P1064 [NOIP2006 提高组] 金明的预算方案

思路：带有附件的背包问题，它属于01背包的变式。这题还好，每一个物品最多只有两个附件，那么我们在对主件进行背包的时候，决策就不再是两个了，而是五个。

分别是：

1.不选，然后去考虑下一个

2.选且只选这个主件

3.选这个主件，并且选附件1

4.选这个主件，并且选附件2

5.选这个主件，并且选附件1和附件2.

我们令dpmainv数组表示某个主件的费用，而dpmainw数组表示某个主件的价值。

同样的，用二维数组dpannexv表示某个附件的费用，dpannexw表示某个附件的价值，第二维只需要0,1,2这三个数，其中第二维是0的场合表示这个主件i的附件数量，它只能等于0或1或2。第二维是1或者是2的值代表以i为主件的附件1或者附件2的相关信息（费用 价值）。

这样，状态转移方程就是四个。

不选附件的①：dp[j] = max(dp[j], dp[j - dpmainv[i]] + dpmainw[i]);

选附件1的②：dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][1]] + dpmainw[i] + dpannexw[i][1]);

选附件2的③：dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][2]] + dpmainw[i] + dpannexw[i][2]);

选附件1和附件2的④：dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][1] - dpannexv[i][2]] + dpmainw[i] + dpannexw[i][1] + dpannexw[i][2]);

#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 10;
int dpmainv[N], dpmainw[N];
int dpannexv[N][3], dpannexw[N][3];
int cnt[N];
int dp[N];
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    int a, b, q;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &a, &b, &q);
        if (q == 0)
        {
            dpmainv[i] = a;
            dpmainw[i] = a * b;
        }
        else
        {
            cnt[q]++;
            dpannexv[q][cnt[q]] = a;
            dpannexw[q][cnt[q]] = a * b;
        }
    }
    for (int i = 1; i <= m; i++)
    {
        for (int j = n; j >= dpmainv[i] && dpmainv[i] > 0; j--)
        {
            dp[j] = max(dp[j], dp[j - dpmainv[i]] + dpmainw[i]);
            if (j >= dpmainv[i] + dpannexv[i][1])
            {
                dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][1]] + dpmainw[i] + dpannexw[i][1]);
            }
            if (j >= dpmainv[i] + dpannexv[i][2])
            {
                dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][2]] + dpmainw[i] + dpannexw[i][2]);
            }
            if (j >= dpmainv[i] + dpannexv[i][1] + dpannexv[i][2])
            {
                dp[j] = max(dp[j], dp[j - dpmainv[i] - dpannexv[i][1] - dpannexv[i][2]] + dpmainw[i] + dpannexw[i][1] + dpannexw[i][2]);
            }
        }
    }
    printf("%d\n", dp[n]);
    return 0;
}

洛谷 P1352 没有上司的舞会

思路：

经典的树形dp

设

dp[ans][0]表示以ans为根的子树,且ans不参加舞会的最大快乐值

dp[ans][1]表示以ans为根的子树，且ans参加了舞会的最大快乐值

则dp[ans][0]+=max(dp[cnt][0], dp[cnt][1]);(cnt是ans的儿子)

dp[ans][1] += dp[cnt][0]; (cnt是ans的儿子)

这题首先找到根几点，然后dfs向下遍历，dp转移就行了

#include <bits/stdc++.h>
using namespace std;
const int N = 6e3 + 10;
int a[N];
int dp[N][2];
int vis[N];
vector<int> v[N];
void dfs(int ans)
{
    dp[ans][1] = a[ans];
    for (int i = 0; i < v[ans].size(); i++)
    {
        int cnt = v[ans][i];
        dfs(cnt);                                  //往下遍历
        dp[ans][0] += max(dp[cnt][0], dp[cnt][1]); //他的下属参加还是不参加
        dp[ans][1] += dp[cnt][0];                  //此时下属不能参加
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    int p, q;
    for (int i = 1; i <= n - 1; i++)
    {
        scanf("%d%d", &p, &q);
        v[q].push_back(p);
        vis[p] = 1; //把职员标记上
    }
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        if (vis[i] == 0) //找最高职位，也就是树的根
        {
            ans = i;
            break;
        }
    }
    dfs(ans);
    printf("%d\n", max(dp[ans][0], dp[ans][1]));
    return 0;
}

能量项链

思路：一道典型的区间dp题，对于一般的n颗珠子，我们求它的最大能量值。我们可以把它的上一步的时候的组成分为dp[1]max,dp[n-1]max; dp[2]max,dp[n-2]max; dp[3]max,dp[n-3]max ……dp[n]max,dp[1]max;它右这n种情况的合并而成我们只要求出这n种情况的最大值即可求出n颗珠子时的能量的最大值。但是别忘了，题目是没有说起点在哪里的，也没有说方向是向哪里的，因此我们还得以每一个点为起点做一次分组算一遍。

状态转移方程：dp[l][r] = max(dp[l][r], dp[l][k] + dp[k][r] + a[l] * a[k] * a[r]);

#include <iostream>
#include <cstdio>
#include <cstring>
#include <math.h>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 2e2 + 10;
int a[N];
int dp[N][N];
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        a[i + n] = a[i];
    }
    // 2 3 5 10 2 3 5 10
    //还是环形石子问题
    for (int len = 3; len <= n + 1; len++) //最少要三个值才能聚合两个珠子，但最后一个值最后还会用到
    {
        for (int l = 1; l + len - 1 <= 2 * n; l++)
        {
            int r = l + len - 1;
            for (int k = l + 1; k < r; k++) //由于每颗珠子分首尾，所以k最小也得是l+1
            {
                dp[l][r] = max(dp[l][r], dp[l][k] + dp[k][r] + a[l] * a[k] * a[r]); //由于k位置这个元素会重复用到，所以不用加一！！！
            }
        }
    }
    int maxn = 0;
    for (int i = 1; i <= n; i++)
    {
        maxn = max(maxn, dp[i][n + i]);
        // printf("%d\n", dp[i][i + n]);
    }
    printf("%d\n", maxn);
    return 0;
}

HDU - 2639 

思路：01背包+第k最优解

#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int dp[N][N];
int a[108], b[108];
int c[108], d[108];
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        memset(dp, 0, sizeof(dp));
        memset(c, 0, sizeof(c));
        memset(d, 0, sizeof(d));
        int n, v, p;
        scanf("%d%d%d", &n, &v, &p);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &b[i]);
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = v; j >= b[i]; j--)
            {
                for (int k = 1; k <= p; k++)
                {
                    c[k] = dp[j][k]; //体积为j时的第k大价值
                    d[k] = dp[j - b[i]][k] + a[i];
                }
                int q = 1, l = 1, r = 1;
                while (q <= p && (l <= p || r <= p))
                {
                    if (c[l] >= d[r]) //比较两个数的大小，谁大就用谁赋值
                    {
                        dp[j][q] = c[l++];
                    }
                    else
                    {
                        dp[j][q] = d[r++];
                    }
                    if (dp[j][q] != dp[j][q - 1]) //这里要去一下重
                    {
                        q++;
                    }
                }
            }
        }
        printf("%d\n", dp[v][p]);
    }
    return 0;
}

HDU - 5323

思路：根据线段树 父亲节点的区间 和 孩子节点的 区间的关系，可得知 若孩子节点是[l,r]，则父亲节点有4种情况即[l - 1 - (r - l), r]，[l, r + 1 + r - l]，[l - 1 - (r - l) - 1, r]，[l, r + 1 + r - l - 1]

然后暴力搜索即可，注意当r >= ans和l - 1 - (r - l) < 0时就要return；

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans;
void dfs(ll l, ll r) //建立左区间和右区间递归搜索
{
    if (l == 0)
    {
        if (r != 0)
        {
            ans = min(ans, r);
        }
    }
    if (r >= ans) //右边界
    {
        return;
    }
    if (l - 1 - (r - l) < 0) //左边界
    {
        return;
    }
    dfs(l - 1 - (r - l), r); //奇数区间
    dfs(l, r + 1 + r - l);
    dfs(l - 1 - (r - l) - 1, r); //偶数区间
    dfs(l, r + 1 + r - l - 1);
}
int main()
{
    ll l, r;
    while (scanf("%lld%lld", &l, &r) != EOF)
    {
        ans = 0x3f3f3f3f;
        dfs(l, r);
        if (l == 0 && r == 0)
        {
            printf("0\n");
        }
        else
        {
            if (ans == 0x3f3f3f3f)
            {
                printf("-1\n");
            }
            else
            {
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}

xwsfw
关注
C语言中猜数大小的实验报告,猜数字游戏实验报告
weixin_33172127的博客
05-17 1579
《猜数字游戏实验报告》由会员分享，可在线阅读，更多相关《猜数字游戏实验报告(17页珍藏版)》请在人人文库网上搜索。1、C语言课程设计报告题 目：猜数字游戏班 级：通信工程组 名：第三组指导教师：李梅日 期：2011/12/1;.目 录C语言课程设计报告1目 录21 需求分析31.1问题分析31.2采用技术31.3设计目标32 总体设计42.1程序设计思路简介42.2系统模块设计43 详细设计53....
SQL练习题（共82题）
weixin_43176270的博客
08-05 2975
id 表示用户 id；非禁止用户即 Banned 为 No 的用户，禁止用户即 Banned 为 Yes 的用户。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JX7NHMq3-1691249682537)(imgs/image-20211128192755637.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p7aupgxU-1691249682537)(imgs/image-20211128192845380.png)]
本周学习报告
雨潇的博客
04-07 683
就在同学们都忙于那个省赛的时候，我，正在跟朋友在青岛哈皮。 因为这个比赛，我玩的也有点心不在焉，心里一直在想这件事情，一直在思考不报名到底是对是错，我是不是丢掉了一次机会呢？ 可是我又深知此刻的我太过菜鸡，去参加比赛最大的可能就是浪费了钱还得不到什么名次，最大的好处可能就是熟悉了比赛流程，体验了一把参加比赛的感觉。而且最为重要的是，我已经很难分辨到底是陪我的小票票重要还是参加这种不可能得奖的比...
007本周总结报告
weixin_30245867的博客
08-25 117
这周感觉自己什么也没做，好没有成就感。这周大部分的时间都用来学车了，自己也是东跑西跑的，然而车也没有学好，java也学习的少的可伶。自己总是感觉自己学车都要忙死了。哪有什么时间学习java啊，能学好车就不错了。其实在这一周即将过去后自己想了想，其实自己可以做到学车和学Java甚至做其他的事情可以兼顾并且把他们做好的，只是自己不愿面对现实，不愿承担自己该承担的压力。总是想逃避，总是被自己身...
数组三题的实验报告
weixin_38171245的博客
12-30 206
题目一 7-3将数组中的数逆序存放 （1）PTA提交列表 （2）设计思路 本题要求输入一串数字后使其逆序数输出，需要用到中间数使其对换。而运用数组会使代码更简洁易懂。 流程图如下： （3）代码截图 （4）调试过程中遇到的问题以及pta提交列表的错误说明 原来不是要做这题，但是不小心画了流程图。不想浪费。主要说我个人在编写过程中遇到的问题。 在第二层for循...
本周学习报告 第二周 12.7
qq_45944336的博客
12-07 198
本周主要重点学习了 1.c语言的一些提高题 矩阵的转置 绘制棱形 猜数 2.HTTP的部分内容 包括故障代码和报文等等 3百度比赛学到的部分碎片式内容 1c语言 矩阵的转置 输入和输出只要依靠叠加for就可以完成 关键的转置步骤其实也很简单 a【i】【j】=b【j】【i】即可 再通过for来批量转化。 这里主要运用了函数来声明，可以把主要结构写得较为简单，有利于阅读理解。 另外void也值得熟...
本周学习报告 第三周 12.14
qq_45944336的博客
12-14 332
本周主要学习了 1洛谷刷题 2c语言函数部分学习 3虚拟机制作 虚拟机制作 主要是运用镜像和软件 在电脑上模拟一台设备 因为本人之前有过类似经验，主要在自己使用PE盘备份，还原数据迁移等等，以及重装系统的硬件驱动方面比较擅长。所以装虚拟机问题不大。 准备 ISO或gho镜像文件 虚拟机系统（这次使用的是vm）即可 虚拟机软件会进行一些调试和模拟，之后和给电脑装系统一样，把镜像装到软件模拟的硬盘...
职场神器：只需三分钟，让ChatGPT帮我写周报
软件架构农
04-10 3222
说到周报，尽管周报的目的是为了提高团队合作和项目进展的透明度，但很多职场员工都觉得是件麻烦事。 本来忙碌了一周到周五的下午，工作完成了，可以下班去吃饭，去嗨皮了，结果临走前还得写一份“每周工作报告”，描述自己在这一周的工作内容，实在是一万个不想写。 这个时候，偷懒工具ChatGPT就可以派上用场了。
java实验报告10_第二次Java实验报告
weixin_36035466的博客
02-26 294
Java实验报告班级计科二班 学号20188437 姓名何磊完成时间2019/9/12评分等级实验二 Java简单类与对象实验目的掌握类的定义，熟悉属性、构造函数、方法的作用，掌握用类作为类型声明变量和方法返回值；理解类和对象的区别，掌握构造函数的使用，熟悉通过对象名引用实例的方法和属性；理解static修饰付对类、类成员变量及类方法的影响。实验内容写一个名为Rectangle的类表示矩形。其属性...
转正报告不会写？资深软件测试工程师手把手教学，赶紧收藏
qq_60168783的博客
01-18 171
转正报告不知道怎么写？为大家写了个模板，可能写的不好，给各位参考参考\ 进入公司的三个月时间里，在领导和同事们的悉心关怀和指导协助下，使我在较短的时间内适应了公司的工作环境，也熟悉了公司的支付业务流程，目前能应对测试部门的工作任务; 一、性能测试方面： 生产环境微信公众号下单接口性能测试，根据私钥密钥规则，编写性能测试脚本，并发数100、200、300、500、800、1000压测；tps从30+笔/s提升到393笔/s，配合研发、运维优化调整从日志等级调整为error；增加数据库连接数；增加服务
实训报告万能模板计算机专业,计算机实训报告模板
weixin_29819789的博客
06-16 1812
计算机实训报告模板计算机专业的同学们，大家一定要参加过实训吧，那么大家知道计算机实训报告怎么写吗？以下是小编为大家整理好的计算机实训报告模板，一起看看吧！篇【1】：计算机实训报告模板一、实训目的1、 贯彻坚强实践环节和理论联系实际的教学原则，增加学生对专业感性认识的深广度，运用所学知识和技能为后续课程奠定较好的基础，计算机实训报告。2、通过实习，开阔学生眼界和知识面，获得计算机硬件安装和系统维护的...
C Primer Plus (第六版）第七章 编程 练习题 部分 解答
chenwei8711的博客
12-19 1935
C Primer Plus (第六版）第七章 编程练习题 部分答题代码 最近在学习C Primer Plus ,以下是其中第七章编程题，我写的代码。已测试通过。（IDE ：Codeblocks），不妥之处请指正 1.读取输入读到#字符停止，然后报告读取的空格数、换行数和所有其他字符 #include &amp;lt;stdio.h&amp;gt; int main(void) { char ch; ...
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1277
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 366
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 990
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 379
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1277
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
Python编程：经典练习题集锦
"这是一份包含15个Python编程练习题的集合，旨在帮助学习者提升Python编程技能。这些题目涵盖了基础的算术操作、逻辑判断、字符串处理、循环、函数应用等多个方面，适合初学者至进阶者进行自我检测和提高。" 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值