我正在研究一个优化问题，即找到一个最大化某个目标函数的区域，我使用一组像素坐标来跟踪该区域，并且每一步我都会在边界处添加或删除一个像素，以查看目标函数是否增加。我希望该区域是连通的，是否有任何数据结构可以快速决定删除一个像素是否会使该区域断开连接？这里我们假设一个像素与其四个邻居相连。
还有一个类似的问题：如果我希望该区域始终是单连通的，该怎么办？单连通的意思是没有洞，而添加一个像素可能会产生一个洞。
我正在寻找具有以下几个属性的寻路算法：
- 速度非常必要，一旦选定目标，就需要快速制定次优路径，然后在运动过程中进行改进。这让我觉得我需要一个“随时算法”
- 环境中还有其他参与者，因此不断变化。这让我想到基于D* 或 D* Lite的算法，这样可以快速替换路径。
这两个要求让我想到了Anytime D*，除了我的最后一个要求外，它似乎可以正常工作：
- 返回的路径必须快速跟随，并且直接。由Field D*生成的路径就是很好的例子。
有没有一种算法可以结合这两种算法（Anytime D* 和 Field D*）的各个方面？如果没有，是否可以将 Anytime D* 的改进纳入 Field D* 中？还是我遗漏了什么，而我已经拥有了我需要的东西？
我晚上晚些时候会写这篇文章，所以几个小时内我都无法回复任何内容。我希望我有足够的背景信息。
感谢您的所有帮助！
是否存在一种算法，可以有效地将 uint32 转换为不同的 uint32，并在给定可变的随机种子时产生 1：1 的映射？
我对此的初步方向是一种算法，其中种子以某种方式表达数字中要重新排列的位（这样 0000 0101 就变成了 0100 1000，种子为 [0->6, 2->3]），但我不确定如何生成一种有效地进行混洗的方法。
一些限制：
- 生成从种子进行改组的算法不需要非常快
- 实际上，对 uint32 执行 shuffle 应该很快
- 对于给定的种子，输出中不应有重复（唯一的 uint32 产生唯一的 uint32）
我正在一个在线平台上解决一个测试，问题陈述与此类似。
Stuart 必须从一个地方到另一个地方（A->B），他每次可以跳 1 步、2 步或 3 步。A 和 B 之间可以有 n 个阻挡器。
我们需要找出他能做到这一点的方法数量。
我觉得这类似于经典的爬楼梯问题，但区别不大，在爬楼梯问题中，你最终必须到达第 n 级台阶，而在这个特定问题中，你必须走下楼梯，这样可能就是第 n+1 级台阶。我说得对吗？
所以我写的代码是这样的：
function countWays(n) {
if (n < 0) return 0;
if (n === 0) return 1;
if (n === 1) return 2; //If you have one stop-over, there's two ways to reach. One is take one jump and then one more. Second is take two jumps at once and reach the destination
return countWays(n-1) + countWays(n-2) + countWays(n-3);
}
console.log(countWays(4))这没有被接受。所以我想知道这有什么问题。我是否也应该添加基本情况n==2？
if (n === 2) return 4
但这仍然没有任何好处，因为n = 3它会返回6，而从视觉上我可以看到，如果有 3 个中途停留，就会有 7 种方式。
我想问的另一个问题是，
在经典的楼梯案例中，基准情况n === 0是 1。这里还是一样吗？这让我有点困惑，因为当没有更多的台阶可以爬的时候，结果怎么会是 1。另一方面，当n === 1你仍然有一条路可以到达目的地时。
此外，f(3)逻辑和直觉表明应该是：
number of ways to reach first stopover + f(2)
而且number of ways to reach first stopover只有一种方式可以做到这一点（跳一次）。
但是，我不能输入if(n == 1) return 1基本情况，因为这样不正确。假设只有一个中途停留点 (n = 1)，实际上有两种到达方式：
- 跳 2 步
- 跳 1 步，然后再跳 1 步。
这也造成了一些混乱。
在Sedgewick & et al.的算法第4版第296页中，作者写道：
截止值 M 的最佳值取决于系统，但在大多数情况下，5 到 15 之间的任何值都可能效果良好。
但是我不明白截止值依赖于系统是什么意思，因为算法的性能的衡量标准是它执行的操作数，而不是与计算机处理器的速度无关？
ALGO(A,s,d)
m=d-s+1
if m>=2 then
q=⌊m/2⌋
return 2ALGO(A, s, s+q-1) + 3ALGO(A, s+q, d);
else
return 1
endif
我有这段代码，我必须找到 函数中的递归关系n。问题指出该算法最初用 调用ALGO(A, 1, n)。A 是一个大小为 的数组n，s并且d是整数，q是 的 floor 函数m/2。
我想到的解决方案是：
T(n) = 1 if n<2
T(n) = T(⌊n/2⌋) + T(⌈n/2⌉) + theta(1) if n>=2.
我的理由是if s=1，在第一个递归调用中，我有d=n，所以，对于第二个调用，所以，因为在 if 中我计算了哪些成本。我不知道我想出的解决方案是否正确m=n，也不知道如何解决它。对于解决方案，我不知道我是否可以说。q=⌊n/2⌋s=1d=⌊n/2⌋m=⌊n/2⌋s=s+q=1+⌊n/2⌋ d=nm=⌈n/2⌉T(⌊n/2⌋) + T(⌈n/2⌉) + theta(1)q1T(⌊n/2⌋) + T(⌈n/2⌉) = T(n)
我正在研究一个涉及 3D（立方）无限细胞自动机的挑战，其定义为：
初始状态：我们从位于立方体顶点的 8 个单元开始，每个单元处于 4 种状态之一 {0：粉色、1：红色、2：绿色、3：蓝色}。
增长：在每一步中，立方体都会通过在每对现有单元之间插入新单元来扩展。新单元的状态由其最近邻居的状态总和模 4 确定。请注意，根据其位置，新单元有 2、4 或 8 个最近邻居（这是 3D Moore 邻域）。
为了说明这一点，下面是第一步的说明：
初始状态
步骤 1
例如，中心节点为绿色，因为它有 8 个邻居，它们的类型总和为 2（绿色）+ 1（红色）+ 1（红色）+ 0（粉色）+ 2（绿色）+ 0（粉色）+ 3（蓝色）+ 1（红色）= 10 % 4 = 2（绿色）
第 2 步
我们感兴趣的是追踪每个状态 [0, 1, 2, 3] 的细胞数量的演变。以下是第一步的计数：
- 初始：2、3、2、1
- 步骤 1：6、10、7、4
- 第 2 步：30、36、31、28
- 步骤 3：196、192、155、186
- 步骤 4：1'162、1'276、1'207、1'268
我们的目标是确定第 19 步中每个细胞状态的数量。鉴于指数增长，蛮力是不可行的。有人告诉我可以在不到一秒的时间内解决它。有人知道如何解决这个问题吗？
提前感谢您的帮助！
我遇到了一种将颜色从 RGB 转换为 HSI 的相当三角函数式的实现。具体来说，就是从 RGB 转换为“由双锥体给出的 HSI 颜色空间”，我猜想这是HSL 的双六锥体模型的另一个名称。
作者描述了“他们首选的变换”RGB-->HSI 的方程式，我已在 Python 中将其实现如下。没有给出反向变换，HSI-->RGB。
def rgb_to_hsi(r, g, b):
# r, g, b in [0..1]
x = min(r, g, b)
y = max(r, g, b)
I = (x + y) / 2.0
S = y - x
c1 = r - (g + b) / 2.0
c2 = (np.sqrt(3) * (b - g)) / 2.0
H = np.arctan2(c2, c1)
H = np.mod(-H, 2 * pi) # re-range to [0..2PI], rotating from red at 0 to green at 2/3PI, etc.
return [H, S, I] # H in [0..2PI], S in [0..1], I in [0..1]
该算法和我的实现似乎都是正确的，并提供符合该图的结果（即红色（rgb（1,0,0））给出[0.0, 1, 0.5]）：
但我无法找到或推导出这种转换的逆向工作方法hsi_to_rgb()。
我尝试了几种实现方式，但它们倾向于映射hsi(0.0, 1, 0.5)到rgb(0.5, 0, 0)（半亮度的红色，而不是全亮度的红色）。
我怀疑这是因为大多数 HSL 实现使用HSL 的圆柱模型，而不是双圆锥模型——这是真的吗？
无论哪种方式，将 HSL 双锥模型转换为 rgb 的有效算法（理想情况下是三角算法）是什么？
给定一个无符号的 64 位整数y，有没有一种有效的方法来找到所有无符号的 64 位整数，x使得
(x & (x + y)) == 0？
以下是一些小例子y：
y=0：唯一可能的解决方案x=0y=1x=(1<<n)-1：对于某些 n>=0，所有解都具有以下形式y=2x=(1<<n)-2：对于某些 n>=1，所有解都属于以下形式y=3：要么x=(1<<n)-3，n>=2，要么x=(1<<n)-2，n>=1
一般来说，要考虑的案例数量取决于的位表示中 1 和 0 的运行次数y。
问题的解决方案可能是使用迭代器函数，找到下一个有效的x，如下所示：
uint64 next(uint64 x, uint64 y) {
x++;
while (x & (x+y)) x++;
return x;
}
由于标准(x & (x + y)) == 0相当简单，这可能是一个已知问题，有比上述更有效的解决方案。
我正在尝试寻找解决这一挑战的方法：
给定 n，即一个由 1 填充的数组的大小。此数组上可以进行两种类型的操作：
- 增加（x，y，m）：将 m 添加到从位置 x 到 y（包括）的区间内的所有数组元素。1 <= x <= y <= n。
- 给出（x，y）：返回给定区间上的非减序列的最大长度。
例子：
输入：
n = 5：运营：
增加 1 2 3 (x = 1, y = 2, m = 3)
现在我们的数组是
[4, 4, 1, 1, 1]给出 2 4 (x = 2, y = 4)
最大长度为 2，因为最大非递减序列为 1, 1。
我寻找一个解决方案，其中每个操作都有 O(log(n)) 的时间复杂度。
我的方法
我注意到我们可以将此数组存储为零数组，其中每个元素表示它比前一个元素大多少。例如，[1, 4, 2, 5]我们有而不是[0, 3, -2, 3]。现在我们只需查看负数就可以轻松找到非递减序列。我曾尝试过这种方式并优化查找负数（例如通过使用集合或树），但在某些情况下，“给予”操作仍然具有 O(n) 复杂度，这不是我想要的。
我的算法是这样工作的：
请注意，如果我们使用一个零数组，我们可以只用两个步骤来改变它（当有增加操作时）：arr[x] += m 和 arr[y + 1] -= m（我假设 arr 是基于 1 的）。一开始我有一个新的空集。在增加操作期间，我执行上述两个步骤，然后：
如果“+= m”操作后 arr[x] 不小于 0，则从集合中删除 x。
如果“-= m”操作后 arr[y + 1] 不再等于或大于 0，则将 y + 1 添加到集合中。
在所有增加操作之后，我们将得到一组全负数。正如我上面所写的，这些都是非递减区间。例如，如果我们有n = 6和set = {2, 6}，我们就有 3 个非递减区间：(1, 1)、(2, 5)、(6, 6)。所以我们可以在 O(set.size()) 中执行 Give 操作，这并不好。
如何以 O(logn) 时间复杂度执行每个操作？