Leetcode 115 Distinct Subsequences 解题报告

Distinct Subsequences

Total Accepted: 38466 Total Submissions: 143567My Submissions
Question Solution

Given a string S and a string T, count the number of distinct subsequences of T in S.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie,

"ACE"

is a subsequence of

"ABCDE"

while

"AEC"

is not).

Here is an example:
S =

"rabbbit"

, T =

"rabbit"

Return

3

.

　　首先要读懂题意。题目中“count the number of distinct subsequences of T in S.” sequence是序列的意思，subqequence就是子序列。我们知道序列是由一个个元素排列而成。所以，题目中的“字符串T”为“字符串S”的子序列。求“字符串S”中“子序列字符串T”的个数，也就变形为：取出“字符串S”中的若干元素，顺序排列，组成“字符串T”，有多少种取法？
　　我认为上述分析思路比题目中提到的“删除元素”的思路要好。因为当T和S长度相近时，两种思路效率差不多；当S远大于T时，由于组成一次“字符串T”要删除非常多的元素，显然，效率远低于第一种思路。

　　参考 Rachel Zhang 的解题报告，同样的，我具体用了两种不同的方法去解这个题。

　　方法一：迭代+递归，具体思路是深度优先搜索（Depth First Search），但无法通过，因为TLE（Time Limit Exceeded）
　　以字符串S=“PabZcdefSghZijZkSlmZnoPqrStuZvwSxZyZ” ，字符串T=“PSZ”为例。
　　为了方便大家观察，我把'P'、'S'、'Z'在字符串S中的位置着重标出来。
　　S中元素'P'的位置=0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
　　S中元素'S'的位置=0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
　　S中元素'Z'的位置=0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
　　观察字符串。字符串中任意的元素'P'、'S'、'Z'，如果以顺序排列，则组成满足条件的字符串S"PSZ"。
　　那么我们如何保证在取'P'、'S'、'Z'的时候既是顺序排列，又不多取，不少取呢？
　　显然，用DFS就可以做到。
　　下面为不熟悉DFS的朋友具体讲个例子，高手可以直接跳过。
　　Eg:
　　先找字符串S中有几个'P'，2个: 0, 23
　　对位置为0的字符‘P’，其后面有几个'S'，4个：8，16，25，31
　　对位置为8的字符'S',其后面有几个'Z',6个：11，14，19, 28， 33， 35
　　所以'0 8 11'， '0 8 14 ', '0 8 19', '0 8 28', '0 8 28', '0 8 33', '0 8 35'都是subsequence“PSZ”。
　　依次再遍历'0 16 X'、'0 25 X'的情况，依次类推。非常明显，这个例子就是“深度优先的”。
　　以下是代码：

class Solution(object):
def numDistinct(self, s, t):
"""
:type s: str
:type t: str
:rtype: int
"""
num=[0]
self.CountSubsequence(s,t,0,0,num)
return num[0]
def CountSubsequence(self,father_sequence,child_sequence,index_father,index_child,num):
#print(index_father,index_child)
len_father=len(father_sequence)
len_child=len(child_sequence)
if index_child==len_child:
num[0]+=1
#print("匹配到了相同的")
else:
#print("进入迭代")
for i in range(index_father,len_father):
if father_sequence[i]==child_sequence[index_child]:
self.CountSubsequence(father_sequence,child_sequence,i+1,index_child+1,num)
#这里num是一个列表，可以从外部访问的，所以不需要return

　　方法二：DP（Dynamic Programming, 动态规划）

　　此处参考陆草纯的解题报告将问题转化为“二维地图走法问题”。

　　我觉得他在文章里对转化为“二维地图走法问题”说明的不清楚：

　　疑问一：为何走的时候只能“对角线走”和“向右向下走”，不能“向下向右走”。

　　疑问二：为何字符判断相等时，是“对角线走”和“向右向下走”相加；而字符不等时，只能“向右向下走”。

　　经过自己的思考，我来说一下我的理解：

　　一个子字符串t'，一个父字符串s'，两者一点一点相加。最终子字符串的长度加到T的长度，父字符串的长度加到S的长度。

　　当字符不等时，也就是说，父字符串s‘中新加的元素s'[i]无法对走法有贡献，所以可以删掉，于是就变成了“向右向下走”

　　字符相等时，父字符串s'中新加的元素s'[i]对走法有贡献，所以对角线是可以取的；同时“向右向下走”（即删掉s'[i]）也是可行的；由于两者是不同的走法，自然要相加。

　　显然，DP的思路是从0开始一点一点增加子字符串的长度，最终达到我们想要匹配的字符串长度。显然不能减少字符串t'的长度。

　　大家画个图就明白了，以s' 为纵轴，t'为横轴。下面直接上AC的python代码：

　　

class Solution(object):
def numDistinct(self, s, t):
"""
:type s: str
:type t: str
:rtype: int
"""
#s is father_sequence
#t is child_sequence
len_father=len(s)
len_child=len(t)
dp=[[0 for i in range(len_child)] for j in range(len_father)]
if len_father==0 or len_child==0:
result=0
else:
#dp=[[0 for i in range(len_child)] for j in range(len_father)]
if s[0]==t[0]:
dp[0][0]=1
for i in range(1,len_father):
dp[i][0]=dp[i-1][0]
if s[i]==t[0]:
dp[i][0]+=1

for i in range(1,len_father):
for j in range(1,len_child):
if i>=j:
if s[i]==t[j]:
dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
else:
dp[i][j]=dp[i-1][j]
result=dp[len_father-1][len_child-1]
return result