Posts on Yosgi Blog

From Extracting Drawing Text to Placing 2D Annotations in a 3D Scene

Thu, 11 Jun 2026 00:00:00 +0000

A practical engineering recap of how a simple drawing text extraction task turned into a 2D-to-3D mapping workflow for digital twins, combining SVG parsing, vision models, geometry rules, registration math, and agent tool design.

AI Won’t Replace Software Engineers. It Will Replace the Parts of Coding We Never Loved.

Tue, 19 May 2026 00:00:00 +0000

AI will not replace software engineers as a whole. It will remove much of the repetitive, mechanical work and give engineers more leverage to focus on judgment, systems, users, and building better products.

Your Agent Is Not Inconsistent Because It Is Dumb. It Just Has Too Many Tool Paths.

Thu, 07 May 2026 00:00:00 +0000

Multi-tool agents become unreliable when the same task takes different tool paths each time. This article explains why Skills should preserve validated execution paths, not one-off results, and why those Skills need to evolve over time.

Tool for Control, Code for Analysis(3)

Wed, 28 Jan 2026 00:00:00 +0000

In large-scale Agent systems, pure Tool-based approaches tend to collapse under context pressure, while pure Code-based approaches introduce excessive latency. Based on real-world experiments, this article introduces a dual-path execution model that uses a “Context Off-Ramp” to switch between Tool and Code execution.

Why Tool and Code Fail Differently in Agent Systems（2）

Sat, 27 Dec 2025 00:00:00 +0000

Tool and Code do not just differ in expressiveness; they also fail at different times. This article explains why multi-round Agent systems amplify that difference.

An MCP-as-Code Refactor, and Why It Did Not Work the Way I Expected

Thu, 18 Dec 2025 00:00:00 +0000

A real-world MCP-as-Code refactor on where Code helps, where Tool still fits better, and why Agent runtime needs both.

2025 Investment Review

Mon, 15 Dec 2025 00:00:00 +0000

2025 Investment Review: A Bet-the-Dip Strategy in AI-Driven Markets

High-Frequency Synchronization Architecture Between React State and a 3D Engine

Wed, 01 Oct 2025 00:00:00 +0000

A synchronization paradigm for massive real-time data: a middle layer isolates high-frequency data sources, and React consumes only the linear projection of the visible viewport.

Early Experiences with Building MCP Tools

Tue, 01 Jul 2025 00:00:00 +0000

How Cut 6,000 Tokens Down to 500

Circle After the Hype, Was a $40 Billion Valuation Justified?

Sun, 29 Jun 2025 00:00:00 +0000

Circle is a high-quality company operating in a promising sector, but at a valuation of roughly $40 billion, the market had already priced in a substantial portion of its future growth.

1104-Binary Tree Pathfinding

Thu, 29 Jul 2021 00:00:00 +0000

The first thing I thought of was to construct a binary tree, and then use the symmetric relationship of each layer to find the parent node var pathInZigZagTree = function(label) { let stack = [] for (let i = 1; i <= label; i++) { let level = Math.floor(Math.log(i) / Math.log(2)) if (!stack[level]) { stack[level] = [] } if (level % 2 === 0) { stack[level].push(i) } else { stack[level].unshift(i) } } var level = Math.floor(Math.log(label) / Math.log(2)) let ans = [] while (level) { ans.push(label) level-- label = Math.floor(label / 2) let index = stack[level].length - 1 - stack[level].indexOf(label) label = stack[level][index] } ans.push(1) return ans.reverse() }Sorry, timeout. Inspired by the answer, since it is symmetrical, the sum of the symmetrical numbers is the same when the number of layers is the same.

Reverse Linked List 2

Fri, 23 Jul 2021 00:00:00 +0000

Considering that the head may also be reversed, a dummy head is needed. During the traversal process, the tail node after the reversal and the previous node are recorded. Finally, the node link processing is performed. var reverseBetween = function(head, m, n) { let noob = new ListNode(0) noob.next = head let cur = noob let index = 0 let A,B while (index < m) { A = cur // A records the previous node of the reverse subchain cur = cur.next index++ } B = cur // B records the tail node after reversal let pre = cur while (index <= n) { let next = cur.next cur.next = pre pre = cur cur = next index++ } // After execution, the cur pointer is at the next node of the reverse subchain B.next = cur A.next = pre return noob.next };

1893-Check if all integers in the region are covered

Fri, 23 Jul 2021 00:00:00 +0000

I didn’t think of any good way to get it, so I used brute force to solve it first. var isCovered = function(ranges, left, right) { for(let i = left ; i <= right ; i ++) { let include = false for(let index = 0 ; index < ranges.length ; index ++) { let [start,end] = ranges[index] if (i >=start && i <=end) { include = true } } if (!include) return false } return true};Thinking about optimization, you can use start, end. When start <= left, the [left … end] set is already included. Continue compressing [end + 1, right] until there are no elements in the set. var isCovered = function(ranges, left, right) { ranges = ranges.sort((a,b) => a - b) for(let i = 0 ; i < ranges.length;i++) { let [start,end] = ranges[i]; // Shrink the left boundary according to the range if (start <= left) { left = Math.max(end,right) } if (left >= right) { return true } } return left >= right };I didn’t think of any good way to get it, so I used brute force to solve it first.

138-Copying a linked list with random pointers

Thu, 22 Jul 2021 00:00:00 +0000

The idea behind the question is to use double pointers to point to the old and new nodes, and then add a map to map the old and new nodes. recursion var listMap = new Map() var copyRandomList = function(head) { if(head === null) return head if (listMap.get(head)) { return listMap.get(head) } let newNode = new Node(head.val,null,null) listMap.set(head, newNode) newNode.next = copyRandomList(head.next) newNode.random = copyRandomList(head.random) return newNode }; ```Iteration ```javascript var copyRandomList = function(head) { if(head == null) return head var listMap = new Map() listMap.set(null,null) var cur = head while (cur!= null) { listMap.set(cur,new Node(cur.val,null,null)) cur = cur.next } cur = head while (cur!= null) { listMap.get(cur).next = listMap.get(cur.next) listMap.get(cur).random = listMap.get(cur.random) cur = cur.next } return listMap.get(head) };The idea behind the question is to use double pointers to point to the old and new nodes, and then add a map to map the old and new nodes.

684-Redundant Connection

Wed, 07 Jul 2021 00:00:00 +0000

Time: 15 minutes Use the union-find template var findRedundantConnection = function(edges) { var n = edges.length var fa = new Array(n + 1) var find = function (x) { if (x != fa[x]) { fa[x] = find(fa[x]) } return fa[x] } for(let i = 1 ; i <= n ; i ++) { fa[i] = i } for(let i = 0 ; i < n ; i ++) { var [x,y] = edges[i] if (find(x) === find(y)) { return [x,y] } else { fa[find(x)] = find(y) } } };

1202-Swap elements in a string

Tue, 06 Jul 2021 00:00:00 +0000

It is mainly used for learning and checking ideas, and you will start only after looking at the answers. The idea is to group the interchangeable strings first, sort the groups, and then combine them Union-find is to use recursion or while loop to implement find, and then use arrays and subscripts to implement union var smallestStringWithSwaps = function(s, pairs) { var fa = [] var find = function (x) { if (x === fa[x]) { return x } else { return fa[x] = find(fa[x]) } } for (let i = 0; i < s.length; i++) { fa[i] = i } for(let i = 0 ; i < pairs.length ; i ++) { const [x,y] = pairs[i] fa[find(x)] = find(y) } var n = s.length // Calculate the grouped map const vec = new Array(n).fill(0).map(() => new Array()); for (let i = 0; i < n; i++) { fa[i] = find(i); vec[fa[i]].push(s[i]); } console.log(fa) // Sort the grouped map for (let i = 0; i < n; ++i) { if (vec[i].length > 0) { vec[i].sort((a, b) => a.charCodeAt() - b.charCodeAt()); } } // Combined into ans const ans = new Array(n).fill(0); for (let i = 0; i < n; ++i) { var group = fa[i] if ( group!= undefined && vec[group].length) { // Take out the smallest number in each group ans[i] = vec[fa[i]].shift() } else { ans[i] = s[i] } } return ans.join('') };It is mainly used to learn and check the ideas, and you will start only after looking at the answers.

778-Swimming in a rising pool

Mon, 05 Jul 2021 00:00:00 +0000

Time: 20 minutes First of all, it can be seen that this is a question to examine DFS var swimInWater = function(grid) { let row = grid.length; let col = grid[0].length; var step = 0 while(true) { for(let i = 0 ; i < row ; i ++) { for(let j = 0 ; j < col ; j ++){ grid[i][j] -- } } var visited = [] for(let i = 0 ; i < row ; i ++) { let arr = [] for(let j = 0 ; j < col ; j ++) { arr.push(false) } visited.push(arr) } var dfs = function (i,j) { if ( i< 0 || j < 0 || i >= row || j >= col) return false if (visited[i][j]) { return false } else { visited[i][j] = true } if (grid[i][j] > 0) return false if (i === row - 1 && j === col - 1 && grid[i][j] <= 0) return true return dfs(i+1,j) || dfs(i-1,j) || dfs(i,j-1)|| dfs(i,j + 1) } step++ if (dfs(0,0) === true) break } return step };We don’t have to start from 1, we can use the binary search to find the leftmost insertion point. var swimInWater = function(grid) { let row = grid.length; let col = grid[0].length; let right = -Infinity let left = Infinity for(let i = 0 ; i < row ; i ++) { for(let j = 0 ; j < col ; j ++ ){ let num = grid[i][j] right = Math.max(right,num) left = Math.min(left,num) } } let mid = left + Math.floor( (right - left) / 2 ) while(left <= right) { mid = left + Math.floor( (right - left) / 2 ) var visited = [] var new_grid = [] for(let i = 0 ; i < row ; i ++) { let arr = [] let _grid = [] for(let j = 0 ; j < col ; j ++) { arr.push(false) _grid.push(grid[i][j] - mid) } visited.push(arr) new_grid.push(_grid) } var dfs = function (i,j) { if ( i < 0 || j < 0 || i >= row || j >= col) return false if (visited[i][j]) { return false } else { visited[i][j] = true } if (new_grid[i][j] > 0) return false if (i === row - 1 && j === col - 1 && new_grid[i][j] <= 0) return true return dfs(i+1,j) || dfs(i-1,j) || dfs(i,j-1)|| dfs(i,j + 1) } if(dfs(0,0)) { // Found the spare tire, continue to see if it can be smaller right = mid - 1 } else { left = mid + 1 } } return left };

475-Heater

Thu, 10 Jun 2021 00:00:00 +0000

The first thing that comes to mind is to find the distance r of all heaters that are the shortest distance from the house, and then return the largest r var findRadius = function(houses, heaters) { var max = 0 for(let i = 0 ; i < houses.length ; i ++) { var house_position = houses[i] var r = Infinity for(let j = 0 ; j < heaters.length ; j ++) { var heat_position = heaters[j] var reduce = Math.abs(house_position - heat_position) r = Math.min(r,reduce) } max = Math.max(r,max) } return max };In this case, we can also use the dichotomy method to find the heater var findRadius = function(houses, heaters) { var r = 0 for(let i = 0 ; i < houses.length ; i ++) { var house_position = houses[i] let left = 0 , right = heaters.length - 1 // Find the heat_position closest to house_position // That is, find the rightmost insertion point of house_position while(left <= right && right < heaters.length) { let mid = left + Math.floor((right - left) / 2) var heat_position = heaters[mid] // If the one found is not greater than, go to the right if(heat_position <= house_position) { left = mid + 1 } else { right = mid - 1 } } // The insertion point found at this time is not necessarily the closest one. The one on the left is smaller than it, so we need to compare it var R = Math.abs(heaters[right] - house_position) if(right > 0) { R = Math.min( Math.abs( heaters[right - 1] - house_position) , R) } r = Math.max(r,R) } return r };

875-Keke who loves bananas

Wed, 28 Apr 2021 00:00:00 +0000

Time: 60 minutes The quickest way of thinking when getting the question is to enumerate all the speeds at which bananas can be eaten and find the minimum speed at which all bananas can be eaten. The enumeration speed range is [1… the largest pile of bananas], because the speed will not be less than 1, and there is no need for the speed to be faster than the largest pile of bananas.

973-K points closest to the origin

Sat, 10 Apr 2021 00:00:00 +0000

Time: 15 minutes There is nothing much to say about conventional heap sort class Heap { constructor(list, compare = (a, b) => a - b) { this.left = index => 2 * index + 1 this.right = index => 2 * index + 2 this.parent = index => Math.floor((index - 1) / 2) this.heapify = (index = 0) => { const { list } = this const leftIndex = this.left(index) const rightIndex = this.right(index) let maxIndex = index if (list[leftIndex] !== undefined && this.compare(list[maxIndex], list[leftIndex]) > 0) { maxIndex = leftIndex } if (list[rightIndex] !== undefined && this.compare(list[maxIndex], list[rightIndex]) > 0) { maxIndex = rightIndex } if (index !== maxIndex) { const temp = list[index] list[index] = list[maxIndex] list[maxIndex] = temp this.heapify(maxIndex) } } this.buildHeap = () => { for (let i = Math.floor(this.list.length / 2); i >= 0; i--) { this.heapify(i) } return this.list } this.extract = () => { const temp = this.list[0] this.list[0] = this.list[this.list.length - 1] this.list[this.list.length - 1] = temp const result = this.list.pop() this.heapify(0) return result } this.top = () => { return this.list[0] } this.insert = (item) => { const { list } = this list.push(item) let index = list.length - 1 let parentIndex = this.parent(index) while (list[parentIndex] !== undefined && this.compare(list[parentIndex], list[index]) > 0) { const temp = list[index] list[index] = list[parentIndex] list[parentIndex] = temp index = parentIndex parentIndex = this.parent(index) } } this.list = list this.compare = compare this.buildHeap() } } var kClosest = function(points, k) { // To find the nearest point, a max heap should be used to store the k smallest var compare = function (a,b) { var A = a[0] * a[0] + a[1] * a[1] var B = b[1] * b[1] + b[0] * b[0] return B - A } var heap = new Heap([],(a,b) => { return compare(a,b) }) for(let i = 0 ; i < points.length ; i ++) { if (i < k) { heap.insert(points[i]) } else { var top = heap.top() // top is greater than the current value, exit top if(compare(points[i],top) > 0) { heap.extract() heap.insert(points[i]) } } } return heap.list};

Interview Question-17-14-Minimum Number of K

Thu, 08 Apr 2021 00:00:00 +0000

Time: 10 minutes const swap = function (arr,i,j) { [arr[i],arr[j]] = [arr[j],arr[i]] } class MaxHeap { constructor() { this.count = 0 this.data = new Array(this.count + 1) } shiftUp(k) { // Put the new elements up while(k>=1) { let father = Math.floor(k / 2) if (this.data[k] > this.data[father]) { swap(this.data,k,father) k = father } else { break } } } shiftDown(k) { while( k * 2 <= this.count) { // Indicates that k has children let j = k if (k * 2 + 1 <= this.count && this.data[k * 2 + 1] > this.data[k] && this.data[k * 2 + 1] > this.data[k * 2]) { j = k * 2 + 1 } else if (this.data[k * 2] > this.data[k]) { j = k * 2 } else { break } swap(this.data,j,k) k = j } } size() { return this.count } isEmpty() { return this.count === 0 } insert(item) { this.data[++this.count] = item this.shiftUp(this.count) } extractMax() { if (this.count < 0) return let ret = this.data[1] swap(this.data,1,this.count--) this.shiftDown(1) return ret } top() { return this.data[1] } } var smallestK = function(arr, k) { var heap = new MaxHeap() var K = 0 while(K < k) { heap.insert(arr[K]) K++ } // Maintain the heap at size K while(K < arr.length) { var max = heap.top() if (arr[K] < max) { heap.extractMax() heap.insert(arr[K]) } K++ } var size = heap.size() return heap.data.slice(1, 1 + size ) };

347-first-K-high-frequency elements

Thu, 08 Apr 2021 00:00:00 +0000

Time: 30 minutes The idea is to first use the time complexity of On to count, and then solve it using the minimum heap method class Heap { constructor(list, compare = (a, b) => a - b) { this.left = index => 2 * index + 1 this.right = index => 2 * index + 2 this.parent = index => Math.floor((index - 1) / 2) this.heapify = (index = 0) => { const { list } = this const leftIndex = this.left(index) const rightIndex = this.right(index) let maxIndex = index if (list[leftIndex] !== undefined && this.compare(list[maxIndex], list[leftIndex]) > 0) { maxIndex = leftIndex } if (list[rightIndex] !== undefined && this.compare(list[maxIndex], list[rightIndex]) > 0) { maxIndex = rightIndex } if (index !== maxIndex) { const temp = list[index] list[index] = list[maxIndex] list[maxIndex] = temp this.heapify(maxIndex) } } this.buildHeap = () => { for (let i = Math.floor(this.list.length / 2); i >= 0; i--) { this.heapify(i) } return this.list } this.extract = () => { const temp = this.list[0] this.list[0] = this.list[this.list.length - 1] this.list[this.list.length - 1] = temp const result = this.list.pop() this.heapify(0) return result } this.top = () => { return this.list[0] } this.insert = (item) => { const { list } = this list.push(item) let index = list.length - 1 let parentIndex = this.parent(index) while (list[parentIndex] !== undefined && this.compare(list[parentIndex], list[index]) > 0) { const temp = list[index] list[index] = list[parentIndex] list[parentIndex] = temp index = parentIndex parentIndex = this.parent(index) } } this.list = list this.compare = compare this.buildHeap() } } var topKFrequent = function(nums, k) { var map = {} for(let i = 0 ; i < nums.length ; i ++) { var num = nums[i] if (map[num] == undefined) { map[num] = 1 } else { map[num] ++ } } // Use a minimum heap to maintain the K highest elements var heap = new Heap([],(a,b) => a[1] - b[1]) var K = 0 // Because the api is a maximum heap, we need to take the opposite number Object.entries(map).forEach(([key,val]) => { if (K < k) { heap.insert([key,-val]) } else { var top = heap.top() if (val > - top[1]) { heap.extract() heap.insert([key,-val]) } } }) return heap.list.map((v) => v[0]).slice(0,k) };

295-Median of data streams

Wed, 24 Mar 2021 00:00:00 +0000

Time: Read the answer Since it is a pile exercise, it must be closer to the idea of pile Since we only want the median, there is no need to sort all the numbers. You can use two heaps, a maximum heap and a minimum heap When the total number is odd (i.e., the number of maximum heaps - minimum heaps = 1), get the maximum value of the maximum heap

1738-Find the K-th largest XOR coordinate value

Mon, 22 Mar 2021 00:00:00 +0000

Time: Refer to the answer After reading the title, the first thing that comes to mind is that dp cannot escape But writing the conversion equation requires some skill Observe that dp[1][1] = matrix[0][0] ^ matrix[0][1] ^ matrix[1][0] ^ matrix[1][1] Then use the property of XOR The same value is XORed to 0, and any value XORed with 0 is itself Can be written as dp[1][1] = matrix[0][0] ^ (matrix[0][1] ^ matrix[0][0]) ^ (matrix[1][0] ^ matrix[1][0]) ^ matrix[1][1]

865 - Minimum subtree with all deepest nodes

Sun, 21 Mar 2021 00:00:00 +0000

Time: 60 minutes I was misled by the depth of the question and thought that the calculation depth should be done from top to bottom. In fact, it can be done from bottom to top. If the left and right subtrees have the same height, return the node itself and its depth. If the left subtree is deeper, it means that the smallest and deepest part is in the left subtree. Return the left subtree and its own depth.

1046-The Weight of the Last Stone

Sun, 21 Mar 2021 00:00:00 +0000

Time: 10 minutes A simple question shouldn’t ask me to write the maximum heap by hand. const swap = function (arr,i,j) { [arr[i],arr[j]] = [arr[j],arr[i]] } class MaxHeap { constructor() { this.count = 0 this.data = new Array(this.count + 1) } shiftUp(k) { // Put the new elements up while(k>=1) { let father = Math.floor(k / 2) if (this.data[k] > this.data[father]) { swap(this.data,k,father) k = father } else { break } } } shiftDown(k) { while( k * 2 <= this.count) { // Indicates that k has children let j = k if (k * 2 + 1 <= this.count && this.data[k * 2 + 1] > this.data[k] && this.data[k * 2 + 1] > this.data[k * 2]) { j = k * 2 + 1 } else if (this.data[k * 2] > this.data[k]) { j = k * 2 } else { break } swap(this.data,j,k) k = j } } size() { return this.count } isEmpty() { return this.count === 0 } insert(item) { this.data[++this.count] = item this.shiftUp(this.count) } extractMax() { if (this.count < 0) return let ret = this.data[1] swap(this.data,1,this.count--) this.shiftDown(1) return ret } } var lastStoneWeight = function(stones) { var heap = new MaxHeap() for(let i = 0 ; i < stones.length ; i++) { heap.insert(stones[i]) } while(heap.size() > 1) { var s1 = heap.extractMax() var s2 = heap.extractMax() var reduce = Math.abs(s1 - s2) if (reduce) { heap.insert(reduce) } } if (heap.size() === 0) { return 0 } return heap.extractMax() };Time: 10 minutes

783-Binary Search Tree Node Minimum Distance

Thu, 18 Mar 2021 00:00:00 +0000

Time: 10 minutes Solve by using the property of pre-order traversal of binary tree var minDiffInBST = function(root) { var min = Infinity var pre = null var dfs = function (root) { if (!root) return if (root.left) { dfs(root.left) } if (pre == null) { pre = root.val } else { console.log(pre,root.val) var reduce = Math.abs(pre - root.val) min = Math.min(min,reduce) pre = root.val } if (root.right) { dfs(root.right) } } dfs(root) return min };

814-Binary Tree Pruning

Wed, 17 Mar 2021 00:00:00 +0000

Time: 6 minutes It’s very simple. In-order traversal, calculate whether the value 1 exists in the subtrees on both sides, and remove it if not. If the left or right subtree or the tree itself contains 1, return true. Otherwise, return false. var pruneTree = function(root) { var DFS = function (root) { if (!root) return false var left = DFS(root.left) var right = DFS(root.right) if (!left) { root.left = null } if (!right) { root.right = null } if (left) { return true } if (right) { return true } if( root.val === 1) { return true } } var dummp = new TreeNode(1) dummp.left = root DFS(dummp) return dummp.left};One point to note is that the root itself may also need to be pruned, so a virtual node is added as the parent node

1448-Count the number of good nodes in a binary tree

Wed, 17 Mar 2021 00:00:00 +0000

Notes on counting good nodes in a binary tree using DFS with a running max.

1325-Delete the leaf node of the given value

Wed, 17 Mar 2021 00:00:00 +0000

Post-order traversal approach to delete target-valued leaf nodes using a dummy root.

1022 - the sum of the binary numbers from root to leaf

Wed, 17 Mar 2021 00:00:00 +0000

Time: 10 minutes The preorder is calculated from top to bottom, there is nothing much to say Converting binary to decimal is quite difficult, so I just parseInt(path, 2) var sumRootToLeaf = function(root) { var ans = 0 var dfs = function (root,path) { if (!root) return path += root.val if (!root.left && !root.right) { ans += parseInt(path, 2) } root.left && dfs(root.left,path) root.right && dfs(root.right,path) } dfs(root,'') return ans };Time: 10 minutes The preorder is calculated from top to bottom, there is nothing much to say Converting binary to decimal is quite difficult, so I just parseInt(path, 2) var sumRootToLeaf = function(root) { var ans = 0 var dfs = function (root,path) { if (!root) return path += root.val if (!root.left && !root.right) { ans += parseInt(path, 2) } root.left && dfs(root.left,path) root.right && dfs(root.right,path) } dfs(root,'') return ans };

Interview Question-04-12-Sum Path

Tue, 16 Mar 2021 00:00:00 +0000

Time: 20 minutes Because we are looking for “the path starting from each node is sum” Obviously, backtracking comes to mind. Since it is a binary tree, double recursion is used. The outer recursion is used to find all nodes, and the inner recursion is used to calculate the path of the nodes. var pathSum = function(root, sum) { var res = 0 var dfs = function (root,total,visited) { if (!root) return if (total + root.val == sum) { res++ } else if (total + root.val > sum) { return } dfs(root.left,total + root.val,[...visited,root.val]) dfs(root.right,total + root.val,[...visited,root.val]) } var dfs_outer = function (root) { if (!root )return root.left && dfs_outer(root.left) dfs(root,0,[]) root.right && dfs_outer(root.right) } dfs_outer(root) return res };

563-Slope of Binary Tree

Tue, 16 Mar 2021 00:00:00 +0000

Time: 15 minutes Time: 15 minutes My first reaction when I got the question was to use recursion, but after I started writing it, I found that The condition that recursion needs to meet is that the problem can be split into sub-problems, but according to the meaning of the question, what we need to find is the difference between the sum of the left and right nodes of each node. This “sum of the left and right nodes” is a different problem for each node.

129-Find the sum of numbers from the root node to the leaf node

Tue, 16 Mar 2021 00:00:00 +0000

The question is about starting from the root node. The first thing that comes to mind is top-down DFS, passing parameters downward, and the end condition has no left or right children. Start with the pre-order traversal, and you can assume that all the previous nodes have been processed. var sumNumbers = function(root) { var ans = 0 var DFS = function (root,path) { if (!root) return path += root.val if (!root.left && !root.right) { ans += Number(path) } root.left && DFS(root.left,path) DFS(root.right, path) } DFS(root,'') return ans };The question is about starting from the root node. The first thing that comes to mind is top-down DFS, passing parameters downward, and the end condition has no left or right children.

124-Maximum Path Sum in a Binary Tree

Mon, 15 Mar 2021 00:00:00 +0000

Time: 30 minutes Once you understand the question, you can actually do it quickly. The question is about the value of any node. We can find the value of each node and choose the largest one. Since the path cannot return, we know that the path of the child node of the root node we start from can only choose left or right, or neither, and the result is x When finding max, compare x with the case where both sides are selected.

99-Restore Binary Search Tree

Sat, 13 Mar 2021 00:00:00 +0000

Time: 60 minutes The idea is still in-order traversal, using pre to cache the previous node. Because the in-order traversal is incremental, you must find the larger one first and then the smaller one. So the first problem is pre, the second is root var recoverTree = function(root) { var left = null var right = null var pre = null // You must find the big one first, then the small one, so the first one to have a problem is pre, and the second one to have a problem is root var DFS = function (root) { if (root.left) { DFS(root.left) } if (pre) { console.log(pre.val) if (pre.val > root.val) { if(!left) { left = pre right = root } else { right = root } } pre = root } else { pre = root } if (root.right) { DFS(root.right) } } DFS(root) if (left && right) { [left.val,right.val] = [right.val,left.val] } return root}

98-Verify Binary Search Tree

Sat, 13 Mar 2021 00:00:00 +0000

Time: 10 minutes Just use the increasing property of in-order traversal of the binary search tree In-order traversal to find the left child Does pre exist? If not, assign , find the right child, and return 1 If it exists, is it less than val? If yes, do not increment, and return false If not, increment, assign pre, and return 1 var isValidBST = function(root) { var preVal = null var DFS = function(root) { var left = true var right = true if (root.left) { left = DFS(root.left) } if (preVal !== null) { if (preVal >= root.val) return false preVal = root.val } else { preVal = root.val } if (root.right) { right = DFS(root.right) } return left && right } return DFS(root) };

863-All nodes with distance -K- in a binary tree

Sat, 13 Mar 2021 00:00:00 +0000

Time: 60 minutes The idea is still very simple. First use DFS to add a parent to each node, and find the required target by the way. Then starting from the target, use DFS to find a point K away from the target. Find all the parents of target in turn and use DFS to find the point with a distance K. The reason why it takes so much time is that after finding the parent, DFS is used to find it back, causing a memory overflow.

662-Binary Tree Maximum Width

Sat, 13 Mar 2021 00:00:00 +0000

Time: 120 minutes The initial idea was to use BFS, and remove a whole queue when removing it (later I learned that this is called breadth traversal) Then the double pointer finds the left and right nodes. End when both the left and right nodes do not exist var widthOfBinaryTree = function(root) { var que = [root] var max = 0 while(que.length) { var len = que.length var left = 0 var right = que.length - 1 while(!que[left] && left < len) { left ++ } while(!que[right] && right >= 0) { right -- } if (left > right) { break } max = Math.max(max,right - left+ 1) for(let i = 0 ; i < len ; i ++) { var node = que.shift() if (!node) { que.push(node) que.push(node) continue } node.left ? que.push(node.left) : que.push(null) node.right ? que.push(node.right) : que.push(null) } } return max };Soon, the submission showed that the execution exceeded the time limit, so a queue for storing sequence numbers was added, which was synchronized with the BFS stack to calculate the left and right distances.

222-Number of nodes in a complete binary tree

Sat, 13 Mar 2021 00:00:00 +0000

Time: 80 minutes The first reaction when I got the question was of course to solve it with DFS. But this is a complete binary tree, so we should use the properties of a complete binary tree. You can examine the depth of the left and right subtrees of the binary tree If the left depth is greater than the right depth, it means that the right side is full. The number of full nodes is 2 to the power of n - 1, plus the root is 2 to the power of n, and continue recursively on the left side.

669-Pruning a Binary Search Tree

Thu, 11 Mar 2021 00:00:00 +0000

#669. Pruning a binary search tree Release Date: March 11, 2021 Time: 20 minutes Similar to the previous question, most of them are divided into situations where the parent node is in the interval and not in the interval var trimBST = function(root, low, high) { var add = function (root,node) { if (!node || !root) return null if (node.val > root.val ) { if (!root.right) { root.right = node } else { add(root.right,node) } } if (node.val < root.val) { if (!root.left) { root.left = node } else { add(root.left,node) } } } var walk = function (root) { if (!root) return root if (root.val < low || root.val > high) { var left = walk(root.left) var right = walk(root.right) if (!left && !right) { root = null } else if (right && left) { root = right add(root,left) } else if (left) { root = left } else { root = right } } else { root.left= walk(root.left) root.right = walk(root.right) } return root } return walk(root) };After reading the analysis, I found that it can be simpler. The idea is that if it is greater than the right boundary, look directly in the left branch; if it is less than the left boundary, look directly in the right branch. This saves the step of deleting the node.

450-Delete a node in a binary search tree

Thu, 11 Mar 2021 00:00:00 +0000

Time: 30 minutes The question is divided into two parts to be solved, search and delete The search part is to find the node. You can find the required node according to the properties of the binary search tree. There are three types of deletion If there is only a left child, replace it with the left child. If there is only a right child, replace it with the right child. If there is neither child, assign null. (Since there was a recursive assignment earlier, this will succeed.) If there are both children, store the left child, replace it with the right child, and then find the left child’s position on the right. var deleteNode = function(root, key) { function insert(root,node) { if (root.val > node.val) { if (!root.left) { root.left = node } else { insert(root.left,node) } } else { if (!root.right) { root.right = node } else { insert(root.right,node) } } } function search(root) { if (!root) { return null } if (root.val > key) { root.left = search(root.left) } else if (root.val < key){ root.right = search(root.right) } else { if (!root.left && !root.right) { root = null } else if (root.left && root.right) { var left = root.left root = root.right insert(root,left) } else if (root.left) { root = root.left } else if (root.right) { root = root.right } } return root } return search(root) };Points to note

116-Fill in the next right node pointer of each node

Wed, 10 Mar 2021 00:00:00 +0000

Time: 25 minutes The main idea is to use the stack. The difference from the ordinary level-order traversal is that the stack is cleared every time var connect = function(root) { if (!root) return null var stack = [root] while(stack.length) { var _stack = [...stack,null] stack = [] var pre = _stack.shift() while(_stack.length || pre) { pre.left && stack.push(pre.left) pre.right && stack.push(pre.right) pre.next = _stack.shift() pre = pre.next } } return root};Obviously, the memory space of On I used does not meet the constant space requirement of the question, considering that the links of each layer can be found in the form of a linked list by relying on the parent node.

1008-Pre-order traversal to construct a binary search tree

Wed, 10 Mar 2021 00:00:00 +0000

Time: Not done The main reason I didn’t make it was that I kept thinking about how to use a stack. When I looked at the answer to the stack later, I found that recursion was the simplest. recursion The idea is very simple. First, write out how to insert a child node. If the node is smaller than the parent node and the parent node’s left node is empty, make it the left node. If the node is larger than the parent node and the parent node’s right node is empty, make it the right node. If the node is smaller than the parent node, assign the parent node to the parent node’s left node and return to 1. If the node is larger than the parent node, assign the parent node to the parent node’s right node and return to 1. Traverse the entire array and insert each node one by one to get the result. var bstFromPreorder = function(preorder) { var add = function (node,val) { if (val < node.val && !node.left) { node.left = new TreeNode(val) } if (val > node.val && !node.right) { node.right = new TreeNode(val) } if (val < node.val) { add(node.left,val) } if (val > node.val) { add(node.right,val) } } var root = new TreeNode(preorder.shift()) for(let i = 0 ; i < preorder.length ; i ++) { add(root,preorder[i]) } return root};Time: Not done

894-All possible full binary trees

Sun, 07 Mar 2021 00:00:00 +0000

Time: I copied the answers and finished it. It is easy to see that the idea is to use recursion, but the coding is the real problem. What we need to return is the root node, but the recursion is from bottom to top Try to solve it using dynamic programming, where dp(n) is the combination of dp(x) and dp (n - x - 1) var allPossibleFBT = function(n) { var dp = [] var buld = function (n) { for(let i = 1 ; i <= n ; i ++ ) { if (i === 1) { dp[i] = new TreeNode(0) } else if (i % 2 === 0) { dp[i] = undefined } else { dp[i] = [] for(let left = 1; left < i; left ++) { var leftNodes = dp[left] var rightNodes = dp[i - left - 1] for(let j = 0 ; j < leftNodes.length ; j ++) { for(let k = 0 ; k < rightNodes.length ; k ++) { var node = new TreeNode(0) node.left = leftNodes[j] node.right = rightNodes[k] dp[i].push(node) } } } } } } buld(n) return dp[n] };

297-Serialization and Deserialization of Binary Trees

Thu, 04 Mar 2021 00:00:00 +0000

Time: 30 minutes Serialization is simple and can be solved using BFS Deserialization requires the use of the properties of a binary tree, that is, the child nodes of the i-th node are (i + 1) * 2 - 1 and (i + 1) * 2 respectively. Find the parent node and push it onto the stack. At this point, pointer i is at the parent node’s val. Pop the parent node from the stack and find the parent node’s left and right nodes. The pointers find their values twice according to the rules. Push the left and right nodes onto the stack. i++ Repeat 1. var serialize = function(root) { if (!root) return [] var que = [root] var res = [] while(que.length) { var cur = que.shift() if (cur) { res.push(cur.val); que.push(cur.left); que.push(cur.right); } else { res.push('null'); } } return res.join(',') };/** * Decodes your encoded data to tree. * * @param {string} data * @return {TreeNode} */var deserialize = function(data) { if (!data.length) return null var nodes = data.split(',') var i = 0 var root = new TreeNode(nodes[i]) var que = [root] while ( que.length) { var node = que.shift() var left = nodes[ (i + 1) * 2 - 1] var right = nodes[ (i + 1) * 2] if (left !== 'null') { node.left = new TreeNode(left) que.push(node.left) } else { node.left = null } if (right !== 'null') { node.right = new TreeNode(right) que.push(node.right) } else { node.right = null } i++ } return root};

1372-Longest Alternating Path in a Binary Tree

Mon, 01 Mar 2021 00:00:00 +0000

Time: 25 minutes In fact, this is a relatively common DFS type question. The reason why it took so long is because there was a problem in judging the boundary value. When starting from the root, since the root may not have child nodes, the len value is 0 Starting from the child node, since the child nodes have been judged, it is considered that there is an edge of length 1 from the current node to the next node, so it is 1

Summary of Binary Trees

Sun, 28 Feb 2021 00:00:00 +0000

When traversing a binary tree in front, middle, or post-order, we use a stack to simplify operations. This is because they are all recursive structures of DFS, which means processing from bottom to top. However, I always start writing code from the root node, so I need a stack, and the stack is first-in-first-out. This way, I can process the root node last. Level-order traversal is BFS, from top to bottom. The root element that was enqueued first is also the one I want to process first. This is why DFS uses a stack and BFS uses a queue.

133-Path Sum II

Sun, 28 Feb 2021 00:00:00 +0000

Time: 10 minutes The question is to find the path from the root node to the child nodes whose sum is equal to the target value. It is easy to think of using DFS. The path can be passed as a parameter. As long as the last node is a leaf node, it can be used. var pathSum = function(root, sum) { var res = [] if (!root) return [] var dfs = function (node,visited,total) { if (sum === total && (!node.left && !node.right)) { res.push(visited) return } node.left && dfs(node.left,[...visited,node.left.val],total + node.left.val) node.right && dfs(node.right ,[...visited,node.right.val], total + node.right.val) } dfs(root,[root.val],root.val) return res };Time: 10 minutes

102 - Level-order Traversal of a Binary Tree

Sun, 28 Feb 2021 00:00:00 +0000

Techniques and examples for breadth-first (level-order) traversal of binary trees.

Two-color labeling

Sat, 27 Feb 2021 00:00:00 +0000

As you can see from the previous questions, the recursive methods for front-, middle-, and post-order traversal of a binary tree are similar, but the iterative implementation is completely different. Get inspired by the three-color marking method of garbage collection and find their common points Push the node onto the stack and mark it as 0 (unvisited). Pop the node off the stack. If it has been visited, pop it. If it has not been visited, mark it as visited and push it onto the stack. Continue with the left and right nodes to 1. In this way, we can use similar code to iteratively traverse a binary tree in front, middle, and back order by controlling the order in which we push the nodes onto the stack. All we need to do is create an additional On space to store the node status. Take post-order traversal as an example

145-Post-order traversal of a binary tree

Fri, 26 Feb 2021 00:00:00 +0000

1h The order of in-order traversal is left - right - center recursion It’s very easy with recursion var postorderTraversal = function(root) { var res = [] if (!root) return res var travel = function (node) { node.left && travel(node.left) node.right && travel(node.right) res.push(node.val) } travel(root) return res }; ```Iteration 1. Push the root node onto the stack. 1. Determine whether a node can be popped. If so, record itself as the node that was popped and pop it. 1. If a node cannot be popped, push the right and left nodes onto the stack. 1. Repeat step 2. ```javascript var postorderTraversal = function(root) { var stack = [root] var res = [] if (!root) { return res } var pre = root while(stack.length) { var node = stack[stack.length - 1] // When the left/right node of a node is the last node to be output, it means that both the left and right nodes have been output (because the root node is at the end of the post-order traversal) if ( (!node.left && !node.right) || (node.left === pre || node.right === pre)) { // Only when there is no left or right node, or both left and right nodes have been output, can node = stack.pop() be output. pre = node res.push(node.val) } else { if (node.right) { stack.push(node.right) } if(node.left) { stack.push(node.left) } } } return res }; ```Summarize Although I have completed the forward, in-order, and post-order traversal of a binary tree, I have a feeling that I will forget it soon, especially the in-order and post-order traversal. I have not found any similarities between the two, so I will make a summary later. 1h The order of in-order traversal is left - right - center recursion It's very easy with recursion ```javascript var postorderTraversal = function(root) { var res = [] if (!root) return res var travel = function (node) { node.left && travel(node.left) node.right && travel(node.right) res.push(node.val) } travel(root) return res }; ```Iteration 1. Push the root node onto the stack. 1. Determine whether a node can be popped. If so, record itself as the node that was popped and pop it. 1. If a node cannot be popped, push the right and left nodes onto the stack. 1. Repeat step 2. ```javascript var postorderTraversal = function(root) { var stack = [root] var res = [] if (!root) { return res } var pre = root while(stack.length) { var node = stack[stack.length - 1] // When the left/right node of a node is the last node to be output, it means that both the left and right nodes have been output (because the root node is at the end of the post-order traversal) if ( (!node.left && !node.right) || (node.left === pre || node.right === pre)) { // Only when there is no left or right node, or both left and right nodes have been output, can node = stack.pop() be output. pre = node res.push(node.val) } else { if (node.right) { stack.push(node.right) } if(node.left) { stack.push(node.left) } } } return res }; ```Summarize Although I've completed the forward, in-order, and post-order traversals of a binary tree, I have a feeling I'll soon forget them. This is especially true for the in-order and post-order traversals. I haven't found any similarities between them, so I'll summarize them later.

Understanding React Hooks

Thu, 25 Feb 2021 00:00:00 +0000

Understanding React Hooks Release Date: February 25, 2021 Understanding React Hooks Those who have used the old version of react should know that react’s class component has state to manage the internal state, as shown in the following example code class Clock extends React.Component { constructor(props) { super(props); this.state = {date: new Date()}; } render() { return (

Hello, world!

It is {this.state.date.toLocaleTimeString()}.

); } }Function components do not have their own state, as shown in the following example code function Clock() { return (

Hello, world!

It is {new Date().toLocaleTimeString()}.

) }If I want to use a function component and want to have manual control over the date, I have to modify the component using props as follows, which transfers control to the parent component:

94-In-order traversal of a binary tree

Thu, 25 Feb 2021 00:00:00 +0000

30min The order of in-order traversal is left - middle - right recursion It’s very easy with recursion var inorderTraversal = function(root) { var res = [] if (!root) { return res } var travel = function (node) { node.left && travel(node.left) res.push(node.val) node.right && travel(node.right) } travel(root) return res }; ```Iteration The iterative steps are more complicated because the root node is not output first, so the root node needs to be retained 1. Push the root node onto the stack and check if it has a left child. If so, continue pushing until you reach a leaf node. 1. Pop the stack, output, and check if it has a right child. If so, push it onto the stack and continue with step 2. ```javascript var inorderTraversal = function(root) { var stack = [] var res = [] if (!root) return res stack.push(root) while(root.left) { stack.push(root.left) root = root.left } while(stack.length) { // At this point the top of the stack is the leftmost node in the tree var node = stack.pop() res.push(node.val) // There is a right node, push it into the stack and continue to look for the left node if (node.right) { node = node.right stack.push(node) while(node.left) { stack.push(node.left) node = node.left } } } return res };

215. Kth Largest Element in an Array

Thu, 25 Feb 2021 00:00:00 +0000

30min The first thing that comes to mind when I get the question is to sort it directly… But we can optimize the quick sort to get the result Solution 1. Quick sort The idea of quick sort is to find a benchmark in the array and divide the array into the benchmark, the part smaller than the benchmark, and the part larger than the benchmark. The benchmark itself has been sorted. If the benchmark is the kth largest element, the result can be obtained directly.

144-Pre-order traversal of a binary tree

Thu, 25 Feb 2021 00:00:00 +0000

10min The order of pre-order traversal of a binary tree is center-left-right First traverse all root nodes and left nodes, then process the right node It can be seen that this is a recursive behavior. Recursive problems can be simplified using stacks. Iterative solution var preorderTraversal = function(root) { if (!root) return null var stack = [root] var res = [] while(stack.length) { var node = stack.pop() res.push(node.val) node.right && stack.push(node.right) node.left && stack.push(node.left) } return res };Recursive solution Recursive problems can of course be solved recursively var preorderTraversal = function(root) { var res = [] if (!root) return res var travel = function (node) { res.push(node.val) node.left && travel(node.left) node.right && travel(node.right) } travel(root) return res };10min

Review of login and registration requirements

Sun, 21 Feb 2021 00:00:00 +0000

A few years ago, the company needed to log in and register, and the estimated construction period was one month. As a result, the project became uncontrollable during the process, and it took almost three months to complete. In order not to waste the overtime work during this period, I reviewed the process of completing the project. About Requirements Review Let’s briefly review the requirements first. Registration/login has three channels: account/password, mobile phone number, and three-party (including WeChat QR code scanning, QQ authorization, and Weibo authorization). Through a series of rules and guidance, you will eventually reach the login/registration success page and then jump to the source web page.

105-Constructing a binary tree from pre-order and in-order traversal sequences-1

Wed, 27 Jan 2021 00:00:00 +0000

Time: 40 minutes ####105. Construct a binary tree from pre-order and in-order traversal sequences recursion Pre-order traversal: center-left-right In-order traversal: left-middle-right Therefore, we can first find the root element from the pre-order traversal, and then determine the number of left and right subtrees from the in-order traversal. var buildTree = function(preorder, inorder) { if (preorder.length === 0 || inorder.length=== 0) return null let nodeVal = preorder.shift() let node = new TreeNode(nodeVal) let index = inorder.indexOf(nodeVal) node.left = buildTree(preorder.slice(0,index), inorder.slice(0,index)) node.right = buildTree(preorder.slice(index),inorder.slice(index + 1)) return node }; ```Optimization Slices are very performance-intensive. In fact, there is no need to pass arrays. Functions can just pass pointers. ```javascript var buildTree = function(preorder, inorder) { var helper = function (p_start,p_end,i_start,i_end) { if (p_start > p_end || i_start > i_end ) return null let nodeVal = preorder[p_start] let node = new TreeNode(nodeVal) let index = inorder.indexOf(nodeVal) let left = index - i_start node.left = helper(p_start + 1 , p_start + left , i_start ,index - 1) node.right = helper(p_start + left + 1,p_end, index + 1,i_end) return node } return helper(0,preorder.length - 1,0,preorder.length - 1) };Summarize:

Hexo upgraded to 5

Fri, 11 Dec 2020 12:37:55 +0000

Filling Diary

Update after a year

Fri, 11 Dec 2020 00:17:30 +0000

One month after leaving Dahua

CSS pseudo-class selector nth-child

Thu, 07 Mar 2019 17:32:19 +0000

About nth-child and HTML specifications

Vue + express + mongodb build a backend login system

Thu, 13 Dec 2018 18:15:10 +0000

Keywords nodejs vue express mongodb

Ajax data transmission optimization

Wed, 28 Nov 2018 14:47:40 +0000

High Performance Javascript Knowledge Points

UI interface response optimization

Thu, 22 Nov 2018 16:55:21 +0000

High Performance Javascript Knowledge Points

Regular expression performance optimization

Tue, 06 Nov 2018 15:48:14 +0000

High Performance Javascript Knowledge Points

Algorithm and process control optimization

Thu, 25 Oct 2018 14:33:59 +0000

High Performance Javascript Knowledge Points

Performance optimization of DOM operations

Wed, 12 Sep 2018 15:09:33 +0000

High Performance Javascript Knowledge Points

Summary of Vue's easy-to-error and easy-to-confuse knowledge points

Mon, 10 Sep 2018 18:30:10 +0000

Knowledge Points Summary

JavaScript Loading Optimization

Tue, 04 Sep 2018 09:23:11 +0000

Notes from 'High Performance JavaScript'

DOM event flow

Wed, 29 Aug 2018 17:29:45 +0000

DOM event flow is easy to confuse

Arrays, stacks, queues

Wed, 22 Aug 2018 15:09:45 +0000

Javascript Data Structures

Proxy implementation of data response

Fri, 27 Jul 2018 15:56:49 +0000

Javascript

HTTP Protocol Summary

Mon, 23 Jul 2018 23:29:19 +0000

HTTP simple organization

ES5-Inheritance

Tue, 17 Jul 2018 09:57:34 +0000

ES5 knowledge review

ES5 - Creating Objects

Fri, 13 Jul 2018 16:51:52 +0000

ES5 knowledge review

async

Wed, 11 Jul 2018 14:47:05 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Generator functions and applications

Fri, 06 Jul 2018 18:37:55 +0000

"ES6 Standard Introduction" Knowledge Points Summary

A Brief Introduction to Web Security

Thu, 05 Jul 2018 10:05:36 +0000

Web security related content

promise

Wed, 27 Jun 2018 13:18:47 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Javascript deep copy implementation

Tue, 26 Jun 2018 17:01:50 +0000

Javascript Basics

Javascript sorting algorithm

Mon, 25 Jun 2018 18:48:42 +0000

Javascript algorithm sorting algorithm

proxy

Fri, 18 May 2018 09:59:26 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Observer mode and Vue monitoring object changes

Sat, 05 May 2018 22:38:54 +0000

Javascript Design Patterns Knowledge Points

Set and Map Data Structures

Wed, 02 May 2018 00:00:00 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Object Expansion

Tue, 24 Apr 2018 00:00:00 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Iterator pattern

Fri, 20 Apr 2018 09:41:05 +0000

Javascript Design Patterns Knowledge Points

Proxy Mode

Thu, 19 Apr 2018 09:46:11 +0000

Javascript Design Patterns Knowledge Points

Js singleton pattern

Fri, 13 Apr 2018 20:06:30 +0000

Javascript Design Patterns Knowledge Points

Function extension

Thu, 12 Apr 2018 00:00:00 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Array expansion

Wed, 11 Apr 2018 00:00:00 +0000

"ES6 Standard Introduction" Knowledge Points Summary

Destructuring assignment of variables

Tue, 10 Apr 2018 11:07:34 +0000

"ES6 Standard Introduction" Knowledge Points Summary