C++学习笔记之算法模板

已于 2024-08-21 23:16:56 修改
阅读量807 收藏 29
点赞数 12
文章标签： c++ 学习 笔记
于 2024-08-18 15:07:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sincerelover/article/details/140800544
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、双指针

  双指针（Two Pointers）是一种常用的算法技巧，主要用于处理数组或字符串中的某些问题。它通过维护两个指针来遍历数据结构，从而高效地解决问题。根据指针的移动方向和位置，双指针技术可以分为同向双指针和对向双指针。

1.1 有序数组的合并

  这里以88.合并两个有序数组为例，这里的思路为先复制的一个数组p1_copy，然后用两个指针分别指向p1_copy和p2，最后依次比较两个数组里的元素大小并填充。
在这里插入图片描述

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int* p1_copy = new int[m];
        std::copy(nums1.begin(), nums1.begin() + m, p1_copy);
        
        int p1 = 0, p2 = 0, cur = 0;
        
        while (p1 < m && p2 < n) {
            if (p1_copy[p1] <= nums2[p2]) nums1[cur++] = p1_copy[p1++];
            else nums1[cur++] = nums2[p2++];
        }

        // 如果 p1_copy 中还有剩余元素，拷贝到 nums1
        while (p1 < m) {
            nums1[cur++] = p1_copy[p1++];
        }

        // 如果 nums2 中还有剩余元素，拷贝到 nums1
        while (p2 < n) {
            nums1[cur++] = nums2[p2++];
        }

        // 释放动态分配的内存
        delete[] p1_copy;
    }
};

1.2 快慢指针/删除有序数组中的重复项

  除了进行插入操作，双指针也可以用作快慢指针，例如26.删除有序数组中的重复项，这里的主要思路是利用两个指针，快指针用于判断每一个元素的值，慢指针用于进行赋值。
在这里插入图片描述

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) return 0;

        int len = 1; // 因为至少有一个元素不会被移除
        for (int i = 1; i < n; i++) {
            if (nums[i] != nums[len - 1]) {
                nums[len] = nums[i];
                len++;
            }
        }
        return len;
    }
};

1.3 求和

  167.两数之和和15.三数之和是双指针另一种常用方式，二者的本质其实都是对向双指针（有点类似二分法），判断和与目标数的大小关系进行指针的调整。三数之和是在二数的基础上多加了一层遍历，将每次取得的数作为目标数，再转化成二数之和。值得注意的是需要跳过重复数字。

//二数之和
class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int n = numbers.size();

        int i = n - 1;
        int j = 0;
        while(numbers[i] + numbers[j] != target){
            if(numbers[i] + numbers[j] < target) j++;
            else if(numbers[i] + numbers[j] > target) i--;
            else break;
        }
    return {j + 1, i + 1};
    }
};

//三数之和
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        int n = nums.size();
        
        for (int i = 0; i < n - 2; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 跳过重复数字
            
            int target = -nums[i];
            int l = i + 1;
            int r = n - 1;
            
            while (l < r) {
                int sum = nums[l] + nums[r];
                if (sum > target) r--;
                else if (sum < target) l++;
                else {
                    ans.push_back({nums[i], nums[l], nums[r]});
                    while (l < r && nums[l] == nums[l + 1]) l++; // 跳过重复数字
                    while (l < r && nums[r] == nums[r - 1]) r--; // 跳过重复数字
                    l++;
                    r--;
                }
            }
        } 
        return ans;
    }
};

二、动态规划

  动态规划（Dynamic Programming，简称 DP）是一种用于解决具有重叠子问题和最优子结构性质的问题的算法设计技术。动态规划通过将问题分解成更小的子问题，并保存这些子问题的解决方案，以避免重复计算，从而提高算法效率。

2.1 自底向上和自顶向下（带备忘录）

  这里以70.爬楼梯为例，我们用 f(x) 表示爬到第 x 级台阶的方案数，考虑最后一步可能跨了一级台阶，也可能跨了两级台阶，所以我们可以列出动态规划的转移方程：f(x)=f(x−1)+f(x−2)，即爬到第 x 级台阶的方案数是爬到第 x−1 级台阶的方案数和爬到第 x−2 级台阶的方案数的和。

class Solution {
public:
    int climbStairs(int n) {
        if (n == 1) return 1;
        if (n == 2) return 2;

        int* num = new int[n + 1];
        num[1] = 1;
        num[2] = 2;

        for (int i = 3; i <= n; i++) {
            num[i] = num[i - 1] + num[i - 2];
        }

        int result = num[n];
        delete[] num;

        return result;
    }
};

  118.杨辉三角也是一个很好的自顶向下示例，如下图所示。可以看到其规律为：（1）每一排的第一个数和最后一个数都是 1，即 c[i][0]=c[i][i]=1；（2）其余数字，等于左上方的数，加上正上方的数，即 c[i][j]=c[i−1][j−1]+c[i−1][j]。
在这里插入图片描述
  我们简单地抽象一下这个三角形，即{[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]},那么我们可以将其看作是二维数组，然后每一层比上面一层多一个元素，利用resize()函数扩充一个元素。

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows); // 正确初始化二维向量
        for(int i = 0; i < numRows; i++){
            dp[i].resize(i + 1, 1);      // 调整第i行的大小为i+1，并填充1
            for(int j = 1; j < i; j++){
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; // 计算杨辉三角的值
            }
        }
        return dp;
    }
};

2.2 带有当前状态

2.3 背包问题

  常见的背包问题分为0/1背包和完全背包，遍历顺序也有两种：如果求组合数就是外层for循环遍历物品，内层for遍历背包；如果求排列数就是外层for遍历背包，内层for循环遍历物品。

2.3.1 0/1背包问题

  0/1完全背包问题可以简单总结为：有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

  1. dp[j]为 容量为j的背包所背的最大价值；
  2. dp[0]表示背包容量为0时的总价值，这时候什么都放不下，所以dp[0]=0，且由于每次都去最大值，则使得整个数组初始值为0；
  3. 此时dp[j]有两个选择，一个是取自己dp[j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，所以取最大的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

2.3.2 完全背包

  完全背包问题和0/1背包问题的最多差别在于每件物品都有无限个（也就是可以放入背包多次），我们这里以322.零钱兑换为例，其思路大致如下：

  1. 将dp[j]视为凑足总额为j所需钱币的最少个数；
  2. dp[0] = 0，但为了防止min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖，将dp[i]赋值为INT_MAX；
  3. 递推公式：dp[i] = min(dp[i - coins[j]] + 1, dp[i]);
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]有效
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }

        if (dp[amount] > amount) return -1;        // 若硬币数超出amount则说明出错
        return dp[amount];
    }
};

三、二分算法

  二分法（Binary Search）是一种在有序数组中查找目标值的高效算法。它通过不断将查找范围减半，从而在每次比较后将查找范围缩小一半，最终找到目标值或确定目标值不存在。其基本思路如下所示：

  1. 初始化: 设定查找范围的左边界 left 和右边界 right。
  2. 计算中间点: 计算中间点 mid = left + (right - left) / 2。
  3. 比较中间点的值与目标值:
    • 如果 nums[mid] == target，则找到目标值，返回 mid。
    • 如果 nums[mid] < target，则目标值在右半部分，调整左边界 left = mid + 1。
    • 如果 nums[mid] > target，则目标值在左半部分，调整右边界 right = mid - 1。
  4. 重复步骤 2 和 3，直到找到目标值或查找范围为空（left > right）。

2.1 经典二分查找

  这里以34.在排序数组中查找元素的第一个和最后一个位置，这里可以简单改写一下这个问题，将其改写成寻找第一个target的位置和第一个target+1的位置，相当于两次利用二分。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int begin = findborder(nums, target);
        if (begin == nums.size() || nums[begin] != target) return {-1, -1};
        int end = findborder(nums, target + 1);
        return {begin, end - 1};
    }

    int findborder(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int mid;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (nums[mid] < target) left = mid + 1;
            else right = mid - 1;
        }
        return left;
    }
};

2.2 寻找峰值

  以162.寻找峰值为例，本题的目标是在一个无序数组中找到一个“峰值”元素的索引。与上题不同的是无序数组没有全局的有序性，因此需要通过局部性质来判断搜索的方向：如果中间元素比右侧元素大，那么峰值可能在左侧（包括中间元素），因此缩小搜索范围到左半部分；如果中间元素比右侧元素小，那么峰值一定在右侧，因此缩小搜索范围到右半部分。

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left = 0, right = nums.size() - 1;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] > nums[mid + 1]) right = mid;  // 峰值在左半部分（包括 mid）
            else left = mid + 1;  // 峰值在右半部分（不包括 mid）
        }
        return left;
    }
};

3.3 寻找选择排序数组中的最小值

 &esmp;这种类型的题目最为关键的一点在于它的数组不是升序的，例如，原数组 nums = [0,1,2,4,5,6,7] 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]，这样的话我们就不能简单地将left和righ定义在数组的两端，然后逐次逼近，需要多考虑将原数组分化成两个数组，且在哪个数组中是有序的，以便我们进行分类处理。以153.寻找选择排序数组中的最小值为例，我们的解决思路大致如下：

  1. 按照惯例定义left，righ及mid；
  2. 取右半部分（mid -> right）进行判别，若left < right，则说明在该部分是有序的，则说明最小值不可能在(mid,righ]之间，故将righ移动到mid(防止最小值就是mid);
  3. 与此同时，若left >= right，则证明该部分是无序的，结合示例数组可知最小值一定在该部分内。
class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0, right = nums.size() - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < nums[right]) {
                right = mid;  // 最小值在右半部分
            } else {
                left = mid + 1;  // 最小值在左半部分或者就是 mid
            }
        }
        return nums[left];
    }
};

四、贪心算法

  贪心算法（Greedy Algorithm）是一种在求解优化问题时所采用的方法。贪心算法的核心思想是：在每一步选择中，选择当前状态下最好（即最优）的选择，期望通过局部最优选择达到全局最优。贪心算法通常用于解决一些特定类型的问题，这些问题具有“贪心选择性质”和“最优子结构性质”。贪心算法的基本步骤为：

  1. 建立数学模型来描述问题。
  2. 将问题分解为若干个子问题。
  3. 对每个子问题求解，得到局部最优解。
  4. 将所有子问题的局部最优解合并成一个全局解。

  通常情况下，有两种基本贪心策略：从最小/最大开始贪心，优先考虑最小/最大的数。在此基础上，衍生出了反悔贪心；从最左/最右开始贪心，思考第一个数/最后一个数的贪心策略，把 n 个数的原问题转换成n−1 个数（或更少）的子问题。

4.1 从最小/最大开始贪心

  我们以55.跳跃游戏为例，根据题目要求我们在规定的可选步长（step）内选择合适的长度，最终到达最后一个元素即可，但是实际上如果我们陷入这样的思维就很难继续了，例如对于给出的[2,3,1,1,4]，我可以选择分别走2->1->1，也可以走1->3，但是我们可以发现一个现象如果我们在每步都取最大步长，且各个部分的最大步长合起来可以覆盖到终点就可以代表能走到最后，这样就不需要考虑各地方到底是怎么走的了，如图所示。
在这里插入图片描述

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size() == 1) return true;
        int step = 0;
        for(int i = 0; i <= step; i++){
            step = max(i + nums[i], step);
            if(step >= nums.size() - 1) return true;
        }
    return false;
    }
};

4.2 从最左/右开始贪心

  这里以134.加油站为例，通过在遍历过程中动态调整起点来找到唯一的可行起点。具体来说，贪心策略体现在每次遇到当前油量不足的情况时，立即放弃从当前起点到当前加油站之间的所有加油站作为起点，因为如果从这些加油站中的任何一个出发，都无法到达当前加油站。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int current = 0;
        int total = 0;
        int start = 0;
        for(int i = 0; i < gas.size(); i++){
            current = current + (gas[i] - cost[i]);
            total = total  + (gas[i] - cost[i]);
            if(current < 0){
                start = i + 1;
                current = 0;
            }
        }
        if(total < 0) return -1;
        return start;
    }
};

4.3 区间

  在计算机中区间和数学中一样，均表示一个范围，通常情况下会写成字符串数组的形式。以例57.插入区间为例，这里我们就可以使用贪心算法，其体现在两个方面：不重叠的区间直接添加；发现当前区间 x 与 newInterval 重叠则选择合并。

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        // 如果 intervals 为空，直接返回 newInterval 作为唯一的结果
        if(intervals.empty()) return {newInterval};       
        
        vector<vector<int>> res;
        bool inserted = false;

        for(auto x : intervals){
            if(x[1] < newInterval[0]){
                // 当前区间在 newInterval 左侧，无重叠
                res.push_back(x);
            }
            else if(newInterval[1] < x[0]){
                // 当前区间在 newInterval 右侧，无重叠
                if(!inserted) {
                    res.push_back(newInterval);
                    inserted = true;
                }
                res.push_back(x);
            }
            else{
                // 当前区间与 newInterval 有重叠，合并
                newInterval[0] = min(newInterval[0], x[0]);
                newInterval[1] = max(newInterval[1], x[1]);
            }
        }

        // 如果 newInterval 还未插入，则插入它
        if(!inserted) {
            res.push_back(newInterval);
        }

        return res;
    }
};

  值得注意的是if (!inserted) 语句的作用是在处理所有的区间后，确保新区间 newInterval 被正确地插入到结果中。假设 intervals 中的所有区间都在 newInterval 的左侧且不重叠，循环中每次都会走到 if (x[1] < newInterval[0]) 分支，将所有的原始区间直接添加到 res，但 newInterval 并没有被插入；另一种情况是 newInterval 小于所有区间且不重叠，在这种情况下，newInterval 应该在最前面插入。但如果不检查 !inserted，newInterval 可能会被忽略，因此在遍历完成后，newInterval 需要被手动添加。

云雨歇
关注
  • 12
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++STL学习笔记.pdf
05-23
C++ Standard Template Library（STL）是C++编程语言的一个重要组件，它提供了一系列通用的数据结构和算法模板，使程序员能够以一种标准化和高效的方式处理数据。STL的主要组成部分包括容器（containers）、迭代器...
c++学习笔记
04-07
这份"C++学习笔记"涵盖了C++的基础概念、语法结构、面向对象编程以及可能的高级主题，旨在帮助初学者或者有经验的程序员巩固C++知识。 首先，C++是从C语言发展而来，它保留了C语言的效率，同时引入了类和对象的概念...
C++学习笔记——标准模板库
华数云图小分队的博客
01-13 1222
C++标准模板库（STL）是C++的一个重要组成部分，它提供了一套丰富的通用数据结构和算法。STL以其高度模块化、可复用的特性，在C++编程中发挥着重要作用。本篇博客将带你深入了解STL，并介绍其常见的组件和使用方法。C++标准模板库（STL）是C++语言的一个标准库，它提供了一套通用的数据结构和算法，以支持高效的编程。STL的设计目标是使程序员能够以简洁、高效和可复用的方式开发代码。// 输出vector的大小return 0;
C++学习笔记——模板
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
07-24 1084
总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建。函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个。总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板。总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp。总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别。1、如果函数模板和普通函数都可以实现，优先调用普通函数。总结：类模板中成员函数类外实现时，需要加上模板参数列表。
C++学习笔记
weixin_45668170的博客
03-23 1044
本文为学习C++时做的笔记，参考视频为bilibili的黑马程序员的C++入门教程**浅拷贝：**简单的拷贝赋值操作**深拷贝：**在堆区重新申请空间，进行拷贝操作 **总结：**如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题**作用：**C++提供了初始化列表语法，用来初始化属性 1.3 类对象作为类成员 类中的成员可以是另一个类的对象 B类中有对象A作为成员，A作为对象成员。先构造A,再构造B。析构与构造顺序相反静态成员分为： 2. C++对象模型和this指针 2.1 成员变
C++学习笔记之四（标准库、标准模板库、vector类）
weixin_45885074的博客
10-27 1436
C++learning note
C++Primer Plus学习笔记
weixin_45068267的博客
04-08 1844
此博文是通过翻阅C++ Primer Plus中文第6版（2020），逐章学习记录笔记由此学习C++的基础特性和语法知识，有别于其它视频教学+代码+笔记的学习途径，更趋向传统的书籍+代码+笔记学习，Cpp第6版以C++11标准为主，学习C++基础编程绰绰有余.
C++学习笔记——类模板
liangjian990709的博客
12-04 805
类模板 类模板的定义和声明 1. 定义 template <typename T> class B { }; 2. 声明 template <typename T> class B; 3. 要点 翻译单元级一处定义原则 类模板不是类，在被调用时实例化 4. 类模板内定义成员函数 类模板中定义成员函数 注意：类内部使用类名时不用B{}，可以直接B{} // 类内定义成员函数: template <typename T> class B { publi
C++学习笔记——函数模板
liangjian990709的博客
11-29 546
函数模板 函数模板的定义和声明 1. 定义： template <typename T> void fun(T input) { ... } //或 template <class T> void fun(T input) { ... } 2. 声明 template <typename T> void fun(T input); 3. 要点 函数模板不是函数，不能直接调用，在编译期编译期对其进行实例化产生相应的函数才能调用 两对形参实参，fun(3
C++学习笔记-函数模版与类模版
chen_mp的博客
07-25 860
C++模板是C++语言中的一个重要特性，它使得代码能够重用和泛化，提高了编程的效率和代码质量。无论是函数模板还是类模板，都是编写高效、通用代码的重要工具。通过理解和掌握模板的使用，可以大大提高C++编程的灵活性和效率。
每日学习笔记：C++ STL算法之比较容器
Jane_Yih的博客
04-08 341
每日学习笔记：C++ STL算法之比较容器
C++学习笔记：标准模板库STL的string类
weixin_45463470的博客
04-06 864
答：双引号之间的一串字符，如"Hello"通过双引号定义了一个字符串字面量），例如u""（转char16_t），U""（转char32_t）、L""（转wchar_t），R""（表示可以忽略转义字符），可以得到对应的字符串。STL的字符串类（包括std::string（普通字符串）和std::wstring（宽字符串））解决了这些问题。缺陷：实现较复杂，例如，将一个对象赋给另一个对象时，必须编写正确的复制构造函数和赋值运算符，否则会导致两个对象指向内存内相同的缓冲区，使销毁对象时出错。
C++学习笔记共82页.pdf.zip
10-29
【标题】"C++学习笔记共82页.pdf.zip" 提供的是一个关于C++编程语言的学习资料，其中包含了82页的详细笔记。这个压缩文件可能是为了方便学习者整理和下载，便于他们系统地掌握C++的基础知识和进阶技巧。 【描述】...
c++学习笔记.zip
09-19
10. **STL（Standard Template Library）标准模板库**：包括容器（如vector、list、map等）、算法（如排序、查找、迭代器操作等）和迭代器，极大地提高了C++程序员的开发效率。 11. **文件I/O**：C++提供了流式I/O...
王道C++46期学习笔记记录.zip
10-18
《王道C++46期学习笔记记录》是一份详细且深入的C++学习资源，旨在帮助编程初学者以及有经验的开发者进一步提升C++技能。C++是一种强大的、通用的编程语言，以其面向对象的特性、高效性能和丰富的库支持而闻名。这46...
C++(11)类语法分析(2)
Once_day的回忆
08-17 1192
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C++匿名函数lamba简介
yao_tao11的博客
08-18 645
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 340
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】一文掌握C++中的IO流
JLX_1的博客
08-16 1269
本文详细讲解了C++中的IO流体系，讲解了各种接口的使用方法！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值