Java 给定一个字符串S和一个字符串T，计算S中T的不同子序列数

大家好：有人能给我解释一下这个算法是如何工作的吗？我不理解这个机制。谢谢

问题：给定一个字符串S和一个字符串T，计算S中T的不同子序列数

字符串的子序列是一个新字符串，它是通过删除某些字符（可以是无字符）而从原始字符串中形成的，而不会干扰其余字符的相对位置。（即，“ACE”是“ABCDE”的子序列，而“AEC”不是）

以下是一个例子： S=“rabbit”，T=“rabbit”

返回3

解决方案：

public int numDistincts(String S, String T)
{
  int[][] table = new int[S.length() + 1][T.length() + 1];

  for (int i = 0; i < S.length(); i++)
      table[i][0] = 1;

  for (int i = 1; i <= S.length(); i++) {
      for (int j = 1; j <= T.length(); j++) {
          if (S.charAt(i - 1) == T.charAt(j - 1)) {
              table[i][j] += table[i - 1][j] + table[i - 1][j - 1];
          } else {
              table[i][j] += table[i - 1][j];
          }
      }
  }

  return table[S.length()][T.length()];
}

public int numDistincts（字符串S，字符串T）
{
int[]table=新的int[S.length（）+1][T.length（）+1]；
对于（int i=0；i对于（int i=1；i首先，请注意+=也可以是=，因为[i][j]的每个组合只访问一次-事实上=会更好，因为它不必使用Java中int初始化为0的事实

这是一个动态的编程解决方案。表[i] [j]在只考虑S的第一个I字符和T.
的第一个I字符时，结束存储答案。
第一个循环说，如果T是零长度字符串，那么S中T的唯一子序列就是零长度子序列——其中有一个

第二个循环将S的第i个字符与T的第j个字符进行比较，同时这两个字符都是要处理的短字符串的最后一个字符。如果这些字符不匹配，S中T的唯一子序列也是S的子序列，最后一个不匹配的字符被截断，我们已经在表[i-1]中计算了这些字符[j] 。如果它们确实匹配，则会有额外的子序列与最后一个字符匹配。如果从子序列中去掉最后一个字符，则会从T段中找到一个子序列，其中一个字符被删除，另一个字符与S中的一个字符被删除，并且您已经在表[i-1][j-1]中对其进行了计数-因此，对于匹配，答案是表[i-1][j]+表[i-1][j-1]

当然，在最后，您会发现您已经在表[S.length][T.length]
中使用O（m*n）空间计算了S和T的全长答案，其中m是S的长度，n是T的长度。下面是只有O（n）空间的解

公共类解决方案{
public int numDistinct（字符串s，字符串t）{
如果（s==null | | t==null | | t.length（）==0）返回0；
int[]dp=新的int[t.length（）]；
对于（int i=0；i=0；j--）{
如果（c==t.charAt（j））{
dp[j]=dp[j]+（j！=0？dp[j-1]：1）；
}  
}  
}  
返回dp[t.length（）-1]；
}  
}  

从。
您可能会在cs.stackexchange.com或programmers.stackexchange.com上得到更好的响应，只需试着用您的rabbbit示例进行一次试运行即可。
public class Solution {  
    public int numDistinct(String s, String t) {  
        if(s == null || t == null || t.length() == 0) return 0;  
        int[] dp = new int[t.length()];  

        for(int i = 0; i<s.length(); i++){  
            char c = s.charAt(i);  
            for(int j=dp.length-1; j>=0; j--){  
                if(c == t.charAt(j)){  
                    dp[j] = dp[j] + (j!=0?dp[j-1]: 1);  
                }  
            }  
        }  
        return dp[t.length()-1];  
    }  
}