【基础算法】回溯算法相关题目

已于 2023-11-29 20:51:02 修改
阅读量322 收藏
点赞数
分类专栏： 秋招面试 文章标签： 算法 java 开发语言
于 2023-08-23 16:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43840665/article/details/132455985
版权
本文详细介绍了回溯算法的基本概念、理论基础，包括组合、排列问题及其无重复/有重复元素的版本，以及常见面试题的解法，如组合39/40、分割回文串、复原IP地址等。提供C++代码模板和实例，助力求职者准备算法面试。
摘要由CSDN通过智能技术生成

系列综述：
💞目的：本系列是个人整理为了秋招算法的，整理期间苛求每个知识点，平衡理解简易度与深入程度。
🥰来源：材料主要源于代码随想录进行的，每个算法代码参考leetcode高赞回答和其他平台热门博客，其中也可能含有一些的个人思考。
🤭结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢🎈🎄🌷！！！
🌈【C++】秋招&实习面经汇总篇

文章目录

😊点此到文末惊喜↩︎

一、回溯算法理论基础

定义

  1. 回溯算法 = 穷举 + 剪枝
  2. 回溯算法解决的问题一般为npc问题，难以使用常规算法进行解决
    • 组合问题：N个数里面按一定规则找出k个数的集合
      • 切割问题：一个字符串按一定规则有几种切割方式
      • 子集问题：一个N个数的集合里有多少符合条件的子集
    • 排列问题：N个数按一定规则选出M个，有几种排列方式
    • 棋盘问题：N皇后，解数独等等
  3. 排列和组合的区别： 组合是不强调元素顺序的，排列是强调元素顺序。
  4. 所有的回溯法解决的问题都可以抽象为树形结构
  5. 回溯基本结构
    • 根节点是总数据集合，树枝节点是可选数据集合
    • 叶子节点为根节点到叶子节点的路径的选择集合
    • for循环表示结果集中的进行元素的选取

在这里插入图片描述
```cpp
// 合法性判断
bool isValid(const type &data){
// type中数据项的合法性判断
}
// 回溯函数
vector<vector res;
vector path;
void backtracking(vecotr candidates, int startIndex) {
auto is_ok = [](const type &data){

	};
	// 递归出口：路径值判断
    if (符合条件isValid) {
        res.push_back(path);
        return;
    }
	// 
	// 延申和回撤路径时，可能涉及多个状态标记变量的改动
    for (int i = startIndex; i < candidates.size(); ++i) {
    	剪枝判断;
    	// 状态延申改动
        path.push_back(candidates[i]);// 向下延申
        backtracking(剩余可选列表); // 回溯
        // 状态回撤改动
        path.pop_back();// 回撤延申
    }
}
// 主函数
vector<vector<int>> combine(vector<type>& candidates) {
    res.clear(); // 可以不写
    path.clear();// 可以不写
    backtracking(candidates, 0);
    return result;
}
```

二、回溯基础算法模板

模板使用的初衷：通过模板的深入理解和背诵，可以做题过程中，比较快的进行问题的划分和抽象转换，然后调用背诵（或者微修改）的回溯模板进行求解。即将模板视为一个功能函数，通过抽象的问题输入进行求解。

组合问题

- 无重复元素的组合
  1. 基本概述
    • 问题：从无重复元素的组合中选出若干元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
    • 举例：从元素集合{1，2，3}中选择2个元素的组合为{(1,2)，(1,3)，(2,3)}。
      在这里插入图片描述
  2. 代码
    • 解决的问题：给定一个线性表，求该线性表中满足条件的组合
    • 示例：求线性表中所有个数为target的结果。
    • 剪枝：列表中剩余元素(vec.size() - i) >= 所需需要的元素个数(target - path.size()) 
    vector<vector<int>> subsets(vector<int>& nums) {
    vector<int> path;			// 符合条件的路径
    vector<vector<int>> res;	// 符合条件的路径集合
    auto self = [&](auto &&self, vector<int> &vec, int target, int start){
    	// 递归出口：满足条件的路径加入结果集中
        if (path.size() == target) {
            res.push_back(path);
            return ;
        }
        // i = start表示从之后剩余中选择
        for (int i = start; i < vec.size(); ++i) {
            if (i > vec.size() - (target-path.size())) 
                continue;
            path.push_back(vec[i]);			// 做出选择
            self(self, vec, target, i+1);	// 递归
            path.pop_back();				// 撤销选择
        }
    };
	// 以下两步可以不写
    path.clear();
    res.clear();
	self(self, nums, nums.size(), 0);
    return res;
}
- 有重复元素的组合
  1. 基本概述
    • 问题：从有重复元素的组合中选出若干元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
    • 举例：从集合{1, 2, 2, 3}中选择2个元素的组合为{1, 2}、{1, 3}、{2, 2}、{2, 3}。
  2. 代码
    • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复
    class Solution {
public:
    vector<vector<int>> combine(vector<int> vec, int k) {
        result.clear(); // 可以不写
        path.clear();   // 可以不写
        sort(vec.begin(), vec.end()); // 注意需要先进行一个排序
        BackTracking(vec, 0,  k);
        return result;
    }
};
private:
    // 回溯核心算法
    vector<vector<int>> result; // 存放符合条件结果的集合
    vector<int> path; // 用来存放符合条件结果
    void BackTracking(vector<int> &vec, int start, int target) {
    	// 递归出口：满足条件则加入结果集中
        if (path.size() == target) {
            result.push_back(path);	
            return ;
        }
        // 回溯算法
        for (int i = start; i < vec.size(); i++) {
        	// 剪枝：重复选择只选一次，需要配合sort使用
        	if (i > start && vec[i] == vec[i - 1]) 
            	continue;
  			// 回溯步骤
            path.push_back(vec[i]); 	// 做出选择
            BackTracking(vec, i + 1, target);// 递归
            path.pop_back(); 			// 撤销选择
        }
    }

排列问题

- 无重复元素的全排列
  1. 基本概述
    • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有可能的组合，每个元素只出现一次。
    • 举例：从集合{1, 2, 3}，则可以产生以下6种无重复元素的排列：{1, 2, 3}、{1, 3, 2}、{2, 1, 3}、{2, 3, 1}、{3, 1, 2}、{3, 2, 1}。
      在这里插入图片描述
  2. 代码
vector<vector<int>> permute(vector<int>& nums) {
    // 无重复元素全排列匿名函数模板
    vector<int> path;			// 回溯路径
    vector<vector<int>> res;	// 回溯路径结果集合
    auto self = // 将自身作为右值引用进行递归传递
      [&](auto&& self, vector<int> &nums, vector<bool> used){
      	// 递归出口：找到一条合法路径
        if (path.size() == nums.size()) {
            res.push_back(path);
            return ;
        }
        for (int i = 0; i < nums.size(); ++i) {
        	// path里已经收录的元素，直接跳过
            if (used[i] == true) continue;
            // 增加选择
            used[i] = true;
            path.push_back(nums[i]);
            // 进行回溯
            self(self, nums, used);
            // 撤回选择
            used[i] = false;
            path.pop_back();
        }
    };
    
    // 主要部分
    res.clear();
    path.clear();
    // 注意选择的初始化
    vector<bool> used(nums.size(), false);
    self(self, nums, used);
    return res;
}
- 有重复元素的全排列
  1. 基本概述
    • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有的不重复组合
    • 举例：从集合[1,1,2]，则可以产生无重复的全排列： [1,1,2], [1,2,1], [2,1,1]
  2. 代码
    • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复
    • 去重操作需要对线性数组中的元素进行排序
    class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        // 重复计数
        unordered_map<int, int> umap;
        for (auto i : nums) ++umap[i];
        backtrace(umap, 0, nums.size());
        return res;
    }
private:
    vector<vector<int> > res;
    vector<int> path;
    void backtrace(unordered_map<int, int> &umap, int k, int total) {
        if (k == total) {
            res.push_back(path);
            return;
        }
        for (auto& p : umap) {	// 每轮递归结束会进入循环
            if (p.second == 0) continue;
            --p.second;
            path.push_back(p.first);
            backtrace(umap, k + 1, n);
            ++p.second;
            path.pop_back();
        }
    }
};

三、回溯算法基本题目

77. 组合

  1. 77. 组合
    • 题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
    • 组合中的元素不能重复
    // 函数式编程？
vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果
void backtracking(int n, int k, int startIndex) {
    // 递归结束条件：组合树的叶子节点的条件
    if (path.size() == k) {
        result.push_back(path);
        return ;
    }
    // 回溯的递归：
    for (int i = startIndex; i <= n; i++) {
        path.push_back(i); // 处理节点 
        backtracking(n, k, i + 1); // 递归
        path.pop_back(); // 回溯，撤销处理的节点
    }
}
vector<vector<int>> combine(int n, int k) {
    result.clear(); // 可以不写
    path.clear();   // 可以不写
    backtracking(n, k, 1);
    return result;
}

39. 组合总和

  1. 39. 组合总和
    • 问题：给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回
    vector<vector<int>> res;
vector<int> path;
void backtracking(vector<int> &candidates, int startIndex, int target, int sum){
	// 结束条件
    if (sum > target) return ;
    if (sum == target) {
        res.push_back(path);
        return ;
    }
	// 路径回溯
    for (int i = startIndex; i < candidates.size(); ++i) {
        sum += candidates[i];// 路径值累加
        path.push_back(candidates[i]);// 路径延申
        backtracking(candidates, i, target, sum);
        sum -= candidates[i];
        path.pop_back();
    }
}

vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
    res.clear();
    path.clear();
    backtracking(candidates, 0, target, 0);
    return res;
}

40.组合总和II

  1. 40.组合总和II
    • 集合（数组candidates）有重复元素，但还不能有重复的组合。
    • 同一个层不可重复选取两个相同的元素
    // 结果容器
vector<vector<int>> result;
vector<int> path;
// 回溯函数
void backtracking(vector<int>& candidates, int target, int sum, 
	int startIndex, vector<bool>& used) {
    if (sum == target) {
        result.push_back(path);
        return;
    }
    for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
        // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
        // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
        // 要对同一树层使用过的元素进行跳过
        if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
            continue;
        }
        // 延申路径：改变状态机中路径相关变量，sum、path、used
        sum += candidates[i];
        path.push_back(candidates[i]);
        used[i] = true;
        // 回溯函数
        backtracking(candidates, target, sum, i + 1, used); 
        // 回缩路径
        used[i] = false;
        sum -= candidates[i];
        path.pop_back();
    }
}

vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
    vector<bool> used(candidates.size(), false);
    path.clear();
    result.clear();
    // 首先把给candidates排序，让其相同的元素都挨在一起。
    sort(candidates.begin(), candidates.end());
    backtracking(candidates, target, 0, 0, used);
    return result;
}

131. 分割回文串

  1. 131. 分割回文串
    • 获取[startIndex,i]在s中的子串s.substr(startIndex, i - startIndex + 1)
    // 判断是否为回文字符串
bool isPalindrome(const string& s, int start, int end) {
    for (int i = start, j = end; i < j; i++, j--) {
        if (s[i] != s[j]) {
            return false;
        }
    }
    return true;
}
// 基本的回溯
vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
    for (int i = startIndex; i < s.size(); i++) {
    	// 剪枝与枝的延长
        if (isPalindrome(s, startIndex, i)) {   // 是回文子串
            // 获取[startIndex,i]在s中的子串
            string str = s.substr(startIndex, i - startIndex + 1);
            path.push_back(str);
        } else {  // 不是回文，跳过
            continue;
        }
        backtracking(s, i + 1); // 寻找i+1为起始位置的子串
        path.pop_back(); // 回溯过程，弹出本次已经填在的子串
    }
}


vector<vector<string>> partition(string s) {
    result.clear();
    path.clear();
    backtracking(s, 0);
    return result;
}

93. 复原 IP 地址

  1. 93. 复原 IP 地址
    • str.insert(1,s);在原串下标为1的字符e前插入字符串s
    • str.erase(0);删除下标为0的字符
    vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {
    if (pointNum == 3) { // 逗点数量为3时，分隔结束
        // 判断第四段子字符串是否合法，如果合法就放进result中
        if (isValid(s, startIndex, s.size() - 1)) {
            result.push_back(s);
        }
        return;
    }
    
    for (int i = startIndex; i < s.size(); i++) {
        if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
            s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
            pointNum++;
            backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
            pointNum--;                         // 回溯
            s.erase(s.begin() + i + 1);         // 回溯删掉逗点
        } else break; // 不合法，直接结束本层循环
    }
}
// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
    if (start > end) {
        return false;
    }
    if (s[start] == '0' && start != end) { // 0开头的数字不合法
            return false;
    }
    int num = 0;
    for (int i = start; i <= end; i++) {
        if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
            return false;
        }
        num = num * 10 + (s[i] - '0');
        if (num > 255) { // 如果大于255了不合法
            return false;
        }
    }
    return true;
}

vector<string> restoreIpAddresses(string s) {
    result.clear();
    if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
    backtracking(s, 0, 0);
    return result;
}

1005. K 次取反后最大化的数组和

  1. 1005. K 次取反后最大化的数组和
    • sort的使用：第三个参数为自定义的排序队则，在头文件#include
    • accumulate的使用：第三个参数为累加的初值，在头文件include
    static bool cmp(int a, int b) {
    return abs(a) > abs(b);// 绝对值的从大到小进行排序
}
int largestSumAfterKNegations(vector<int>& A, int K) {
	// 将容器内的元素按照绝对值从大到小进行排序
    sort(A.begin(), A.end(), cmp); 
    // 在K>0的情况下，将负值按照绝对值从大到小依次取反
    for (int i = 0; i < A.size(); i++) { 
        if (A[i] < 0 && K > 0) {
            A[i] *= -1;
            K--;
        }
    }
    // 如果K为奇数，将最小的正数取反
    if (K % 2 == 1) 
    	A[A.size() - 1] *= -1; 
   	// 求和
    return accumulate(A.begin(),A.end(),0);
    // 第三个参数为累加的初值，在头文件include<numeric>
}
少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。
不如点赞·收藏·关注一波

🚩点此跳转到首行↩︎

参考博客

  1. 代码随想录
  2. letcode回溯题解——空条承子
  3. 大力王_leetcode全排列回溯
逆羽飘扬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法基础（Java）--回溯算法
m0_73757009的博客
03-15 962
s的每一个元素s【i】(i >= 0&&i < n),都为数组a中的任意元素a【j】(j >= 0&&j < n)，不过要保证任意的s【i】不相等。乘以2，格子上填的就是左括号或者右括号，这里的剪枝条件是，当前右括号数量超过了左括号，或左括号数量超过了一半。上面的i代表解空间的第i个位置，往往从0开始，而n则代表解空间的大小。因此我们看到，回溯本身是很简单的，单纯的模板套用，难的在于需要根据回溯条件来定义各种别的变量，以及最后结果的记录。这个向量的每个元素都是问题的部分解，只有当这个数组的每一个元素都。
回溯算法题
qq_31997185的博客
10-25 161
1. 括号生成：数字n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。有效括号组合需满足：左括号必须以正确的顺序闭合。 输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()()"] class Solution: def generateParenthesis(self, n: int) -> List[str]: self.n = n def backtra...
回溯算法理论基础
代码随想录
11-23 594
> 今天开始正式回溯法的讲解，老规矩，先概述
C++基础算法之DFS与回溯
qq_74729280的博客
04-24 1139
回溯算法，以其独特的试错机制，让我们在面对诸如组合优化、排列等复杂问题时，能够有条不紊地尝试各种可能性，并在遇到无解的情况时，优雅地回退到前一步，继续探索新的道路。这种不断尝试、不断回退的过程，不仅锻炼了我们的逻辑思维能力，也让我们深刻体会到了“失败乃成功之母”的真谛。而深度优先搜索，则以其深入骨髓的搜索方式，让我们在遍历树或图时能够一往无前，直达问题的核心。它不畏艰难，不惧险阻，只要还有未探索的分支，它就会继续前行。
与回溯相关的算法题
Zha_yc的博客
01-12 259
回溯的基本模板： void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { //横向遍历 处理节点; backtracking(路径，选择列表); // 递归 纵向遍历 回溯，撤销处理结果 } } 1. 电话号码的字母组合 1.1 思路 本题采用回溯的思想，因为需要通
中学生C++信息学奥赛一本通基础算法CSP-J/S网课 青少年竞赛NOIP视频
06-13
课程中的基础算法包括但不限于排序、搜索、图论、动态规划、回溯法等。排序算法如快速排序、归并排序、堆排序等，是解决问题的基础工具，能帮助学生高效处理数据。搜索算法如深度优先搜索（DFS）和广度优先搜索（BFS...
十道基础算法题，内有代码和题目，建议先做一遍再看代码
03-29
这些题目涵盖了基础算法的多个重要领域，包括排序、搜索、数据结构等。下面将对每一道题目的知识点进行详细介绍。 1. **排序算法**：排序是计算机科学中最基础且广泛使用的算法之一。可能的题目包括经典的冒泡排序...
JAVA零基础算法练习题
10-02
"JAVA零基础算法练习题"就是针对这样的需求而设计的一系列练习题目，旨在帮助初学者提升对Java语言的理解和运用，同时培养解决问题的能力。 首先，让我们深入了解一下算法。算法是一系列精确的规则或步骤，用于解决...
基础练习-蓝桥杯算法题库含VIP题目。2020/4/20日更新
04-22
【描述】中的关键信息是“基础练习”和“HTML形式展示”，这表明题库包含了不同难度级别的算法题目，主要面向初学者，帮助他们逐步建立起坚实的算法基础。以HTML的形式展示，意味着这些题目可能通过网页的形式呈现，...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 860
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 358
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法025：前缀和
m0_62319039的博客
08-22 212
算法025：前缀和
计算机毕业设计选题推荐-二手房价分析与预测-Python爬虫可视化-算法
IT研究室的博客
08-21 880
随着城市化进程的加快和房地产市场的发展，二手房市场日益活跃。二手房价格不仅受到经济、政策、地理位置等多种因素的影响，还与房屋本身的结构、面积、建造年代等属性密切相关。根据国家统计局的数据，近年来，二手房交易量持续增长，房价波动也成为社会关注的焦点。有效的二手房价分析与预测对于政府制定房地产政策、投资者做出投资决策以及普通购房者选择购房时机都具有重要意义。本课题旨在开发一个二手房价分析与预测系统，通过该系统，管理员和用户能够对二手房市场进行深入的数据分析和房价预测。
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 984
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
最小区间00
青釉Oo的博客
08-21 491
最小区间
算法笔试-编程练习-01-B-23
志远的博客
08-23 810
小红组内有 n 个人，大家合作完成了一个初版方案，初始时大家的愤怒值都是 0。 但是领导对方案并不满意，共需要修改 m 次方案，每次修改会先让第 l 到 r 个人的愤怒值加 1，然后再修改方案；
代码随想录算法训练营第二十二天| 回溯算法理论基础 77. 组合 216.组合总和III 17.电话号码的字母组合
Mwicogito的博客
08-23 1105
回溯法章节开始，逐渐开始正式复习算法设计课的知识。文章图片来源：代码随想录 (https://programmercarl.com/)
超分之最近邻插值、线性插值、双线性插值、双三次插值原理
最新发布
weixin_44342777的博客
08-25 537
超分用于对照实验，或生成低分辨率数据集的常用插值方式：最近邻插值、线性插值、双线性插值、双三次插值的实现原理
代码随想录day46 647. 回文子串 516.最长回文子序列
weixin_45461296的博客
08-22 366
【代码】代码随想录day46 647. 回文子串 516.最长回文子序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

逆羽飘扬

如果有用，请支持一下。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值