算法（Algorithm）是解决特定问题的有限步骤序列，是一系列定义明确的指令。在计算机科学和数学中，算法通常用于数据处理、计算和自动推理任务。正确的算法会在给定输入的情况下按预定步骤执行并最终产生输出或确认解决方案。

算法

### Knuth-Morris-Pratt（KMP）算法的应用

KMP算法是一种用于字符串搜索的算法，它可以在一个主文本字符串S内查找一个词W的出现位置。这种算法通过避免重新检查之前已匹配的字符来提高搜索效率。

#### 应用举例：

1. **文本编辑软件**：在文本编辑软件中，用户经常需要查找特定的单词或短语，KMP算法能够高效地帮助实现这一功能。
2. **数据挖掘**：在数据挖掘中，经常需要在大量文本中查找或匹配特定模式，KMP通过减少不必要的比较，加快搜索速度。
3. **网络安全**：在网络安全领域，例如入侵检测系统中，KMP算法可以用来查找和匹配恶意代码或特定的字符串模式。
4. **生物信息学**：在DNA序列分析中，常常需要在DNA字符串中查找特定的序列，KMP算法提供了一种有效的搜索方法。

### Knuth-Morris-Pratt（KMP）算法的实现

KMP算法的核心在于一个"部分匹配"表（也称为"前缀函数"），该表用于在发生不匹配时，决定搜索中下一步匹配的起始位置，以此避免从头开始匹配。

#### 实现步骤：

1. **构建部分匹配表**：
 - 这个表为每一个位置保存了一个数值，该数值表示当前位置之前的字符串中有多大长度的相同前缀后缀。
 - 例如，对于字符串"ABCDABD"，部分匹配表是 `[0, 0, 0, 0, 1, 2, 0]`。

2. **使用部分匹配表进行搜索**：
 - 在主字符串S中，从第一个字符开始尝试匹配词W。
 - 当发现不匹配时，可以利用部分匹配表中记录的数值，跳过一些无需比较的字符，直接从潜在的匹配位置开始。

#### 代码示例（Python）：

```python
def KMP_search(text, pattern):
 # 计算部分匹配表
 def compute_lps(pattern):
 lps = [0] * len(pattern)
 length = 0
 i = 1
 while i < len(pattern):
 if pattern[i] == pattern[length]:
 length += 1
 lps[i] = length
 i += 1
 else:
 if length != 0:
 length = lps[length - 1]
 else:
 lps[i] = 0
 i += 1
 return lps

 lps = compute_lps(pattern)
 i = j = 0 # i是文本的索引，j是模式的索引
 while i < len(text):
 if pattern[j] == text[i]:
 i += 1
 j += 1

 if j == len(pattern):
 print(f"Found pattern at index {i - j}")
 j = lps[j - 1]

 # mismatch后，利用部分匹配表决定下一步的匹配位置
 elif i < len(text) and pattern[j] != text[i]:
 if j != 0:
 j = lps[j - 1]
 else:
 i += 1

KMP_search("ABABDABACDABABCABAB", "ABABCABAB")
```

以上是KMP算法的简要介绍、应用和实现示例。通过这种方式，KMP算法能够有效地减少不必要的比较，从而提高字符串匹配的效率。

讨论Knuth-Morris-Pratt（KMP）算法的应用和实现。

最小生成树（MST）是一种用于图论中的数据结构，具体来讲是在一个加权无向图中找到一个子图（这个子图也必须是一棵树），使得连接图中所有顶点的总边权最小。这个数据结构在多种场景，如网络设计（如电话网络、电网络等）、路径寻找、最优化问题等领域有广泛的应用。

### 基本概念

在更详细地描述之前，我们先定义几个基本概念：

- **图**：由顶点（或节点）以及连接顶点的边组成的集合。
- **加权图**：每条边都分配了一个重量或成本。
- **无向图**：图中的边没有方向。

### MST的性质

- MST连接图中的所有顶点且没有任何环。
- MST的总边权要尽可能小。
- 对于含有n个顶点的图，其MST有n-1条边。

### 算法

构建最小生成树的常用算法有Kruskal算法和Prim算法：

1. **Kruskal算法**  
   - 初始状态下，森林中每个顶点都是一个独立的树。
   - 按照边的权重顺序（从小到大）将边加入森林中，但是在添加边的时候要保证不会形成环。
   - 重复上述过程，直到森林中所有的顶点都连通。

2. **Prim算法**  
   - 从图中的任意顶点u开始，生成树G的初始状态只包含u。
   - 从所有连接生成树G与图中其他未包含在G中的顶点的边中，挑选权重最小的边，并将这条边及其对应的顶点加入到G中。
   - 重复上述过程，直到G包含图中的所有顶点。

### 应用实例

**网络设计**：假设需要设计一个新的电信网络来连接多个城市，城市之间铺设网络线路的成本不同。使用最小生成树可以帮助找到成本最低的网络铺设方案，确保任何两个城市之间至少有一条直接或间接的连接线路，而且总成本是最低的。

通过以上说明，最小生成树不仅是一个理论上的数学概念，它还有着非常实际的应用价值，能够解决实际生活中的许多最优化问题。

描述最小生成树（MST）数据结构？

采用几种不同的方法来解决这个问题。这里我会介绍两种比较常见的方法，一种是使用哈希表，另一种是使用异或操作。

### 方法一：使用哈希表

使用哈希表来记录数组中每个元素出现的次数，然后遍历哈希表找到只出现一次的数字。

**步骤如下：**

1. 初始化一个空的哈希表。
2. 遍历数组，对于每个元素，如果它不在哈希表中，就添加进去并设置计数为1；如果已经在哈希表中，就将其计数加1。
3. 再次遍历哈希表，寻找计数为1的元素。

**代码示例（Python）：**

```python
def singleNumber(nums):
    count_map = {}
    for num in nums:
        if num in count_map:
            count_map[num] += 1
        else:
            count_map[num] = 1
  
    for num, count in count_map.items():
        if count == 1:
            return num
```

### 方法二：使用异或操作

异或（XOR）操作有一个非常有趣的性质：任何数和0做异或运算结果都是数本身，任何数和自己做异或运算结果都是0。利用这个性质，我们可以轻松找到只出现一次的数字。

**步骤如下：**

1. 初始化一个变量 `result`为0。
2. 遍历数组，将每个元素与 `result`进行异或操作。
3. 由于数组中除了一个数字之外，其他的数字都出现了两次，它们将被抵消。
4. 最终 `result`的值就是只出现一次的数字。

**代码示例（Python）：**

```python
def singleNumber(nums):
    result = 0
    for num in nums:
        result ^= num
    return result
```

### 总结

如果考虑到时间和空间效率，使用异或操作的方法更为高效，因为它的时间复杂度是O(n)，且空间复杂度为O(1)。而使用哈希表的方法虽然时间复杂度也是O(n)，但空间复杂度是O(n)，因为需要额外的空间来存储元素及其计数信息。


这两种情况的解决方案有所不同，但我可以为两种情况提供思路。

### 情况1：寻找只出现一次的数字，其余数字均出现两次或多次

如果数组中所有元素都是成对出现的，除了一个数字只出现一次，那么这个问题的一个非常高效的解决方法是使用异或运算（XOR）。异或运算有以下几个特点：  

- 一个数和它本身做异或运算结果为0，即 `a ^ a = 0`。
- 一个数和0做异或运算结果为它本身，即 `a ^ 0 = a`。
- 异或运算满足交换律和结合律，即 `a ^ b ^ a = (a ^ a) ^ b = 0 ^ b = b`。

因此，我们可以通过对数组中所有元素进行异或运算，成对出现的数字会两两抵消为0，最终剩下的结果就是唯一一个只出现一次的数字。这个方法的时间复杂度是O(n)，空间复杂度是O(1)，非常高效。

例如，数组 `[4, 1, 2, 1, 2]` 中，使用异或运算：

```
4 ^ 1 ^ 2 ^ 1 ^ 2 = (1 ^ 1) ^ (2 ^ 2) ^ 4 = 0 ^ 0 ^ 4 = 4
```

最终结果就是 `4`，这是唯一只出现一次的数字。

### 情况2：寻找只出现一次的数字，无其他限制

如果数组中数字出现的次数没有限制，那么使用异或运算的方法可能不适用。在这种情况下，我们可以考虑使用哈希表（Hash Table）来记录每个数字出现的次数。

具体步骤如下：

1. 遍历数组，将每个元素作为键存入哈希表，值是该元素出现的次数。
2. 再次遍历哈希表，找到值为1的键，即为只出现一次的数字。

这种方法的时间复杂度和空间复杂度都是O(n)。例如，数组 `[4, 1, 2, 1, 2, 4, 3]`，构建哈希表：

```plaintext
{
  1: 2,
  2: 2,
  3: 1,
  4: 2
}
```

遍历哈希表后，我们发现数字 `3` 的出现次数为1，因此 `3` 就是唯一只出现一次的数字。

如何查找数组中唯一不出现两次的数字

在Python中，计算算法的运行时间主要有几种常用方法：

### 1. 使用 `time` 模块

最基本的方法是使用内置的`time`模块。你可以在算法执行前后分别获取时间戳，然后相减得到运行时间。

```python
import time

start_time = time.time() # 获取开始时间

# 这里放置你的算法代码
for i in range(1000000):
 pass

end_time = time.time() # 获取结束时间
elapsed_time = end_time - start_time # 计算运行时间
print(f"运行时间：{elapsed_time}秒")
```

### 2. 使用 `timeit` 模块

对于需要更精确测量时间，或者想要自动化重复运行以获取更稳定的结果的场景，可以使用`timeit`模块。这个模块专门用于小代码片段的时间测试。

```python
import timeit

code_to_test = """
a = [1, 2, 3, 4, 5]
b = [x + 1 for x in a]
"""

# timeit.repeat可以自动多次运行并返回一个列表，包含每次运行的时间
elapsed_time = min(timeit.repeat(stmt=code_to_test, repeat=3, number=1000))
print(f"运行时间：{elapsed_time}秒")
```

### 3. 使用 `datetime` 模块

这种方法类似于使用`time`模块，但使用`datetime`模块可以提供更多的日期和时间格式化选项。

```python
from datetime import datetime

start_time = datetime.now()

# 算法代码
for i in range(1000000):
 pass

end_time = datetime.now()
elapsed_time = end_time - start_time
print(f"运行时间：{elapsed_time}")
```

### 实际应用示例

假设我们需要衡量一个排序算法（比如快速排序）的性能：

```python
import time

def quick_sort(arr):
 if len(arr) <= 1:
 return arr
 pivot = arr[len(arr) // 2]
 left = [x for x in arr if x < pivot]
 middle = [x for x in arr if x == pivot]
 right = [x for x in arr if x > pivot]
 return quick_sort(left) + middle + quick_sort(right)

# 测试数据
data = [3, 6, 8, 10, 1, 2, 1]

start_time = time.time()
sorted_data = quick_sort(data)
end_time = time.time()

print(f"排序后的数据: {sorted_data}")
print(f"快速排序的运行时间：{end_time - start_time}秒")
```

通过这种方式，我们不仅可以了解算法的实际运行时间，还可以通过调整数据的大小和复杂度来进一步探索算法的性能。

Python 如何在中计算算法的运行时间

在C++中，从容器中获取随机元素是一种常见的操作，尤其是在需要随机化算法或测试数据的场合。C++标准库中的容器如`vector`, `deque`, `list`, `set`, `map`等都可以用来存储数据，但获取它们中的随机元素的方法可能会有所不同。以下是几种常见容器的处理方法及示例：

### 1. 对于顺序容器（如`vector`, `deque`）

这些容器提供了通过下标访问元素的能力，因此获取随机元素较为简单。可以使用`<random>`头文件中的功能来生成随机下标。示例代码如下：

```cpp
#include <iostream>
#include <vector>
#include <random>

int main() {
 std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

 // 随机数生成器
 std::random_device rd;
 std::mt19937 gen(rd());
 std::uniform_int_distribution<> distrib(0, data.size() - 1);

 // 获取随机元素
 int random_element = data[distrib(gen)];
 std::cout << "Random Element: " << random_element << std::endl;

 return 0;
}
```

### 2. 对于关联容器和无序容器（如`set`, `map`, `unordered_map`）

这些容器不支持直接通过下标访问元素。如果要获取随机元素，我们可以通过获取一个随机的迭代器来实现。示例代码如下：

```cpp
#include <iostream>
#include <set>
#include <random>
#include <iterator>

int main() {
 std::set<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

 // 随机数生成器
 std::random_device rd;
 std::mt19937 gen(rd());
 std::uniform_int_distribution<> distrib(0, data.size() - 1);

 // 获取随机迭代器
 auto it = data.begin();
 std::advance(it, distrib(gen));

 // 输出随机元素
 std::cout << "Random Element: " << *it << std::endl;

 return 0;
}
```

### 注意事项

- 当使用随机设备和生成器时，确保你的编译器支持C++11或更高版本，因为`<random>`库是在C++11中引入的。
- 对于`set`和`map`这类容器，上述方法可能效率不高，特别是在容器元素非常多时。如果性能是关键考虑，可能需要考虑其他数据结构或算法。

通过这些示例，你可以看到如何在不同类型的C++容器中获取随机元素，并理解每种方法的适用场景和潜在的性能影响。

如何从C++容器中获取随机元素？

回溯算法的时间复杂度计算通常涉及分析算法的递归树。回溯算法常用于解决决策问题，如排列、组合、子集生成以及一些图论问题中的路径和匹配问题。这些问题通常有多个阶段，每个阶段都有多个选择。

要计算回溯算法的时间复杂度，我们需要考虑以下几个因素：

1. **选择的数量（分支因子）**：在递归树的每一层，有多少种不同的选择可以进行下一步操作。这个因素决定了递归树的宽度。

2. **问题求解的深度**：决策需要进行多少步才能到达终点（或无法继续进行的点）。这个因素决定了递归树的深度。

3. **剪枝效率**：在搜索过程中，能有效减少不必要路径的剪枝策略能显著减少递归树的规模，从而降低时间复杂度。

具体来说，回溯算法的时间复杂度计算示例可以参照这样的步骤：

### 1. 确定递归树的形状
首先，画出完整的递归树，这棵树表示了执行过程中所有可能的决策路径。递归树的每个节点代表算法中的一个递归调用。

### 2. 计算树的节点总数
时间复杂度和递归树的节点总数密切相关。对于完全树，节点总数可以通过分支因子和深度来计算。假设每个决策点有 `b` 个分支，且深度为 `d`，那么节点总数大致为 `O(b^d)`。

### 3. 考虑每个节点的计算复杂度
了解每个节点上的操作复杂度也很重要。例如，如果每次递归调用的复杂度为 `O(n)`，则总的时间复杂度将是节点总数乘以每个节点的复杂度。

### 4. 考虑剪枝策略
剪枝可以减少需要探索的节点数。例如，如果通过剪枝，我们可以排除一半的分支，则递归树的实际大小将大幅减少。

**例子：N皇后问题**

在 N 皇后问题中，我们要在 N×N 的棋盘上放置 N 个皇后，使任何两个皇后都不在同一行、同一列或同一斜线上。用回溯算法解决时：

- **选择的数量**: 最坏情况下，我们对棋盘上的每一列都有 N 个选择（放置皇后的位置）。
- **问题的深度**: 深度为 N，因为我们需要放置 N 个皇后。
- **剪枝效率**: 通过检查攻击线，我们可以在放置每个皇后时剪枝，从而减少递归树的大小。

最坏情况下，时间复杂度为 `O(N!)`，但由于剪枝的存在，实际的时间复杂度通常远低于这个上界。

计算回溯算法的时间复杂度是一项估算的工作，通常取决于问题的具体情况和剪枝策略的有效性。

如何计算回溯算法的时间复杂度？

首先，我需要明确“具有一定性质”的具体含义。这个性质可能是数学上的一个特性，比如说素数、完全数、回文数等。比如，如果我们要找出在大整数A和B之间（包括A和B）的所有素数，我们可以使用以下步骤：

1. **验证输入**：确认A和B是整数，且A小于等于B。

2. **确定性质**：明确“具有一定性质”的含义。例如，如果性质是“素数”，则定义一个函数来检查一个给定的数是否是素数。

3. **筛选算法**：选择一个适合的算法来筛选具有该性质的数字。对于素数，可以使用埃拉托斯特尼筛法（Sieve of Eratosthenes）或更高效的筛法，如Atkin筛法。

4. **迭代与检查**：从A开始迭代到B，对每个数使用第2步定义的函数来检查它是否具有该性质。

5. **收集结果**：将检查通过的数收集起来。

6. **输出结果**：将所有符合条件的数以列表或其他形式输出。

举一个具体的例子，比如我们需要找出大整数A = 10^9 和 B = 10^9 + 50 之间所有的素数。

我们可以编写一个检查素数的函数，然后对于每个数x，从A到B，用这个函数检查x是否为素数。如果是，则将其添加到结果列表中。最后，输出这个结果列表。

这只是一个简化的描述，实际的实现中，我们可能需要考虑性能优化，比如减少不必要的除法操作，使用高效的数据结构等。如果具体性质不同，算法的选择和实现也将不同。如果您能提供更具体的性质描述，我可以提供更详尽的算法描述和可能的代码实现。

如何计算具有一定性质的大 A 和 B 之间的整数？

计算两个矩形重叠部分的面积是计算重叠度的常用方法。以下是计算两个矩形重叠度的步骤：

### 1. 理解矩形的表示
通常情况下，一个矩形可以由它的左下角和右上角的坐标来表示，假设有两个矩形 A 和 B，它们可以表示为：
- 矩形 A: (Ax1, Ay1) 到 (Ax2, Ay2)，其中 (Ax1, Ay1) 是左下角坐标，(Ax2, Ay2) 是右上角坐标。
- 矩形 B: (Bx1, By1) 到 (Bx2, By2)，同样的表示方法。

### 2. 计算重叠部分的坐标
重叠部分矩形的左下角坐标由矩形 A 和 B 左下角的最大横纵坐标组成，右上角坐标由矩形 A 和 B 右上角的最小横纵坐标组成。即：
- 重叠部分左下角坐标：(max(Ax1, Bx1), max(Ay1, By1))
- 重叠部分右上角坐标：(min(Ax2, Bx2), min(Ay2, By2))

### 3. 检查矩形是否重叠
只有当重叠矩形的两个坐标都是合法的，即左下角的横纵坐标都小于或等于右上角的横纵坐标时，矩形才重叠。可以表示为：
- 如果 max(Ax1, Bx1) < min(Ax2, Bx2) 且 max(Ay1, By1) < min(Ay2, By2)，则矩形重叠。

### 4. 计算重叠部分的面积
如果矩形重叠，重叠部分的面积可以通过下面的公式计算：
- 重叠面积 = (min(Ax2, Bx2) - max(Ax1, Bx1)) * (min(Ay2, By2) - max(Ay1, By1))

### 5. 计算重叠度
重叠度通常表示为重叠面积与两个矩形面积之和的比例。可以表示为：
- 重叠度 = 重叠面积 / (面积A + 面积B - 重叠面积)

其中，面积 A 和面积 B 分别为：
- 面积 A = (Ax2 - Ax1) * (Ay2 - Ay1)
- 面积 B = (Bx2 - Bx1) * (By2 - By1)

### 示例
假设有两个矩形 A 和 B 的坐标分别为：
- A: (1, 1) 到 (3, 4)
- B: (2, 3) 到 (5, 6)

1. 计算重叠部分的坐标：
 - 左下角坐标：(max(1, 2), max(1, 3)) = (2, 3)
 - 右上角坐标：(min(3, 5), min(4, 6)) = (3, 4)
2. 判断是否重叠：
 - 因为 2 < 3 且 3 < 4，所以矩形 A 和 B 重叠。
3. 计算重叠面积：
 - 重叠面积 = (3 - 2) * (4 - 3) = 1
4. 分别计算两个矩形的面积：
 - 面积 A = (3 - 1) * (4 - 1) = 6
 - 面积 B = (5 - 2) * (6 - 3) = 9
5. 计算重叠度：
 - 重叠度 = 1 / (6 + 9 - 1) = 1 / 14 ≈ 0.0714 或 7.14%

因此，矩形 A 和 B 的重叠度大约为 7.14%。

如何计算两个矩形重叠度是多少？

文档差异算法通常用于比较两个文本文件的内容差异，并且可以用来实现版本控制系统中的差异检测功能。实现文档差异算法的一种常见方法是使用“最长公共子序列”（Longest Common Subsequence, LCS）算法。下面我会详细描述LCS算法的工作原理以及如何用它来实现文档差异。

### 最长公共子序列（LCS）算法

LCS算法用于查找两个序列（在这个场景中是两个文档中的字符串）的最长公共子序列，这个子序列不需要在原字符串中连续，但必须保持原有的顺序。例如，对于字符串"ABCD"和"ACBD"，它们的一个最长公共子序列是"ABD"。

### LCS算法实现步骤

1. **初始化二维数组**：创建一个(m+1) x (n+1)的二维数组`dp`，其中m和n分别是两个文档的长度。`dp[i][j]`将会存储文档1的前i个字符和文档2的前j个字符的最长公共子序列的长度。

2. **填充数组**：
   - 如果`A[i] == B[j]`（文档1的第i个字符和文档2的第j个字符相同），则`dp[i][j] = dp[i-1][j-1] + 1`。
   - 如果`A[i] != B[j]`，则`dp[i][j] = max(dp[i-1][j], dp[i][j-1])`。

3. **从数组构建LCS**：从`dp[m][n]`开始，反向遍历数组，根据`dp`数组的值来确定LCS的字符。

### 找出差异

一旦我们有了LCS，就可以通过以下步骤来确定两个文档的差异：

1. **遍历原始文档**：从头开始遍历两个文档，与LCS进行比较。
2. **标识差异**：如果当前字符不在LCS中，那么它是一处差异。如果它在文档1中而不在文档2中，那么它是被删除的部分；反之，它是被添加的部分。

### 例子

举个例子，我们要比较两个字符串：

- Document 1: `ABCDFG`
- Document 2: `ABEDFHG`

首先，我们按照上述方法计算LCS，它是`ABDFG`。然后，我们逐字符遍历每个文档，与LCS比较，得到以下差异：

- 在Document 1中，`C`不在LCS中，表示它在Document 2中被删除或修改。
- 在Document 2中，`E`和`H`不在LCS中，表示它们是新添加的字符。

最终，我们可以生成一个差异报告，告诉用户如何从Document 1修改到Document 2。

### 优化和替代算法

- LCS算法的时间复杂度是O(m*n)，空间复杂度也是O(m*n)，对于大文件来说可能会很慢。可以通过只存储当前行和上一行的动态规划数组来减少空间复杂度。
- 对于更高效的差异检测，可以使用其他算法如 Myers' diff algorithm，它在实践中比LCS更快，特别是在处理大型文件时。
- 现代版本控制系统如 `git` 使用的是一种基于 Myers 算法的变体，进行了进一步的优化和调整，以处理实际应用中的各种情况。

在实际应用中，文档差异工具通常还会包含诸如忽略空白差异、格式化差异展示等功能。这些工具也会有一些交互式界面的特性以方便用户理解和应用这些差异。

如何实现文档差异算法？

### 对于如何找到最大生成树的问题

在图论中，生成树是一个无环的连通子图，并包括图中所有的顶点。最大生成树则是指边的权值和最大的生成树。寻找最大生成树的问题经常出现在网络设计、电路设计等领域。解决这个问题的常用算法有两种：普里姆算法（Prim's Algorithm）和克鲁斯卡尔算法（Kruskal's Algorithm）。这两种算法通常用于寻找最小生成树，但是通过对权值的处理，同样可以用来寻找最大生成树。

#### 普里姆算法

普里姆算法的基本思想是从图中的某一顶点开始，逐渐长出一棵包含所有顶点的生成树。每次迭代添加与当前生成树连接的最大权值的边。

1. 选取图中的任意一个顶点作为开始。
2. 找到连接当前生成树和图中剩余顶点的最大权值的边。
3. 将这条边以及其对应的顶点加入到当前生成树中。
4. 重复步骤2和3，直到所有的顶点都被包含在生成树中。

#### 克鲁斯卡尔算法

克鲁斯卡尔算法的基本思想是将图中的所有边按照权值从大到小进行排序，然后按照顺序选取边，构造最大生成树。

1. 将图中所有的边按照权值从大到小进行排序。
2. 初始化只包含所有顶点但不包含任何边的森林（每个顶点自成一个连通分量）。
3. 依序考虑每一条边，如果这条边连接的两个顶点属于不同的连通分量，则添加这条边，并合并相应的连通分量。
4. 重复步骤3，直到所有的顶点都在同一个连通分量中，即构成了一个生成树。

#### 示例

假设我们有一个图，它包含4个顶点和5条边，边的权值分别是：

- A-B: 7
- A-D: 6
- B-C: 9
- B-D: 8
- C-D: 5

使用克鲁斯卡尔算法寻找最大生成树的步骤如下：

1. 对边进行排序：B-C(9), B-D(8), A-B(7), A-D(6), C-D(5)。
2. 从权值最大的边开始添加：首先添加B-C。
3. 接着添加B-D，这时我们的生成树中包含了顶点B, C, D。
4. 然后添加A-B，此时所有顶点都包含在生成树中。
5. 此时，最大生成树包含的边为：B-C, B-D, A-B，总权值为24。

使用普里姆算法也可以获得同样的最大生成树，只不过迭代的过程有所不同。

这两种算法，无论是寻找最大生成树还是最小生成树，关键都在于如何定义和比较边的权值。通过对权值的相反数处理，我们可以利用这些算法找到最大生成树。

如何找到最大生成树？

推荐系统是一种信息过滤系统，它的目的是预测用户可能感兴趣的物品或内容。它们在众多应用中发挥作用，从电子商务网站推荐产品，到社交媒体平台推荐内容，再到流媒体服务推荐电影和音乐。推荐系统通常利用以下几种主要技术：协同过滤、内容基过滤和混合方法。

**协同过滤**是一种利用用户的历史行为数据来预测他们可能喜欢的项目的方法。它又可以细分为用户基和物品基推荐。

- **用户基协同过滤**侧重于找到与目标用户拥有相似品味的用户，并推荐那些相似用户喜欢的物品。例如，如果用户A和用户B在过去喜欢了很多相同的电影，系统会认为他们有相似的口味，因此会向用户A推荐用户B喜欢的电影，反之亦然。

- **物品基协同过滤**则是基于物品之间的相似度进行推荐。如果电影X和电影Y被很多用户同时喜欢，那么喜欢电影X的用户可能会收到电影Y的推荐。

**内容基过滤**侧重于物品本身的特性，比如描述、关键词、类别等。这种方法会分析用户过去喜欢的内容的特征，并推荐具有相似特征的新内容。举个例子，如果一个用户经常观看科幻电影，系统可能会发现这一趋势，并推荐其他具有相似风格、主题或导演的科幻电影。

**混合方法**将协同过滤和内容基过滤相结合，以克服单一方法的限制。例如，Netflix的推荐算法就采用了混合方法。这种方式可以通过整合不同类型的数据和算法来提高推荐的准确性和多样性。

除了这些传统技术，现代推荐系统还可能利用复杂的机器学习模型，包括基于矩阵分解的模型、深度学习方法等。这些模型可以从大量的数据中学习用户行为的复杂模式，并做出更精确的个性化推荐。

例如，我曾参与开发一个个性化新闻推荐系统，我们使用了混合推荐方法。系统分析了用户阅读历史中的文章属性，如主题、作者和阅读时间长度，并结合了用户与其他类似阅读喜好的用户的交互数据。这样，我们不仅能推荐内容上和用户历史兴趣相符的新闻，还能发现其他相似用户喜欢的内容，进而提供更广泛的、个性化的新闻推荐。

推荐系统是如何工作的？

要在Java中高效且安全地生成随机字母数字字符串，我们可以使用`java.security.SecureRandom`类，因为它提供了一个加密强随机数生成器 (RNG)。以下是一个生成安全的随机字母数字字符串的步骤和代码示例：

### 步骤：

1. **创建`SecureRandom`实例**：`SecureRandom`实例应该被重用而不是每次需要时都被创建，以提高效率并减少资源消耗。
 
2. **定义一个字符集**：创建一个包含所有可能字符的字符串，例如所有大写和小写字母以及数字。

3. **随机选择字符**：对于所需的随机字符串长度，从字符集中随机选取字符。

4. **构建随机字符串**：使用`StringBuilder`或类似工具来逐步构建最终的随机字符串。

### 代码示例：

```java
import java.security.SecureRandom;

public class SecureRandomStringGenerator {

 // 定义可能的字符集
 private static final String ALPHA_NUMERIC_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 private static final SecureRandom random = new SecureRandom();

 public static String generateRandomAlphaNumeric(int length) {
 StringBuilder builder = new StringBuilder(length);

 for (int i = 0; i < length; i++) {
 // 随机选择字符
 int randomIndex = random.nextInt(ALPHA_NUMERIC_STRING.length());
 builder.append(ALPHA_NUMERIC_STRING.charAt(randomIndex));
 }

 return builder.toString();
 }

 public static void main(String[] args) {
 // 生成一个16位长度的随机字符串
 String secureRandomString = generateRandomAlphaNumeric(16);
 System.out.println("Secure Random String: " + secureRandomString);
 }
}
```

### 使用示例说明：

在上述代码中，`generateRandomAlphaNumeric`方法接受生成字符串的长度作为参数。在方法内部，我们创建了一个`StringBuilder`来高效地构建字符串，并利用`SecureRandom`实例从定义好的字符集中随机选择字符。

使用`SecureRandom`是生成随机字母数字字符串的安全做法，因为它足够强大以对抗暴力破解和预测攻击，这对于密码、会话标识符或其他敏感信息的生成至关重要。此外，重用`SecureRandom`实例和使用`StringBuilder`可以提高代码的效率。

如何在Java中高效地生成安全的随机字母数字字符串？

`use strict`是JavaScript中的一个指令，用于开启严格模式。它于ECMAScript 5引入，主要有以下几个作用：

1. **消除Javascript语法的一些不严谨之处**：严格模式下，一些原本不会报错的编码习惯会抛出错误。例如，给未声明的变量赋值会抛出一个错误。

   ```javascript
   'use strict';
   undeclaredVariable = 1; // ReferenceError: undeclaredVariable is not defined
   ```

2. **消除一些静默错误**：在非严格模式中，一些类型错误会被静默忽略。但在严格模式下，这些错误会被抛出，便于开发者发现并修复。

   ```javascript
   'use strict';
   false.true = '';         // TypeError: Cannot create property 'true' on boolean 'false'
   (14).sailing = 'home';   // TypeError: Cannot create property 'sailing' on number '14'
   ```

3. **提高编译器效率，增加运行速度**：因为严格模式规避了一些语言特性，JavaScript引擎可以更容易地进行代码优化。

4. **禁用了一些语言上容易混淆的特性**：
   - 不能使用`with`语句，因为它会改变作用域并导致优化问题。
   - 为对象的不可写属性赋值，为对象的只读属性赋值，为对象的不可扩展属性添加新属性，为禁止扩展的对象添加新属性，删除不可删除的属性等行为会抛出错误。
   - 函数的参数不能有同名属性，否则也会抛出错误。

   ```javascript
   'use strict';
   function duplicateParam(p, p) { // SyntaxError: Duplicate parameter name not allowed in this context
       return p + p;
   }
   ```

5. **为将来新版本的JavaScript做好准备**：严格模式禁用了一些在未来语言标准中可能会被赋予新意义的语法，从而可以减少向后兼容问题。

如何应用`use strict`：
- 可以应用于整个脚本，只需在脚本顶部添加`'use strict';`。
- 也可以应用于单个函数，将它放在函数体的顶部。

```javascript
function myFunction() {
  'use strict';
  // Function-level strict mode syntax
  var v = "Hi! I'm a strict mode script!";
}
```

使用严格模式有助于提升代码质量和可维护性，并且使得JavaScript代码更加安全。不过，也需要注意在混合使用严格模式和非严格模式代码时可能会遇到的兼容性问题。

This to me sounds like a reasonably common problem that junior to intermediate developers tend to face at some point: they either don't know or don't trust the contracts they are participating in and defensively overcheck for nulls. Additionally, when writing their own code, they tend to rely on returning nulls to indicate something thus requiring the caller to check for nulls.
To put this another way, there are two instances where null checking comes up:
<ol>
<li>Where null is a valid response in terms of the contract; and
</li>
<li>Where it isn't a valid response.
</li>
</ol>
(2) is easy. As of Java 1.7 you can use <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Objects.html#requireNonNull(T)" rel="noreferrer"><code>Objects.requireNonNull(foo)</code></a>. (If you are stuck with a previous version then <a href="https://docs.oracle.com/javase/7/docs/technotes/guides/language/assert.html" rel="noreferrer"><code>assert</code>ions</a> may be a good alternative.)
"Proper" usage of this method would be like below. The method returns the object passed into it and throws a <code>NullPointerException</code> if the object is null. This means that the returned value is always non-null. The method is primarily intended for validating parameters.
<pre class="lang-java s-code-block"><code class="hljs language-java">public Foo(Bar bar) {
 this.bar = Objects.requireNonNull(bar);
}
</code></pre>
It can also be used like an <code>assert</code>ion though since it throws an exception if the object is null. In both uses, a message can be added which will be shown in the exception. Below is using it like an assertion and providing a message.
<pre class="lang-java s-code-block"><code class="hljs language-java">Objects.requireNonNull(someobject, "if someobject is null then something is wrong");
someobject.doCalc();
</code></pre>
Generally throwing a specific exception like <code>NullPointerException</code> when a value is null but shouldn't be is favorable to throwing a more general exception like <code>AssertionError</code>. This is the approach the Java library takes; favoring <code>NullPointerException</code> over <code>IllegalArgumentException</code> when an argument is not allowed to be null.
(1) is a little harder. If you have no control over the code you're calling then you're stuck. If null is a valid response, you have to check for it.
If it's code that you do control, however (and this is often the case), then it's a different story. Avoid using nulls as a response. With methods that return collections, it's easy: return empty collections (or arrays) instead of nulls pretty much all the time.
With non-collections it might be harder. Consider this as an example: if you have these interfaces:
<pre class="lang-java s-code-block"><code class="hljs language-java">public interface Action {
 void doSomething();
}

public interface Parser {
 Action findAction(String userInput);
}
</code></pre>
where Parser takes raw user input and finds something to do, perhaps if you're implementing a command line interface for something. Now you might make the contract that it returns null if there's no appropriate action. That leads the null checking you're talking about.
An alternative solution is to never return null and instead use the <a href="https://en.wikipedia.org/wiki/Null_Object_pattern" rel="noreferrer">Null Object pattern</a>:
<pre class="lang-java s-code-block"><code class="hljs language-java">public class MyParser implements Parser {
 private static Action DO_NOTHING = new Action() {
 public void doSomething() { /* do nothing */ }
 };

 public Action findAction(String userInput) {
 // ...
 if ( /* we can't find any actions */ ) {
 return DO_NOTHING;
 }
 }
}
</code></pre>
Compare:
<pre class="lang-java s-code-block"><code class="hljs language-java">Parser parser = ParserFactory.getParser();
if (parser == null) {
 // now what?
 // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
 // do nothing
} else {
 action.doSomething();
}
</code></pre>
to
<pre class="lang-java s-code-block"><code class="hljs language-java">ParserFactory.getParser().findAction(someInput).doSomething();
</code></pre>
which is a much better design because it leads to more concise code.
That said, perhaps it is entirely appropriate for the findAction() method to throw an Exception with a meaningful error message -- especially in this case where you are relying on user input. It would be much better for the findAction method to throw an Exception than for the calling method to blow up with a simple NullPointerException with no explanation.
<pre class="lang-java s-code-block"><code class="hljs language-java">try {
 ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
 userConsole.err(anfe.getMessage());
}
</code></pre>
Or if you think the try/catch mechanism is too ugly, rather than Do Nothing your default action should provide feedback to the user.
<pre class="lang-java s-code-block"><code class="hljs language-java">public Action findAction(final String userInput) {
 /* Code to return requested Action if found */
 return new Action() {
 public void doSomething() {
 userConsole.err("Action not found: " + userInput);
 }
 }
}
</code></pre>

If you use (or planning to use) a Java IDE like <a href="https://www.jetbrains.com/idea/" rel="noreferrer">JetBrains IntelliJ IDEA</a>, <a href="https://www.eclipse.org/" rel="noreferrer">Eclipse</a> or <a href="https://netbeans.org/" rel="noreferrer">Netbeans</a> or a tool like findbugs then you can use annotations to solve this problem.

Basically, you've got <code>@Nullable</code> and <code>@NotNull</code>.

You can use in method and parameters, like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">@NotNull public static String helloWorld() {
 return "Hello World";
}
</code></pre>

or

<pre class="lang-java s-code-block"><code class="hljs language-java">@Nullable public static String helloWorld() {
 return "Hello World";
}
</code></pre>

The second example won't compile (in IntelliJ IDEA).

When you use the first <code>helloWorld()</code> function in another piece of code:

<pre class="lang-java s-code-block"><code class="hljs language-java">public static void main(String[] args)
{
 String result = helloWorld();
 if(result != null) {
 System.out.println(result);
 }
}
</code></pre>

Now the IntelliJ IDEA compiler will tell you that the check is useless, since the <code>helloWorld()</code> function won't return <code>null</code>, ever.

Using parameter

<pre class="lang-java s-code-block"><code class="hljs language-java">void someMethod(@NotNull someParameter) { }
</code></pre>

if you write something like:

<pre class="lang-java s-code-block"><code class="hljs language-java">someMethod(null);
</code></pre>

This won't compile.

Last example using <code>@Nullable</code>

<pre class="lang-java s-code-block"><code class="hljs language-java">@Nullable iWantToDestroyEverything() { return null; }
</code></pre>

Doing this

<pre class="lang-java s-code-block"><code class="hljs language-java">iWantToDestroyEverything().something();
</code></pre>

And you can be sure that this won't happen. :)

It's a nice way to let the compiler check something more than it usually does and to enforce your contracts to be stronger. Unfortunately, it's not supported by all the compilers.

In IntelliJ IDEA 10.5 and on, they added support for any other <code>@Nullable</code> <code>@NotNull</code> implementations.

See blog post <a href="https://blog.jetbrains.com/idea/2011/03/more-flexible-and-configurable-nullublenotnull-annotations/" rel="noreferrer">More flexible and configurable @Nullable/@NotNull annotations</a>.

<h2>If null-values are not allowed</h2>

If your method is called externally, start with something like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">public void method(Object object) {
 if (object == null) {
 throw new IllegalArgumentException("...");
 }
</code></pre>

Then, in the rest of that method, you'll know that <code>object</code> is not null.

If it is an internal method (not part of an API), just document that it cannot be null, and that's it.

Example:

<pre class="lang-java s-code-block"><code class="hljs language-java">public String getFirst3Chars(String text) {
 return text.subString(0, 3);
}
</code></pre>

However, if your method just passes the value on, and the next method passes it on etc. it could get problematic. In that case you may want to check the argument as above.

<h2>If null is allowed</h2>

This really depends. If find that I often do something like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">if (object == null) {
 // something
} else {
 // something else
}
</code></pre>

So I branch, and do two completely different things. There is no ugly code snippet, because I really need to do two different things depending on the data. For example, should I work on the input, or should I calculate a good default value?

<hr>

It's actually rare for me to use the idiom "<code>if (object != null &amp;&amp; ...</code>".

It may be easier to give you examples, if you show examples of where you typically use the idiom.

Wow, I almost hate to add another answer when we have 57 different ways to recommend the <code>NullObject pattern</code>, but I think that some people interested in this question may like to know that there is a proposal on the table for Java 7 to add <a href="http://tech.puredanger.com/java7/#null" rel="noreferrer">"null-safe handling"</a>—a streamlined syntax for if-not-equal-null logic.

The example given by Alex Miller looks like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">public String getPostcode(Person person) { 
 return person?.getAddress()?.getPostcode(); 
} 
</code></pre>

The <code>?.</code> means only de-reference the left identifier if it is not null, otherwise evaluate the remainder of the expression as <code>null</code>. Some people, like Java Posse member Dick Wall and the <a href="http://blog.joda.org/2008/12/jdk-7-language-changes-devoxx-votes_3751.html" rel="noreferrer">voters at Devoxx</a> really love this proposal, but there is opposition too, on the grounds that it will actually encourage more use of <code>null</code> as a sentinel value.

<hr>

Update: An <a href="http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000047.html" rel="noreferrer">official proposal</a> for a null-safe operator in Java 7 has been submitted under <a href="http://openjdk.java.net/projects/coin/" rel="noreferrer">Project Coin.</a> The syntax is a little different than the example above, but it's the same notion.

<hr>

Update: The null-safe operator proposal didn't make it into Project Coin. So, you won't be seeing this syntax in Java 7.

<h2>If undefined values are not permitted:</h2>

You might configure your IDE to warn you about potential null dereferencing. E.g. in Eclipse, see Preferences &gt; Java &gt; Compiler &gt; Errors/Warnings/Null analysis.

<h2>If undefined values are permitted:</h2>

If you want to define a new API where undefined values make sense, use the <a href="http://www.codecommit.com/blog/scala/the-option-pattern" rel="noreferrer">Option Pattern</a> (may be familiar from functional languages). It has the following advantages:

<ul>
<li>It is stated explicitly in the API whether an input or output exists or not.</li>
<li>The compiler forces you to handle the "undefined" case.</li>
<li><a href="http://james-iry.blogspot.com/2007/08/martians-vs-monads-null-considered.html" rel="noreferrer">Option is a monad</a>, so there is no need for verbose null checking, just use map/foreach/getOrElse or a similar combinator to safely use the value <a href="http://blog.tackley.net/2010/09/option-in-scala-vs-null-in-java.html" rel="noreferrer">(example)</a>.</li>
</ul>

Java 8 has a built-in <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Optional.html" rel="noreferrer"><code>Optional</code></a> class (recommended); for earlier versions, there are library alternatives, for example <a href="http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained" rel="noreferrer">Guava</a>'s <a href="https://google.github.io/guava/releases/19.0/api/docs/com/google/common/base/Optional.html" rel="noreferrer"><code>Optional</code></a> or <a href="http://code.google.com/p/functionaljava" rel="noreferrer">FunctionalJava</a>'s <a href="http://www.functionaljava.org/javadoc/4.4/functionaljava/fj/data/Option.html" rel="noreferrer"><code>Option</code></a>. But like many functional-style patterns, using Option in Java (even 8) results in quite some boilerplate, which you can reduce using a less verbose JVM language, e.g. Scala or Xtend.

If you have to deal with an API which might return nulls, you can't do much in Java. Xtend and Groovy have the <a href="https://www.eclipse.org/xtend/documentation.html#operators" rel="noreferrer">Elvis operator</a> <code>?:</code> and the <a href="https://www.eclipse.org/xtend/documentation.html#nullSafeFeatureCalls" rel="noreferrer">null-safe dereference operator</a> <code>?.</code>, but note that this returns null in case of a null reference, so it just "defers" the proper handling of null.

Only for this situation -

Not checking if a variable is null before invoking an equals method (a string compare example below):

<pre class="lang-java s-code-block"><code class="hljs language-java">if ( foo.equals("bar") ) {
 // ...
}
</code></pre>

will result in a <code>NullPointerException</code> if <code>foo</code> doesn't exist.

You can avoid that if you compare your <code>String</code>s like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">if ( "bar".equals(foo) ) {
 // ...
}
</code></pre>

Java 8 introduced the <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html" rel="nofollow noreferrer"><code>java.util.Optional</code></a> class that addresses some of the problem. One can at least say that it improves the readability of the code, and in the case of public APIs make the contract clearer to the client developer.
They work as follows:
An optional object for a given type (<code>Fruit</code>) is created as the return type of a method. It can be empty or contain a <code>Fruit</code> object:
<pre class="lang-java s-code-block"><code class="hljs language-java">public static Optional&lt;Fruit&gt; find(String name, List&lt;Fruit&gt; fruits) {
 for (Fruit fruit : fruits) {
 if (fruit.getName().equals(name)) {
 return Optional.of(fruit);
 }
 }
 return Optional.empty();
}
</code></pre>
Now look at this code where we search a list of <code>Fruit</code> (<code>fruits</code>) for a given Fruit instance:
<pre class="lang-java s-code-block"><code class="hljs language-java">Optional&lt;Fruit&gt; found = find("lemon", fruits);
if (found.isPresent()) {
 Fruit fruit = found.get(); // Prefer found.orElseThrow() in Java 9+
 String name = fruit.getName();
}
</code></pre>
You can use the <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#map(java.util.function.Function)" rel="nofollow noreferrer"><code>map</code></a> method to perform a computation on — or extract a value from —&nbsp;an optional object. The <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#orElse(T)" rel="nofollow noreferrer"><code>orElse</code></a> method lets you provide a fallback for missing values, converting an <code>Optional</code> to a non-nullable value.
<pre class="lang-java s-code-block"><code class="hljs language-java">String nameOrFallback = find("lemon", fruits)
 .map(f -&gt; f.getName())
 .orElse("empty-name");
</code></pre>
Of course, handling the null/empty value is still necessary, but at least the developer is conscious that the value might be empty and the risk of forgetting to check is limited.
In an API built from scratch using <code>Optional</code> whenever a return value might be empty, and returning a plain object only when it cannot be <code>null</code> (convention), the client code might abandon null checks on simple object return values.
Of course <code>Optional</code> could also be used as a method argument, perhaps a better way to indicate optional arguments than 5 or 10 overloading methods in some cases. Be aware that using it in this manner is <a href="https://stackoverflow.com/a/26328555/1108305">recommended against</a> by Java Language Architect Brian Goetz: "You should almost never use <code>Optional</code> as […] a method parameter."
<code>Optional</code> offers other convenient methods, such as <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#orElseGet(java.util.function.Supplier)" rel="nofollow noreferrer"><code>orElseGet</code></a> that calculates a default value only if the <code>Optional</code> is empty, and <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#ifPresent(java.util.function.Consumer)" rel="nofollow noreferrer"><code>ifPresent</code></a> that peforms an operation only if the <code>Optional</code> is non-empty, both of which work with <a href="https://en.wikipedia.org/wiki/Anonymous_function" rel="nofollow noreferrer">lambda expressions</a>.
I invite you to read this article (the main source for writing this answer) in which the problematic behavior of <code>NullPointerException</code> (and in general null pointer) and the (partial) solution brought by <code>Optional</code> are well explained: <a href="http://java.dzone.com/articles/java-optional-objects" rel="nofollow noreferrer">Java Optional Objects</a>.

Depending on what kind of objects you are checking you may be able to use some of the classes in the apache commons such as: <a href="http://commons.apache.org/lang/" rel="noreferrer">apache commons lang</a> and <a href="http://commons.apache.org/collections/" rel="noreferrer">apache commons collections</a>

Example: 

<pre class="lang-java s-code-block"><code class="hljs language-java">String foo;
...
if( StringUtils.isBlank( foo ) ) {
 ///do something
}
</code></pre>

or (depending on what you need to check):

<pre class="lang-java s-code-block"><code class="hljs language-java">String foo;
...
if( StringUtils.isEmpty( foo ) ) {
 ///do something
}
</code></pre>

The StringUtils class is only one of many; there are quite a few good classes in the commons that do null safe manipulation.

Here follows an example of how you can use null vallidation in JAVA when you include apache library(commons-lang-2.4.jar)

<pre class="lang-java s-code-block"><code class="hljs language-java">public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
 Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
 return read(new StringReader(xml), true, validationEventHandler);
}
</code></pre>

And if you are using Spring, Spring also has the same functionality in its package, see library(spring-2.4.6.jar) 

Example on how to use this static classf from spring(org.springframework.util.Assert)

<pre class="lang-java s-code-block"><code class="hljs language-java">Assert.notNull(validationEventHandler,"ValidationHandler not Injected");
</code></pre>

<ul>
<li>If you consider an object should not be null (or it is a bug) use an assert.</li>
<li>If your method doesn't accept null params say it in the javadoc and use an assert.</li>
</ul>

You have to check for object != null only if you want to handle the case where the object may be null...

There is a proposal to add new annotations in Java7 to help with null / notnull params:
<a href="http://tech.puredanger.com/java7/#jsr308" rel="noreferrer">http://tech.puredanger.com/java7/#jsr308</a>

I'm a fan of "fail fast" code. Ask yourself - are you doing something useful in the case where the parameter is null? If you don't have a clear answer for what your code should do in that case... i.e. - it should never be null in the first place, then ignore it and allow a <code>NullPointerException</code> to be thrown. The calling code will make just as much sense of an NPE as it would an <code>IllegalArgumentException</code>, but it'll be easier for the developer to debug and understand what went wrong if an NPE is thrown rather than your code attempting to execute some other unexpected contingency logic - which ultimately results in the application failing anyway.

In Java 1.7 or later, the standard way to do this is as follows:

<pre class="lang-java s-code-block"><code class="hljs language-java">import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);
</code></pre>

See <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadLocalRandom.html#nextInt(int,int)" rel="noreferrer">the relevant JavaDoc</a>. This approach has the advantage of not needing to explicitly initialize a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html" rel="noreferrer">java.util.Random</a> instance, which can be a source of confusion and error if used inappropriately.

However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.

Before Java 1.7, the standard way to do this is as follows:

<pre class="lang-java s-code-block"><code class="hljs language-java">import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * &lt;code&gt;Integer.MAX_VALUE - 1&lt;/code&gt;.
 *
 * @param min Minimum value
 * @param max Maximum value. Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

 // NOTE: This will (intentionally) not run as written so that folks
 // copy-pasting have to think about how to initialize their
 // Random instance. Initialization of the Random instance is outside
 // the main scope of the question, but some decent options are to have
 // a field that is initialized once and then re-used as needed or to
 // use ThreadLocalRandom (if using at least Java 1.7).
 // 
 // In particular, do NOT do 'Random rand = new Random()' here or you
 // will get not very good / not very random results.
 Random rand;

 // nextInt is normally exclusive of the top value,
 // so add 1 to make it inclusive
 int randomNum = rand.nextInt((max - min) + 1) + min;

 return randomNum;
}
</code></pre>

See <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html#nextInt(int)" rel="noreferrer">the relevant JavaDoc</a>. In practice, the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html" rel="noreferrer">java.util.Random</a> class is often preferable to <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html#random()" rel="noreferrer">java.lang.Math.random()</a>.

In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.

Note that this approach is more biased and less efficient than a <code>nextInt</code> approach, <a href="https://stackoverflow.com/a/738651/360211">https://stackoverflow.com/a/738651/360211</a>

One standard pattern for accomplishing this is:

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (int)(Math.random() * ((Max - Min) + 1))
</code></pre>

The <a href="http://en.wikipedia.org/wiki/Java_%28programming_language%29" rel="noreferrer">Java</a> Math library function Math.random() generates a double value in the range <code>[0,1)</code>. Notice this range does not include the 1.

In order to get a specific range of values first, you need to multiply by the magnitude of the range of values you want covered. 

<pre class="lang-java s-code-block"><code class="hljs language-java">Math.random() * ( Max - Min )
</code></pre>

This returns a value in the range <code>[0,Max-Min)</code>, where 'Max-Min' is not included.

For example, if you want <code>[5,10)</code>, you need to cover five integer values so you use

<pre class="lang-java s-code-block"><code class="hljs language-java">Math.random() * 5
</code></pre>

This would return a value in the range <code>[0,5)</code>, where 5 is not included.

Now you need to shift this range up to the range that you are targeting. You do this by adding the Min value.

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (Math.random() * (Max - Min))
</code></pre>

You now will get a value in the range <code>[Min,Max)</code>. Following our example, that means <code>[5,10)</code>:

<pre class="lang-java s-code-block"><code class="hljs language-java">5 + (Math.random() * (10 - 5))
</code></pre>

But, this still doesn't include <code>Max</code> and you are getting a double value. In order to get the <code>Max</code> value included, you need to add 1 to your range parameter <code>(Max - Min)</code> and then truncate the decimal part by casting to an int. This is accomplished via:

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (int)(Math.random() * ((Max - Min) + 1))
</code></pre>

And there you have it. A random integer value in the range <code>[Min,Max]</code>, or per the example <code>[5,10]</code>:

<pre class="lang-java s-code-block"><code class="hljs language-java">5 + (int)(Math.random() * ((10 - 5) + 1))
</code></pre>

Use:

<pre class="lang-java s-code-block"><code class="hljs language-java">Random ran = new Random();
int x = ran.nextInt(6) + 5;
</code></pre>

The integer <code>x</code> is now the random number that has a possible outcome of <code>5-10</code>.

Use:
<pre class="lang-java s-code-block"><code class="hljs language-java">minValue + rn.nextInt(maxValue - minValue + 1)
</code></pre>

With <a href="https://www.oracle.com/java/technologies/java8.html" rel="noreferrer">Java 8</a> they introduced the method <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Random.html#ints-int-int-" rel="noreferrer"><code>ints(int randomNumberOrigin, int randomNumberBound)</code></a> in the <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Random.html" rel="noreferrer"><code>Random</code></a> class.
For example if you want to generate five random integers (or a single one) in the range [0, 10], just do:
<pre class="lang-java s-code-block"><code class="hljs language-java">Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
</code></pre>
The first parameter indicates just the size of the <code>IntStream</code> generated (which is the overloaded method of the one that produces an unlimited <code>IntStream</code>).
If you need to do multiple separate calls, you can create an infinite primitive iterator from the stream:
<pre class="lang-java s-code-block"><code class="hljs language-java">public final class IntRandomNumberGenerator {

 private PrimitiveIterator.OfInt randomIterator;

 /**
 * Initialize a new random number generator that generates
 * random numbers in the range [min, max]
 * @param min - the min value (inclusive)
 * @param max - the max value (inclusive)
 */
 public IntRandomNumberGenerator(int min, int max) {
 randomIterator = new Random().ints(min, max + 1).iterator();
 }

 /**
 * Returns a random number in the range (min, max)
 * @return a random number in the range (min, max)
 */
 public int nextInt() {
 return randomIterator.nextInt();
 }
}
</code></pre>
You can also do it for <code>double</code> and <code>long</code> values.

You can edit your second code example to:

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
</code></pre>

Just a small modification of your first solution would suffice.

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);
</code></pre>

<hr>

See more here for implementation of <a href="https://insight.io/github.com/lambdalab-mirror/jdk8u-jdk/blob/master/src/share/classes/java/util/Random.java?line=77" rel="noreferrer"><code>Random</code></a>

<code>ThreadLocalRandom</code> equivalent of class <code>java.util.Random</code> for multithreaded environment. Generating a random number is carried out locally in each of the threads. So we have a better performance by reducing the conflicts. 

<pre class="lang-java s-code-block"><code class="hljs language-java">int rand = ThreadLocalRandom.current().nextInt(x,y);
</code></pre>

<code>x</code>,<code>y</code> - intervals e.g. (1,10)

The <code>Math.Random</code> class in <a href="http://en.wikipedia.org/wiki/Java_%28programming_language%29" rel="noreferrer">Java</a> is 0-based. So, if you write something like this: 

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rand = new Random();
int x = rand.nextInt(10);
</code></pre>

<code>x</code> will be between <code>0-9</code> inclusive.

So, given the following array of <code>25</code> items, the code to generate a random number between <code>0</code> (the base of the array) and <code>array.length</code> would be:

<pre class="lang-java s-code-block"><code class="hljs language-java">String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );
</code></pre>

Since <code>i.length</code> will return <code>25</code>, the <code>nextInt( i.length )</code> will return a number between the range of <code>0-24</code>. The other option is going with <code>Math.Random</code> which works in the same way.

<pre class="lang-java s-code-block"><code class="hljs language-java">index = (int) Math.floor(Math.random() * i.length);
</code></pre>

For a better understanding, check out forum post <a href="http://web.archive.org/web/20070308142422/http://www.kirupa.com/forum/showthread.php?s=&amp;postid=81565" rel="noreferrer">Random Intervals (archive.org)</a>.

It can be done by simply doing the statement:
<pre class="lang-java s-code-block"><code class="hljs language-java">Randomizer.generate(0, 10); // Minimum of zero and maximum of ten
</code></pre>
Below is its source code.
<h3>File Randomizer.java</h3>
<pre class="lang-java s-code-block"><code class="hljs language-java">public class Randomizer {
 public static int generate(int min, int max) {
 return min + (int)(Math.random() * ((max - min) + 1));
 }
}
</code></pre>
It is just clean and simple.

in your terminal type
<pre><code>cd /
</code></pre>
then use this command:
<pre><code>du -h --max-depth=1
</code></pre>
it will take some time, but you will get folder list with sizes
<a href="https://i.sstatic.net/i850f.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/i850f.jpg" alt="enter image description here"></a>
as explained in details here:
<a href="https://floyk.com/en/post/how-to-find-which-folders-are-taking-the-disk-space-by-using-terminal-on-linux" rel="nofollow noreferrer">https://floyk.com/en/post/how-to-find-which-folders-are-taking-the-disk-space-by-using-terminal-on-linux</a>

It could be coming from Jenkins, Docker or any other process. To solve that, you should <a href="https://puvox.software/blog/solution-clean-full-disk-space-by-dev-vda1/" rel="nofollow noreferrer">clean logs and set it's size</a>.

From the above output of 'df -h' the disk space is used by some file or folders in '/' location. As you are able to SSH in to the server follow the below steps and that will show the files that are using more space.

<ul>
<li>cd /</li>
<li>ls -lSr | tail -10</li>
</ul>

The first command [cd space slash] will direct you to the '/' folder and second command will list files based on its size. Please post the output of the above command. This will show the files that are using more space on the current directory. Once you can find this you will be able to remove the unused files (if any). Or you can contact the hosting provider to mount another harddisk space to '/' to migrate those files and free more space.

<pre class="lang-js s-code-block"><code class="hljs language-javascript">const usernameChangeHandler = async (event) =&gt; {
 await setEnteredUsername(event.target.value);
 console.log(enteredUsername, enteredAge); 
};
</code></pre>
<code>enteredUsername</code> is never going to change. It's a closure variable that's local to this single time you rendered the component. It's usually a <code>const</code>, but even if it was made with <code>let</code>, <code>setEnteredUsername</code> does not even attempt to change its value. What <code>setEnteredUsername</code> does is ask react to rerender the component. When the render eventually happens, a new local variable will be created with the new value, but code from your old render has no access to that.
If you need to run some code after calling <code>setEnteredUsername</code>, but you don't actually care if the component has rerendered yet, the just use the value in <code>event.target.value</code>, since you know that's going to be the new value of the state:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">const usernameChangeHandler = (event) =&gt; {
 setEnteredUsername(event.target.value);
 console.log(event.target.value, enteredAge);
}
</code></pre>
If instead you need to make make sure that the component has rerendered and then do something after that, you can put your code in a useEffect. Effects run after rendering, and you can use the dependency array to make it only run if the values you care about have changed:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">const [enteredUsername, setEnteredUsername] = useState('');

useEffect(() =&gt; {
 console.log('rendering complete, with new username', enteredUsername);
}, [enteredUsername]);

const usernameChangeHandler = (event) =&gt; {
 setEnteredUsername(event.target.value);
};
</code></pre>

the act of setting state is asynchronous; therefore, console logging directly after setting your state will not accurately provide you with how state currently looks. Instead as many have suggested you can utilize the useEffect lifecycle hook to listen for changes in your enteredUserName state like so:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">useEffect(() =&gt; {
 console.log(enteredUsername);
}, [enteredUsername]);
</code></pre>
listening for changes within the useEffect will allow you to create side effects once state has updated and caused your component to rerender. This in turn will trigger your useEffect with the enteredUsername dependency, as the enteredUserName state has changed.

It's not documented (at time of asking), but NPM can filter workspace commands to subdirectories of workspaces by giving the <code>--workspace</code> flag a path as its value. For example:
<pre><code>npm run --workspace packages/presets --workspace packages/plugins build
</code></pre>
This will find workspaces that are directly in <code>$project_root/packages/presets/</code> or <code>$project_root/packages/plugins/</code>, but not workspaces in subdirectories of these subdirectories.
Deeper-nested subdirectories can be included using <code>/**</code>, like:
<pre><code>npm run --workspace packages/** build
</code></pre>
<hr>
The above examples would work with workspaces organised into subdirectories, defined in package.json like:
<pre><code> "workspaces": [
 "packages/plugins/*",
 "packages/presets/*",
 ...more
 ],
</code></pre>
...or a catch-all like:
<pre><code> "workspaces": [
 "packages/**",
 ...more
 ],
</code></pre>
<hr>
While pointing <code>--workspace</code> to subdirectories of workspaces instead of individual workspaces like this doesn't seem to be documented anywhere at time of writing, it does appear to be an intentional, planned, supported feature. I found a note proposing it <a href="https://github.com/npm/rfcs/pull/117" rel="noreferrer">deep in one of the rfcs</a>:
<blockquote>
Note: Globs are not supported as a valid --workspace argument value, the proposed alternative is to use npm --workspace= in which is a folder containing multiple workspaces.
</blockquote>
I couldn't find anything explicitly stating that this proposal was implemented, but I tried reorganising my monorepo into subdirectories and using a subdirectory with the <code>--workspace</code> flag, and it worked.
Their reason for choosing paths rather than glob patterns in workspace names (like yarn does and lerna did) appears to be because of the:
<blockquote>
many pitfalls of supporting globs in the variety of supported shells and operational systems
</blockquote>

<a href="https://stackoverflow.com/a/71350662/3404438">This answer</a> is very complete. Just a couple of tweaks that worked for me:
I needed to use the npm command/script before the --workspace flag, and I did not needed to use the <code>/**</code> at the end.
<pre><code>npm run &lt;script-name&gt; --workspace parent/directory/
</code></pre>
Examples:
<pre><code>npm publish --workspace packages/public/
npm run build --workspace packages/helpers/
</code></pre>
This is documented in other parts of npm so it took a bit of digging. The information is generally the same in all places, because the <code>--workspace</code> flag is a configuration for multiple npm commands:
<pre><code>Valid values for the workspace config are either:

Workspace names
Path to a workspace directory
Path to a parent workspace directory (will result in selecting all workspaces within that folder)
</code></pre>
I found it documented <a href="https://docs.npmjs.com/cli/v8/using-npm/config#workspace" rel="nofollow noreferrer">here</a> and <a href="https://docs.npmjs.com/cli/v8/commands/npm-publish#workspace" rel="nofollow noreferrer">here</a>.
Unfortunately there does not seem to be a way to use globs. Only way to group things would be by parent directory.
Disclaimer: I was going to add a comment to <a href="https://stackoverflow.com/a/71350662/3404438">this answer</a> but it was becoming too long and details might have been missed. I think that is the right answer.

算法相关问题