山脊方向

Question

在 D 维 空间 中给定两个单纯形（例如，D3 空间 中的二维 三角形 面> 对于 四面体) 相邻的 facets V（可见）和 H（水平），由两个数组定义 D D-维点 P_V和P_H 。上述数组中元素的顺序是严格定义的，依次在空间中定义一个facets的orientations。比如说，他们在 universal 点集合中的索引 U（涉及几何计算）表示为两个std::list< std::size_t >s。 ridge 是 facet 的 D - 1 维边界元素（例如 D3 中四面体的 1 维 edges 空格）。要定义两个 facets 共有的 points，我只需执行以下操作：

point_list visible_set_ = visible_facet_.vertices_;
point_list horizon_set_ = horizon_facet_.vertices_;
visible_set_.sort();
horizon_set_.sort();
point_list ridge_;
std::set_intersection(visible_set_.cbegin(), visible_set_.cend(),
                      horizon_set_.cbegin(), horizon_set_.cend(),
                      std::back_inserter(ridge_));

但是在std::sort 执行期间，我丢失了关于ridge R 的codirectionality 的信息，定义为上面的ridge_，同样两个面中任何一个的脊。

同向性可以随后通过计算交换数来定义，最少需要执行从 1 开始的置换。）点的数组 >ridge 按其在给定的 facet 的 points 数组中呈现的顺序排列 2.) 生成的 points 数组em> ridge R 本身。但我确信这里有开销。

定义同向性的另一种方法是计算两个面的定向正方形（一个由唯一的点（facet 和 ridge 的区别）然后是 ridge 和一个通过简单修改 facet：将排他点移到前面，因为它位于两个 facets 中的第一个）。

如何以固定的元素顺序执行两个未排序数组的交集，以便结果数组保存第一个（异或第二个）数组中呈现的元素顺序。有没有这样的算法，时间复杂度小于O(n²)？对 STL 辅助实现的可能性特别感兴趣。

Answer 1

My version 将排他点替换为最远点，保持其在原始可见方面的顺序。作为结果创建的 Newfacet（就原始 qhull 实现而言）：

point_set horizon_(horizon_facet_.vertices_.cbegin(),
                   horizon_facet_.vertices_.cend()); // n * log(n) +
auto const hend = horizon_.end();
point_list ridge_;
for (size_type const p : vertices_) { // n *
    auto const h = horizon_.find(p); // (log(n) +
    if (h == hend) {
        ridge_.push_back(apex);
    } else {
        ridge_.push_back(p);
        horizon_.erase(h); // const)
    }
}

Answer 2

如果我对问题的理解正确，您可以使用以下方案。首先，制作原始数组的副本（称它们为visible_set_for_sorting 和horizon_set_for_sorting）。然后对它们进行排序。然后按以下方式形成交集：

std::set<int> intersection;
std::set_intersection(
    visible_set_for_sorting.begin(), visible_set_for_sorting.end(),
    horizon_set_for_sorting.begin(), horizon_set_for_sorting.end(),
    std::inserter(intersection, intersection.begin()));

现在您可以迭代任何原始数组（visible_set_ 或 horizon_set_），检查该点是否在 intersection 中，并按所需顺序形成结果列表。

std::list<int> list;
for (int p : visible_set_)
{
    if (intersection.find(p) != intersection.end())
    {
        list.push_back(p);
    }
}

复杂度不应高于 O(N*log(N))。