刷题套路总结：

双指针：

单调性；对两端按照规律进行操作移动；
常见移法，右指针右移扩大范围，左指针左移缩小范围；
先举例模拟，然后推导公式；

递归，回溯 ：

原问题，拆分为子问题
怎么往下递，怎么往上归
边界条件逻辑写对
模版：

子集型回溯、组合型回溯、排列型回溯

0,1背包也可看成一种子集型回溯 （打家劫舍类似也可以）

子集型回溯，本质就是看对每一个元素，是选它，还是不选它，

两种解法：

第一种思路，选还是不选每一个元素

class Solution {    
public:
    vector<int>path;
    vector<vector<int>>res;
    void dfs(int i,int n, vector<int>& nums)
    {
        if(i==n)
        {
            res.push_back(path); // 这里表示只有到第n层，才算确定一种path答案
            return; 
        }
        // 不选 nums[i]
        dfs(i+1,n,nums);
        // 选 nums[i]
        path.push_back(nums[i]);
        dfs(i+1,n,nums);
        path.pop_back();

    }
    vector<vector<int>> subsets(vector<int>& nums) {
        int n=nums.size();
        dfs(0,n,nums);
        return res;

    }
};

第二种思路，每次进行枚举选一个严格递增的元素，这里由于子集的长度没有约束，所以每种长度都可以是答案。

class Solution {
public:
    vector<int>path;
    vector<vector<int>>res;
    void dfs(int i,int n, vector<int>& nums)
    {
        res.push_back(path); // 这里表示任意到一层，都算一种path答案
        if(i==n)
        {
            return; 
        }
        for(int j=i;j<n;j++)
        {
            // 枚举每次选的nums[i]
            path.push_back(nums[j]);
            dfs(j+1,n,nums);
            path.pop_back();
        }


    }
    vector<vector<int>> subsets(vector<int>& nums) {
        int n=nums.size();
        dfs(0,n,nums);
        return res;

    }
};

组合型回溯，相比子集型回溯，是有额外的一些限制（优化）条件的，常见条件：选k个数，选的数求和为target，针对这些条件进行一定的剪枝操作；

倒着枚举， 从n开始；剪枝操作

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>>ans;
        vector<int>path;
        function<void(int)>dfs=[&](int i)
        {
            int d=k-path.size();
            if(d==0)
            {
                ans.push_back(path);
                return;
            }
            for(int j=i;j>=d;j--) //减枝
            {
                path.push_back(j);
                dfs(j-1);
                path.pop_back();
            }
        };
        dfs(n);
        return ans;

    }
};

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>>ans;
        vector<int>path;
        function<void(int,int)>dfs=[&](int i,int t)
        {
            int d=k-path.size();
            if(t<0 || t>((i*2-d+1)*d/2))  // 不可能符合和为t的条件  减枝
            {
                return;
            }
            if(d==0)
            {
                ans.push_back(path);
                return;
            }
            for(int j=i;j>=d;j--) //减枝 ，个数不够k，
            {
                path.push_back(j);
                dfs(j-1,t-j);  // 和减去枚举的数
                path.pop_back();
            }
        };
        dfs(9,n);
        return ans;

    }
};

字符串
C++语法
digits[i] - ‘0’ 是一个常见的编程技巧，用于将字符型数字转换为整数型。
在ASCII码表中，字符’0’到’9’的编码是连续的，因此通过减去字符’0’的ASCII码值（即48），可以将字符型数字转换为对应的整数值。
digits[i] + ‘0’ 是将整数型数字转换为字符型数字的技巧。
在ASCII码表中，字符’0’到’9’的编码是连续的，因此通过加上字符’0’的ASCII码值（即48），可以将整数值转换为对应的字符型数字。