牛客-模拟、枚举、贪心 2022.10.27

Ls_attack Ls_attack 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 200+累计阅读 259平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2025-07-21 09:03:37 发布 259 阅读 AI 写同款· GEO 优化 ›
别再为CAD和GIS数据对不上而头疼了！一份完整的ArcGIS for AutoCAD坐标系定义与数据套合指南 本文详细介绍了如何通过ArcGIS for AutoCAD插件解决CAD与GIS数据坐标系不匹配的问题，实现数据的精准套合。文章从坐标系冲突分析、插件核心功能解析到五步标准化工作流，提供了完整的解决方案，帮助工程师和设计师提升跨平台协作效率。 阅读详情

[NOIP2007]字符串的展开

简单模拟输出即可

#include<bits/stdc++.h>
using namespace std;
int main() {
    int p1, p2, p3;
    cin >> p1 >> p2 >> p3;
    string s;
    cin >> s;
    if(p1 == 1) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }   
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b + 32 - 1; j > a + 32; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    } else if(p1 == 2) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a - 32 + 1; j < b - 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 32 - 1; j > a - 32; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    } else if(p1 == 3) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    }
    return 0;
}

[NOIP2010]机器翻译

简单模拟输出即可

#include <bits/stdc++.h>
using namespace std;
int num[5010];
bool vis[1010];
int main() {
    int m, n;
    cin >> m >> n;
    memset(num, 0, sizeof(num));
    memset(vis, false, sizeof(vis));
    int start = 0, end = 0, res = 0;
    for(int i = 0; i < n; i++) {
        int tar;
        cin >> tar;
        if(!vis[tar]) {
            res += 1;
            vis[tar] = true;
            num[end] = tar;
            end += 1;
            if(end - start > m) {
                vis[num[start]] = false;
                start += 1;
            }
        }
    }
    cout << res << endl;
    return 0;
}

收录于
牛客网_CSP-J入门组

当前文章被收录于：

牛客网_CSP-J入门组
29 篇文章 0 人学习
订阅专栏 查看详情
标签
#算法 #c++ #贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
算法 | A*算法实现最优路径规划 启发式探索是利用问题拥有的启发信息来引导搜索，达到减少探索范围、降低问题复杂度的目的。A*寻路算法是启发式探索的一个典型实践，在寻路搜索的过程中，给每个节点绑定了一个估计值(即启发式)，在对节点的遍历过程中采取估计值优先原则，估计值更优的节点会被优先遍历。... 阅读详情

相关推荐

Halcon阈值算子 -- 局部阈值之dyn_threshold

Halcon阈值算子 – dyn_threshold HALCON有很多阈值算子，接下来将一一介绍。本文先介绍dyn_threshold。 以下介绍主要参考HALCON帮助文档，并加上自己的体会。如有纰漏，欢迎留言指出 理论介绍 dyn_threshold算子的函数签名如下： dyn_threshold(OrigImage, ThresholdImage : RegionDynThresh : Offset, LightDark : ) 输入参数有： OrigImage：待处理图像 ThresholdIm

m0_47015717的博客 5385

牛客入门题单：模拟、枚举与贪心

题单：模拟、枚举与贪心

qq_52138199的博客 980

Android开发Intent详解

本文详解Android开发Intent。

qq_30725967的博客 2414

牛客-模拟、枚举与贪心 2022.11.16

分成三类，稳定值增加，不变，减少。考虑从后往前遍历减少的情况，可以发现最后一个要符号条件，需要当前值大于消耗值，而恢复值是不需要看的，因为消耗完就结束了，所以恢复值不是那么重要。看到异或操作其实第一反应就是将数据改写成二进制形式，之后再观察样例的输出结果，可以发现如果当前二进制位零的个数超过了数据个数的一半，就讲结果这一位二进制写为零，否则写为一（因为需要多组可行解的情况下，数值尽可能小）（零的个数正好为一半时可以为零，也可以为一，但是为了数值尽可能小，所以选择为零）但是直接遍历只能过60%，还需要优化。

Ls_attack的博客 469

SpringCloud 2025王炸更新！GraalVM原生镜像启动速度提升90%实战

在当今云原生和Serverless架构盛行的时代，应用的启动速度已成为衡量技术栈竞争力的关键指标。传统SpringCloud应用由于依赖JVM的动态类加载、反射等机制，启动时间通常超过30秒，在Kubernetes滚动更新和函数计算场景下成为显著性能瓶颈。2025年，SpringCloud迎来里程碑式更新，通过深度集成GraalVM原生镜像技术，实现了启动速度提升90%的惊人突破，让SpringCloud应用正式进入"秒级启动"时代。

小筱在线博客 1099

LeGO-LOAM相对LOAM的改进---地面分离的方法-算法原理+代码讲解

实际上此种地⾯分离算法有⼀些简单，我们可以结合激光雷达安装⾼度等其他先验信息进⾏优化,避免将桌子这些当作地面点。LeGO-LOAM中前端改进中很重要的⼀点就是充分利⽤了地⾯点，那⾸先⾃然是提取对地⾯点的提取。理想情况下， 应该接近0,考虑到⼀⽅⾯激光雷达安装也⽆法做到绝对⽔平，另⼀⽅⾯，地⾯也不是绝。对⽔平，因此，这个⾓度会略微⼤于0,考虑到作者实际在草坪之类的场景下运动，因此这个值被设置成。如上图，相邻的两个扫描线束的同⼀列打在地⾯上如AB点所⽰，他们的垂直⾼度差。，计算垂直⾼度差和⽔平⾼度差的⾓度。..

zysss_的博客 775

牛客小白赛复盘] 牛客小白月赛74

做了5题就下班跑路了哈哈,路上看了FG题面，G不会证明。A 模拟。B 模拟。C 贪心+哈希表。D 贪心排序E 分类讨论，数学F 二分答案+并查集G 单调栈+贪心+树状数组RURQ。

liuliangcan的博客 1393

SAR成像概述

1. 发展概述 雷达是英文Radar（Radio detection and ranging）的音译，原意为“无线电探测与测距”。雷达的发明是无线电发展史上的里程碑，二战时，英国急需通过雷达探测空中金属物体来帮助搜寻德国飞机，这期间，雷达技术飞速发展，发展出了地对空、空对地轰炸、空对空火控、敌我识别等功能。雷达在第二次世界大战中发挥了重大作用，至今仍是军用和许多民用领域的重要传感器。 早期雷达系统通过时间延迟来测距，通过天线指向来测角，通过多普勒频移测速。1951年，Carl Wiley发现，通..

5070

牛客-模拟、枚举与贪心 2022.10.24

直接贪心，直接算出平均的水温,再分类讨论一下即可。假如平均的水温比n个杯子里的都小,那么肯定大水缸是降温的.假如平均的水温比最大的要大,说明大水缸是升温的,不然我的大水缸的温度夹在max和min中间,那么一定是不能调节的。记录每行，每列可以分隔的同桌人数，然后按照行号，列号从小到大的顺序输出前k行，前l列最大的数值即可。如果是正数，直接将其放到到第一个进行删除是最优的，如果是负数，将其在当前位置删除则是最优的。

Ls_attack的博客 214

PCIe-Orders set Blocks之symbol对齐

有序集的使用场合很多，如在链路link阶段，进入polling后，便开始有序集的发送。一个 Ordered Set Block 包含一个同步头，后跟一个有序集。多通道链路的所有 Lane 必须同时传输相同的有序集，而且有序集的第一个符号定义了有序集的类型。但在PCIE中，8GT/s及以上的速率，采用的是128b/130b编码。128-bit是想要传输的payload，实际会传输130-bit，多出来的2-bit就是sync header。Block有两种，通过Sync header区分：10b：表示data

weixin_44700185的博客 813

iOS应用突然无法从App Store获取到内购(IAP)产品列表的解决

问题现象 Apple开发中，在应用中嵌入内购(IAP)功能的小伙伴们可能会发现，吃着火锅唱着歌，突然App就无法获取到产品列表了，而且产品请求操作并不会返回任何错误。 此时检查发现，并没有对App的内购逻辑做任何改动。 那么，这是什么原因导致的呢？ Let’s find out！???? 问题分析 1. 排除其它原因 首先，你先得排除不是你IAP内购逻辑变更或其他原因导致的。 在SKProductsRequestDelegat代理实现的productsRequest方法里下断点: func produc

享受开发，颠倒银河 6141

牛客-模拟、枚举、贪心 2022.11.18

从样例可以发现，首先可以假设所有的奶牛都为最高值，然后对于每一对给出的奶牛的区间，在这区间之间编号的奶牛需要高度减去一（区间为左开右开）。经过一番操作之后，即可得到所有奶牛可能的最高值。（当然可能重复出现的区间，对于重复出现的区间不需要进行重复操作即可）从高位到低位依次枚举，优先考虑从0变为1，就是说尽可能的让这个数小一点。可以考虑最开始每一位为 0/1，然后到最后是否可以变回 1。贪心排序花和道路所需时间即可。

Ls_attack的博客 286

OPC通信从入门到精通_1_OPC基础知识及简单C#程序编写（OPCDA，OPCUA简介；OPC通信数据流框架图；C#程序编写）

ModbusTCP通信是采用直接方式进行通信，用OPC的方式如何去做呢？PLC作为ModbusTCP服务器，用KepServer作为ModbusTCP客户端，同时作为OPC服务器，PC作为OPC客户端新建项目，加载dll库（利用COM技术写的）添加引用，查看到其中包含了众多方法其中OPCGroups继承于IOPCGroups接口。

分享学习成长历程，Winter is coming！ 1万+

牛客 NC21653 巨型迷宫 （枚举 + 贪心）

牛客 NC21653 ： NC21653 巨型迷宫 标签是贪心题， 但是我这个解法并没有多大的体会到贪心的思想。 实际上也就是枚举情况了 图片太长， 题目大意： 有 n 行。每行的代表的数不相同，同一行的数全部一样（行可理解成无限长） 同时给定四个点(sx,sy)(sx, sy)(sx,sy)， (ex,ey)(ex, ey)(ex,ey)，分别代表 起点和终点。 需要算出起点到终点的路径上的数字和最少 注意数据范围 >> int 存储 sum 必然是不行的了… 但是很奇葩，int

lankerens 740

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料，已经经过了本人的筛选和整理，希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助！

牛客-【237题】算法基础精选题单-第一章 模拟、枚举和贪心

牛客-【237题】算法基础精选题单

weixin_52490191的博客 1335

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0， 兼容Win7/Win10/WinXP，解压就可用。

牛客-模拟、枚举与贪心 2022.10.23

先对数组按照从小打到排序，第一次，先让第一个数和第二个数大小相等，即相加的n-1个数只除了第二个数字，第二次，让第一第二个数和第三个数大小相等，即相加的n-1个数只除了第三个数字，之后每次相加同理，相加n-1次，即可得到答案，最后的结果就是最大的数字加上每次两个数字的差值，做一个前缀和相加。简单模拟输出，一眼可知，凳子消除最贵的商品，所以比较凳子和购物车两者的最小值，即可以得到最终的结果。一开始的想法是从前往后相加相同的数字，然后删除，但是会导致之后的数字也相同，导致并不是最少的次数。

Ls_attack的博客 462

蓝牙模块HM-10手册

蓝牙模块HM-10手册，该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

牛客-模拟、枚举与贪心-2022.10.18

输出第一个最小的非零的数字，如果存在零，只输出一个，然后输出零个数的一半，之后继续从小到大输出即可。昨天和今天写的题都比较简单，本来都不想挂，但是还是觉得浅浅记录一下。

Ls_attack的博客 233

牛客-模拟、枚举与贪心 2022.10.20

可以看到，当将第一行的答案放在第一列的时候，剩下的就是求的答题卡规模为(n - 1) * (n - 1) 的所有方案,当第一行的答案放在第二列的时候，剩下的就是求答题卡规模为(n - 2) * (n - 2) 的所有方案（因为此时根据答案横竖相同要求的对称性，确定了一行的同时也就确定了一列，所以此时有两行和两列都不能进行选择），同理将第一行的答案放在第三列也是一样的。所以横答题卡某一行的答案确定之后，对应的竖答题卡的某一列的答案也就确定了，并且交于这两个答案的行和列也已经确定了。在棋盘规模为 的情况下，

Ls_attack的博客 339

牛客-模拟、枚举与贪心 2022.10.22

由于全是小写字符串，使用一个数组，记录每个字母存在的最后一个位置。从最大字母开始遍历到最小字符，这一过程中遍历原字符串，输出其中的当前最大字符，即可得到最终的结果。昨天写的题目较为简单，和今天写的一起做一个总结。构建哈夫曼树，哈夫曼编码。

Ls_attack的博客 216

[牛客周赛复盘] 牛客周赛 Round 1 20230702

牛客第一次，据说排名系统还在测试环境哈哈。A 大模拟。B 分类计数。C 贪心双指针模拟。D 同余dp.

liuliangcan的博客 503

牛客-模拟、枚举与贪心 2022.10.31

当我们希望对原数组的某一个区间[l,r]施加一个增量inc时，差分数组d对应的变化是：d[l]增加inc，d[r+1]减少inc，并且这种操作是可以叠加的。这道题目中，每次增量的数目为1。之后对于每个位置的不同货物的种数，进行一个前缀和，即可得到每个位置的不同货物的数目。当我们需要对原数组的不同区间施加不同的增量，我们只要按规则修改差分数组即可。（新学了差分数组这一数据结构，初次接触，之后好好复习）

Ls_attack的博客 264

牛客-模拟、枚举与贪心 2022.10.25

根据这个关注点可以知道，这里我们不用从后先前逐个进行四舍五入。a.i-1位的值为9，那么将该位置置0，向前进1；如果首位为9加1那么先输出一个1在输出数字。1、若i 的值是四，那么可以继续五入并继续检查i-1是否为4，如果为4那么继续进行五入。2、i的值为小数点，那么将此位置为结束位。同时查看i-1位即小数点前一位的值。先mark，还在求解中，感觉这周可能都调试不出，提高组水平的题。b.i-1的值不为9，该位加1.让他的成绩可以在小数点后的。

Ls_attack的博客 250

模拟、枚举与贪心1（上）

在本文章中将以两道例题介绍什么是算法中的模拟，并附有题解与感悟

qq_63211065的博客 648

牛客-模拟、枚举与贪心 2022.10.19

递推 用res[i]表示iloveyou匹配了前i个的字符的子序列数，当遇到第i个字符，则之前匹配了前i-1个的字符的子序列都可以变为匹配了前i个的字符的子序列，即res[i]=res[i]+res[i-1]递推+高精度（所以python）

Ls_attack的博客 565

牛客-模拟、枚举、贪心 2022.11.15

之后对于每个名字的查询，从名字的第一个字母出现的第一个位置开始，二分查找之后每个字母的位置是否大于当前的位置，如果大于，更新当前位置，直至名字数组结束，说明存在子序列，否则不存在。如果二者最高位相同，则比较下一位，直到出现不同的二进制位置，那么从这一位置开始往后到二进制的最低位，存在全为一的最大值，之前的高位置都相同，异或结果为0。对于药剂的数值，按照从大到小排序，对于奶牛的区间，按照区间最小值从大到小排序，之后遍历奶牛，对于每头奶牛，遍历药剂看是否存在符合条件的药剂，记录结果即可。模拟遍历01串即可。

Ls_attack的博客 392

比赛记录:牛客小白月赛90 A~F

比赛记录:牛客小白月赛90 A~F

yingjiayu12的博客 1057
上一篇： 牛客-模拟、枚举与贪心 2022.10.25
下一篇： 牛客-模拟、枚举与贪心 2022.10.31
点赞 0
评论 0
书签 书签 0
Ls_attack
Ls_attack
博客等级 码龄10年 25粉丝 81原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值