第一讲 基础算法

已于 2024-09-19 22:16:41 修改
阅读量219 收藏
点赞数 2
分类专栏： 数据结构和算法 文章标签： 算法 数据结构 排序算法
于 2024-08-10 21:51:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanxuewei666/article/details/141095916
版权

学习方法

  • 课上：学习算法思想，明白这个算法为什么是对的，听课的时候跟着敲一遍代码，学完一个知识点之后，再独立敲一遍
  • 课后：跟着博客进行复习
    读入规模较大的时候，使用scanf
    ——积跬步，至千里；积小流，成江海。

快速排序

算法思想：基于分治

  1. 确定分界点
  2. 调整范围，使得分界点的左边元素都比其小，分界点的右边元素都比其大
  3. 递归处理左右两端

分治算法

题目链接：785. 快速排序

#include<iostream>
using namespace std;
const int N = 100005;
int q[N];
void quick_sort(int q[], int l, int r){
    if(l >= r){
        return;
    }
    int i = l - 1, j = r + 1, x = q[(l + r) >> 1];
    while(i < j){
        //从左往右，找到大于x的数字
        do{
            i ++;
        }while(q[i] < x);
        
        //从右往左，找到小于x的数字
        do{
            j --;
        }while(q[j] > x);
        
        //将大于x的元素和小于x的元素进行交换
        if(i < j){
            int t = q[i];
            q[i] = q[j];
            q[j] = t;
        }
    }
    //x左边的元素都小于等于它，x右边的元素都大于等于它
    //递归处理x左右两边
    quick_sort(q, l, j);
    quick_sort(q, j + 1, r);
}
int main(){
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i ++){
        scanf("%d", &q[i]);
    }
    quick_sort(q, 0, n - 1);
    for(int i = 0; i < n; i ++){
        printf("%d ", q[i]);
    }
    return 0;
}

题目链接：786. 第k个数

利用快速排序的思想解题，每次划分，只要递归包含第k个数的那部分，时间复杂度为O (n)

归并排序

在这里插入图片描述

787. 归并排序 - Acwing题库

归并排序也是基于分治法：

  • 分解：将数列分成左右两半
  • 解决：递归排序左边和右边，分解到不能再分解
  • 合并：把每次分开的两部分合并到一起
#include<iostream>
using namespace std;
const int N = 100005;
int q[N], tmp[N];//tmp为辅助数组
void merge_sort(int q[], int l, int r){
    if(l >= r){//如果区间个数为1个或者没有的话，直接返回
        return;
    }
    
    int mid = (l + r) >> 1; //获取分界点
    
    //递归排左右两边
    merge_sort(q, l, mid); merge_sort(q, mid + 1, r);
    
    int k = 0, i = l, j = mid + 1;
    while(i <= mid && j <= r){
        if(q[i] <= q[j]){
            tmp[k++] = q[i++];
        }else{
            tmp[k++] = q[j++];
        }
    }
    //有可能左半边序列没有比较完，或者右半边没有比较完
    while(i <= mid){
        tmp[k++] = q[i++];
    }
    while(j <= r){
        tmp[k++] = q[j++];
    }
    
    //将辅助数组复制回原数组
    for(int i = l, j = 0; i <= r; i++, j ++){
        q[i] = tmp[j];
    }
    
}
int main(){
    int n;
    scanf("%d", &n);
    
    for(int i = 0; i < n; i ++){
        scanf("%d", &q[i]);
    }
    
    merge_sort(q, 0, n - 1);
    
    //输出
    for(int i = 0; i < n; i ++){
        printf("%d ", q[i]);
    }
    return 0;
}

题目链接：788. 逆序对的数量 - Acwing题库

二分

整数二分：

二分的本质其实是“边界”，例如，左边红色区域可以满足某个条件，右边绿色区域不可以满足某个条件，注意两个区间是没有交集的，因为这是整数二分，那么二分就是找到这个边界，那么既可以是红色区域的最右边那个位置，也可以是绿色区域最左边那个位置，这就对应着接下来将的两个模版。
二分一定有解，无界是题目中涉及的情况，可以特判。
在这里插入图片描述

题目链接：789. 数的范围

#include<iostream>
using namespace std;
const int N = 100005;
int q[N];
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    
    for(int i = 0; i < n; i ++){
        cin >> q[i];
    }
    
    while(m--){
        int x;
        scanf("%d", &x);
        //先递归满足条件的最左边
        int l = 0, r = n - 1;
        while(l < r){
            int mid = (l + r) >> 1;
            if(q[mid] >= x){// 边界的位置在左半边
                r = mid;// 这种更新条件， mid不需要补1
            }else{
                l = mid + 1;
            }
        }
        if(q[l] != x){
            cout << "-1 -1"<< endl;
        }else{
            cout << l << ' ';
            //递对满足条件的右边界
            int l = 0, r = n - 1;
            while(l < r){
                int mid = 1 + (l + r) >> 1;
                if(q[mid] <= x){
                    l = mid;
                }else{
                    r = mid - 1;
                }
            }
            cout << l <<' ' << endl;
        }
    }
    return 0;
}

实数二分

题目链接：790. 数的三次方根

#include<iostream>
using namespace std;
int main(){
    double n;
    cin >> n;
    double l = -100, r = 100;// 三次方根的范围
    while(r - l > 1e-8){// 当区间长度小于一个很小的数字的时候就得到结果
        double mid =(l + r) / 2;
        if(mid * mid * mid >= n){
            r = mid;
        }else{
            l = mid;
        }
    }
    printf("%.6lf\n", l);
    return 0;
}

高精度

高精度情况分类

  • A+B：一个大整数加上一个大整数 1 0 6 10^6 106
  • A-B：一个大整数-一个大整数 1 0 6 10^6 106
  • A*b：一个大整数 * 一个小整数

高精度加法

题目链接：791. 高精度加法

#include<iostream>
#include<vector>
using namespace std;
//C = A + B
vector<int> add(vector<int> &A, vector<int> &B){
    vector<int> C;
    int t = 0;// 用来存储进位
    for(int i = 0; i < A.size() || i < B.size(); i ++){
        if(i < A.size()) t += A[i];
        if(i < B.size()) t +=B[i];
        C.push_back(t % 10);
        t /= 10;
    }
    if(t){
        C.push_back(1);
    }
    return C;
}
int main(){
    string a, b;
    vector<int>A, B;
    cin >> a >> b;// a = "123456"
    for(int i = a.size() - 1; i >= 0; i--){ //A = [6, 5, 4, 3, 2, 1]
        A.push_back(a[i] - '0');
    }
    for(int i = b.size() - 1; i >= 0; i--){
        B.push_back(b[i] - '0');
    }
    
    auto c = add(A, B);
    for(int i = c.size() - 1; i >= 0; i --){
        printf("%d", c[i]);
    }
    return 0;
}

高精度减法

题目链接：792. 高精度减法

#include<iostream>
#include<vector>
using namespace std;
//判断是否有 A>=B
bool cmp(vector<int> &A, vector<int> &B){
    if(A.size() != B.size()){
        return A.size() > B.size();
    }
    for(int  i = A.size() - 1; i >= 0; i --){//从高位开始比较
        if(A[i] != B[i]){
            return A[i] > B[i];
        }
    }
    return true;
}

//C = A - B
vector<int> sub(vector<int> &A, vector<int> &B){
    vector<int> C;
    for(int i = 0, t = 0; i < A.size(); i++){//已经判断过A和B的大小，所以A.size() >= B.size()
        t = A[i] - t;//减去借位
        if(i < B.size()){
            t -= B[i];
        }
        C.push_back((t + 10) % 10);
        if(t < 0){
            t = 1;
        }else{
            t = 0;
        }
    }
    //去掉前导0
    while(C.size() > 1 && C.back() == 0){
        C.pop_back();
    }
    return C;
}
int main(){
    string a, b;
    cin >> a >> b;
    vector<int> A, B;
    for(int i = a.size() - 1; i >= 0; i --){
        A.push_back(a[i] - '0');
    }
    for(int i = b.size() - 1; i >= 0; i --){
        B.push_back(b[i] - '0');
    }
    //判断两个大整数，谁大
    if(cmp(A, B)){
        auto  C = sub(A, B);
        for(int i = C.size() - 1; i >= 0; i--){
            printf("%d", C[i]);
        }
    }else{
        auto C = sub(B, A);
        printf("-");//-(B - A)
        for(int i = C.size() - 1; i >= 0; i--){
            printf("%d", C[i]);
        }
    }
    return 0;
}

高精度乘法

题目链接：793. 高精度乘法

#include<iostream>
#include<vector>
using namespace std;
vector<int> mul(vector<int> &A, int b){
    vector<int> C;
    int t = 0;// 第零位进位为0
    for(int i = 0; i < A.size() || t; i ++){
        if(i < A.size()){
            t += A[i] * b;
        }
        C.push_back(t % 10);
        t /= 10;
    }
    return C;
}
int main(){
    string a;
    int b;
    cin >> a >> b;
    vector<int>A;
    for(int i = a.size() - 1; i >= 0; i --){
        A.push_back(a[i] - '0');
    }
    if(b == 0){
        printf("0");
    }else{
        auto C = mul(A, b);
    
        for(int i = C.size() - 1; i >= 0; i --){
            printf("%d", C[i]);
        }
    }
    
    return 0;
}

高精度除法

题目链接：794. 高精度除法

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
// A / b, 商是c，余数是r
vector<int> div(vector<int> A, int b, int &r){//r 是余数,用引用传递
    vector<int> C;
    r = 0;
    //从最高位开始计算
    for(int i = A.size() - 1; i >= 0; i--){
        r = r * 10 + A[i];//补位
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(),C.end());
    while(C.size() > 1 && C.back() == 0){
        C.pop_back();
    }
    return C;
}
int main(){
    string a;
    int b;
    cin >> a >> b;
    vector<int> A;
    for(int i = a.size() - 1; i >= 0; i--){
        A.push_back(a[i] - '0');
    }
    int r;
    auto C = div(A, b, r);
    for(int i = C.size() - 1; i >= 0; i--){
        printf("%d", C[i]);
    }
    cout << endl;
    cout << r << endl;
    return 0;
}

1h： 18min

前缀和和差分

一维前缀和

数组元素（这里规定下标从1开始，a[0] = 0，下文解释）： a 1 + a 2 + a 3 . . . + a n a_1 + a_2 + a_3 ...+ a_n a1​+a2​+a3​...+an​

前缀和公式： S i S_i Si​ = a 1 + a 2 + a 3 . . . + a i ​ a_1 + a_2 + a_3 ...+ a_i​ a1​+a2​+a3​...+ai​​

如何求 S i S_i Si​

s[0] = 0;//下标从1开始，a[0] = 0;
for(int i = 1; i <= n; i++){
    s[i] = s[i - 1] + a[i];
}

前缀和的作用

例如：计算 a l + a l + 1 + a l + 2 . . . + a r a_l+ a_ {l + 1}+ a_{l + 2} ...+ a_{r} al​+al+1​+al+2​...+ar​，就是求集合中[l, r]元素的和

使用前缀和的解决方式：s[r] - s[l -1] =（ a 1 + a 2 + a 3 . . . + a r a_1 + a_2 + a_3 ...+ a_r a1​+a2​+a3​...+ar​）- （ a 1 + a 2 + a 3 . . . + a l a_1 + a_2 + a_3 ...+ a_l a1​+a2​+a3​...+al​）= a l + a l + 1 + a l + 2 . . . + a r a_l+ a_ {l + 1}+ a_{l + 2} ...+ a_{r} al​+al+1​+al+2​...+ar​

这样做的优点在于提高了速度，如果从l遍历到n进行计算，时间复杂度为O(n),而使用前缀和的方式，时间复杂度为O（1）

那么解释一下为什么元素下标从1开始呢，是为了处理边界 。由a[0] = 0,可以得出s[0] = 0。如果想要计算[1, 10]，则计算s[10] - s[0]，这里s[0] = 0，所以在边界情况就不需要特判了。

题目链接：前缀和

#include<iostream>
using namespace std;
const int N = 100005;
int a[N];
int s[N];
int main(){
    int n, m, l, r;
    cin >> n >> m;
    for(int i = 1; i <= n; i++){
        cin >> a[i];//读入数组元素
        s[i] =a[i] + s[i - 1];//更新前缀和数组
    }
    for(int i = 1; i <= m; i++){
        cin >> l >> r;
        cout << s[r] - s[l - 1] <<endl;//求【l,r】元素的和
    }
    return 0;
}

二维前缀和

二维前缀和是用来在一个矩阵中求子矩阵的和。例如我们用s[3][3]表示下面这个绿色区域的元素总和。

image.png

(x1, y1) (x2, y2)这一子矩阵中所有数的和如何计算

二维前缀和公式推导.jpg

s[i][j]如何计算

用二维数组a存储矩阵中每一个元素，可以用以下方式计算s[i][j]

QQ图片20240728113101.jpg

题目链接：子矩阵的和

#include<iostream>
using namespace std;
int a[1005][1005];
int s[1005][1005];
int main(){
    int n, m, q;
    int x1, y1, x2, y2;
    cin >> n >> m >> q;
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            cin >> a[i][j];
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
        }
    }
    while(q --){
        cin >> x1 >> y1 >> x2 >> y2;
        printf("%d\n",s[x2][y2] - s[x1 -1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
    }
    return 0;
}

一维差分

《算法竞赛》P65-67

题目链接：797. 差分 - Acwing题库

#include<iostream>
using namespace std;
const int N = 100010;
int a[N], b[N];
void insert(int l, int r, int c){
    b[l] += c;
    b[r + 1] -= c;
}
int main(){
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++){
        cin >> a[i];
    }
    for(int i = 1; i <=n; i ++){
        insert(i, i, a[i]);
    }
    while(m --){
        int l, r, c;
        cin >> l >> r >> c;
        insert(l, r, c);
    }
    //对差分数组求一遍前缀和
    for(int i = 1; i <= n; i ++){
        b[i] += b[i - 1];
        cout << b[i] << " ";
    }
    
    
    return 0;
}

二维差分

a[i][j]是b[i][j]（没有被表示出来）的前缀和
在这里插入图片描述

现在的目的就是在中间的子矩阵中加上一个c，如何做呢，可以按照下述四步。
在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
int a[N][N], b[N][N];

void insert(int x1, int y1, int x2, int y2, int c)
{
    b[x1][y1] += c;
    b[x2 + 1][y1] -= c;
    b[x1][y2 + 1] -= c;
    b[x2 + 1][y2 + 1] += c;
}

int main()
{
    scanf("%d%d%d", &n, &m, &q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &a[i][j]);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            insert(i, j, i, j, a[i][j]);

    while (q -- )
    {
        int x1, y1, x2, y2, c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        insert(x1, y1, x2, y2, c);
    }

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];


    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= m; j ++ ) printf("%d ", b[i][j]);
        puts("");
    }

    return 0;
}

区间合并

803. 区间合并 - Acwing题库
解题思路：
输入的所有区间，看其中能否合并，能合并的则合并，合并之后算作一个区间，最后看总共包含几个区间。就是要思考如何快速的进行区间合并。
合并：

  • 排序： 区间按照起点进行排序，确保可以按顺序处理。
  • 合并逻辑：
    • st 表示当前区间的起点，ed 表示当前区间的终点。
    • 如果当前区间的起点大于当前正在合并的区间的终点 (ed < seg.first)，则将之前的区间加入到结果中，并开始一个新的区间。否则，两个区间有重叠，此时更新终点为两个区间的最大终点 (ed = max(ed, seg.second))。
    • 最后，将合并后的区间保存回 segs。
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
//这里定义了一个 PII 类型，表示一个包含两个整数的 pair（对），这两个整数表示区间的起点和终点
typedef pair<int, int> PII;

void merge(vector<PII> &segs)
{
    vector<PII> res;

    sort(segs.begin(), segs.end());

    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);

    if (st != -2e9) res.push_back({st, ed});

    segs = res;
}

int main()
{
    int n;
    scanf("%d", &n);

    vector<PII> segs;
    for (int i = 0; i < n; i ++ )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        segs.push_back({l, r});
    }

    merge(segs);

    cout << segs.size() << endl;

    return 0;
}
爱敲代码的憨仔
关注
专栏目录
《算法零基础100讲》(第2讲) 数列
英雄哪里出来
10-20 5619
数列，在程序中，表示为数组
《算法零基础100讲》(第30讲) 概率与统计
英雄哪里出来
11-19 3839
概率论，永远的痛
acwing算法基础课(第一讲 基础算法)(1)
2401_84584817的博客
05-16 748
阿里伤透我心，疯狂复习刷题，终于喜提offer 哈哈~好啦，不闲扯了1、JAVA面试核心知识整理（PDF）：包含JVMJAVA集合JAVA多线程并发，JAVA基础，Spring原理微服务，Netty与RPC，网络，日志，ZookeeperKafkaRabbitMQ，Hbase，MongoDB设计模式负载均衡数据库一致性哈希JAVA算法数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算共30个章节。2、Redis学习笔记及学习思维脑图。
算法零基础100讲 第一讲
weixin_43752644的博客
03-13 1148
题目描述：给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。 如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。 leetcode地址 bool isPowerOfTwo(int n){ if(n==0){ return false; } int x = (int)(log2(n)+1e-8); return fabs(n - pow(2,
算法基础课：第一讲——基础算法
m0_52806260的博客
07-02 682
包括快速排序、归并排序、二分、高精度、前缀和与差分、双指针、位运算、离散化、区间合并
《算法零基础》第16讲 ：变量交换算法
Sauron7i的博客
11-05 1896
位操作：变量交换算法
《零基础学算法》（第一讲）位运算的奇技淫巧
Ceylan__的博客
04-22 1366
《零基础算法小课堂》（第一讲）位运算，学会位运算的奇技淫巧，你不来看看吗？
【算法基础——第八讲】离散化
m0_63233163的博客
05-05 3827
大家好，我是quicklysleep，欢迎大家光临我的博客,算法学习笔记系列持续更新中~ 文章目录一、前言二、排序算法的介绍三、排序算法的运用1.快速排序模板2.冒泡排序模板3.归并排序模板最后 一、前言 排序算法是最基本的算法之一。 二、排序算法的介绍 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排.
【基础算法Ⅰ】算法入门篇
weixin_72686492的博客
11-25 3563
什么是枚举■枚举是基于已有知识来猜测答案的一种问题求解策略。■枚举的思想是不断地猜测，从可能的集合中一一尝试，然后再判断题目的条件是否成立。枚举的要点■建立简洁的数学模型。枚举的时候要想清楚：可能的情况是什么？要枚举哪些要素？■枚举的范围是什么？是所有的内容都需要枚举吗？在用枚举法解决问题的时候，一定要想清楚这两件事，否则会带来不必要的时间开销。■根据题目判断。比如例题中要求的是最大的符合条件的素数，那自然是从大到小枚举比较合适。
贪心算法 第1讲： 分配问题
刷刷刷，刷Leetcode
06-24 3612
一、什么是贪心算法？ 贪心算法是一种对某些求最优解问题的更简单、更迅速的设计技术。 贪心算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，省去了为找最优解要穷尽所有可能而必须耗费的大量时间。 贪心算法采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择，就将所求问题简化为一个规模更小的子问题，通过每一步贪心选择，可得到问题的一个最优解。 虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪心算法不要回溯 。 举一个
第1章绪论第5讲-算法分析基础1
02-15
数据结构第5版教程视频
第1章绪论第5讲-算法分析基础2
02-15
数据结构第5版教学视频
acwing算法第三讲
04-30
acwing算法第三讲 -acwing算法第三讲中，闫学灿强调了编程语言语法是次要的，思维是主要的。学习循环语句需要抓住一个要点——代码执行顺序。 一、 while 循环 while 循环可以简单理解为循环版的 if 语句。如果...
【OpenCv基础】第四十四讲 分水岭算法.zip
05-02
在本讲中，我们将深入探讨一个特定的图像分割算法——分水岭算法。分水岭算法是一种基于图像拓扑性质的图像分割方法，常用于处理具有多个连续区域的图像。 分水岭算法的灵感来源于地理学中的分水岭概念。在地理上，...
(完整版)大学计算机第7讲-算法-程序与计算系统之灵魂.ppt
11-23
通过数学建模，我们可以将复杂的问题转化为一组易于处理的数学公式或规则，从而使得算法的设计和分析成为可能。在算法类问题求解中，数学建模至关重要，因为它： 1. **简化问题**：数学模型通常简化了实际问题的...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 438
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
python 实现harmonic series调和级数算法
luthane的博客
09-24 956
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
【算法】贪心+堆排序实现大根堆及标准库容器类的融合使用
2301_77954967的博客
09-25 1724
先看题这个算法，是要通过循环找到所有元素中最大的那个偶元素，对其除以2，然后再找这之后的最大的那个偶元素以此类推笔者的经历不多，第一次做的时候没有想到大根堆的算法，只是用sort将每次除以2后的整个数组进行降序排序，这样的作法使用sort对数组进行排序后，虽然可以确定数组中的元素大小顺序，但在每次选择偶数进行减半操作时，需要遍历整个数组来找到合适的偶数，效率较低。对于一个较大的数组，排序后可能需要花费较多的时间来找到下一个要进行减半操作的偶数，尤其是当操作次数较多时，这种遍历的方式会变得非常耗时。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 128
初识算法之二分查找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值