## Sunday, March 24, 2019

### Problem Statement

Given a non-empty string `s`, you may delete at most one character. Judge whether you can make it a palindrome.
Example 1:
```Input: "aba"
Output: True
```
Example 2:
```Input: "abca"
Output: True
Explanation: You could delete the character 'c'.
```
Note:
1. The string will only contain lowercase characters a-z. The maximum length of the string is 50000.

### Video Tutorial

You can find the detailed video tutorial here

### Thought Process

We should all be very familiar with how to determine if a string is a palindrome by keeping two pointers, one from beginning and one from the end of the string. The variation of this problem is to we can at most delete one character. Our thought process is the same to try two pointers.

Let's use one example:  "abbac", when we start two pointers, the first char 'a' and the last char 'c' are different. We might want to check if the previous of 'c' equals to 'a', we can have a chance OR the next after 'a' is a 'c', we can also have a chance. In this case, we return True since the previous of 'c' indeed is 'a' and the rest is simply a palindrome.

However, what happens if we do have two choices? For example, "accac", the first 'a' and last 'c' are different, but we can choose either way, but it will result in different results. (i.e., "ccac" or "acca"), as long as one of the is a palindrome, we return True. Sounds familiar, yes, we can easily use recursion to achieve that. To make it better, we only need to recurse at most once since we are only allowed to delete at most one char.

### Solutions

#### Implementation V2

Time Complexity: O(N), N is the string length, worst case we traverse the string twice using recursion , O(N) + O(N) still equals O(N)

Space Complexity: No additional space is needed (recursion function stack not included). Even counting function recursion stack, it's still O(1), which means constant space since you are bound to recurse only once

## Tuesday, March 12, 2019

### Problem Statement

Design a data structure that supports the following two operations:
```void addWord(word)
bool search(word)
```
search(word) can search a literal word or a regular expression string containing only letters `a-z` or `.`. A `.`means it can represent any one letter.
Example:
```addWord("bad")
search("b..") -> true
```

### Video Tutorial

You can find the detailed video tutorial here

### Thought Process

It's a string pattern searching problem, and because it matches the word strictly from the beginning to the end (note, even the partial matching is considered False, e.g., word "abcd", search("abc") should return False), the Trie (prefix tree) data structure comes very handy. It's a common simple data structure that often comes in coding interviews, be sure you can write it bug free.

Once we are familiar with Trie, addWord simply builds the Trie and search just looks for the exact matching. One tricky part of this problem is ".", which can match any one and only one letter. This requires a recursive search of all the sub-nodes in the trie when encountering a "."

Even not asked in this leetcode question, but there are some very good follow up question

### Solutions

Time Complexity:
• addWord: O(N), N is the length of the word
• search: O(M), where M is the entire Trie's space (i.e., the total number of Trie nodes). Think about a worst case of N "............" dots. where N is the length of the word that is larger than the depth of the Trie (larger than the longest word seen so far). More specifically, it's N * (Nodes on Trie's each level) = N * (M / lgM) assuming trie's height is lgM, for worst case, N equals lgM, so N *(M / lgM) = lgM * (M / lgM) = M. Note a trie could be compressed (e.g., the single nodes are merged back to the upper level) but this analysis still holds true
Space Complexity:
• addWord: O(N), creating N more nodes in the trie, N is the length of the word
• search: No additional space needed