LeetCode Master

https://github.com/youngyangyang04/leetcode-master
Admin
LeetCode Master offers a systematic, step-by-step plan for mastering data structures and algorithms,...
Tokens:865,651
Snippets:5,273
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install PowerVim

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/vim.md

Clone the PowerVim repository and run the install script to set up the configuration. The script backs up existing configurations before applying changes.

```bash
git clone https://github.com/youngyangyang04/PowerVim.git
cd PowerVim
sh install.sh
```

--------------------------------

### Topological Sort Example Input

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/kamacoder/0117.软件构建.md

Example input for the software build dependency problem, specifying the number of files and their dependencies.

```text
5 4
0 1
0 2
1 3
2 4
```

--------------------------------

### Topological Sort Example Output

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/kamacoder/0117.软件构建.md

Example output for the software build dependency problem, showing a valid file processing order.

```text
0 1 2 3 4
```

--------------------------------

### Queue Operations Example

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0225.用队列实现栈.md

Demonstrates the sequence of basic queue operations.

```cpp
queue.push(1);
queue.push(2);
queue.pop();   // 注意弹出的操作       
queue.push(3);
queue.push(4);
queue.pop();  // 注意弹出的操作    
queue.pop();    
queue.pop();    
queue.empty();    
```

--------------------------------

### Example SSH Connection Test

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/gitserver.md

An example of testing the SSH connection to a Git server running on localhost.

```bash
ssh git@127.0.0.1
```

--------------------------------

### File Storage Server Example

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/server.md

This snippet demonstrates a command-line approach to uploading files to a server and generating a downloadable link. It's useful for personal file management and sharing.

```Shell
uploadtomyserver
```

--------------------------------

### Example Usage of MyQueue

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0232.用栈实现队列.md

Demonstrates the usage of the `MyQueue` class, including pushing elements, peeking at the front, popping elements, and checking if the queue is empty.

```cpp
MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

```

--------------------------------

### Go: Alternative DP Approach

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0746.使用最小花费爬楼梯.md

Uses a DP array where dp[i] represents the minimum cost starting from step i. Handles the base cases and the final step differently.

```Go
func minCostClimbingStairs(cost []int) int {
	n := len(cost)
	dp := make([]int, n+1)
	dp[0], dp[1] = cost[0], cost[1]
	for i := 2; i <= n; i++ {
		if i < n {
			dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
		} else {
			dp[i] = min(dp[i-1], dp[i-2])
		}
	}
	return dp[n]
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
```

--------------------------------

### Check Git Installation

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Verify if Git is already installed on your CentOS server. If Git is present, its usage information will be displayed.

```bash
[root@instance-5fcyjde7 ~]# git
usage: git [--version] [--help] [-c name=value]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
           <command> [<args>]

The most commonly used git commands are:
   add        Add file contents to the index
   bisect     Find by binary search the change that introduced a bug
   branch     List, create, or delete branches
   checkout   Checkout a branch or paths to the working tree
   clone      Clone a repository into a new directory
   commit     Record changes to the repository
   diff       Show changes between commits, commit and working tree, etc
   fetch      Download objects and refs from another repository
   grep       Print lines matching a pattern
   init       Create an empty Git repository or reinitialize an existing one
   log        Show commit logs
   merge      Join two or more development histories together
   mv         Move or rename a file, a directory, or a symlink
   pull       Fetch from and merge with another repository or a local branch
   push       Update remote refs along with associated objects
   rebase     Forward-port local commits to the updated upstream head
   reset      Reset current HEAD to the specified state
   rm         Remove files from the working tree and from the index
   show       Show various types of objects
   status     Show the working tree status
   tag        Create, list, delete or verify a tag object signed with GPG

'git help -a' and 'git help -g' lists available subcommands and some
concept guides. See 'git help <command>' or 'git help <concept>'
to read about a specific subcommand or concept.
```

--------------------------------

### Whitespace: Operator Spacing

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/代码风格.md

This example demonstrates the Google C++ style guide rule for whitespace around operators. A space should be placed on both sides of an operator.

```C++
i = i + 1;
```

--------------------------------

### Generate Spiral Matrix in JavaScript

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0059.螺旋矩阵II.md

This JavaScript solution generates a spiral matrix using a similar layer-by-layer approach as the Java and Python examples. It uses variables to manage the starting position, rotation count, and offset.

```javascript
var generateMatrix = function(n) {
    let startX = startY = 0;   // 起始位置
    let loop = Math.floor(n/2);   // 旋转圈数
    let mid = Math.floor(n/2);    // 中间位置
    let offset = 1;    // 控制每一层填充元素个数
    let count = 1;     // 更新填充数字
    let res = new Array(n).fill(0).map(() => new Array(n).fill(0));

    while (loop--) {
        let row = startX, col = startY;
        // 上行从左到右（左闭右开）
        for (; col < n - offset; col++) {
            res[row][col] = count++;
        }
        // 右列从上到下（左闭右开）
        for (; row < n - offset; row++) {
            res[row][col] = count++;
        }
        // 下行从右到左（左闭右开）
        for (; col > startY; col--) {
            res[row][col] = count++;
        }
        // 左列做下到上（左闭右开）
        for (; row > startX; row--) {
            res[row][col] = count++;
        }

        // 更新起始位置
        startX++;
        startY++;

        // 更新offset
        offset += 1;
    }
    // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
    if (n % 2 === 1) {
        res[mid][mid] = count;
    }
    return res;
};
```

--------------------------------

### Variable Naming: Small Camel Case Example

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/代码风格.md

Demonstrates the small camel case naming convention for variables, where the first word is lowercase and subsequent words start with an uppercase letter. This style is often used in languages like Java and Go, and is adopted here to match LeetCode's default function naming.

```C++
int myAge;
```

--------------------------------

### Check Git Installation on CentOS

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/gitserver.md

Verify if Git is already installed on your CentOS server. If Git is installed, this command will display its usage information.

```bash
su root
```

```bash
[root@instance-5fcyjde7 ~]# git
usage: git [--version] [--help] [-c name=value]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
           <command> [<args>]

The most commonly used git commands are:
   add        Add file contents to the index
   bisect     Find by binary search the change that introduced a bug
   branch     List, create, or delete branches
   checkout   Checkout a branch or paths to the working tree
   clone      Clone a repository into a new directory
   commit     Record changes to the repository
   diff       Show changes between commits, commit and working tree, etc
   fetch      Download objects and refs from another repository
   grep       Print lines matching a pattern
   init       Create an empty Git repository or reinitialize an existing one
   log        Show commit logs
   merge      Join two or more development histories together
   mv         Move or rename a file, a directory, or a symlink
   pull       Fetch from and merge with another repository or a local branch
   push       Update remote refs along with associated objects
   rebase     Forward-port local commits to the updated upstream head
   reset      Reset current HEAD to the specified state
   rm         Remove files from the working tree and from the index
   show       Show various types of objects
   status     Show the working tree status
   tag        Create, list, delete or verify a tag object signed with GPG

'git help -a' and 'git help -g' lists available subcommands and some
concept guides. See 'git help <command>' or 'git help <concept>'
to read about a specific subcommand or concept.
```

--------------------------------

### Create and Initialize Local Git Repository

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Use these commands to create a new directory for your project, navigate into it, and initialize a Git repository.

```bash
mkdir world
cd world
```

```bash
cd world
git init
```

--------------------------------

### Install Git on CentOS

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Install Git on your CentOS server using yum if it is not already present. The default version installed by yum is typically 1.8.3.1.

```bash
yum install git
```

--------------------------------

### Create and Initialize Local Git Repository

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/gitserver.md

Create a local directory, navigate into it, and initialize a new Git repository. Ensure the local directory name matches the remote repository name for clarity.

```bash
mkdir world
cd world
git init
```

--------------------------------

### JavaScript: Greedy by Start Time (Reverse Iteration)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by their start times. It then iterates backward through the sorted intervals, counting the maximum number of non-overlapping intervals. The 'end' variable tracks the start of the current interval being considered for non-overlap. This approach prioritizes intervals with larger start times when overlaps occur.

```javascript
var eraseOverlapIntervals = function(intervals) {
    // 按照左边界升序排列
    intervals.sort((a, b) => a[0] - b[0])
    let count = 1
    let end = intervals[intervals.length - 1][0]
    // 倒序遍历，对单个区间来说，左边界越大越好，因为给前面区间的空间越大
    for(let i = intervals.length - 2; i >= 0; i--) {
        if(intervals[i][1] <= end) {
            count++
            end = intervals[i][0]
        }
    }
    // count 记录的是最大非重复区间的个数
    return intervals.length - count
}
```

--------------------------------

### Check Git Version

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

After installation, verify the installed Git version on your CentOS server.

```bash
git --version
```

--------------------------------

### Compile and Run KV Storage Engine Demo

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/kvstore.md

Compile the main C++ file using make and then run the executable to interact with the KV storage engine demo. This demonstrates basic operations like insertion, deletion, and display.

```bash
make            // complie demo main.cpp
./bin/main      // run
```

--------------------------------

### Complete DFS Solution 1 (C++)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0841.钥匙和房间.md

This is a complete C++ implementation of the 'Keys and Rooms' problem using the first DFS approach, where the current node is processed upon visiting. It initializes a visited array, starts DFS from room 0, and then checks if all rooms have been visited.

```C++
class Solution {
private:
    void dfs(const vector<vector<int>>& rooms, int key, vector<bool>& visited) {
        if (visited[key]) {
            return;
        }
        visited[key] = true;
        vector<int> keys = rooms[key];
        for (int key : keys) {
            dfs(rooms, key, visited);
        }
    }
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        vector<bool> visited(rooms.size(), false);
        dfs(rooms, 0, visited);
        for (int i : visited) {
            if (i == false) return false;
        }
        return true;
    }
};
```

--------------------------------

### Initialize Bare Git Repository

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Initializes a new, bare Git repository. Bare repositories are used on servers and do not have a working directory, only the Git version history.

```bash
git init --bare
```

--------------------------------

### Project Compilation and Execution

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/kvstore.md

Instructions on how to compile and run the KV storage engine project.

```APIDOC
## Project Compilation and Execution

To compile and run the KV storage engine:

1.  **Compile**: Use the `make` command in the project's root directory.
    ```bash
    make
    ```
2.  **Run**: Execute the compiled program.
    ```bash
    ./bin/main
    ```

This will run the main application which demonstrates various functionalities like inserting, deleting, and displaying data. To use the KV storage engine in your own C++ programs, include `skiplist.h` and utilize its provided interfaces.
```

--------------------------------

### Python: Greedy by Start Time (Counting Non-Overlaps)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by start time. It counts the maximum number of non-overlapping intervals. If the current interval does not overlap with the previous one (start >= previous end), it increments the non-overlapping count. If they overlap, it updates the current interval's end to the minimum of the two to potentially allow more subsequent intervals.

```python
class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0
        
        intervals.sort(key=lambda x: x[0])  # 按照左边界升序排序
        
        result = 1  # 不重叠区间数量，初始化为1，因为至少有一个不重叠的区间
        
        for i in range(1, len(intervals)):
            if intervals[i][0] >= intervals[i - 1][1]:  # 没有重叠
                result += 1
            else:  # 重叠情况
                intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])  # 更新重叠区间的右边界
        
        return len(intervals) - result
```

--------------------------------

### TypeScript: Greedy by Start Time (Counting Removals)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by their start times. It iterates from left to right, counting the number of intervals to remove. When an overlap is detected (current interval's start is less than the 'right' boundary), the 'right' boundary is updated to the minimum of the current 'right' and the current interval's end, and the removal count is incremented.

```typescript
function eraseOverlapIntervals(intervals: number[][]): number {
    if (intervals.length === 0) return 0;
    intervals.sort((a, b) => a[0] - b[0]);
    let right: number = intervals[0][1];
    let tempInterval: number[];
    let resCount: number = 0;
    for (let i = 1, length = intervals.length; i < length; i++) {
        tempInterval = intervals[i];
        if (tempInterval[0] >= right) {
            // 未重叠
            right = tempInterval[1];
        } else {
            // 有重叠，移除当前interval和前一个interval中右边界更大的那个
            right = Math.min(right, tempInterval[1]);
            resCount++;
        }
    }
    return resCount;
};
```

--------------------------------

### Go: 二叉树层平均值层序遍历 (list.New)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0102.二叉树的层序遍历.md

使用 container/list 实现的队列进行层序遍历，计算每层的和与节点数，然后求平均值。注意保存当前层长度以正确处理元素个数。

```go
/**
637. 二叉树的层平均值
 */
func averageOfLevels(root *TreeNode) []float64 {
    if root == nil {
        // 防止为空
        return nil
    }
    res := make([]float64, 0)
    queue := list.New()
    queue.PushBack(root)

    var sum int
    for queue.Len() > 0 {
        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
        length := queue.Len()
        for i := 0; i < length; i++ {
            node := queue.Remove(queue.Front()).(*TreeNode)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
            // 当前层元素求和
            sum += node.Val
        }
        // 计算每层的平均值，将结果添加到响应结果中
        res = append(res, float64(sum)/float64(length))
        sum = 0 // 清空该层的数据
    }
    return res
}
```

--------------------------------

### Python: Greedy by Start Time (Counting Overlaps)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by their start times. It iterates through the sorted intervals, identifying overlaps where the current interval's start is less than the previous interval's end. When an overlap is found, it updates the current interval's end to the minimum of the two overlapping intervals' ends and increments the overlap count.

```python
class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0
        
        intervals.sort(key=lambda x: x[0])  # 按照左边界升序排序
        count = 0  # 记录重叠区间数量
        
        for i in range(1, len(intervals)):
            if intervals[i][0] < intervals[i - 1][1]:  # 存在重叠区间
                intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])  # 更新重叠区间的右边界
                count += 1
        
        return count
```

--------------------------------

### Brute Force Approach for Gas Station

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0134.加油站.md

Iterates through each gas station as a potential starting point and simulates a full circle. If a full circle can be completed without running out of gas, the starting index is returned. This method has a time complexity of O(n^2).

```C++
class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for (int i = 0; i < cost.size(); i++) {
            int rest = gas[i] - cost[i]; // 记录剩余油量
            int index = (i + 1) % cost.size();
            while (rest > 0 && index != i) { // 模拟以i为起点行驶一圈（如果有rest==0，那么答案就不唯一了）
                rest += gas[index] - cost[index];
                index = (index + 1) % cost.size();
            }
            // 如果以i为起点跑一圈，剩余油量>=0，返回该起始位置
            if (rest >= 0 && index == i) return i;
        }
        return -1;
    }
};
```

--------------------------------

### Java: Min Cost Climbing Stairs (Method 2: First step paid)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0746.使用最小花费爬楼梯.md

This Java solution considers the cost of the first step. It calculates the minimum cost to reach each step and returns the minimum cost to reach either of the last two steps, as the top can be reached from either.

```java
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length];
        dp[0] = cost[0];
        dp[1] = cost[1];
        for (int i = 2; i < cost.length; i++) {
            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
        }
        //最后一步，如果是由倒数第二步爬，则最后一步的体力花费可以不用算
        return Math.min(dp[cost.length - 1], dp[cost.length - 2]);
    }
}
```

--------------------------------

### Java: Greedy by Start Time (Minimizing Removals - Alternative)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by start time. It iterates through intervals, incrementing a 'remove' count when an overlap is detected. The 'pre' variable tracks the end of the last non-overlapping interval, updated to the minimum end of overlapping intervals.

```java
class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, (a,b)-> {
            return Integer.compare(a[0],b[0]);
        });
        int remove = 0;
        int pre = intervals[0][1];
        for(int i = 1; i < intervals.length; i++) {
            if(pre > intervals[i][0]) {
                remove++;
                pre = Math.min(pre, intervals[i][1]);
            }
            else pre = intervals[i][1];
        }
        return remove;
    }
}
```

--------------------------------

### Build Tree from Inorder and Postorder (With Debugging Logs)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0106.从中序与后序遍历序列构造二叉树.md

This C++ version includes `cout` statements to log the partitioning of inorder and postorder arrays during recursion. These logs are helpful for debugging but should be removed for submission to avoid performance issues.

```cpp
class Solution {
private:
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;

        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorder.size() == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        postorder.resize(postorder.size() - 1);

        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        // 以下为日志
        cout << "----------" << endl;

        cout << "leftInorder :";
        for (int i : leftInorder) {
            cout << i << " ";
        }
        cout << endl;

        cout << "rightInorder :";
        for (int i : rightInorder) {
            cout << i << " ";
        }
        cout << endl;

        cout << "leftPostorder :";
        for (int i : leftPostorder) {
            cout << i << " ";
        }
        cout << endl;
         cout << "rightPostorder :";
        for (int i : rightPostorder) {
            cout << i << " ";
        }
        cout << endl;

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

```

--------------------------------

### Greedy Algorithm - Method 2 for Gas Station Problem (C#)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0134.加油站.md

This C# code provides an optimized greedy solution for the Gas Station problem, mirroring the logic of the Scala Method 2. It efficiently determines the starting station by tracking current and total gas sums.

```csharp
// 贪心算法，方法二
public class Solution
{
    public int CanCompleteCircuit(int[] gas, int[] cost)
    {
        int curSum = 0, totalSum = 0, start = 0;
        for (int i = 0; i < gas.Length; i++)
        {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0)
            {
                start = i + 1;
                curSum = 0;
            }
        }
        if (totalSum < 0) return -1;
        return start;
    }
}
```

--------------------------------

### Go DP Solution (2D Array)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0063.不同路径II.md

This Go solution implements a 2D dynamic programming approach. It initializes the DP table, handling obstacles in the first row and column, and then computes the number of paths for the rest of the grid.

```Go
func uniquePathsWithObstacles(obstacleGrid [][]int) int {
	m, n := len(obstacleGrid), len(obstacleGrid[0])
	//如果在起点或终点出现了障碍，直接返回0
	if obstacleGrid[m-1][n-1] == 1 || obstacleGrid[0][0] == 1 {
		return 0
	}
	// 定义一个dp数组
	dp := make([][]int, m)
	for i, _ := range dp {
		dp[i] = make([]int, n)
	}
	// 初始化, 如果是障碍物, 后面的就都是0, 不用循环了
	for i := 0; i < m && obstacleGrid[i][0] == 0; i++ {
		dp[i][0] = 1
	}
	for i := 0; i < n && obstacleGrid[0][i] == 0; i++ {
		dp[0][i] = 1
	}
	// dp数组推导过程
	for i := 1; i < m; i++ {
		for j := 1; j < n; j++ {
			// 如果obstacleGrid[i][j]这个点是障碍物, 那么dp[i][j]保持为0
			if obstacleGrid[i][j] != 1 {
				// 否则我们需要计算当前点可以到达的路径数
				dp[i][j] = dp[i-1][j] + dp[i][j-1]
			}
		}
	}
	return dp[m-1][n-1]
```

--------------------------------

### Java: Greedy by Start Time (Minimizing Removals)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0435.无重叠区间.md

Sorts intervals by start time. When overlaps occur, it updates the current interval's end to the minimum of the overlapping intervals' ends and increments the removal count. This approach aims to keep the current interval as short as possible to accommodate more subsequent intervals.

```java
class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, (a,b)-> {
            return Integer.compare(a[0],b[0]);
        });
        int count = 1;
        for(int i = 1;i < intervals.length;i++){
            if(intervals[i][0] < intervals[i-1][1]){
                intervals[i][1] = Math.min(intervals[i - 1][1], intervals[i][1]);
                continue;
            }else{
                count++;
            }    
        }
        return intervals.length - count;
    }
}
```

--------------------------------

### C++ Solution for Minimum Arrows to Burst Balloons

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0452.用最少数量的箭引爆气球.md

Sorts balloons by their start points and iterates to find overlapping intervals. Updates the end point of the current overlapping interval to the minimum end point of the overlapping balloons. Increments arrow count when a balloon's start point is beyond the current interval's end point.

```C++
class Solution {
private:
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.size() == 0) return 0;
        sort(points.begin(), points.end(), cmp);

        int result = 1; // points 不为空至少需要一支箭
        for (int i = 1; i < points.size(); i++) {
            if (points[i][0] > points[i - 1][1]) {  // 气球i和气球i-1不挨着，注意这里不是>= 
                result++; // 需要一支箭
            }
            else {  // 气球i和气球i-1挨着
                points[i][1] = min(points[i - 1][1], points[i][1]); // 更新重叠气球最小右边界
            }
        }
        return result;
    }
};
```

--------------------------------

### Java: Daily Temperatures - Version 1 (Monotonic Stack)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0739.每日温度.md

First Java solution using a monotonic stack. Stores indices in the stack and calculates the next warmer day.

```java
class Solution {
  // 版本 1
    public int[] dailyTemperatures(int[] temperatures) {

        int lens=temperatures.length;
        int []res=new int[lens];

        /**
        如果当前遍历的元素 大于栈顶元素，表示 栈顶元素的 右边的最大的元素就是 当前遍历的元素，
        	所以弹出 栈顶元素，并记录
        	如果栈不空的话，还要考虑新的栈顶与当前元素的大小关系
        否则的话，可以直接入栈。
        注意，单调栈里 加入的元素是 下标。
        */
        Deque<Integer> stack=new LinkedList<>();
        stack.push(0);
        for(int i=1;i<lens;i++){

            if(temperatures[i]<=temperatures[stack.peek()]){
                stack.push(i);
            }else{
                while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
                    res[stack.peek()]=i-stack.peek();
                    stack.pop();
                }
                stack.push(i);
            }
        }

        return  res;
    }

    //--------这 是一条分界线
    // 版本 2
    class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int lens=temperatures.length;
        int []res=new int[lens];
        Deque<Integer> stack=new LinkedList<>();
        for(int i=0;i<lens;i++){

           while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
                    res[stack.peek()]=i-stack.peek();
                    stack.pop();
                }
                stack.push(i);
        }

        return  res;
    }
}

}
```

--------------------------------

### Validate Mountain Array using Two Pointers (Rust)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0941.有效的山脉数组.md

This Rust function validates a mountain array using two pointers, `i` and `j`. It checks for a strictly increasing sequence from the start and a strictly decreasing sequence from the end. The array is a valid mountain if `i` and `j` meet at the same index, which is neither the start nor the end of the array, and if both pointers have moved from their initial positions.

```rust
impl Solution {
    pub fn valid_mountain_array(arr: Vec<i32>) -> bool {
        let mut i = 0;
        let mut j = arr.len() - 1;
        while i < arr.len() - 1 && arr[i] < arr[i + 1] {
            i += 1;
        }
        while j > 0 && arr[j] < arr[j - 1] {
            j -= 1;
        }
        i > 0 && j < arr.len() - 1 && i == j
    }
}
```

--------------------------------

### Go: Dynamic Programming Solution

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0746.使用最小花费爬楼梯.md

Calculates the minimum cost using dynamic programming with an auxiliary array. Initializes base cases and iterates to find the minimum cost for each step.

```Go
func minCostClimbingStairs(cost []int) int {
    f := make([]int, len(cost) + 1)
    f[0], f[1] = 0, 0
    for i := 2; i <= len(cost); i++ {
        f[i] = min(f[i-1] + cost[i-1], f[i-2] + cost[i-2])
    }
    return f[len(cost)]
}
func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}
```

--------------------------------

### Greedy Algorithm (Method 2) for Gas Station

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0134.加油站.md

This method iterates through the gas stations, maintaining a current sum of gas minus cost. If the current sum drops below zero, it means the current starting point is invalid, and the next station is considered as a potential start. The total sum is checked at the end to ensure a solution exists. Time complexity is O(n).

```C++
class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {   // 当前累加rest[i]和 curSum一旦小于0
                start = i + 1;  // 起始位置更新为i+1
                curSum = 0;     // curSum从0开始
            }
        }
        if (totalSum < 0) return -1; // 说明怎么走都不可能跑一圈了
        return start;
    }
};
```

--------------------------------

### Java: Min Cost Climbing Stairs (State Compression)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0746.使用最小花费爬楼梯.md

This Java solution uses state compression to optimize space complexity. It uses three variables to track the minimum costs of the previous two steps and the current step, avoiding the need for a DP array.

```java
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        // 以下三个变量分别表示前两个台阶的最少费用、前一个的、当前的。
        int beforeTwoCost = 0, beforeOneCost = 0, currentCost = 0;
        // 前两个台阶不需要费用就能上到，因此从下标2开始；因为最后一个台阶需要跨越，所以需要遍历到cost.length
        for (int i = 2; i <= cost.length; i ++) {
            // 此处遍历的是cost[i - 1]，不会越界
            currentCost = Math.min(beforeOneCost + cost[i - 1], beforeTwoCost + cost[i - 2]);
            beforeTwoCost = beforeOneCost;
            beforeOneCost = currentCost;
        }
        return currentCost;
    }
}
```

--------------------------------

### Reverse Substring

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0151.翻转字符串里的单词.md

A helper function to reverse a portion of a string within the given start and end indices (inclusive).

```C++
// 反转字符串s中左闭右闭的区间[start, end]
void reverse(string& s, int start, int end) {
    for (int i = start, j = end; i < j; i++, j--) {
        swap(s[i], s[j]);
    }
}
```

--------------------------------

### Java: Min Cost Climbing Stairs (Method 1: First step free)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0746.使用最小花费爬楼梯.md

This Java solution assumes the first step has no cost. It calculates the minimum cost to reach each step, including an imaginary step beyond the last one. The result is the minimum cost to reach this imaginary step.

```java
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int len = cost.length;
        int[] dp = new int[len + 1];

        // 从下标为 0 或下标为 1 的台阶开始，因此支付费用为0
        dp[0] = 0;
        dp[1] = 0;

        // 计算到达每一层台阶的最小费用
        for (int i = 2; i <= len; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }

        return dp[len];
    }
}
```

--------------------------------

### Switch to Root User

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Use this command to switch to the root user on your server. This is often required for system-level installations and configurations.

```bash
su root
```

--------------------------------

### Build Tree from Preorder and Inorder (Recursive Slicing)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0106.从中序与后序遍历序列构造二叉树.md

This Go snippet constructs a binary tree from preorder and inorder traversals by recursively slicing the input arrays. It identifies the root from the start of the preorder array and finds its position in the inorder array to partition subtrees.

```go
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func buildTree(preorder []int, inorder []int) *TreeNode {
    if len(preorder) == 0 {
        return nil
    }
    
    // 前序遍历数组第一个元素，就是当前的中间节点
    rootValue := preorder[0]
    root := &TreeNode{Val:rootValue}
    
    // 叶子结点
    if len(preorder) == 1 {
        return root
    }
    
    // 找到中序遍历的切割点
    var delimiterIndex int
    for delimiterIndex = 0; delimiterIndex < len(inorder); delimiterIndex++ {
        if inorder[delimiterIndex] == rootValue {
            break
        }
    }
    
    // 切割中序数组
    // 左闭右开区间：[0, delimiterIndex)
    leftInorder := inorder[:delimiterIndex]
    // [delimiterIndex + 1, end)
    rightInorder := inorder[delimiterIndex+1:]
    
    // preorder 舍弃首位元素
    preorder = preorder[1:]
    
    // 切割前序数组
    // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
    // [0, len(leftInorder))
    leftPreorder := preorder[:len(leftInorder)]
    // [len(leftInorder), end)
    rightPreorder := preorder[len(leftInorder):]
    
    root.Left = buildTree(leftPreorder, leftInorder)
    root.Right = buildTree(rightPreorder, rightInorder)
    
    return root
}
```

--------------------------------

### Build Tree from Preorder and Inorder (Optimized with Map)

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0106.从中序与后序遍历序列构造二叉树.md

This Go snippet constructs a binary tree from preorder and inorder traversals using a hash map for efficient lookup of inorder element indices. It employs a recursive helper function to rebuild the tree.

```go
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
var (
    hash map[int]int
)
func buildTree(preorder []int, inorder []int) *TreeNode {
    hash = make(map[int]int, len(inorder))
    for i, v := range inorder {
        hash[v] = i
    }
    root := build(preorder, inorder, 0, 0, len(inorder)-1)  // l, r 表示构造的树在中序遍历数组中的范围
    return root
}
func build(pre []int, in []int, root int, l, r int) *TreeNode {
    if l > r {
        return nil
    }
    rootVal := pre[root]  // 找到本次构造的树的根节点
    index := hash[rootVal]  // 根节点在中序数组中的位置
    node := &TreeNode {Val: rootVal}
    node.Left = build(pre, in, root + 1, l, index-1)
    node.Right = build(pre, in, root + (index-l) + 1, index+1, r)
    return node
}
```

--------------------------------

### Initialization of Targets and Result

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/0332.重新安排行程.md

Initializes the 'targets' map to store flight relationships and the 'result' vector with the starting airport 'JFK'.

```cpp
for (const vector<string>& vec : tickets) {
    targets[vec[0]][vec[1]]++; // 记录映射关系
}
result.push_back("JFK"); // 起始机场
```

--------------------------------

### O(1) Space Complexity Example

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/前序/空间复杂度.md

This code demonstrates constant space complexity. The memory allocated does not change with the input size 'n'.

```C++
int j = 0;
for (int i = 0; i < n; i++) {
    j++;
}
```

--------------------------------

### Create and Navigate to New Git Repository Directory

Source: https://github.com/youngyangyang04/leetcode-master/blob/master/problems/qita/gitserver.md

Creates a new directory for a Git repository, conventionally named with a '.git' suffix, and then changes into that directory.

```bash
mkdir world.git
cd world.git
```
Tokens:
Raw