leetcode回溯法专栏（详解）

最新推荐文章于 2023-09-11 00:22:15 发布
最新推荐文章于 2023-09-11 00:22:15 发布
阅读量1k 收藏 9
点赞数
分类专栏： C++ 算法笔试 算法与数据结构 文章标签： 回溯法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/excellent_sun/article/details/97743946
版权

leetcode回溯法专栏

预备知识（递归）

#include<iostream>
#include<vector>

using namespace std;

class Solution {
public:
	void generation(int i, vector<int>& nums, vector<int>& item, vector<vector<int>>& result) {
		if (i>=nums.size()) {
			return;	
		}
		item.push_back(nums[i]);
		result.push_back(item);
		generation(i+1, nums, item, result);
	}
};
int main() {
	vector<int> nums;
	nums.push_back(1);
	nums.push_back(2);
	nums.push_back(3);
	vector<int> item;
	vector<vector<int>> result;
	Solution().generation(0, nums, item, result);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;

}

回溯法

LeetCode 17 电话号码的字母组合

code1

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Solution {
public:
	vector<string> letterCombinations(string digits) {
		if (digits.empty()) return {};
		vector<string> res;
		vector<string> dict{ " ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };
		letterCombinationsDFS(digits, dict, 0, "", res);
		return res;
	}
	void letterCombinationsDFS(string& digits, vector<string>& dict, int level, string out, vector<string>& res) {
		if (level == digits.size()) { res.push_back(out); return; }
		string str = dict[digits[level] - '0'];//找到数字字符对应的字母
		for (int i = 0; i < str.size(); ++i) {
			letterCombinationsDFS(digits, dict, level + 1, out + str[i], res);
		}
	}
};
int main() {
	vector<string> res = Solution().letterCombinations("234");
	for (int i = 0; i < res.size(); i++)
		cout << res[i] << endl;
	system("pause");
	return 0;
}

code2

#include<iostream>
#include<vector>
#include<assert.h>
#include<string>

using namespace std;

class Solution {
private:
	vector<string> res;
	const string letterMap[10] = {
		" ",
		"",
		"abc",
		"def",
		"ghi",
		"jkl",
		"mno",
		"pqrs",
		"tuv",
		"wxyz"
	};
	void findCombinations(const string& digits, int index, const string& s) {
		if (index == digits.size()) {
			res.push_back(s); 
			return;
		}
			
		char c = digits[index];
		assert( c >= '0' && c <= '9' && c != '1');
		string letters = letterMap[c - '0'];
		for (int i = 0; i < letters.size(); ++i) {
			findCombinations(digits,index+1,s+letters[i]);
		}
	}
public:
	vector<string> letterCombinations(string digits) {
		res.clear();
		if (digits == "") return res;
		findCombinations(digits,0,"");
		return res;
	}
};
int main() {
	string digits = "23";
	vector<string> res = Solution().letterCombinations(digits);
	for (int i = 0; i < res.size(); ++i) {
		cout << res[i] << endl;
	}
	system("pause");
	return 0;
}

LeetCode 39 组合总和

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

class Solution {
public:
	vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
		vector<vector<int>> res;
		vector<int> out;
		combinationSumDFS(candidates, target, 0, out, res);
		return res;
	}
	void combinationSumDFS(vector<int>& candidates, int target, int start, vector<int>& out, vector<vector<int>>& res) {
		if (target < 0) return;
		if (target == 0) { res.push_back(out); return; }
		for (int i = start; i < candidates.size(); ++i) {
			out.push_back(candidates[i]);
			combinationSumDFS(candidates, target - candidates[i], i, out, res);
			out.pop_back();
		}
	}
};
int main() {
	vector<int> candidates = {2,3,6,7};
	int target = 7;
	vector<vector<int>> result = Solution().combinationSum(candidates, target);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

LeetCode 40 组合总和2

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

class Solution {
public:
	vector<vector<int> > combinationSum2(vector<int> &num, int target) {
		vector<vector<int> > res;
		vector<int> out;
		sort(num.begin(), num.end());
		combinationSum2DFS(num, target, 0, out, res);
		return res;
	}
	void combinationSum2DFS(vector<int> &num, int target, int start, vector<int> &out, vector<vector<int> > &res) {
		if (target < 0) 
			return;
		else if (target == 0) res.push_back(out);
		else {
			for (int i = start; i < num.size(); ++i) {
				if (i > start && num[i] == num[i - 1]) 
					continue;
				out.push_back(num[i]);
				combinationSum2DFS(num, target - num[i], i, out, res);
				out.pop_back();
			}
		}
	}
};
int main() {
	vector<int> candidates = {2,2,2,2,1,7};
	int target = 8;
	vector<vector<int>> result = Solution().combinationSum2(candidates, target);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

LeetCode 46 全排列

图解

在这里插入图片描述

code1

#include<iostream>
#include<vector>

using namespace std;

class Solution {
public:
	vector<vector<int>> permute(vector<int>& num) {
		vector<vector<int>> res;
		permuteDFS(num, 0, res);
		return res;
	}
	void permuteDFS(vector<int>& num, int start, vector<vector<int>>& res) {
		if (start >= num.size()) res.push_back(num);
		for (int i = start; i < num.size(); ++i) {
			swap(num[start], num[i]);
			permuteDFS(num, start + 1, res);
			swap(num[start], num[i]);
		}
	}
};
int main() {
	vector<int> num{1,2,3};
	vector<vector<int>> res = Solution().permute(num);
	for (int i = 0; i < res.size(); i++) {
		for (int j = 0; j < res[i].size(); j++)
			cout << res[i][j];
		cout << endl;
	}	
	system("pause");
	return 0;
}

code2

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
private:
	vector<vector<int>> res;
	vector<bool> used;
	void generatePermutation(const vector<int>& nums, int index, vector<int>& p) {
		if (index == nums.size()) { 
			res.push_back(p); 
			return; 
		}
		for (int i = 0; i < nums.size(); i++) {
			if (!used[i]) {
				p.push_back(nums[i]);
				used[i] = true;
				generatePermutation(nums, index + 1, p);
				p.pop_back();
				used[i] = false;
			}
		}
		return;
	}
public:
	vector<vector<int>> permute(vector<int>& nums) {
		res.clear();
		if (nums.size() == 0)
			return res;
		used = vector<bool>(nums.size(), false);
		vector<int> p;
		generatePermutation(nums, 0, p);
		return res;
	}
};
int main() {
	vector<int> num{1, 2, 3};
	vector<vector<int>> res = Solution().permute(num);
	for (int i = 0; i < res.size(); i++) {
		for (int j = 0; j < res[i].size(); j++)
			cout << res[i][j];
		cout << endl;
	}
	system("pause");
	return 0;
}

leetcode 78. 子集

code1

#include<iostream>
#include<vector>

using namespace std;

class Solution {
private:
	void generation(int i, vector<int>& nums, vector<int>& item, vector<vector<int>>& result) {
		if (i>=nums.size()) {
			return;	
		}
		
		item.push_back(nums[i]);
		result.push_back(item);
		generation(i + 1, nums, item, result);
		item.pop_back();
		generation(i + 1, nums, item, result);	
	}
public:
	vector<vector<int>> subsets(vector<int>& nums) {
		vector<int> item;
		vector<vector<int>> result;
		result.push_back(item);
		generation(0, nums, item, result);
		return result;
	}
};
int main() {
	vector<int> nums;
	nums.push_back(1);
	nums.push_back(2);
	nums.push_back(3);
	vector<vector<int>> result = Solution().subsets(nums);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

code2

#include<iostream>
#include<vector>

using namespace std;

class Solution {
private:
	void generation(int pos, vector<int>& nums, vector<int>& item, vector<vector<int>>& result) {
		result.push_back(item);
		for (int i = pos; i < nums.size(); i++) {
			item.push_back(nums[i]);
			generation(i + 1, nums, item, result);
			item.pop_back();
		}
	}
public:
	vector<vector<int>> subsets(vector<int>& nums) {
		vector<int> item;
		vector<vector<int>> result;
		generation(0, nums, item, result);
		return result;
	}
};
int main() {
	vector<int> nums;
	nums.push_back(1);
	nums.push_back(2);
	nums.push_back(3);
	vector<vector<int>> result = Solution().subsets(nums);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout <<result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

LeetCode 79 单词搜索

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Solution {
public:
	bool exist(vector<vector<char>>& board, string word) {
		if (board.empty() || board[0].empty()) return false;
		int m = board.size(), n = board[0].size();
		vector<vector<bool>> visited(m, vector<bool>(n));
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j) {
				if (search(board, word, 0, i, j, visited)) return true;
			}
		}
		return false;
	}
	bool search(vector<vector<char>>& board, string word, int idx, int i, int j, vector<vector<bool>>& visited) {
		if (idx == word.size()) return true;
		int m = board.size(), n = board[0].size();
		if (i < 0 || j < 0 || i >= m || j >= n || visited[i][j] || board[i][j] != word[idx]) return false;
		visited[i][j] = true;
		bool res = search(board, word, idx + 1, i - 1, j, visited)
			|| search(board, word, idx + 1, i + 1, j, visited)
			|| search(board, word, idx + 1, i, j - 1, visited)
			|| search(board, word, idx + 1, i, j + 1, visited);
		visited[i][j] = false;
		return res;
	}
};
int main() {
	vector<vector<char>> board = 
	        {
		    {'A', 'B', 'C', 'E'},
			{'S', 'F', 'C', 'S'},
			{'A', 'D', 'E', 'E'}
	        };
	string word = "ABCCED";
	bool res = Solution().exist(board, word);
	cout << res << endl; 
	system("pause");
	return 0;
}

LeetCode 90 子集2

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

class Solution {
public:
	vector<vector<int>> subsetsWithDup(vector<int> &S) {
		if (S.empty()) return {};
		vector<vector<int>> res;
		vector<int> out;
		sort(S.begin(), S.end());
		getSubsets(S, 0, out, res);
		return res;
	}
	void getSubsets(vector<int> &S, int pos, vector<int> &out, vector<vector<int>> &res) {
		res.push_back(out);
		cout << endl;
		for (int i = pos; i < S.size(); ++i) {
			out.push_back(S[i]);
			getSubsets(S, i + 1, out, res);
			out.pop_back();
			while (i + 1 < S.size() && S[i] == S[i + 1]) 
				++i;
		}
	}
};
int main() {
	vector<int> nums = {2,1,2,2};
	vector<vector<int>> result = Solution().subsetsWithDup(nums);
	for (int i = 0; i < result.size(); i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

LeetCode 93 复原IP地址

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>

using namespace std;

class Solution {
public:
	vector<string> restoreIpAddresses(string s) {
		vector<string> res;
		restore(s, 4, "", res);
		return res;
	}
	void restore(string s, int k, string out, vector<string> &res) {
		if (k == 0) {
			if (s.empty()) res.push_back(out);
		}
		else {
			for (int i = 1; i <= 3; ++i) {
				if (s.size() >= i && isValid(s.substr(0, i))) {
					if (k == 1) restore(s.substr(i), k - 1, out + s.substr(0, i), res);
					else restore(s.substr(i), k - 1, out + s.substr(0, i) + ".", res);
				}
			}
		}
	}
	bool isValid(string s) {
		if (s.empty() || s.size() > 3 || (s.size() > 1 && s[0] == '0')) return false;
		int res = atoi(s.c_str());
		return res <= 255 && res >= 0;
	}
};
int main() {
	string s = "25525511135";
	vector<string> result = Solution().restoreIpAddresses(s);
	for (int i = 0; i < result.size(); i++) {
		cout << result[i] << endl;
	}
	system("pause");
	return 0;
}

LeetCode 131 分隔回文串

如果原字符串是 abcd, 那么访问顺序为: a -> b -> c -> d -> cd -> bc -> bcd-> ab -> abc -> abcd, 这是对于没有两个或两个以上子回文串的情况。那么假如原字符串是 aabc，那么访问顺序为：a -> a -> b -> c -> bc -> ab -> abc -> aa -> b -> c -> bc -> aab -> aabc。
在这里插入图片描述

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Solution {
public:
	vector<vector<string>> partition(string s) {
		vector<vector<string>> res;
		vector<string> out;
		helper(s, 0, out, res);
		return res;
	}
	void helper(string s, int start, vector<string>& out, vector<vector<string>>& res) {
		if (start == s.size()) { 
			res.push_back(out); 
			return;
		}
		for (int i = start; i < s.size(); ++i) {
			if (!isPalindrome(s, start, i)) continue;
			out.push_back(s.substr(start, i - start + 1));
			helper(s, i + 1, out, res);
			out.pop_back();
		}
	}
	bool isPalindrome(string s, int start, int end) {
		while (start < end) {
			if (s[start] != s[end]) return false;
			++start; --end;
		}
		return true;
	}
};

int main() {
	string s = "aabc";

	vector<vector<string>> res = Solution().partition(s);
	for (int i = 0; i < res.size(); i++) {
		for (int j = 0; j < res[i].size(); j++) {
			cout << res[i][j] << " ";
		}
	}
	system("pause");
	return 0;
}
知行SUN
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 78题：子集 回溯法
01-21
回溯法本质是尝试所有的可能性，并把符合条件的可能记录下来，不符合的情况及时退出的一种方法。下面我们通过两个具体的题目来深刻理解回溯法的思想。 第一题：子集 题目分析：数组长度为n的数组的所有子集，其长度...
LeetCode算法之----回溯
程序大视界
01-07 928
回溯算法
Leetcode回溯法
baidu_41553551的博客
04-03 746
回溯法是复杂度很高的暴力搜索算法，实现简单且有固定模板，常被用于搜索排列组合问题的所有可行解。不同于普通的暴力搜索，回溯法会在每一步判断状态是否合法，而不是等到状态全部生成后再进行确认。当某一步状态非法时，它将回退到上一步中正确的位置，然后继续搜索。前进和后退是回溯法关键的动作。 回溯的本质就是暴力枚举所有可能。要注意的是，由于回溯通常结果集都记录在回溯树的路径上，因此如果不进行撤销操作， 则可能在回溯后状态不正确导致结果有差异， 因此需要在递归到底部往上冒泡的时候进行撤销状态。 如果你每次递归的过
图解 LeetCode 算法汇总——回溯
最新发布
qq_42700121的博客
09-11 784
回溯算法尝试在问题的解空间中搜索可能的解，并在搜索过程中进行选择、撤销选择和终止搜索，直到找到解或确定无解为止。通常通过递归函数来实现回溯算法。在每一步，需要做出选择（选择一个分支）然后递归地探索该选择的结果。在递归返回后，需要撤销之前的选择，以便继续探索其他分支。使用条件语句或循环来控制选择的范围和条件。
LeetCode之回溯算法
ji_meng的博客
05-09 720
（如果要问为什么还需要startIndex，因为这还是组合问题啊，也就是不能走回头路，比如[1,2,3]，目标和是4，你可以选[1,1,2]，如果没有startIndex，当你到2的时候，又会有[2,1,1]的可能！首先需要建立一个映射，从字符2-9映射到字母，可以hash可以数组。输入：nums = [1,2,2] 输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
Leetcode--------回溯法
qq_40128284的博客
08-05 254
回溯法模板： 回溯三部曲： 回溯函数模板返回值以及参数，习惯是函数起名字为backtracking 回溯函数终止条件 if (终止条件) { 存放结果; return; } 回溯搜索的遍历过程 总结： void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { 处理节点;
leetcode详解.zip_leetcode_leetcode详解
07-15
程序员招工组必备，leetcode刷题中文详解，迅速提升代码能力
leetcode——-解数独(回溯法)
01-20
重要：对于回溯法，一定会有个[规则]，这个[规则]将会决定是否回退，所以当我们在使用回溯法时，一定要留意能否构建[规则]。 如这一题，在数独中，规则就是： 1. 在同一列和同一行中，不能出现一样的数字。 2. 在同...
LeetCode算法详解
07-13
5. 回溯法：当面临多个选择时，尝试所有可能的路径，直到找到解决方案或确定无解，然后回溯撤销前一步。 6. 分治策略：将大问题分解为小问题，独立解决后再合并答案。 三、问题求解策略 1. 枚举：对所有可能的解...
leetcode思维导图-回溯
08-13
leetcode思维导图-回溯
leetcode之回溯算法
can_chen的博客
02-01 709
目录一 组合问题1. leetcode 77.组合2. leetcode 39.组合总和3. leetcode 40.组合总和II4. leetcode 216.组合总和III5. leetcode 377.组合总和IV6. leetcode 17.电话号码的字母组合二 排列问题1. leetcode 46.全排列2. leetcode 47.全排列II 一 组合问题 1. leetcode 77.组合 leetcode 77.组合 题目描述： 给定两个整数 n 和 k，返回 1 … n 中所有可能的 k
Leetcode学习之回溯算法
frighting_ing的博客
11-14 4472
1. 回溯算法理论基础 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以回溯函数也就是递归函数，指的都是一个函数。 回溯法的效率 回溯法的性能如何呢，必须强调的是，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，**如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回
【LeetCode】-回溯算法
银尘博客
03-22 2254
文章目录前言一、组合 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、组合 题目： 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3],
回溯算法小结（leetcode回溯题集合）
qq_36309684的博客
10-24 474
回溯算法小结 回溯法定义 回溯法：采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 上面说到回溯法在试错的过程中，会取消上一步或者几步的操作，从而开始进行其它的尝试。这时候的这个过程，
力扣刷题框架——回溯法
qq_36919342的博客
07-20 190
回溯法来啦1. 全排列问题1.1 题目描述1.2 解题思路 这篇来讲讲回溯法，其实就是DFS(深度优先搜索)解决一个回溯问题，实际上就是一个决策树的遍历过程。考虑三个问题： 路径：也就是已经做出的选择。 选择列表：也就是你当前可以做的选择。 结束条件：也就是到达决策树底层，无法再做选择的条件。 代码框架： result = [] def backtrack(路径, 选择列表): if 满足结束条件: result.add(路径) return f
力扣46.全排列（回溯法）
qq_56932198的博客
09-18 936
力扣46.全排列（回溯法）
力扣专题. 回溯法
爱学习i的博客
10-06 556
1. 回溯法与深度遍历的联系以及不同点： 回溯法采用试错的思想，它尝试分步的去解决一个问题。当它发现分步的答案不能得到有效的解决时就会退回上一步甚至上几步。回溯法通常用递归的方法来解决。 深度遍历是树的一种遍历方法，它强调的是一头扎到底然后再往回走的途中去遍历其它结点，这个过程会一直持续到初始的根结点。 2.回溯法与动态规划的区别和共同点： 共同点： 一个问题都能够分为很多步骤来解决； 每一个步骤包含了很多种选择； 不同点： 动态规划强调的是问题的最优解，它只需要知道最终的结果； 回溯可以搜索到问
Leetcode 回溯法详解
若明天不见
02-12 820
本文为回溯法详解及相关题型的解答思路。回溯法有“通用解题法”之称。用它可以系统地搜索问题的所有解。回溯法是一个既带有系统性又带有跳跃性的搜索算法。
LeetCode题解之回溯算法
wenxingxingxing的博客
06-08 396
回溯算法回溯算法要点组合问题77. 组合216. 组合总和 III39. 组合总和40. 组合总和 II 回溯算法要点 回溯法，⼀般可以解决如下⼏种问题： 组合问题： N个数⾥⾯按⼀定规则找出k个数的集合 切割问题：⼀个字符串按⼀定规则有⼏种切割⽅式 ⼦集问题：⼀个N个数的集合⾥有多少符合条件的⼦集 排列问题： N个数按⼀定规则全排列，有⼏种排列⽅式 棋盘问题： N皇后，解数独等等 回溯模板三部曲： 1. 回溯函数模板返回值以及参数，返回值一般为void 2. 回溯函数终止条件 3. 回溯搜索的遍历过程 回
leetcode 回溯
08-22
在LeetCode上，有许多使用回溯算法的题目。 回溯算法的基本思想是通过深度优先搜索，不断地尝试下一个可能的解，如果当前解不符合要求，则回退到上一个状态，继续尝试其他可能的解。这种方式有点类似于穷举法，但是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

知行SUN

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值