# 392. 判断子序列 - LeetCode Python/Java/C++ 题解
访问原文链接：[392. 判断子序列 - LeetCode Python/Java/C++ 题解](https://leetcodepython.com/zh/leetcode/392-is-subsequence)，体验更佳！
力扣链接：[392. 判断子序列](https://leetcode.cn/problems/is-subsequence), 难度等级：**中等**。
## LeetCode “392. 判断子序列”问题描述
给定字符串 **s** 和 **t** ，判断 **s** 是否为 **t** 的子序列。
字符串的一个**子序列**是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，`"ace"`是`"abcde"`的一个子序列，而`"aec"`不是）。
**进阶**：
如果有大量输入的 `S`，称作 `S1, S2, ... , Sk` 其中 `k >= 10亿`，你需要依次检查它们是否为 `T` 的子序列。在这种情况下，你会怎样改变代码？
### [示例 1]
**输入**: `s = "abc", t = "ahbgdc"`
**输出**: `true`
### [示例 2]
**输入**: `s = "axc", t = "ahbgdc"`
**输出**: `false`
### [约束]
- `0 <= s.length <= 100`
- `0 <= t.length <= 10^4`
- `s` and `t` consist only of lowercase English letters.
## 思路 1
- 定义两个指针，最初分别指向两个字符串的头部，字符用`t[i]`, `s[j]`引用。
- 在对`t`的遍历过程中，`i`自动加1，如果`t[i] == s[j]`，则`j += 1`。
- 如果`j >= s.length`，返回`true`。如果遍历完`t`了，仍然没有提前返回`true`，则返回`false`。
## 复杂度
- 时间复杂度: `O(N)`.
- 空间复杂度: `O(1)`.
## Python
```python
class Solution:
def isSubsequence(self, s: str, t: str) -> bool:
if s == "":
return True
s_index = 0
for i in range(len(t)):
if t[i] == s[s_index]:
s_index += 1
if s_index >= len(s):
return True
return False
```
## C++
```cpp
class Solution {
public:
bool isSubsequence(string s, string t) {
if (s.empty()) {
return true;
}
int s_index = 0;
for (int i = 0; i < t.length(); i++) {
if (t[i] == s[s_index]) {
s_index++;
if (s_index >= s.length()) {
return true;
}
}
}
return false;
}
};
```
## Java
```java
class Solution {
public boolean isSubsequence(String s, String t) {
if (s.isEmpty()) {
return true;
}
int sIndex = 0;
for (int i = 0; i < t.length(); i++) {
if (t.charAt(i) == s.charAt(sIndex)) {
sIndex++;
if (sIndex >= s.length()) {
return true;
}
}
}
return false;
}
}
```
## C#
```csharp
public class Solution
{
public bool IsSubsequence(string s, string t)
{
if (string.IsNullOrEmpty(s))
{
return true;
}
int sIndex = 0;
for (int i = 0; i < t.Length; i++)
{
if (t[i] == s[sIndex])
{
sIndex++;
if (sIndex >= s.Length)
{
return true;
}
}
}
return false;
}
}
```
## Go
```go
func isSubsequence(s string, t string) bool {
if len(s) == 0 {
return true
}
sIndex := 0
for i := 0; i < len(t); i++ {
if t[i] == s[sIndex] {
sIndex++
if sIndex >= len(s) {
return true
}
}
}
return false
}
```
## JavaScript
```javascript
/**
* @param {string} s
* @param {string} t
* @return {boolean}
*/
var isSubsequence = function(s, t) {
if (s.length === 0) {
return true;
}
let sIndex = 0;
for (let i = 0; i < t.length; i++) {
if (t[i] === s[sIndex]) {
sIndex++;
if (sIndex >= s.length) {
return true;
}
}
}
return false;
};
```
## Ruby
```ruby
# @param {String} s
# @param {String} t
# @return {Boolean}
def is_subsequence(s, t)
return true if s.empty?
s_index = 0
t.each_char.with_index do |char, i|
if char == s[s_index]
s_index += 1
return true if s_index >= s.length
end
end
false
end
```
## Other languages
```java
// Welcome to create a PR to complete the code of this language, thanks!
```
## 思路 2
- `题解1`本质上是用`滚动变量`实现的“动态规划”算法。它很好理解，并且空间复杂度降到了`O(1)`。
- 但现在，我们不仅不做降维，还要升维。理解和实现起来都会更困难些。那为什么还要做这种吃力不讨好的事情呢？
点击查看答案
因为它能处理一类在动态规划中常见的、更为复杂的场景。比如：[583. 两个字符串的删除操作](583-delete-operation-for-two-strings.md) 等。
点击查看答案
当然可以，但考虑本题`一维的滚动数组`不如`二维数组`好理解，实现的过程也容易出错，所以我没有给出相关的代码实现。如何你有兴趣，可以尝试下。