我正在寻找具有以下几个属性的寻路算法：
这两个要求让我想到了Anytime D*，除了我的最后一个要求外，它似乎可以正常工作：
有没有一种算法可以结合这两种算法（Anytime D* 和 Field D*）的各个方面？如果没有，是否可以将 Anytime D* 的改进纳入 Field D* 中？还是我遗漏了什么，而我已经拥有了我需要的东西？
我晚上晚些时候会写这篇文章，所以几个小时内我都无法回复任何内容。我希望我有足够的背景信息。
感谢您的所有帮助！
是否存在一种算法，可以有效地将 uint32 转换为不同的 uint32，并在给定可变的随机种子时产生 1：1 的映射？
我对此的初步方向是一种算法，其中种子以某种方式表达数字中要重新排列的位（这样 0000 0101 就变成了 0100 1000，种子为 [0->6, 2->3]），但我不确定如何生成一种有效地进行混洗的方法。
一些限制：
我正在一个在线平台上解决一个测试，问题陈述与此类似。
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)，实际上有两种到达方式：
这也造成了一些混乱。
在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] 的细胞数量的演变。以下是第一步的计数：
我们的目标是确定第 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) 时间复杂度执行每个操作？
我正在解决 leetcode 问题 1372。为什么这两个代码返回不同的结果？第一个给出了正确答案。第二个没有。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def __init__(self):
self.longest_path = 0
def longestZigZag(self, root: Optional[TreeNode]) -> int:
val1 = 1 + self.helper(root.right, 'r')
val2 = 1 + self.helper(root.left, 'l')
# print(val2, self.longest_path)
val = max(val1, val2)
return max(val, self.longest_path) - 1
def helper(self, root, d):
if root == None:
return 0
if d == 'l':
l_path = 1 + self.helper(root.left, d='l')
self.longest_path = max(self.longest_path, l_path)
return 1 + self.helper(root.right, d='r')
if d == 'r':
r_path = 1 + self.helper(root.right, d='r')
self.longest_path = max(self.longest_path, r_path)
return 1 + self.helper(root.left, d='l')
class Solution:
def __init__(self):
self.longest_path = 0
def longestZigZag(self, root: Optional[TreeNode]) -> int:
val1 = 1 + self.helper(root.right, 'r')
val2 = 1 + self.helper(root.left, 'l')
# print(val2, self.longest_path)
val = max(val1, val2)
return max(val, self.longest_path) - 1
def helper(self, root, d):
if root == None:
return 0
if d == 'l':
self.longest_path = max(self.longest_path, 1 + self.helper(root.left, d='l'))
return 1 + self.helper(root.right, d='r')
if d == 'r':
r_path = 1 + self.helper(root.right, d='r')
self.longest_path = max(self.longest_path, r_path)
return 1 + self.helper(root.left, d='l')
唯一的变化是这一行：
“self.longest_path = max(self.longest_path，1 + self.helper(root.left，d='l'))”