我们已经讨论了检测两个给定线段是否相交的问题。在这篇文章中，我们扩展了这个问题。这里我们给定了 n 条线段，我们需要找出任何两条线段是否相交。
朴素算法解决这个问题的朴素解决方案是检查每一对线并检查这对线是否相交。我们可以在 O(1) 时间内检查两条线段。因此，这种方法需要 O(n 2 )。
Sweep Line Algorithm：我们可以使用 Sweep Line Algorithm在 O(nLogn)时间内解决这个问题。该算法首先沿 x 轴从左到右对端点进行排序，然后从左到右通过一条垂直线穿过所有点并检查是否有交点。以下是详细步骤。
1)假设有 n 条给定的行。必须有 2n 个端点来表示 n 条线。根据 x 坐标对所有点进行排序。在排序时维护一个标志来指示该点是其线的左点还是右点。
2)从最左边的点开始。对每一点进行以下操作
….. a)如果当前点是其线段的左侧点，则检查其线段与其正上方和下方的线段是否相交。并将其线添加到活动线段（可以看到左端点但尚未看到右端点的线段）。请注意，我们只考虑那些仍然活跃的邻居。
…… b)如果当前点是一个正确的点，从活动列表中删除它的线段并检查它的两个活动邻居（正上方和下方的点）是否彼此相交。
第 2 步就像从最左边的点到最右边的点从所有点通过一条垂直线。这就是为什么这个算法被称为扫描线算法。 Sweep Line 技术在许多其他几何算法中很有用，例如计算 2D Voronoi 图
应该使用哪些数据结构来有效实现？
在步骤 2 中，我们需要存储所有活动线段。我们需要有效地进行以下操作：
a) 插入新的线段
b) 删除线段
c) 根据 y 坐标值查找前驱和后继
上述操作的明显选择是自平衡二叉搜索树，如 AVL 树、红黑树。使用自平衡 BST，我们可以在 O(Logn) 时间内完成上述所有操作。
此外，在步骤 1 中，我们可以使用最小堆数据结构代替排序。构建最小堆需要 O(n) 时间，并且每个提取最小操作需要 O(Logn) 时间（请参阅此）。
伪代码：
以下伪代码不使用堆。它只是对数组进行排序。
sweepLineIntersection(Points[0..2n-1]):
1. Sort Points[] from left to right (according to x coordinate)
2. Create an empty Self-Balancing BST T. It will contain
all active line Segments ordered by y coordinate.
// Process all 2n points
3. for i = 0 to 2n-1
// If this point is left end of its line
if (Points[i].isLeft)
T.insert(Points[i].line()) // Insert into the tree
// Check if this points intersects with its predecessor and successor
if ( doIntersect(Points[i].line(), T.pred(Points[i].line()) )
return true
if ( doIntersect(Points[i].line(), T.succ(Points[i].line()) )
return true
else // If it's a right end of its line
// Check if its predecessor and successor intersect with each other
if ( doIntersect(T.pred(Points[i].line(), T.succ(Points[i].line()))
return true
T.delete(Points[i].line()) // Delete from tree
4. return False例子：
让我们考虑以下取自此处的示例。有5个线段1，2，3，4和5。绿色虚线表示扫描线。
以下是算法的步骤。从左到右的所有点都被一一处理。我们维护一个自平衡二叉搜索树。
处理线段 1 的左端点：将1 插入到树中。该树包含1 。没有交集。
处理线段 2 的左端点：检查1和2 的交点。 2被插入到树中。 1&2 Found 的交集（“注意上面的伪代码此时返回”）。我们可以从这里继续报告所有交叉点。树包含1 , 2 。
处理线段 3 的左端点：检查3与1 的交点。没有交集。 3被插入到树中。树包含2 , 1 , 3 。
处理线段 1 的右端点：从树中删除1。检查2和3 的交点。报告了2和3 的交集。该树包含2 , 3 。
处理线段 4 的左端点：检查线4与线2和3 的交点。没有交集。 4被插入到树中。树包含2 , 4 , 3 。
处理线段 5 的左端点：检查5与3 的交点。没有交集。 5被插入到树中。树包含2, 4, 3, 5 。
处理线段 5 的右端点：从树中删除5。树包含2 , 4 , 3 。
处理线段 4 的右端点：从树中删除4。树包含2 , 4 , 3 。检查2与3 的交集。 2与3的交集会被报告（注意 2 和 3 的交集会再次被报告。我们可以添加一些逻辑来检查重复项）。树包含2 , 3 。
线段 2 和 3 的右端点被处理：两者都从树中删除，树变为空。
C++14
#include
using namespace std;
// A point in 2D plane
struct Point
{
int x, y;
};
// A line segment with left as Point
// with smaller x value and right with
// larger x value.
struct Segment
{
Point left, right;
};
// An event for sweep line algorithm
// An event has a point, the position
// of point (whether left or right) and
// index of point in the original input
// array of segments.
struct Event {
int x, y;
bool isLeft;
int index;
Event(int x, int y, bool l, int i) : x(x), y(y), isLeft(l), index(i) {}
// This is for maintaining the order in set.
bool operator<(const Event& e) const {
if(y==e.y)return x= min(p.x, r.x) &&
q.y <= max(p.y, r.y) && q.y >= min(p.y, r.y))
return true;
return false;
}
// To find orientation of ordered triplet (p, q, r).
// The function returns following values
// 0 --> p, q and r are colinear
// 1 --> Clockwise
// 2 --> Counterclockwise
int orientation(Point p, Point q, Point r)
{
// See https://www.geeksforgeeks.org/orientation-3-ordered-points/
// for details of below formula.
int val = (q.y - p.y) * (r.x - q.x) -
(q.x - p.x) * (r.y - q.y);
if (val == 0) return 0; // colinear
return (val > 0)? 1: 2; // clock or counterclock wise
}
// The main function that returns true if line segment 'p1q1'
// and 'p2q2' intersect.
bool doIntersect(Segment s1, Segment s2)
{
Point p1 = s1.left, q1 = s1.right, p2 = s2.left, q2 = s2.right;
// Find the four orientations needed for general and
// special cases
int o1 = orientation(p1, q1, p2);
int o2 = orientation(p1, q1, q2);
int o3 = orientation(p2, q2, p1);
int o4 = orientation(p2, q2, q1);
// General case
if (o1 != o2 && o3 != o4)
return true;
// Special Cases
// p1, q1 and p2 are colinear and p2 lies on segment p1q1
if (o1 == 0 && onSegment(p1, p2, q1)) return true;
// p1, q1 and q2 are colinear and q2 lies on segment p1q1
if (o2 == 0 && onSegment(p1, q2, q1)) return true;
// p2, q2 and p1 are colinear and p1 lies on segment p2q2
if (o3 == 0 && onSegment(p2, p1, q2)) return true;
// p2, q2 and q1 are colinear and q1 lies on segment p2q2
if (o4 == 0 && onSegment(p2, q1, q2)) return true;
return false; // Doesn't fall in any of the above cases
}
// Find predecessor of iterator in s.
set::iterator pred(set &s, set::iterator it) {
return it == s.begin() ? s.end() : --it;
}
// Find successor of iterator in s.
set::iterator succ(set &s, set::iterator it) {
return ++it;
}
// Returns true if any two lines intersect.
int isIntersect(Segment arr[], int n)
{
unordered_map mp; // to note the pair for which intersection is checked already
// Pushing all points to a vector of events
vector e;
for (int i = 0; i < n; ++i) {
e.push_back(Event(arr[i].left.x, arr[i].left.y, true, i));
e.push_back(Event(arr[i].right.x, arr[i].right.y, false, i));
}
// Sorting all events according to x coordinate.
sort(e.begin(), e.end(), [](Event &e1, Event &e2) {return e1.x < e2.x;});
// For storing active segments.
set s;
int ans=0;
// Traversing through sorted points
for (int i=0; i<2*n; i++)
{
Event curr = e[i];
int index = curr.index;
// If current point is left of its segment
if (curr.isLeft)
{
// Get above and below points
auto next = s.lower_bound(curr);
auto prev = pred(s, next);
// Check if current point intersects with
// any of its adjacent
bool flag=false;
if (next != s.end() && doIntersect(arr[next->index], arr[index])){
string s=to_string(next->index+1)+" "+to_string(index+1);
if(mp.count(s)==0){mp[s]++;ans++;} //if not already checked we can increase count in map
}
if (prev != s.end() && doIntersect(arr[prev->index], arr[index])){
string s=to_string(prev->index+1)+" "+to_string(index+1);
if(mp.count(s)==0){mp[s]++;ans++;} //if not already checked we can increase count in map
}
// if same line segment is there then decrease answer as it got increased twice
if(prev != s.end() && next != s.end() && next->index==prev->index)ans--;
// Insert current point (or event)
s.insert(curr);
}
// If current point is right of its segment
else
{
// Find the iterator
auto it=s.find(Event(arr[index].left.x, arr[index].left.y, true, index));
// Find above and below points
auto next = succ(s, it);
auto prev = pred(s, it);
// If above and below point intersect
if (next != s.end() && prev != s.end())
{ string s=to_string(next->index+1)+" "+to_string(prev->index+1);
string s1=to_string(prev->index+1)+" "+to_string(next->index+1);
if (mp.count(s)==0&&mp.count(s1)==0&&doIntersect(arr[prev->index], arr[next->index]))
ans++;
mp[s]++;
}
// Remove current segment
s.erase(it);
}
}
//print pair of lines having intersection
for(auto &pr:mp){
cout< 输出：
0如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。