【问题标题】：Indices of objects in a list of non-redundant pairs非冗余对列表中的对象索引
【发布时间】：2019-03-05 02:14:05
【问题描述】：

我正在实现一个碰撞检测算法，将所有对象之间的距离存储在一个八叉树节点中。例如，如果节点中有 4 个对象，则对象 1&2、1&3、1&4、2&3、2&4 和 3&4 之间存在距离。对的总数的公式是 t = n * (n-1) / 2，其中 t 是对的总数，n 是一个节点中的对象数。

我的问题是，如何从列表中的位置转换为一对对象。例如，使用上面的对列表，3 将返回对 2&3。

为了节省内存空间，列表只是距离的浮点列表，而不是包含距离和指向 2 个对象的指针。

我不确定如何在数学上将单个列表索引转换为一对数字。任何帮助都会很棒。我希望能够将其分解为 2 个函数，第一个返回对中的第一个对象，第二个返回第二个，这两个函数都采用 2 个变量，一个是索引，另一个是总对象节点。如果可能的话，我想制作一个没有任何循环或具有递归函数的函数，因为这将为我的碰撞检测算法实时运行。

【问题讨论】：

我是否正确理解您正在寻找“索引”节点列表的排序 nC2（ (8 2) 是最大值， (2 2) 是最小值，假设总是有孩子) 以便给定索引 'n' 您想要该排序组合列表中的对？是这样吗？
@WhozCraig：不，该列表只是对应于一对两个对象的任意距离值的数组。为了减少内存消耗，我只存储表示距离的浮点值，而不是排序的对，而不是距离和 2 个指向对象的指针，这很容易使内存消耗增加一倍甚至三倍。问题是通过数学上以升序计算配对来确定数组条目代表哪两个对象，第一个配对项目具有优先级。
所以 [d1, d2, d3, d4...] 将是 [1&2, 1&3, 1&4, 2&3....] 之间的距离，并且给定距离，返回 [n&m]和它一起去吗？我越来越近了吗？
@WhozCraig：是的，除了给定数组中的索引（即 1 将返回 1&2 并且 3 将返回 1&4）之外，几乎都一样
@WhozCraig：唯一的问题是对象的数量可以改变，因此需要动态计算对。我不想将这对存储在数组中。这样做对节省内存消耗毫无用处

标签： c++ math collision-detection

【解决方案1】：

更好的排序

我建议使用colexicographical order，因为在这种情况下您不必提供对象的总数。像这样订购你的鞋：

 0:   1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  …
0&1, 0&2, 1&2, 0&3, 1&3, 2&3, 0&4, 1&4, 2&4, 3&4, 0&5, 1&5, 2&5, 3&5, …

您将能够将此列表扩展到无限长，因此您可以知道任何对的索引，而无需知道项目的数量。这样做的好处是，当您将新项目添加到数据结构中时，您只需要附加到您的数组，而不是重新定位现有条目。当您标记问题 C++ 时，我已将索引调整为从零开始，因此我假设您将使用从零开始的索引。我在下面的所有答案都假定这种顺序。

您还可以像这样可视化 colex 排序：

 a: 0  1  2  3  4  5 …
b:
1   0
2   1  2     index of
3   3  4  5       a&b
4   6  7  8  9
5  10 11 12 13 14
6  15 16 17 18 19 20
⋮   ⋮                 ⋱

与单个索引配对

让我们首先将一对转换为单个索引。诀窍在于，对于每一对，您查看第二个位置并想象在该位置具有较少数字的所有对。因此，例如对于 2&4 对，您首先计算第二个数字小于 4 的所有对。这是从一组 4 中选择两个项目的可能方法的数量（即数字 0 到 3），所以您可以将其表示为二项式系数 4C2。如果你评估它，你最终会得到 4(4−1)/2=6。为此，您添加第一个数字，因为这是具有较低索引但第二位具有相同数字的对数。对于2&4，这是2，所以2&4的总索引是4(4−1)/2+2=8。

一般来说，对于一对 a&b，索引将是 b(b-1) /2+a.

int index_from_pair(int a, int b) {
  return b*(b - 1)/2 + a;
}

要配对的单个索引

将单个索引 i 变回一对数字的一种方法是增加 b 直到 b(b+1)/2 > i，即b的下一个值会导致索引大于i的情况。然后你可以找到 a 作为差异 a = i−b(b -1)/2。这种通过一次增加一个 b 的方法涉及使用循环。

pair<int, int> pair_from_index(int i) {
  int a, b;
  for (b = 0; b*(b + 1)/2 <= i; ++b)
    /* empty loop body */;
  a = i - b*(b - 1)/2;
  return make_pair(a, b);
}

您也可以将 b(b−1)/2 = i 解释为二次方程，您可以使用平方求解根。你需要的真正的 b 是浮点 b 的底，你会得到这个二次方程的正解。由于这种方法可能会由于舍入错误而遇到问题，因此您可能需要检查 b(b+1)/2 > i .如果不是这种情况，请像在循环方法中那样增加 b 。一旦你有了 b，a 的计算保持不变。

pair<int, int> pair_from_index(int i) {
  int b = (int)floor((sqrt(8*i + 1) + 1)*0.5);
  if (b*(b + 1)/2 <= i) ++b; // handle possible rounding error
  int a = i - b*(b - 1)/2;
  return make_pair(a, b);
}

顺序访问

请注意，您只需将索引转回成对即可随机访问您的列表。当迭代所有对时，一组嵌套循环更容易。所以不是

for (int = 0; i < n*(n - 1)/2; ++i) {
  pair<int, int> ab = pair_from_index(i);
  int a = ab.first, b = ab.second;
  // do stuff
}

你最好写

for (int i = 0, b = 1; b != n; ++b) {
  for (int a = 0; a != b; ++a) {
    // do stuff
    ++i;
  }
}

【讨论】：

【解决方案2】：

根据我对问题的理解，一种从索引（基于 0，在您的示例中为 3）和对象数量 n（在您的示例中为 4你的例子）是：

t = n * (n - 1) / 2;
a = n - floor((1 + sqrt(1 + 8 * (t - index - 1))) / 2);
b = index + (n - a) * (n - a + 1) / 2 - t + a + 1;

感谢http://oeis.org/A002024

可以在Calculate Combination based on position 和http://saliu.com/bbs/messages/348.html 找到通用算法（用于元组而不是对），但它们似乎涉及循环计算组合。

编辑：更好的 a 公式（来自同一来源）：

a = n - floor(0.5 + sqrt(2 * (t - index)));

【讨论】：