（1）动态规划

动态规划是算法当中比较难的内容，在leetcode上关于动态规划的题目也不在少数。动态规划的核心想法是要列出状态方程。需要找到可以用来递推的关系，这一点上与递归不谋而合。

动态规划的突出优点是代码的简介性和运算的快速性。今天在刷到lc上的115题 不同的子序列时，这道题只有用动态规划才能解出来。leetcode上的题目大多有时间限制，在这种情况下动态规划就显得尤为重要。动态规划常用于来得出某些情况的特征，而不能得出详细的子集。

以下是不同的子序列使用动态规划解题的官方代码：

class Solution {
public:
    int numDistinct(string s, string t) {
        clock_t start,end;
        start=clock();
        int m = s.length(), n = t.length();
        if (m < n) {
            return 0;
        }
        vector<vector<long>> dp(m + 1, vector<long>(n + 1));
        for (int i = 0; i <= m; i++) {
            dp[i][n] = 1;
        }
        for (int i = m - 1; i >= 0; i--) {
            char sChar = s.at(i);
            for (int j = n - 1; j >= 0; j--) {
                char tChar = t.at(j);
                if (sChar == tChar) {
                    dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j];
                } else {
                    dp[i][j] = dp[i + 1][j];
                }
            }
        }
        end=clock();
        cout << "The run time is: " <<(double)(end - start) / CLOCKS_PER_SEC << "s" << endl;
          return dp[0][0];
    }
};

使用自己创造例子所花的时间为：

（2）回溯法

回溯法实质上是对所有子集的暴力搜索。虽然中间增加了剪枝操作，但是所花费时间相当之多。时间复杂度也很大。如果不是要求求出具体子集的问题 ，使用回溯法绝对是错的，你会得到超出时间限制的回馈。但是本着增强对递归的理解，遇到可以使用回溯法写出来的题还是忍不住。
回溯法，主要是要找到所有有可能的子集，为了减少时间中间可以增加剪枝操作，不符合条件的树枝直接剪除。下面是使用回溯法来写115题的代码

class Solution {
public:
int a ;
int b;
int ans=0;
    int numDistinct(string s, string t) {
        clock_t start,end;
        start=clock();
        a=t.length();
        b=s.length();
        string ret;
        dfs(s,t,ret,0);
        end=clock();
        cout << "The run time is: " <<(double)(end- start) / CLOCKS_PER_SEC << "s" << endl;
        return ans;

    }
  
        void dfs(string &s,string &t,string &ret,int value){
        if(ret.size()==a){
         if(t==ret){
         ans++;}
         return ;}//设置出口
         for(int c=value;c<b;c++){
          if(ret.size()==0||ret.back()==t[ret.size()-1]){//剪枝操作
            ret.push_back(s[c]);//赋值
            dfs(s,t,ret,c+1);//递归操作
            ret.pop_back();//为下一种可能腾出位置出来，保证子集间的独立性，互不干扰
          }
            
        }
        return;
    }
};//回溯法

下面列出回溯法解决同样例子的时间
可以看到花费的时间相差巨大，而且例子越复杂就相差越大，这也在意料之中。因为动态规划就像解方程一样只需要得出结果，使用回溯法则需要得出所有的子集。