表达式并发计算
问题背景
我们需要计算一个由多步双目运算构成的复杂表达式。这类表达式的结构可以被抽象成一棵二叉树，其中：
- 叶子节点 ：代表操作数（即参与计算的数字）。
- 非叶子节点 ：代表运算符 （例如
+,-,*,/）。
例如，表达式 (1 * 2) + (60 / 3) 可以用下面的二叉树来表示：
javascript
+
/ \
* /
/ \ / \
1 2 60 3计算规则与并发模型
为了提升计算效率，我们希望利用CPU的多核能力进行并行计算。计算遵循以下规则：
-
执行条件 ：一个运算符节点只有在其左右两个子节点都已经是操作数时，才能进行计算。
- 初始时，树的叶子节点是操作数。
- 当一个运算符节点（例如
*）完成计算后，它自身会转变为一个操作数（其值为1 * 2 = 2），这个新的操作数可以作为其父节点（+）的输入。
-
时间模型 ：每一次双目运算（即计算一个运算符节点的值）需要 1 个时间周期。
-
并发能力 ：在一个时间周期内，可以并行执行的运算数量不能超过CPU的核数
coreCount。
目标
给定一个以特定格式描述的表达式二叉树 nodeValues 和CPU的核数量 coreCount，请计算出完成整个表达式计算最少需要多少个时间周期。
输入格式
-
coreCount: 第一个参数，一个整数，表示CPU的核数。1 <= coreCount <= 64
-
nodeValues: 第二个参数，一个数组，以层序遍历的方式表示二叉树的各个节点。-
3 <= nodeValues.length <= 10000 -
数组中的值含义如下：
0: 表示一个非叶子节点（运算符）。1: 表示一个叶子节点（操作数）。-1: 表示一个空节点，代表该位置没有节点，其子节点也不会在数组中出现。
-
用例保证输入可以构造出一棵合法的二叉树。
-
输出格式
- 一个整数，表示计算完成整个表达式所需的最少时间周期。
样例说明
样例输入
ini
coreCount = 3
nodeValues = [0, 0, 0, 1, 1, 1, 1]样例输出
2解释
-
树的结构:
该 nodeValues 数组描述的二叉树结构与问题背景中的图示完全相同：
- 根节点是
0(运算符)。 - 第二层是两个
0(运算符)。 - 第三层是四个
1(操作数)。
- 根节点是
-
计算过程分解:
-
初始状态:
- 最底层的四个节点 (
1, 1, 1, 1) 都是操作数。 - 第二层的两个运算符节点 (
*和/的位置) 的子节点都已准备就绪，因此这两个运算是可计算的。 - 根节点的运算符 (
+的位置) 因为其子节点还是运算符，所以不可计算。
- 最底层的四个节点 (
-
第 1 个时间周期:
- 我们有两个可计算的运算。
- CPU有
coreCount = 3个核心，足以同时处理这两个运算。 - 因此，我们可以并行计算第二层的两个运算。
- 周期结束时: 第二层的两个运算符节点完成计算，变成了操作数。此时，根节点的两个子节点都已成为操作数。
-
第 2 个时间周期:
- 现在，根节点的运算是唯一一个可计算的运算。
- 我们使用 3 个CPU核心中的一个来执行这个运算。
- 周期结束时: 根节点计算完成，整个表达式计算结束。
-
-
结论:
整个过程总共需要 2 个时间周期。因此，最少需要的时间是 2。
java
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* 解决表达式并发计算问题的实现类.
* 核心思想是通过逐时间周期的模拟，来计算在多核CPU下完成整个表达式树计算所需的最少时间。
*/
public class ExpressionCalculator {
/**
* 内部静态类，用于表示二叉树中的一个节点.
*/
private static class TreeNode {
int val; // 节点类型: 0 for operator, 1 for operand
TreeNode left;
TreeNode right;
TreeNode parent; // 指向父节点的引用，用于在计算完成后向上更新状态
public TreeNode(int val) {
this.val = val;
}
}
/**
* 主方法，计算完成表达式所需的最少时间周期.
*
* @param coreCount CPU的核数量
* @param nodeValues 以层序方式表示的二叉树节点数组
* @return 最少需要的时间周期数
*/
public int calculateTime(int coreCount, int[] nodeValues) {
if (nodeValues == null || nodeValues.length == 0) {
return 0;
}
// --- 步骤 1: 从数组构建二叉树 ---
// 同时建立父节点指针，并找出根节点
TreeNode root = buildTree(nodeValues);
// 如果根节点本身就是操作数（例如只有一个节点的树），则不需要时间
if (root.val == 1) {
return 0;
}
// --- 步骤 2: 找到初始可计算的节点 ---
// 初始可计算的节点是那些左右子节点都是操作数(1)的运算符(0)节点。
List<TreeNode> readyNodes = new ArrayList<>();
findInitialReadyNodes(root, readyNodes);
// --- 步骤 3: 模拟逐个时间周期的计算过程 ---
int timeCycles = 0;
// 循环直到根节点被计算完成（即其值变为1）
while (root.val == 0) {
timeCycles++; // 进入下一个时间周期
// 确定本周期可以执行的操作数量
int opsToPerform = Math.min(readyNodes.size(), coreCount);
// 存储在本周期内被计算完成的节点
List<TreeNode> computedInThisCycle = new ArrayList<>();
// 从待执行列表中取出相应数量的节点进行计算
for (int i = 0; i < opsToPerform; i++) {
// 从列表头部取出一个节点（也可以从尾部，顺序不影响结果）
computedInThisCycle.add(readyNodes.remove(0));
}
// --- 步骤 4: 更新状态，为下一周期做准备 ---
// 遍历本周期内所有被计算的节点
for (TreeNode computedNode : computedInThisCycle) {
// 将其标记为已计算（变为操作数）
computedNode.val = 1;
// 检查其父节点是否因此变得可计算
TreeNode parent = computedNode.parent;
if (parent != null && parent.val == 0) {
// 如果父节点的左右子节点现在都已是操作数
if (parent.left.val == 1 && parent.right.val == 1) {
// 则父节点成为下一批可计算的节点
readyNodes.add(parent);
}
}
}
}
return timeCycles;
}
/**
* 辅助方法：从层序遍历数组构建二叉树，并设置父节点指针.
*/
private TreeNode buildTree(int[] nodeValues) {
if (nodeValues.length == 0 || nodeValues[0] == -1) {
return null;
}
TreeNode root = new TreeNode(nodeValues[0]);
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
int i = 1; // 从根节点的左子节点开始
while (i < nodeValues.length) {
TreeNode currentNode = queue.poll();
// 如果当前节点是叶子节点(操作数)，则它没有子节点，跳过
if(currentNode.val == 1) {
continue;
}
// 创建并连接左子节点
if (i < nodeValues.length && nodeValues[i] != -1) {
TreeNode leftChild = new TreeNode(nodeValues[i]);
currentNode.left = leftChild;
leftChild.parent = currentNode;
queue.offer(leftChild);
}
i++;
// 创建并连接右子节点
if (i < nodeValues.length && nodeValues[i] != -1) {
TreeNode rightChild = new TreeNode(nodeValues[i]);
currentNode.right = rightChild;
rightChild.parent = currentNode;
queue.offer(rightChild);
}
i++;
}
return root;
}
/**
* 辅助方法：通过后序遍历，递归地查找初始可计算的节点.
*/
private void findInitialReadyNodes(TreeNode node, List<TreeNode> readyNodes) {
if (node == null) {
return;
}
// 先递归处理子节点
findInitialReadyNodes(node.left, readyNodes);
findInitialReadyNodes(node.right, readyNodes);
// 后序位置，检查当前节点是否是初始可计算的
if (node.val == 0 && node.left != null && node.left.val == 1 && node.right != null && node.right.val == 1) {
readyNodes.add(node);
}
}
}