## Problem Description

Welcome to another fun coding challenge! Today, we'll be tackling the Valid Parentheses problem.

Given a string containing just the characters `'('`

, `')'`

, `'{'`

, `'}'`

, `'['`

and `']'`

, determine if the input string is valid. An input string is valid if:

Open brackets must be closed by the same type of brackets.

Open brackets must be closed in the correct order.

That's it! Now, let's dive into the solution.

## Solution

First, we'll start by initializing an empty stack. Then, we'll iterate through each character in the input string. If the current character is an opening bracket, we'll push it onto the stack. If the current character is a closing bracket, we'll check if the stack is empty. If it is, then the input string is invalid. Otherwise, we'll pop the top character from the stack and check if it matches the closing bracket. If it doesn't match, then the input string is invalid. Finally, we'll check if the stack is empty. If it is, then the input string is valid. Otherwise, it's invalid.

Here's the Python code for our solution:

```
def isValid(s: str) -> bool:
stack = []
brackets = {')': '(', '}': '{', ']': '['}
for char in s:
if char in brackets.values():
stack.append(char)
elif char in brackets.keys():
if not stack or brackets[char] != stack.pop():
return False
return not stack
```

Let's go through this code step-by-step.

- We start by initializing an empty stack and a dictionary of bracket pairs.

```
stack = []
brackets = {')': '(', '}': '{', ']': '['}
```

The dictionary `brackets`

maps each closing bracket to its corresponding opening bracket. For example, `')'`

maps to `'('`

, `'}'`

maps to `'{'`

, and `']'`

maps to `'['`

.

- We iterate through each character in the input string
`s`

.

```
for char in s:
```

- If the current character is an opening bracket, we'll push it onto the stack.

```
if char in brackets.values():
stack.append(char)
```

- If the current character is a closing bracket, we'll check if the stack is empty. If it is, then the input string is invalid.

```
elif char in brackets.keys():
if not stack or brackets[char] != stack.pop():
return False
```

The `if not stack`

condition checks if the stack is empty. If it is, then we know that there's no matching opening bracket for the current closing bracket, so the input string is invalid. The `brackets[char] != stack.pop()`

condition checks if the top of the stack contains the corresponding opening bracket for the current closing bracket. If it doesn't match, then the input string is invalid.

- Finally, we'll check if the stack is empty. If it is, then the input string is valid. Otherwise, it's invalid.

```
return not stack
```

The `not stack`

expression returns `True`

if the stack is empty, and `False`

if it's not empty. Since we're checking for validity, we want to return `True`

if the stack is empty (i.e., all brackets have been matched), and `False`

if it's not empty (i.e., there are unmatched opening brackets).

## Complexity Analysis

Now that we have our solution, let's analyze its time and space complexity.

### Time Complexity

Our solution iterates through each character in the input string. Since we're doing constant time operations for each character (pushing and popping from a stack, and checking if a key is in a dictionary), the time complexity of our solution is `O(n)`

, where `n`

is the length of the input string.

### Space Complexity

Our solution uses a stack to keep track of the opening brackets. The maximum size of the stack is `n/2`

, where `n`

is the length of the input string. This happens when the input string consists entirely of opening brackets, followed by their corresponding closing brackets. Therefore, the space complexity of our solution is also `O(n)`

.

## Conclusion

And there you have it! We've successfully tackled the Valid Parentheses problem. I hope you found this blog post helpful and informative. Remember, practice makes **progress**. Happy Coding! 😎.