leetcode
link: https://leetcode.com/problems/largest-time-for-given-digits/ Thought Its easy to think use DFS to solve it: it has limit data(4 digits), and DFS will enumerates all possible combinations Code class Solution: def largestTimeFromDigits(self, A): """ :type A: List[int] :rtype: str "
leetcode
Link: Most Stones Removed with Same Row or Column Thought When I saw the question, I realized its a Union Find question - For any union, I can keep only one stone form it. Then it convert to a count how many unique union finds exist question. So, only need to
leetcode
Link: validate stack sequences Thought Its pretty straight forward, just stimulate a stack and push/pop as the sequence shows. Code class Solution(object): def validateStackSequences(self, pushed, popped): """ :type pushed: List[int] :type popped: List[int] :rtype: bool """ stack = [] visited = set() N = len(
leetcode
Link: Bag of Tokens Thought For this question, I find we could do 2 things: spend any cost form the tokens, and get 1 point. Or, spend 1 point, get any power from the tokens. So it turns to be pretty clear that I will firstly sort all tokens by
leetcode
Link Minimum Increment to Make Array Unique Thought Firstly, I try to enumerate all existing number, and I got TLE :(. Then I realized I could sort the origin array and maintain a upper boundary, for any number, if it smaller than upper boundary, means I can only move it to
leetcode
link: Minimum Area Rectangle Thought I plan to use sweep line to solve. Firstly I put a dictionary with x-val as key, all y-val with coordinate x-val as value. Then, once I check x1, x2, if they has intersection, means there could be a rectangle. So I
leetcode
link: Range Sum of BST Thought When first saw this question, I think using tree traverse could solve it and it did works. Code # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def rangeSumBST(self,
leetcode
link Distinct Subsequences II Thought The very first thought here is use DFS to find all distinct subsequences. However it will time out. So my next idea is using dynamic programming to solve it. I'll define a DP array, where DP[i + 1] stands for how many distinct
leetcode
link: Number of Recent Calls Thought Question ask for numbers of calls in 3000. So sliding windows is my choice here - it will move and drop calls earlier than 3000 - which I don't care, and keep tracing incoming calls. Code class RecentCounter: def __init__(self): self.t = collections.
leetcode
link Knight Dialer Thought Since it ask how many distinct numbers could be generated, DP jumps to my mind immediately. Firstly, the relation is, if knight stop at number 6, it has to come from 1, 7, or 0. So I keep a DP array, DP[j][i] stands for
leetcode
link: Shortest Bridge Thought Since the question ask for shortest, so BFS probabely the best algorithms to solve it. But notice, I will use 2 bfs funciton, one to find the edge of first island, the other one is to reach another island based on first edge. BFS1: input: start
leetcode
Link 931.Minimum Falling Path Sum Thought DFS When first seeing this question, DFS prompt into my mind directly. Take Any node from first level as start, and search down stream. Until reach node in last level. For any path, it will have a value. Find the minimum value and