2116.判断一个括号字符串是否有效

目标

一个括号字符串是只由 '(' 和 ')' 组成的 非空 字符串。如果一个字符串满足下面 任意 一个条件,那么它就是有效的:

  • 字符串为 ().
  • 它可以表示为 AB(A 与 B 连接),其中A 和 B 都是有效括号字符串。
  • 它可以表示为 (A) ,其中 A 是一个有效括号字符串。

给你一个括号字符串 s 和一个字符串 locked ,两者长度都为 n 。locked 是一个二进制字符串,只包含 '0' 和 '1' 。对于 locked 中 每一个 下标 i :

  • 如果 locked[i] 是 '1' ,你 不能 改变 s[i] 。
  • 如果 locked[i] 是 '0' ,你 可以 将 s[i] 变为 '(' 或者 ')' 。

如果你可以将 s 变为有效括号字符串,请你返回 true ,否则返回 false 。

示例 1:

输入:s = "))()))", locked = "010100"
输出:true
解释:locked[1] == '1' 和 locked[3] == '1' ,所以我们无法改变 s[1] 或者 s[3] 。
我们可以将 s[0] 和 s[4] 变为 '(' ,不改变 s[2] 和 s[5] ,使 s 变为有效字符串。

示例 2:

输入:s = "()()", locked = "0000"
输出:true
解释:我们不需要做任何改变,因为 s 已经是有效字符串了。

示例 3:

输入:s = ")", locked = "0"
输出:false
解释:locked 允许改变 s[0] 。
但无论将 s[0] 变为 '(' 或者 ')' 都无法使 s 变为有效字符串。

示例 4:

输入:s = "(((())(((())", locked = "111111010111"
输出:true
解释:locked 允许我们改变 s[6] 和 s[8]。
我们将 s[6] 和 s[8] 改为 ')' 使 s 变为有效字符串。

说明:

  • n == s.length == locked.length
  • 1 <= n <= 10^5
  • s[i] 要么是 '(' 要么是 ')' 。
  • locked[i] 要么是 '0' 要么是 '1' 。

思路

有一个由 () 组成的非空字符串,如果 locked[i]0,可以任意修改 i 位置上的字符,判断能否使括号字符串变得有效。

从左到右累加未匹配的左括号数量,遇到 ( 加一,遇到 ) 减一,对于有效字符串最终会得到 0,并且有效字符串的任意前缀中未匹配的 ( 的数量总是大于等于 0

利用这一性质维护一个未匹配左括号数量的可能取值集合,如果最终集合中包含 0,则说明可以变为有效。具体实现时只需维护集合的最大值与最小值,因为集合中的数字都是同时加一减一,所以它们是连续的奇数或偶数。

具体来说就是遇到不可变字符,( min max 加一,) min max 减一。如果 max < 0,返回 false,如果 min < 0,则取 1(如果 min < 0,说明原来是偶数,由于 max 没有减为负数,说明还有比 0 大的偶数,那么最小值为 2 - 1)。如果遇到可变字符,max 加一,min 减一,如果 min < 0,则取 1

代码


/**
 * @date 2025-03-23 21:12
 */
public class CanBeValid2116 {

    public boolean canBeValid(String s, String locked) {
        int n = s.length();
        if (n % 2 == 1) {
            return false;
        }
        int max = 0, min = 0;
        char[] chars = s.toCharArray();
        for (int i = 0; i < n; i++) {
            if (locked.charAt(i) == '0') {
                max++;
                if (--min < 0) {
                    min = 1;
                }
                continue;
            }
            if ('(' == chars[i]) {
                max++;
                min++;
            } else {
                if (--max < 0) {
                    return false;
                }
                if (--min < 0) {
                    min = 1;
                }
            }
        }
        return min == 0;
    }
}

性能

1472.设计浏览器历史记录

目标

你有一个只支持单个标签页的 浏览器 ,最开始你浏览的网页是 homepage ,你可以访问其他的网站 url ,也可以在浏览历史中后退 steps 步或前进 steps 步。

请你实现 BrowserHistory 类:

  • BrowserHistory(string homepage) ,用 homepage 初始化浏览器类。
  • void visit(string url) 从当前页跳转访问 url 对应的页面 。执行此操作会把浏览历史前进的记录全部删除。
  • string back(int steps) 在浏览历史中后退 steps 步。如果你只能在浏览历史中后退至多 x 步且 steps > x ,那么你只后退 x 步。请返回后退 至多 steps 步以后的 url 。
  • string forward(int steps) 在浏览历史中前进 steps 步。如果你只能在浏览历史中前进至多 x 步且 steps > x ,那么你只前进 x 步。请返回前进 至多 steps步以后的 url 。

示例:

输入:
["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]
[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]
输出:
[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]

解释:
BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
browserHistory.visit("google.com");       // 你原本在浏览 "leetcode.com" 。访问 "google.com"
browserHistory.visit("facebook.com");     // 你原本在浏览 "google.com" 。访问 "facebook.com"
browserHistory.visit("youtube.com");      // 你原本在浏览 "facebook.com" 。访问 "youtube.com"
browserHistory.back(1);                   // 你原本在浏览 "youtube.com" ,后退到 "facebook.com" 并返回 "facebook.com"
browserHistory.back(1);                   // 你原本在浏览 "facebook.com" ,后退到 "google.com" 并返回 "google.com"
browserHistory.forward(1);                // 你原本在浏览 "google.com" ,前进到 "facebook.com" 并返回 "facebook.com"
browserHistory.visit("linkedin.com");     // 你原本在浏览 "facebook.com" 。 访问 "linkedin.com"
browserHistory.forward(2);                // 你原本在浏览 "linkedin.com" ,你无法前进任何步数。
browserHistory.back(2);                   // 你原本在浏览 "linkedin.com" ,后退两步依次先到 "facebook.com" ,然后到 "google.com" ,并返回 "google.com"
browserHistory.back(7);                   // 你原本在浏览 "google.com", 你只能后退一步到 "leetcode.com" ,并返回 "leetcode.com"

说明:

  • 1 <= homepage.length <= 20
  • 1 <= url.length <= 20
  • 1 <= steps <= 100
  • homepage 和 url 都只包含 '.' 或者小写英文字母。
  • 最多调用 5000 次 visit, back 和 forward 函数。

思路

设计一个浏览器历史记录管理器,记录在同一个标签页的浏览历史,允许前进/后退 steps 步(不能超出浏览记录的范围)。如果打开新页面,当前页面记录会覆盖前进的记录。

使用栈模拟,记录 curtail 两个指针,前进取 Math.min(tail, cur + steps),后退取 Math.max(0, cur - steps),访问新页面 ++cur; tail = cur;

代码


/**
 * @date 2025-02-26 8:48
 */
class BrowserHistory {

    String[] history = new String[5000];
    int tail = 0;
    int cur = 0;

    public BrowserHistory(String homepage) {
        history[0] = homepage;
    }

    public void visit(String url) {
        history[++cur] = url;
        tail = cur;
    }

    public String back(int steps) {
        cur = Math.max(0, cur - steps);
        return history[cur];
    }

    public String forward(int steps) {
        cur = Math.min(tail, cur + steps);
        return history[cur];
    }
}

性能

2390.从字符串中移除星号

目标

给你一个包含若干星号 * 的字符串 s 。

在一步操作中,你可以:

  • 选中 s 中的一个星号。
  • 移除星号 左侧 最近的那个 非星号 字符,并移除该星号自身。

返回移除 所有 星号之后的字符串。

注意:

  • 生成的输入保证总是可以执行题面中描述的操作。
  • 可以证明结果字符串是唯一的。

示例 1:

输入:s = "leet**cod*e"
输出:"lecoe"
解释:从左到右执行移除操作:
- 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ,s 变为 "lee*cod*e" 。
- 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ,s 变为 "lecod*e" 。
- 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ,s 变为 "lecoe" 。
不存在其他星号,返回 "lecoe" 。

示例 2:

输入:s = "erase*****"
输出:""
解释:整个字符串都会被移除,所以返回空字符串。

说明:

  • 1 <= s.length <= 10^5
  • s 由小写英文字母和星号 * 组成
  • s 可以执行上述操作

思路

移除字符串中的星号以及星号左侧的非星号字符。

直接模拟栈的行为即可,可以使用StringBuilder,遇到星号就删除最后一个字符。

deleteCharAt(index) 实际上调用的是 System.arraycopy(value, index+1, value, index, count-index-1); 将index后的数据前移了一位。这里删除的是最后一个字符,实际上就是将指针向前移了一位。那我们可以直接将指针向前移,省去这一系列的函数调用。

可以直接原地修改,定义一个指针 pi 同步增长,如果遇到 *, 指针 p 回退,否则将下标 i 对应的值写入当前 p 指向的位置。

代码


/**
 * @date 2024-09-14 8:56
 */
public class RemoveStars2390 {

    public String removeStars_v2(String s) {
        char[] chars = s.toCharArray();
        int n = chars.length;
        int p = 0;
        for (int i = 0; i < n; i++) {
            if (chars[i] == '*') {
                p--;
            } else {
                chars[p++] = chars[i];
            }
        }
        return new String(chars, 0, p);
    }

}

性能

977.有序数组的平方

目标

给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。

示例 1:

输入:nums = [-4,-1,0,3,10]
输出:[0,1,9,16,100]
解释:平方后,数组变为 [16,1,0,9,100]
排序后,数组变为 [0,1,9,16,100]

示例 2:

输入:nums = [-7,-3,2,3,11]
输出:[4,9,9,49,121]

说明:

  • 1 <= nums.length <= 10^4
  • -10^4 <= nums[i] <= 10^4
  • nums 已按 非递减顺序 排序

进阶:

  • 请你设计时间复杂度为 O(n) 的算法解决本问题

思路

有一个非递减顺序排列的数组(数组中存在负数),求其各元素平方组成的数组,要求也按非递减顺序排列。

将负数的绝对值压入栈中直到遇到正数,然后比较当前正数与栈顶元素的大小,取其最小值计算平方即可。这里使用了指针模拟 栈 的操作。

代码


/**
 * @date 2024-09-08 20:40
 */
public class SortedSquares977 {

    public int[] sortedSquares(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        int top = -1;
        int j = 0;
        for (int i = 0; i < n; i++) {
            if (nums[i] <= 0) {
                nums[i] = - nums[i];
                top++;
            } else {
                while (top >= 0 && nums[i] >= nums[top]) {
                    res[j++] = nums[top] * nums[top];
                    top--;
                }
                res[j++] = nums[i] * nums[i];
            }
        }
        // 如果没有正数,循环中的else分支不会执行,这里判断一下
        while (top >= 0) {
            res[j++] = nums[top] * nums[top];
            top--;
        }
        return res;
    }

}

性能

3174.清除数字 – 双端队列

目标

给你一个字符串 s 。

你的任务是重复以下操作删除 所有 数字字符:

  • 删除 第一个数字字符 以及它左边 最近 的 非数字 字符。

请你返回删除所有数字字符以后剩下的字符串。

示例 1:

输入:s = "abc"
输出:"abc"
解释:
字符串中没有数字。

示例 2:

输入:s = "cb34"
输出:""
解释:
一开始,我们对 s[2] 执行操作,s 变为 "c4" 。
然后对 s[1] 执行操作,s 变为 "" 。

说明:

  • 1 <= s.length <= 100
  • s 只包含小写英文字母和数字字符。
  • 输入保证所有数字都可以按以上操作被删除。

思路

删除给定字符串中的数字字符,每次删除操作需要同步删除该字符左侧最后一个非数字字符。

遍历的过程中使用栈保存非数字字符,遇到数字字符就弹栈,然后返回栈底到栈顶的字符即可。

知识点:

  • ArrayDeque 双端队列的特性取决于如何放入数据

                    start
             last           first
    offer       4 3 2 1
    push              1 2 3 4
  • offer是向左添加数据

  • push是向右添加数据

  • poll/pop/remove 默认从右向左取数据

  • 如果api中带last,例如pollLast、removeLast则是从左向右取,first则相反

代码


/**
 * @date 2024-09-05 8:47
 */
public class ClearDigits3174 {

    public String clearDigits(String s) {
        int n = s.length();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (c > '9' || c < '0') {
                sb.append(c);
            } else {
                sb.deleteCharAt(sb.length() - 1);
            }
        }
        return sb.toString();
    }

}

性能

232.用栈实现队列

目标

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):

实现 MyQueue 类:

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空,返回 true ;否则,返回 false

说明:

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。

示例 1:

输入:
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]

输出:
[null, null, null, 1, 1, false]

解释:
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

说明:

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 (例如,一个空的队列不会调用 pop 或者 peek 操作)

进阶:

你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间。

思路

这道题是让我们仅使用push压入栈顶、peek获取栈顶元素、pop弹栈等API实现先进先出队列。

关键是要想明白一点,入栈与出栈操作的是不同的栈,出栈s2中的元素是从入栈s1中获取的,并且,只能在s2为空的时候,将s1中的元素一个个弹栈再入s2,这样才能保证顺序反转。

代码

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * @date 2024-03-04 0:42
 */
public class MyQueue {
    private final Deque<Integer> s1;
    private final Deque<Integer> s2;

    public MyQueue() {
        s1 = new ArrayDeque<>();
        s2 = new ArrayDeque<>();
    }

    public void push(int x) {
        s1.push(x);
    }

    public int pop() {
        if (s2.isEmpty()) {
            while (!s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }

    public int peek() {
        if (s2.isEmpty()) {
            while (!s1.isEmpty()) {
                s2.push(s1.pop());
            }
        }
        if (s2.isEmpty()) {
            throw new RuntimeException();
        }
        return s2.peek();
    }

    public boolean empty() {
        return s2.isEmpty() && s1.isEmpty();
    }
}

Stack注释中有这么一段话,告诉我们应该优先使用Deque接口及其实现。

A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class.

For example: Deque<Integer> stack = new ArrayDeque<Integer>();

在Java中,Stack类是基于Vector实现的,而Vector是一个线程安全的、可动态增长的数组。虽然Stack也是数组实现的,但由于Vector的一些内部机制(例如,每次增长时都会分配更大的数组,并将旧数组的内容复制到新数组中),它可能在某些操作上不如ArrayDeque高效。

相比之下,ArrayDeque是基于循环数组实现的,它避免了不必要的内存分配和复制操作。循环数组意味着当数组的一端达到容量限制时,元素会从另一端开始填充,从而充分利用了数组空间。这种实现方式通常比Vector或Stack更高效。

因此,即使Stack也是数组实现的,但由于Deque(如ArrayDeque)使用了不同的内部机制和优化,它在某些情况下可能会提供更好的性能。

另外,值得注意的是,在Java中,Stack类已经被标记为遗留(legacy),不建议在新的代码中使用。相反,应该使用Deque接口及其实现,如ArrayDeque,因为它们提供了更完整、更一致的操作集合,并且通常具有更好的性能。

性能

时间复杂度:push(数组赋值),empty为O(1),pop与peek虽然涉及到移动数据,但只有在出栈为空的时候才执行,均摊后为O(1)。

空间复杂度为O(n)。

225.用队列实现栈

目标

请你仅使用两个队列实现一个后入先出(LIFO)的栈,并支持普通栈的全部四种操作(push、top、pop 和 empty)。

实现 MyStack 类:

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的,返回 true ;否则,返回 false 。

注意:

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list (列表)或者 deque(双端队列)来模拟一个队列 , 只要是标准的队列操作即可。

示例:

输入:

["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]

输出:

[null, null, null, 2, 2, false]

解释:

MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

说明:

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空

进阶:你能否仅用一个队列来实现栈。

思路

这道题的目的是只使用标准库的部分API实现栈,即后进先出。

Java中可以使用Queue接口,offer插入队尾,peek获取队首元素,poll从队首获取并删除元素。

官网给出了两种方法,一种是使用两个队列,offer总是将新元素放到空队列q中,然后将另一队列q1从头至尾放入q,这样就实现了顺序的反转。

例如,依次入栈1,2,3,4:

说明:队首在右边

offer(1):

q: 1

q1:
----------------------------
offer(2):

q: 1

q1: 2

q1.offer(q.poll()):

q: 

q1: 1 2
----------------------------
offer(3):

q: 3

q1: 1 2

while(!q1.isEmpty){q.offer(q1.poll())}:

q: 1 2 3

q1:
----------------------------
offer(4):

q: 1 2 3

q1: 4

while(!q.isEmpty){q1.offer(q.poll())}:

q:

q1: 1 2 3 4

另一种只用一个队列的方法是:每次offer前先记录队列数据数量n,然后再offer,之后将前面n个数依次poll并offer到队尾。

例如,依次入栈1,2,3,4:

说明:队首在右边

offer(1):

q: 1

----------------------------
n = 1

offer(2):

q: 2 1

p.offer(p.poll()):

q: 1 2

----------------------------
n = 2

offer(3):

q: 3 1 2

循环2次:p.offer(p.poll())

q: 1 2 3

----------------------------
n = 3

offer(4):

q: 4 1 2 3

循环3次:p.offer(p.poll())

q:1 2 3 4

性能

这两种方法的性能基本相同。

时间复杂度:入栈操作均为O(n),其余为O(1)。

空间复杂度:O(n)