Posts tagged as “stack”

花花酱 LeetCode 844. Backspace String Compare

By zxi on June 3, 2018

Problem

题目大意：给你2个字符串表示打字顺序，判断它们的结果是否相同，’#’表示退格键。

https://leetcode.com/problems/backspace-string-compare/description/

Given two strings S and T, return if they are equal when both are typed into empty text editors. # means a backspace character.

Example 1:

Input: S = "ab#c", T = "ad#c"
Output: true
Explanation: Both S and T become "ac".

Example 2:

Input: S = "ab##", T = "c#d#"
Output: true
Explanation: Both S and T become "".

Example 3:

Input: S = "a##c", T = "#a#c"
Output: true
Explanation: Both S and T become "c".

Example 4:

Input: S = "a#c", T = "b"
Output: false
Explanation: S becomes "c" while T becomes "b".

Note:

1 <= S.length <= 200
1 <= T.length <= 200
S and T only contain lowercase letters and '#' characters.

Solution: Simulation

Time complexity: O(|S| + |T|)

Space complexity: O(|S| + |T|)

C++

// Author: Huahua

// Running time: 5 ms

class Solution {

public:

bool backspaceCompare(string S, string T) {

return type(S) == type(T);

}

private:

string type(string S) {

string o;

for (char c : S)

if (c == '#') {

if (!o.empty())

o.pop_back();

} else {

o.push_back(c);

}

return o;

}

};

Java

// Author: Huahua, 7 ms

class Solution {

public boolean backspaceCompare(String S, String T) {

return type(S).equals(type(T));

}

private String type(String s) {

StringBuilder sb = new StringBuilder();

for (char c : s.toCharArray()) {

if (c == '#') {

if (sb.length() > 0)

sb.setLength(sb.length() - 1);

} else {

sb.append(c);

}

return sb.toString();

}

Python3

# Author: Huahua, 40 ms

class Solution:

def backspaceCompare(self, S, T):

def sim(S):

ans = ''

for c in S:

if c == '#':

if len(ans) > 0: ans = ans[:-1]

else:

ans += c

return ans

return sim(S) == sim(T)

花花酱 LeetCode 225. Implement Stack using Queues

By zxi on March 13, 2018

题目大意：用队列来实现栈。

Problem:

https://leetcode.com/problems/implement-stack-using-queues/description/

Implement the following operations of a stack using queues.

push(x) — Push element x onto stack.
pop() — Removes the element on top of the stack.
top() — Get the top element.
empty() — Return whether the stack is empty.

Notes:

You must use only standard operations of a queue — which means only push to back, peek/pop from front, size, and is empty operations are valid.
Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

Idea:

Using a single queue, for every push, shift the queue (n – 1) times such that the last element becomes the first element in the queue.

e.g.

push(1): q: [1]

push(2): q: [1, 2] -> [2, 1]

push(3): q: [2, 1, 3] -> [1, 3, 2] -> [3, 2, 1]

push(4): q: [3, 2, 1, 4] -> [2, 1, 4, 3] -> [1, 4, 3, 2] -> [4, 3, 2, 1]

Solution:

Time complexity:

Push: O(n)

Pop/top/empty: O(1)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 3 ms

class MyStack {

public:

/** Initialize your data structure here. */

MyStack() {}

/** Push element x onto stack. */

void push(int x) {

q_.push(x);

for (int i = 1; i < q_.size(); ++i) {

q_.push(q_.front());

q_.pop();

}

/** Removes the element on top of the stack and returns that element. */

int pop() {

int top = q_.front();

q_.pop();

return top;

}

/** Get the top element. */

int top() {

return q_.front();

}

/** Returns whether the stack is empty. */

bool empty() {

return q_.empty();

}

private:

queue<int> q_;

};

花花酱 LeetCode 496. Next Greater Element I

By zxi on March 5, 2018

题目大意：给你一个组数A里面每个元素都不相同。再给你一个数组B，元素是A的子集，问对于B中的每个元素，在A数组中相同元素之后第一个比它的元素是多少。

Problem:

You are given two arrays (without duplicates) nums1 and nums2 where nums1’s elements are subset of nums2. Find all the next greater numbers for nums1‘s elements in the corresponding places of nums2.

The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.

Example 1:

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].

Output: [-1,3,-1]

Explanation:

For number 4 in the first array, you cannot find the next greater number for it in the second array, so output -1.

For number 1 in the first array, the next greater number for it in the second array is 3.

For number 2 in the first array, there is no next greater number for it in the second array, so output -1.

Example 2:

Input: nums1 = [2,4], nums2 = [1,2,3,4].

Output: [3,-1]

Explanation:

For number 2 in the first array, the next greater number for it in the second array is 3.

For number 4 in the first array, there is no next greater number for it in the second array, so output -1.

Note:

All elements in nums1 and nums2 are unique.
The length of both nums1 and nums2 would not exceed 1000.

Solution 1: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

// Author: Huahua

// Running time: 13 ms

class Solution {

public:

vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {

vector<int> ans;

for (int num : findNums) {

ans.push_back(-1);

int index = std::find(nums.begin(), nums.end(), num) - nums.begin();

for (int i = index; i < nums.size(); ++i)

if (nums[i] > num) {

ans.back() = nums[i];

break;

}

return ans;

}

};

Solution 2: HashTable + Brute Force

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 15 ms

class Solution {

public:

vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {

unordered_map<int, int> indices;

for (int i = 0 ; i < nums.size(); ++i)

indices[nums[i]] = i;

vector<int> ans;

for (int num : findNums) {

ans.push_back(-1);

for (int i = indices[num]; i < nums.size(); ++i)

if (nums[i] > num) {

ans.back() = nums[i];

break;

}

return ans;

}

};

Solution 3: Stack + HashTable

Using a stack to store the nums whose next greater isn’t found yet.

// Author: Huahua

// Running time: 11 ms

class Solution {

public:

vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {

stack<int> s;

unordered_map<int, int> next;

for (int num : nums) {

while (!s.empty() && num > s.top()) {

next[s.top()] = num;

s.pop();

}

s.push(num);

}

vector<int> ans;

for (int num : findNums)

ans.push_back(next.count(num) ? next[num] : -1);

return ans;

}

};

花花酱 LeetCode 636. Exclusive Time of Functions

By zxi on February 5, 2018

题目大意：给你一些函数的起始/终止时间的日志，让你输出每个函数的总运行时间。假设单核单线程，支持递归函数。

Given the running logs of n functions that are executed in a nonpreemptive single threaded CPU, find the exclusive time of these functions.

Each function has a unique id, start from 0 to n-1. A function may be called recursively or by another function.

A log is a string has this format : function_id:start_or_end:timestamp. For example, "0:start:0" means function 0 starts from the very beginning of time 0. "0:end:0" means function 0 ends to the very end of time 0.

Exclusive time of a function is defined as the time spent within this function, the time spent by calling other functions should not be considered as this function’s exclusive time. You should return the exclusive time of each function sorted by their function id.

Example 1:

Input:

n = 2

logs =

["0:start:0",

"1:start:2",

"1:end:5",

"0:end:6"]

Output:[3, 4]

Explanation:

Function 0 starts at time 0, then it executes 2 units of time and reaches the end of time 1.

Now function 0 calls function 1, function 1 starts at time 2, executes 4 units of time and end at time 5.

Function 0 is running again at time 6, and also end at the time 6, thus executes 1 unit of time.

So function 0 totally execute 2 + 1 = 3 units of time, and function 1 totally execute 4 units of time.

Note:

Input logs will be sorted by timestamp, NOT log id.
Your output should be sorted by function id, which means the 0th element of your output corresponds to the exclusive time of function 0.
Two functions won’t start or end at the same time.
Functions could be called recursively, and will always end.
1 <= n <= 100

Solution: Simulate using stack

// Author: Huahua

// Running time: 35 ms

class Solution {

public:

vector<int> exclusiveTime(int n, vector<string>& logs) {

vector<int> ans(n, 0);

char action[6];

int fid;

int curr;

int prev;

stack<int> s;

for (const string& log : logs) {

sscanf(log.c_str(), "%d:%[a-z]:%d", &fid, action, &curr);

if (action[0] == 's') {

if (!s.empty())

ans[s.top()] += curr - prev;

s.push(fid);

prev = curr;

} else {

ans[s.top()] += curr - prev + 1;

s.pop();

prev = curr + 1;

}

return ans;

}

};

花花酱 LeetCode 735. Asteroid Collision

By zxi on December 3, 2017

Problem:

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input:

asteroids = [5, 10, -5]

Output: [5, 10]

Explanation:

The 10 and -5 collide resulting in 10. The 5 and 10 never collide.

Example 2:

Input:

asteroids = [8, -8]

Output: []

Explanation:

The 8 and -8 collide exploding each other.

Example 3:

Input:

asteroids = [10, 2, -5]

Output: [10]

Explanation:

The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.

Example 4:

Input:

asteroids = [-2, -1, 1, 2]

Output: [-2, -1, 1, 2]

Explanation:

The -2 and -1 are moving left, while the 1 and 2 are moving right.

Asteroids moving the same direction never meet, so no asteroids will meet each other.

Note:

The length of asteroids will be at most 10000.
Each asteroid will be a non-zero integer in the range [-1000, 1000]..

Idea:

Simulation

Time complexity: O(n), Space complexity: O(n)

Solution:

C ++

// Author: Huahua

// Runtime: 22 ms

class Solution {

public:

vector<int> asteroidCollision(vector<int>& asteroids) {

vector<int> s;

for (int i = 0 ; i < asteroids.size(); ++i) {

const int size = asteroids[i];

if (size > 0) { // To right, OK

s.push_back(size);

} else {

// To left

if (s.empty() || s.back() < 0) // OK when all are negtives

s.push_back(size);

else if (abs(s.back()) <= abs(size)) {

// Top of the stack is going right.

// Its size is less than the current one.

// The current one still alive!

if (abs(s.back()) < abs(size)) --i;

s.pop_back(); // Destory the top one moving right

}

// s must look like [-s1, -s2, ... , si, sj, ...]

return s;

}

};