【Leetcode】844.Backspace String Compare

【Leetcode】844.Backspace String Compare

String Stack Two Pointers Easy
Given two strings s and t, return true if they are equal when both are typed into empty text editors. ‘#’ means a backspace character.

Note that after backspacing an empty text, the text will continue empty.

Constraints：
1 <= s.length, t.length <= 200
s and t only contain lowercase letters and ‘#’ characters.

Intuition

想象字符串的输入过程，’#‘代表退格键，表示删除前面一个字符。如果前面无字符可删，也不出错。
比较两个字符串：s = “ab##”, t = “c#d#” 是否相等。返回bool型。

总体思路1：分别处理两个字符串，得到最终显示在“屏幕”上的字符串，比较它们是否相等。
总体思路2：边处理边比较（比较难）。

方法一: 栈

预备知识

STL.stack：

1. stack.empty() 空–true
2. stack.pop() 之后stack.size(）会减1
3. stack[i]是错误的

Python语法：

1. len()方法求列表长度
2. ’‘.join(list)完成列表到字符串的转换

思路及算法

新建一个栈用来储存处理过后的字符串。依次读s/t，如果读到’#'且栈不为空，pop一个元素；如果读到其他字符，把它push进栈。

代码

C++

#include<stack>
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        //毫无技巧版
        stack<char> cs, ct;
        for(int i = 0; i < s.size(); i++){
            if(s[i]!='#')
                cs.push(s[i]);
            if(s[i]=='#' && cs.empty() == false)
                cs.pop();
        }
        for(int i = 0; i < t.size(); i++){
            if(t[i]!='#')
                ct.push(t[i]);
            if(t[i]=='#' && ct.empty() == false)
                ct.pop();
        }
        if(cs.size()!=ct.size())
            return false;
        while(cs.empty() == false){
            if(cs.top() != ct.top())
                return false;
            cs.pop();
            ct.pop();
        }
        return true;
    }
};

比较这里还能更快一点：

s.clear(); t.clear();  //节约空间
while(!st1.empty()){
    s+=st1.top();
    st1.pop();
}
while(!st2.empty()){
    t+=st2.top();
    st2.pop();
}						//转换为字符串
if(s==t)return true;	//可以直接比较
return false;

python

class Solution(object):
    def backspaceCompare(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        def Build(str):
            s = []
            for i in str:
                if(i != '#'):
                    s.append(i)
                elif(len(s)>0):
                    s.pop()
             return s
                '''
                elif s:
                    s.pop()
            return "".join(s) #这样返回的还是字符串
                '''
        return Build(s)==Build(t)

复杂度分析

时间复杂度：O(n+m+min(n,m))

空间复杂度：O(n+m)

方法二：双指针

思路及算法

一个非’#‘的字符是否是最终字符串的一部分取决于之后出现的’#‘，那么如果从后往前看这个字符串，我们就能知道有多少个’#'，然后就能判断前面的字符了。

具体算法是：从后向前遍历字符串，如果遇见’#‘，下一个非’#'字符会被跳过，如果字符没被跳过，它是最终字符串的一部分。

那个循环、是否同时到达-1的判断好巧妙，我就想不到呀

代码

c++

#include<stack>
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        //双指针看过解析版
        int i = s.size()-1, j = t.size()-1;
        while(i >= 0 || j >= 0){
            int skip_s = 0;
            while(i >= 0){
                if(s[i] == '#'){
                    skip_s++;
                    i--;
                }
                else if(skip_s>0){
                    skip_s--;
                    i--;
                }
                else 
                    break;
            }
            int skip_t = 0;
            while(j >= 0){
                if(t[j] == '#'){
                    skip_t++;
                    j--;
                }
                else if(skip_t>0){
                    skip_t--;
                    j--;
                }
                else 
                    break;
            }
            if(i>=0 && j >=0 && s[i] != t[j])
                return false;
            if((i>=0)!=(j>=0))
                return false;
            i--;j--;
        }
        return true;
    }
};

java

public boolean backspaceCompare(String S, String T) {
        int i = S.length() - 1, j = T.length() - 1;
        int skipS = 0, skipT = 0;

        while (i >= 0 || j >= 0) { // While there may be chars in build(S) or build (T)
            while (i >= 0) { // Find position of next possible char in build(S)
                if (S.charAt(i) == '#') {skipS++; i--;}
                else if (skipS > 0) {skipS--; i--;}
                else break;
            }
            while (j >= 0) { // Find position of next possible char in build(T)
                if (T.charAt(j) == '#') {skipT++; j--;}
                else if (skipT > 0) {skipT--; j--;}
                else break;
            }
            // If two actual characters are different
            if (i >= 0 && j >= 0 && S.charAt(i) != T.charAt(j))
                return false;
            // If expecting to compare char vs nothing
            if ((i >= 0) != (j >= 0))
                return false;
            i--; j--;
        }
        return true;
    }

python

class Solution(object):
    def backspaceCompare(self, S, T):
        def F(S):
            skip = 0
            for x in reversed(S):
                if x == '#':
                    skip += 1
                elif skip:
                    skip -= 1
                else:
                    yield x

    return all(x == y for x, y in itertools.izip_longest(F(S), F(T)))

相似题

26.删除排序数组中的重复项
27. 移除元素
283.移动零
977.有序数组的平方

踩坑记录

这题是《代码随想录》-数组-双指针 的补充题。那就练练双指针呗。
第一次的做法是为两个数组分别设置一个比较指针ps,pt，初始时指向最后一个元素。如果指针遇到n个#，向前移动到最头一个#前n位，反复比较ps、pt指向的元素是否相等。
这种做法不能处理"bxj##tw" "bxo#j##tw"这种情况。
接下来想到为每个字符串设置两个指针，从头比较。但是一直纠结于边处理边比较，还做不出来。双指针真的好难。

栈方法也遇到了两个坑：

1. 比较数组时用for(int i = 0; i<stack.size(); i++),这样会少判断栈底元素。
2. pop如果放在push前，即如

if(i == '#' and s!=[]):
    s.pop()
else:
    s.append(i)

则不能判断第一个字符。

总结

如果不一直揪着边处理边比较不放，确实是一道简单题。