回溯模板全解

已于 2022-09-11 14:42:02 修改
阅读量638 收藏 4
点赞数 3
分类专栏： 算法日记 文章标签： 算法 c++ leetcode 逻辑回归 深度优先
于 2022-09-04 20:18:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxxxxx123491857/article/details/126693243
版权

目录

​编辑

什么是回溯法

回溯法效率

回溯法解决的问题

回溯抽象成树

基础模板

题目一：77. 组合

题目二：216. 组合总和 III

 题目三：17. 电话号码的字母组合

什么是回溯法

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。其实是每一次递归后再返回上一层，由单一深度搜索拓宽为深度加广度搜索。

回溯法效率

回溯法其实是一个穷尽所有可能的算法，本质是穷举。那为什么不直接用多层for循环呢？ 因为你无法确定for循环的层数，只能通过递归来层层深入。

回溯法解决的问题

  1. 需要穷尽所有可能，并且无法确定for循环层数。
  2. 组合问题：N个数里面按一定规则找出k个数的集合
  3. 切割问题：一个字符串按一定规则有几种切割方式
  4. 子集问题：一个N个数的集合里有多少符合条件的子集
  5. 排列问题：N个数按一定规则全排列，有几种排列方式
  6. 棋盘问题：N皇后，解数独等等

同时此类题必有标注，可以按任意顺序返回。

回溯抽象成树

因为即有深度又有广度，所以所有回溯问题都可以抽象转化成树。

---------------------------------------------------------------------------------------------------------------------------------

基础模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

---------------------------------------------------------------------------------------------------------------------------------

题目一：77. 组合

解析：首先提供两个容器 ，第一个容器ans用来保存最终的答案，path用来保存每一条路径上的答案，如果符合条件再将它放入ans容器中。

        vector<vector<int>> ans;
        vector<int> path;

          写终止条件，根据题目要求找寻k个数的组合，所以如果path中的数达到k个的时候就应该将答案放入ans中。

        if(path.size()==k)
        {
            ans.push_back(path);
            return;
        }

      

 for循环代表当 前层数的所有可能选择，比如说你在第一层，则你有四种选择，分别是1，2，3，4

然后通过递归，进入下一层。这里引用startIndex做为起始位置标志，因为当层数不断深入的时候

起始位置是i+1 ，因为第 i 项在上一层已经取过，如果下次递归的起始位置不从i+1开始的话会导致重复。

       for(int i=startIndex;i<=n;i++)
        {
            path.push_back(i);
            backtracking(n,k,i+1);
            path.pop_back();
        }

 当一个path结束后自动上升一层，此时就要进行回溯，实际上是弹出path中的一个元素，这时候for循环在这一层刚好后移一位，同时path缺少一个元素。再push进去一个元素，进入下一层递归，刚好满足要求，以此类推。

       整体

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(int n,int k,int startIndex)
    {
        if(path.size()==k)
        {
            ans.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) {
        backtracking(n,k,1);
        return ans;
    }
};

---------------------------------------------------------------------------------------------------------------------------------

题目二：216. 组合总和 III

解析：提供容器，第一个容器ans用来保存最终的答案，path用来保存每一条路径上的答案，如果符合条件再将它放入ans容器中。

      vector<vector<int>> ans;
      vector<int> path;

          先明确终止条件是什么，目标是找到相加之和为n的k个元素。分析可知，实际上有两个终止条件，第一个是path的长度必须为k，第二是path元素相加之和为n。

          这里运用逆向思维，相加为n实际上就是，总和n每次都减去元素的值。最后刚好为零的path为所求path。

        if(path.size()==k)
        {
            if(n==0)
            {
                ans.push_back(path);
            }
            return;
        }

       

 如图所示，这幅图我没有标记的很全面，为的是让读者自己认真看图思考一下。其实你会发现，每一个匡都是一个for循环里面可选择的数据。 为什么越往下走，匡里面可循环的元素越来越少呢？是因为你在递归，每次的startIndex都会往前进一位。其实横着看是上一层所有可能选择，竖着看是单一的一条path。

        for(int i=startIndex;i<=9;i++)
        {
            path.push_back(i);
            n=n-i;
            backtracking(k,n,i+1);
            n=n+i;
            path.pop_back();
        }

  每次递归都要把n减去元素i，当满足题目条件，即 n 为 0 的时候证明已经找到了k个元素相加和为n。此时要进行回溯，n 加上 i 返回上一层的for循环直到所有的遍历结束。

  整体

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(int k,int n,int startIndex)
    {
        if(path.size()==k)
        {
            if(n==0)
            {
                ans.push_back(path);
            }
            return;
        }

        for(int i=startIndex;i<=9;i++)
        {
            path.push_back(i);
            n=n-i;
            backtracking(k,n,i+1);
            n=n+i;
            path.pop_back();
        }
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(k,n,1);
        return ans;
    }

};

---------------------------------------------------------------------------------------------------------------------------------

 题目三：17. 电话号码的字母组合

          提供容器ans来接收所有字母组合，让后s 相当于path。

          要提前处理一下按键上的字母组合，把题目上的按键转化为string 数组。同时思考一下，本体和上面题目的区别，本题样本区间取自两个字符串，但是上面题目中的取自都是一个字符串。这一点区别将会为我们如何递归埋下伏笔，也就是startIndex到底该怎么选。

 例如 "abc"  和  "def"  单层先选取 "a"  下一层选取的可不是 "b"  而是 "d"。所以startIndex不能是简单的 i+1 ，需要改变样本区间。

    const string letterMap[10]={
        "","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"
    };
    vector<string> ans;
    string s;

          终止条件非常简单，当组合 s 的长度 等于 digits 的长度的时候就可以结束了。

        if(index==digits.size())
        {
            ans.push_back(s);
            return;
        }

这里重点讲解index的含义是什么，相当于之前的startIndex，但是我们在此基础上动了一些手脚，index实际上是从前到后扫描 digits，让后得到的char 减去起始 ‘0’ 就可以得到到底样本区间是哪一个数字按键。

        int digit=digits[index]-'0';
        string letter=letterMap[digit];
        for(int i=0;i<letter.size();i++)
        {
            s.push_back(letter[i]);
            backtracking(digits,index+1);
            s.pop_back();

        }

到此为止，本题和上面没有什么真正的逻辑上的区别，从逻辑难度来说实际上是比较简单的，因为本体唯一的收取path的限制条件仅仅是长度罢了。其他都是照猫画虎。

看上去复杂是因为，取样本区间竟然不是在一个string当中，而是在两个string区间所取的，同时我们要预先处理一下按键字符。

class Solution {
public:
    const string letterMap[10]={
        "","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"
    };
    vector<string> ans;
    string s;
    void backtracking(const string& digits,int index)
    {
        if(index==digits.size())
        {
            ans.push_back(s);
            return;
        }
        int digit=digits[index]-'0';
        string letter=letterMap[digit];
        for(int i=0;i<letter.size();i++)
        {
            s.push_back(letter[i]);
            backtracking(digits,index+1);
            s.pop_back();

        }
    }
    vector<string> letterCombinations(string digits) {
        if(digits.size()==0) return ans;
        backtracking(digits,0);
        return ans;
    }
};

---------------------------------------------------------------------------------------------------------------------------------

题目四：90. 子集 II

      

          提供容器，老样子提供单条路径path，让后提供所有情况接收容器ans。

    vector<vector<int>> ans;
    vector<int> path;

          本题没有限制，只要是他的子集就可以。 既然没有要求，那么不用写终止条件，同时并不再是一条路只收取一个path，而是一条路上各层之间的path都要收取。

         同层递进减枝：这一部分是重难点，请读者认真阅读。

 通过树形图展开可以发现，同层元素是不能重复的，不然会有重复的path加入到ans当中。但是上下层是可以有重复元素的比如（1，2，2）。

那么，既然有重复我们怎么去重呢? 我们可以使用条件nums[i]==num[i-1] 的时候直接跳过，有些同学会问，为什么不是nums[i]==nums[i+1]的时候跳过呢？

你仔细想一下，当我们进行对比的时候nums[i]==nums[i+1] 我们进行了元素装填么？我是先判断，才把元素放入path中，那么问题来了如果我直接判断第 i 和 i+1项的时候，实际上第 i 和 i+1 项都还没有处理呢。然后你就直接跳过第 i 项了。那么请问你的（1，2，2）三元素集合怎么来？你不是跳过了一个么？？

所以我们需要预先处理再进行判断，如何预先处理？ 那就是nums[i-1]==nums[i]时候跳过，你都到第 i 项了，你 i - 1 项必然已经处理了啊。发现 i 和 i - 1项一样，直接跳过第 i 项不就行了，i - 1项预先处理过在path里了。 

            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();

  你以为到这就结束了？？太年轻，太年轻了。为什么我要强调同层去重和上下层去重？？ 你设立的条件nums[i-1]==nums[i] 针对上下层和同层都适用啊，你上下层startIndex是i+1，那么假如你是（1，2）还余留了一个2，当你进入下一层的时候，本应该是（1，2，2）。结过你一对比，发现俩 2 一样就直接跳过最后一个2了。那么你大错特错！！！

这里引入bool 标志，上下层处理过就把used标明true，代表可以重复。递归结束后，就要进行回溯了，那么必然会回到上层的for循环中，同层不能重复，所以used标明false。

让后判断的时候有两个条件 nums[i-1]==nums[i] && used=false;

lass Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex,vector<bool>& used)
    {
        ans.push_back(path);
        for(int i=startIndex;i<nums.size();i++)
        {
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }
    }


    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,0,used);
        return ans;
    }
};

到此分析完毕，掰开揉碎，只为精品。

---------------------------------------------------------------------------------------------------------------------------------

题目五：46. 全排列

          提供容器

    vector<vector<int>> ans;
    vector<int> path;

          终止条件

        if(path.size()==nums.size())
        {
            ans.push_back(path);
            return;
        }

         同层起始减枝叶

        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }

          整体

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex,vector<bool>& used)
    {
        if(path.size()==nums.size())
        {
            ans.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,0,used);
        return ans;
    }
};

题目六：491. 递增子序列

          提供容器

    vector<vector<int>> ans;
    map<vector<int>,int> mp;
    vector<int> path;

          终止条件

        if(path.size()>=2&&path[path.size()-2]<=path[path.size()-1])
        {
            mp[path]++;
        }else if(path.size()>=2&&path[path.size()-2]>path[path.size()-1])
        {
           return;
        }

       递归

        for(int i=startIndex;i<nums.size();i++)
        {

            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }

     最后 整体 去重

class Solution {
public:
    vector<vector<int>> ans;
    map<vector<int>,int> mp;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex)
    {
        if(path.size()>=2&&path[path.size()-2]<=path[path.size()-1])
        {
            mp[path]++;
        }else if(path.size()>=2&&path[path.size()-2]>path[path.size()-1])
        {
           return;
        }
        for(int i=startIndex;i<nums.size();i++)
        {

            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        for(auto a:mp)
        {
            ans.push_back(a.first);
        }
        return ans;
    }
};

---------------------------------------------------------------------------------------------------------------------------------

题目七：47. 全排列 II
 

           提供容器

    vector<vector<int>> ans;
    map<vector<int>,int> mp;
    vector<int> path;

         递归

        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }

          终止条件

        if(path.size()==nums.size())
        {
            mp[path]++;
            return;
        }

         双重去重

class Solution {
public:
    vector<vector<int>> ans;
    map<vector<int>,int> mp;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex,vector<bool> & used)
    {
        if(path.size()==nums.size())
        {
            mp[path]++;
            return;
        }

        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,0,used);
        for(auto a:mp)
        {
            ans.push_back(a.first);
        }
        return ans;
    }
};

Revenge2322
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
蓝桥杯一周冲刺夺奖计划-枚举法
qq_53283658的博客
04-07 607
枚举算法的思想： 将问题的所有可能成为答案的解一一列举，然后根据问题所给出的条件判断此解是否合适，如果合适就保留，反之则舍弃。 枚举算法解题的基本思路： 确定枚举解的范围，以及判断条件 选取合适枚举方法，进行逐一枚举，此时应注意能否覆盖所有的可能的解 在枚举时使用判断条件检验，留下所有符合要求的解。 枚举算法的一般步骤： 根据题目确定枚举的范围，并选取合适的枚举方式，不能遗漏任何一个真正解，同时避免重复。 为了提高解决问题的效率，看题目是否存在优化，将可能成为解的答案范围尽可能的缩小。 根据
回溯算法及解题模板
Peealy的博客
11-20 2141
文章目录1. 什么是回溯算法？2. 回溯算法的框架3. 针对不同题型的解题模板1.所给数组中的元素互不相同，结果包含所有元素总结 1. 什么是回溯算法？     回溯算法其实是一种穷举的搜索方法，利用回溯解决问题就是在穷举所有的可能，然后找到我们想要的答案。使用回溯算法时需要考虑如下的三个问题：     (1) 可选列表：所有可作出的选择；     (2) 已选列表：也就是之前已经做出的选择；     (3) 结束条件：当已选列表满足题目条件，可以结束穷举； 2. 回溯算法的框架 vector&l
字母异位——从LeetCode题海中总结常见套路
沉迷单车的追风少年
07-09 552
字母异位词在NLP领域中很有用处，同时最早在十几年前微软的面试中被奉为经典，这类题可以涉及哈希表、滑动窗口、、动态规划、双指针等综合知识点，其中也是套路满满，奇技淫巧也是层出不穷，这里仅仅总结一下常见的套路，求道不求术，小众方法、歪门邪道暂且不表。 目录 最主要的套路有两个： 套路入门级：LeetCode242.有效的字母异位词 建立哈希表法 建立26个字母表法 建立字母表：LeetCode1347.制造字母异位词的最小步骤 建立哈希表法：LeetCode49.字母异位词分组 多种套路：Le
回溯算法模板要义及题型总结
如月之恒，如日之升
10-14 238
回溯算法分总结
Leetcode二分查找5:2089. 找出数组排序后的目标下标
weixin_63714970的博客
03-18 214
Leetcode二分查找5:2089. 找出数组排序后的目标下标
python 回溯法模板详解
09-17
回溯法是一种有效的算法策略，用于解决组合优化问题，它通过尝试所有可能的解决方案，并在遇到无效或错误的路径时回溯，...通过理解这些基本概念和示例代码，你可以根据实际问题调整回溯法模板，解决各种组合优化问题。
质量回溯报告模板.ppt
01-06
一个比较完善、标准的质量回溯报告模板；适用于事件回溯、技术漏洞回溯、生产事故回溯、漏测事件回溯等，欢迎大家下载使用并交流。
华为软件测试回溯模板
09-01
【华为软件测试回溯模板】是华为公司供应链质量管理部用于质量提升的一种方法，它结合了根本原因分析（Root Cause Analysis, RCA）和持续改进的过程。质量回溯的主要目的是通过深入探究问题的根源，找到问题产生的...
质量回溯报告单模板下载
最新发布
06-05
对于系统中提交到现场后，发生了质量问题后，需要进行5W1H进行追溯，该模板提供了详细的追溯格式，和举一反三的处理步骤。
回溯算法详解
Go-Hello的博客
07-29 663
回溯算法详解
回溯法常用的解题模板和常见题型
tangyuan_sibal的博客
05-24 1345
文章目录1、什么是回溯法2、通用框架3、模板测试1、subSet2、Permutations3、 Combination Sum4、Palindrome Partitioning4、总结 1、什么是回溯法 wiki上面是这么说的 在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索...
面试必看算法题 | 回溯算法解题框架
weixin_49559515的博客
01-14 836
目录 1. 概述 1.1 回溯思想 回溯算法（Backtrack）是一种试错思想，本质上是深度优先搜索。即：从问题的某一种状态出发，依次尝试现有状态可以做出的选择从而进入下一个状态。递归这个过程，如果在某个状态无法做更多选择，或者已经找到目标答案时，则回退一步甚至多步重新尝试，直到最终所有选择都尝试过。 整个过程就像走迷宫一样，当我们遇到一个分叉口时，可以选择从一个方向进去尝试。如果走到死胡同则返回上一个分叉口，选择另外一条方向继续尝试，直到发现没有出口，或者找到出口。 1.2 回溯的三要素 理解了回.
读书时间--回溯法浅析：逆向思维领略算法之美
weixin_34080571的博客
07-28 280
下面将使用回溯思想解决若干经典问题并通过它们来说明使用回溯的基本思路 什么叫回溯法 回溯是一种比较简单、比较常用的搜索策略。 它的基本思想是假设某问题的解决步骤可能有N步，且每一步的解决方法又可能有M种，那么就按照某种顺序依次试探每一步中的各种方法，一旦某一步的所有方法都失效，那么就返回上一步继续试探上一步骤的其他M−1种方法。简而言之就是从一条路往前走...
leetcode的回溯算法题目用这个模板解题，一网打尽，so easy！！！
weixin_47082274的博客
06-24 480
一篇文章来讲解一下如何做leetcode回溯算法题目，这一段时间我把leetcode上面的回溯算法的题目都刷了个遍，发现了其中一些规律，所以，就想写一篇文章来总结一下，怕以后忘记。 刷完回溯算法的题目，我发现其实可以总结为三大类：子集问题、组合问题、排列问题，那这三大类都是什么意思呢，我分别举一个例子来说明。 子集问题 比如说，数组[1,2,3]，那么对应的子集问题就是，这个数组的子集有：[],[1],[2],[3],[1,3],[2,3],[1,2],[1,2,3]，这就是这个数组的子集，这一类问题在le
回溯算法模板
qq_41876456的博客
05-23 907
leetcode77 从前n个数中挑两个数 var combine = function(n, k) { const combineHepler = (n,k,startIndex)=>{ for (let i = startIndex; i <= n-(k-path.length)+1; ++i) { //startIndex开始序列 path.push(i); combineHepler(n, k, i + 1);
看完必会的回溯算法入门攻略，我奶看了都说妙
m0_62051288的博客
04-28 1234
这是一篇关于回溯算法的「详细的入门级攻略」（真的就只是「入门级」）。 回溯的含义 「回溯」本质上是「搜索的一种方式」，一般情况下，该搜索指「深度优先搜索（dfs）」。且实现上使用「递归」的方式。 从“全排列”开始 全排列是回溯最经典的应用之一，我们以全排列做基本示例，先来理解最简单的回溯是如何执行的。 LeetCode 46. 全排列 给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入样例 3 输出样例 ...
java返回上一级_java中怎么实现跳转？返回上一级
weixin_42099942的博客
02-21 5222
MenuMe=newMenu();switch(Me.menu()){case1:switch(Me.menu_1()){case1:switch(Me.menu_1_1()){case1:;break;case2:;break;//返回上一级}case2:switch(Me.menu_1_2()){case1:;break;c...Menu Me=new Menu();switch(Me.men...
C++ push方法与push_back方法 浅析
热门推荐
稚枭天卓
07-12 9万+
push与push_back是STL中常见的方法，都是向数据结构中添加元素。初识STL，对于添加元素的方法以产生混淆，这里暂对两种方法作出比较分析。此外，本文还将简述push对应的stack与queue系列，常见方法的介绍，以及与push_back相对应的vector系列常见方法介绍。详见下文。
回溯算法模板及其例题组合总和讲解（java）
xdbzdgx的博客
09-12 1284
回溯算法也是常见的算法，使用回溯法要么是求所有的可行解要么是求最优解。无论哪一种，都需要找出所有的可行解，进行比较。因此回溯法本质上还是深度优先遍历。它是将问题转换成图的深度遍历。然后沿着一个方向遍历，遍历到某个和节点的时候，判断这个节点是否可行，如果可行，则以这个节点为根进行子节点深度搜索。如果不可行，则往后退一步到父节点，然后继续判断，也就是说回溯一般使用递推的方式实现。 有上面可知，首先要将问题转化为图的形式，然后开始遍历，每一个节点的下一个节点不止一个，我们将所有的下一个节点放在一个列表里，就叫做
递归回溯和迭代回溯算法模板
07-07
递归回溯算法模板： ```python def backtrack(... if 终止条件: 处理结果 return for 选择 in 选择列表: 做选择 backtrack(...) 撤销选择 ``` 迭代回溯算法模板： ```python def backtrack(...): stack ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值