<think>题目名称：森罗殿的光束交错（题目名称可能为虚构，但根据描述，我们将其视为一个编程问题）
问题描述：在森罗殿中，有若干光束在空间中交错。每道光束由两个端点确定，这些端点位于三维坐标系中。现在需要判断这些光束是否相交（即存在至少两道光束在非端点处有公共点）。如果相交，则输出"Yes"，否则输出"No"。
注意：光束是直线段，且题目要求判断线段之间是否有非端点的交点。
输入格式：
第一行包含一个
整数n，表示光束的数量（即线段的数量）。
接下来n行，每行包含6个
整数x1, y1, z1, x2, y2, z2，表示一条线段的两个端点坐标。
输出格式：
如果存在两道光束（线段）在非端点处相交，输出"Yes"，否则输出"No"。
数据范围：
1 <= n <=
100
坐标范围: [-
1000,
1000]
由于n最大为
100，我们可以使用O(n^2)的
算法，对每两段线段进行判断。
判断两条线段在三维空间中是否相交（非端点）是一个经典问题，但三维空间中的线段相交判断比二维复杂。在三维空间中，两条线段可能不相交，即使它们不平行也不相交（因为可能不在同一平面内）。
步骤：
1. 首先，判断两条线段是否共面。如果不共面，则一定不相交。
2. 如果共面，则问题转化为在二维平面上判断两条线段是否相交（非端点）。
共面的判断：取一条线段上的一个向量，再取另一条线段上的一个向量，再取两条线段上各取一点形成的向量，这三个向量应该是共面的（它们的混合积为0）。
具体方法：
设两条线段AB和CD。
向量AB = B - A, 向量CD = D - C, 向量AC = C - A（或向量AD等）。
则AB和CD共面的条件是：向量AB、向量CD、向量AC的混合积（即标量三重积）为零，即 (AB × CD) · AC = 0。
3. 如果共面，则可以将问题投影到某一坐标平面（例如，选择投影面积最大的平面，或者直接利用共面性质转化为二维平面上的线段相交问题）。注意，在共面的情况下，我们可以将整个平面进行坐标变换，转化为二维平面上的问题。
4. 在二维平面上判断两条线段是否相交（非端点）：
方法1：使用叉积判断（跨立实验）
- 快速排斥实验：先判断两个线段为对角线的矩形是否相交。
- 跨立实验：判断点C和D是否在线段AB的两侧（即向量AB×向量AC与向量AB×向量AD的符号相反），并且点A和B在线段CD的两侧（即向量CD×向量CA与向量CD×向量CB的符号相反）。但是注意，在三维中我们已经共面，所以可以投影到二维，但注意投影可能退化（如投影成点或线），所以需要选择适当的投影平面。
然而，在三维中，我们也可以直接使用参数方程求解，但要注意精度问题。
另一种思路：在共面的前提下，我们可以用二维平面上的方法。选择投影平面：为了避免退化，可以选择法向量为(AB×CD)的平面（但这样我们无法直接投影），所以实际做法是：将平面上的点变换到二维坐标系中。
但是，我们也可以直接使用参数方程求解共面线段交点：
设线段1：A + t*(B-A), t∈[0,1]
线段2：C + s*(D-C), s∈[0,1]
在共面的情况下，我们可以建立方程组：
A + t*(B-A) = C + s*(D-C)
这是一个关于t和s的线性方程组，有3个方程（x,y,z三个分量），但其中两个方程是独立的（因为共面，所以其中一个方程可以用另外两个线性表示）。因此，我们任意取两个方程（例如x和y），然后解出t和s，再代入第三个方程验证是否满足（或者直接使用三个方程中的两个，然后检查第三个方程是否成立，但这样会有精度问题，所以更可靠的是使用两个方程解出t,s，然后检查第三个方程是否满足，同时检查t,s是否在(0,1)内（注意是开区间，因为端点不算）。
但是，如果方程组是病态的（比如分母为0），则说明两线段平行或重合。平行且不共线则不相交；共线则需要判断是否有重叠（但题目要求非端点相交，所以重叠部分在内部也算相交，但注意题目要求非端点，所以重叠部分在内部（非端点）才相交，但共线的情况可能包含端点，所以需要特别处理：判断共线时，检查两条线段在公共直线上的投影区间是否有重叠且重叠部分不是单点（即区间长度大于0）且重叠部分不能仅仅是端点（即内部点相交）？实际上，共线且相交（非端点）的条件是：两条线段的投影区间有重叠，且重叠部分不是一个点（即区间长度大于0）且重叠部分包含至少一个非端点。但这样判断比较复杂。
因此，我们可以这样处理共线的情况：
如果两线段共线，则检查它们在直线上投影的区间。设线段AB在直线上的投影区间为[t0,t1]（t0=0, t1=1，对应A和B），线段CD的投影区间为[s0,s1]（s0=0, s1=1，对应C和D）。将两个区间都映射到直线上的一维坐标，然后判断两个区间是否有重叠，且重叠部分不能仅仅是端点。但是，注意：共线时，两条线段可能部分重叠，那么重叠部分中任意一个非端点的点都是交点（非端点）。所以，只要两个区间的交集长度大于0，且交集不是单点（即长度大于0的区间）？但是，即使交集是单点，如果这个点恰好是某条线段的端点，那么就不算（因为题目要求非端点相交）。所以，共线情况下，我们要判断的是：存在一个点P，它同时位于两条线段的内部（即不在端点）。因此，我们只需要检查两条线段在直线上的投影区间是否有重叠，并且重叠部分包含一个非端点的点（即重叠部分是一个区间，且长度大于0，且这个区间内至少有一个点不是两条线段的端点？）。实际上，只要两条线段在共线的情况下，有重叠部分，且重叠部分不是由两个端点组成的（即重叠部分至少包含一个内部点），那么就算相交。
但是，注意：重叠部分可能由端点组成，比如一条线段的端点落在另一条线段中间（非端点）？不，因为共线时，一条线段的端点落在另一条线段的内部（非端点）是满足条件的（因为对于另一条线段来说，这个点不是它的端点，所以是内部点）。但题目要求的是非端点相交，即这个交点不能是任何一条线段的端点？不对，题目要求是“非端点处相交”，意思是交点是两条线段上的点，但不能是其中任何一条线段的端点。所以，如果一条线段的端点落在另一条线段的内部（非端点），那么对于另一条线段来说，这个点不是端点，所以满足条件？但是，对于这条线段本身，这个点是端点，所以不满足？题目要求的是两道光束在非端点处相交，即这个交点不能是任何一条光束的端点。所以，共线情况下，只有当交点同时是两条线段的内部点时，才满足？不对，题目要求的是“非端点处”，即这个交点不能是任何一条线段的端点。因此，共线情况下，只有当两条线段重叠的部分包含一个点，这个点不是任何一条线段的端点时，才满足。但是，在共线情况下，重叠部分是一个区间，只要这个区间内部存在一个点，它既不是第一条线段的端点（即不是A或B），也不是第二条线段的端点（即不是C或D），那么就算满足。
然而，由于重叠部分是一个连续区间，所以只要重叠部分的长度大于0，那么在这个区间内一定存在无数个点既不是第一条线段的端点也不是第二条线段的端点（除非重叠部分恰好是两个端点，但两个端点重合的情况，由于重叠部分是一个点，且这个点同时是两条线段的端点，所以不满足）。因此，共线情况下，我们只需要判断重叠部分的长度大于0（即两个区间重叠部分不是一个点），那么就有无数个非端点的交点。但注意，重叠部分可能是一个点，而这个点可能是端点也可能不是？在共线情况下，重叠部分是一个点，这个点可能是其中一条线段的端点，也可能是两条线段的端点。但无论如何，只要这个点是一条线段的端点，那么就不满足题目要求（因为题目要求非端点处相交，即交点不能是任何线段的端点）。所以，共线情况下，我们要求重叠部分必须是一个长度大于0的区间（即两个区间重叠部分是一个区间，长度>0），这样这个区间内一定存在非端点的点（因为端点只有两个，而区间是连续的）。所以，共线时，如果重叠部分是一个区间（长度>0），则输出Yes；如果重叠部分是一个点（即两个端点重合），则这个点必然是端点，所以不算；如果没有重叠，则不相交。
但是，共线情况下的重叠部分计算：我们可以将线段投影到直线上，得到两个区间[minA, maxA]和[minB, maxB]（其中A线段投影为[minA, maxA]，B线段投影为[minB, maxB]），然后判断两个区间是否有重叠部分（重叠部分长度>0）。注意，这
里投影区间是闭区间，但重叠部分长度>0意味着开区间内也有点。所以，我们计算重叠区间的长度，如果长度>0，则满足。
然而，由于浮点数的精度问题，我们需要小心处理。
由于题目
数据范围不大，且n<=
100，我们可以使用上述方法。
但是，为了避免精度问题，我们可以使用
整数运算（题目坐标是
整数）。
步骤总结：
对于两条线段AB和CD：
1. 判断是否共面：计算混合积 (AB×CD)·AC 是否为0（注意，由于是
整数，我们可以用
整数计算，然后判断是否等于0）。
2. 如果不共面，则不相交。
3. 如果共面：
a. 判断两线段是否平行：AB×CD是否为0（即叉积向量是否为0向量）。如果叉积为0，则共线（平行且共线）。
b. 如果共线：
将线段投影到直线上（选择AB所在的直线），然后计算两条线段在直线上的投影区间（一维区间），判断两个区间是否重叠且重叠部分的长度大于0（即重叠部分是一个区间，而不是一个点）。注意，这
里重叠部分长度>0是指区间的长度大于0（即两个端点之间的距离大于0），而不是指重叠部分包含的点数（因为连续区间有无穷点，但长度大于0即可）。
具体做法：将线段AB的两个端点投影到直线上，得到区间[mina, maxa]（mina=min(投影值A,投影值B), maxa=max(投影值A,投影值B)），同样得到线段CD的区间[minb, maxb]。然后计算两个区间的交集：左端点left = max(mina, minb)，右端点right = min(maxa, maxb)。如果left < right（注意是严格小于），则重叠部分长度大于0，则相交（非端点），返回true；否则不相交。
注意：投影值如何计算？我们可以取直线上一点（如A）和方向向量AB，然后线段上的点P可以表示为P=A+t*AB，则投影值就是t。对于线段AB上的点，t∈[0,1]；对于线段CD上的点，我们也要用同一直线（即AB所在的直线）和同一点A，那么CD上的点P可以表示为P=A+t*AB，然后解出t（注意，由于共线，所以CD上的点P可以这样表示）。但是，解t：设P=C，则C=A+t*AB，所以t=((C-A)·AB)/(AB·AB)。同理，D点也可以得到一个t值。那么CD在直线上的投影区间就是[min(t_C, t_D), max(t_C, t_D)]。而AB的投影区间就是[0,1]。然后判断两个区间是否有重叠且重叠部分长度>0。
c. 如果不共线（即不平行）：
建立参数方程：
A + t*(B-A) = C + s*(D-C) (0<=t<=1, 0<=s<=1)
将方程按分量展开：
A.x + t*(B.x-A.x) = C.x + s*(D.x-C.x)
A.y + t*(B.y-A.y) = C.y + s*(D.y-C.y)
A.z + t*(B.z-A.z) = C.z + s*(D.z-C.z)
由于共面，这三个方程是线性相关的，所以我们可以取两个方程（比如x和y）解出t和s。然后检查第三个方程（z）是否满足（或者将解代入z方程验证），同时检查t和s是否在(0,1)区间内（注意开区间，因为端点不算）。
解方程组：
t*(B.x-A.x) - s*(D.x-C.x) = C.x - A.x
t*(B.y-A.y) - s*(D.y-C.y) = C.y - A.y
写成矩阵形式：
| (B.x-A.x) -(D.x-C.x) | |t| |C.x-A.x|
| (B.y-A.y) -(D.y-C.y) | * |s| = |C.y-A.y|
行列式：det = (B.x-A.x)*(-(D.y-C.y)) - (-(D.x-C.x))*(B.y-A.y)
= -(B.x-A.x)*(D.y-C.y) + (D.x-C.x)*(B.y-A.y)
如果行列式det为0，则说明两线段平行（但前面已经判断了不共线，所以这
里应该不会出现？实际上，共面且不共线，则两线段要么相交要么平行，但前面已经判断了叉积不为0，所以这
里应该不会出现行列式为0？但注意，叉积是三维向量，而行列式是二维的，所以可能不一致？为了避免这种情况，我们直接使用三维叉积判断平行：AB×CD是否为0向量？所以前面已经判断了共线（即叉积为0向量）的情况，所以这
里一定是不共线（叉积非零），那么二维的行列式可能为0吗？实际上，二维行列式就是三维叉积的模在z方向的分量（如果我们取x,y平面），所以如果叉积非零，但它的z分量可能为0（即叉积向量平行于xy平面，但垂直于z轴？）所以二维行列式可能为0。因此，我们需要处理二维行列式为0的情况：此时两条线段在xy平面上的投影是平行的，那么它们不相交（因为不共线，所以不可能相交）。所以，如果二维行列式为0，则不相交。
因此，步骤：
- 解方程组（取两个方程，比如x,y），计算行列式det。
- 如果det==0（在
整数意义下），则不相交。
- 否则，解出t和s：
t = ( (C.x-A.x)*(-(D.y-C.y)) - (C.y-A.y)*(-(D.x-C.x)) ) / det
s = ( (B.x-A.x)*(C.y-A.y) - (B.y-A.y)*(C.x-A.x) ) / det [或者用其他形式]
但是，由于是
整数，我们需要避免浮点数。我们可以用分数表示，然后判断t和s是否在(0,1)区间内（注意开区间），并且验证第三个方程（z分量）是否成立。
然而，为了避免浮点数，我们可以用交叉相乘的方法判断分数是否在(0,1)内，但这样会引入大数，不过n只有
100，坐标范围[-
1000,
1000]，所以分母最大在
10^6级别，分子最大
10^6*2=2e6，所以不会溢出int（int在32位系统中为4字节，最大20
亿左右，所以安全）。
具体：
t = num1 / det, 其中num1 = (C.x-A.x)*(C.y-D.y) + (D.x-C.x)*(C.y-A.y) [重新整理]
实际上，我们重新写方程组：
t*(B.x-A.x) - s*(D.x-C.x) = C.x - A.x ...(1)
t*(B.y-A.y) - s*(D.y-C.y) = C.y - A.y ...(2)
用克莱姆法则：
det = (B.x-A.x)*(-(D.y-C.y)) - (-(D.x-C.x))*(B.y-A.y)
= (B.x-A.x)*(C.y-D.y) + (D.x-C.x)*(B.y-A.y)
t的分子：由(1)和(2)组成的方程组，将第一列替换为常数项
num_t = (C.x-A.x)*(-(D.y-C.y)) - (C.y-A.y)*(-(D.x-C.x))
= (C.x-A.x)*(C.y-D.y) + (C.y-A.y)*(D.x-C.x)
s的分子：将第二列替换为常数项
num_s = (B.x-A.x)*(C.y-A.y) - (B.y-A.y)*(C.x-A.x) [注意符号：第二列是负的系数，所以常数项替换后要加负号？]
或者，我们重新写标准形式：
方程组：
(B.x-A.x)*t + (-(D.x-C.x))*s = C.x-A.x
(B.y-A.y)*t + (-(D.y-C.y))*s = C.y-A.y
则克莱姆法则：
t = det_t / det, 其中det_t = | (C.x-A.x) -(D.x-C.x) |
| (C.y-A.y) -(D.y-C.y) |
= (C.x-A.x)*(-(D.y-C.y)) - (C.y-A.y)*(-(D.x-C.x))
= (C.x-A.x)*(C.y-D.y) + (C.y-A.y)*(D.x-C.x)
s = det_s / det, 其中det_s = | (B.x-A.x) (C.x-A.x) |
| (B.y-A.y) (C.y-A.y) |
= (B.x-A.x)*(C.y-A.y) - (B.y-A.y)*(C.x-A.x)
然后，我们需要验证：
t在(0,1)内：0 < det_t/det < 1
s在(0,1)内：0 < det_s/det < 1
以及第三个分量方程成立：
A.z + t*(B.z-A.z) = C.z + s*(D.z-C.z)
由于t和s是分数，我们可以写成：
0 < det_t < det (当det>0) 或者 0 > det_t > det (当det<0) -> 即 det_t和det同号，且0<|det_t|<|det|
同理，0 < det_s < |det|? 实际上，我们更希望用乘法避免除法：
对于t：要求0 < det_t/det < 1
两边乘det（注意det的符号）：
如果det>0，则 0 < det_t < det
如果det<0，则 0 > det_t > det -> det < det_t < 0 （因为乘以负数，不等号反向）
所以，统一起来：det_t和det同号，且0<|det_t|<|det|
同理，det_s和det同号，且0<|det_s|<|det|
然后验证第三个分量方程：
(A.z * det + det_t * (B.z-A.z)) * det ?= (C.z * det + det_s * (D.z-C.z)) * det
实际上，我们两边乘以det，得到：
(A.z * det + det_t * (B.z-A.z)) = (C.z * det + det_s * (D.z-C.z))
注意：这
里等式两边乘以det（
整数）后，等式应该成立。
所以，条件：
(A.z * det + det_t * (B.z-A.z)) == (C.z * det + det_s * (D.z-C.z))
但是，注意：由于我们使用了两个方程解出的t和s，那么第三个方程在共面的情况下应该自然满足？不一定，因为共面的条件是混合积为0，而混合积为0保证了第三个方程可以由前两个方程线性表示，所以解出的t,s代入第三个方程应该满足。但是，由于我们计算t,s时使用了
整数运算，可能会有精度问题（
整数除法是整除？）但我们这
里没有用除法，而是保留了分子和分母，所以第三个方程的验证可以用上面的等式（
整数等式）来验证。
然而，由于我们解t和s时使用了x,y分量，那么第三个方程（z分量）是否满足？在共面条件下，这个等式应该成立，但是因为我们在计算t和s时使用了x,y的方程，所以z方程应该由共面条件保证？实际上，共面条件就是三个向量共面，而这
里我们建立方程时，这个方程在三维空间中，所以共面条件保证了方程组有解，但解可能不满足z方程？不，共面条件保证了方程组有解，所以解应该满足所有方程。但是，由于我们只用了两个方程解出了t,s，所以第三个方程应该满足。然而，由于我们使用的是
整数运算，并且没有进行除法，所以第三个方程的验证可以用上面的等式（
整数等式）来验证。
因此，步骤：
1. 计算det（用x,y分量），如果det==0，则不相交（因为不共线，所以这
里det=0意味着在xy平面投影平行，所以不相交）。
2. 计算det_t, det_s（如上）。
3. 检查t是否在(0,1)内：即 (det_t>0 && det_t<det) || (det_t<0 && det_t>det) -> 可以简化为：det_t和det同号，且|det_t| < |det|（因为同号，所以相乘大于0，且|det_t| < |det|）。但是，注意：当det>0时，要求0<det_t<det；当det<0时，要求0>det_t>det（即det<det_t<0）。所以，我们可以用乘法：判断是否 det_t*(det-det_t)>0 ？这样不行。我们可以：
if (det > 0) {
if (det_t <= 0 || det_t >= det) 则不在(0,1)内;
} else {
if (det_t >= 0 || det_t <= det) 则不在(0,1)内; // 因为det<0，所以det_t应该在[det,0]区间外，即不在(0,1)内
}
实际上，我们可以统一写：要求 (det_t>0 && det_t<det) 或者 (det_t<0 && det_t>det) 成立，即 (det_t>0)==(det>0) 且 |det_t|<|det|? 不，比如det>0时，要求0<det_t<det；det<0时，要求det<det_t<0。所以，我们可以用：
if ( (det_t*det <= 0) ) 则不在(0,1)内； // 因为同号要求：如果det_t和det异号，则t<0或t>1
if (abs(det_t) >= abs(det)) 则不在(0,1)内； // 因为分子绝对值大于分母，则|t|>=1
所以，两个条件：det_t*det>0 且 abs(det_t)<abs(det) -> 这样在det>0时，det_t>0且det_t<det；在det<0时，det_t<0且|det_t|<|det|（即det_t>det，因为det为负，所以det_t>det就是大于一个负数，且det_t是负数，所以|det_t|=-det_t，而|det|=-det，所以要求-det_t < -det => det_t>det，而det_t<0，所以就是det<det_t<0，满足）。
因此，条件：det_t*det>0 且 det_t*det < det*det （因为abs(det_t)<abs(det) 等价于 det_t^2 < det^2，即(det_t)^2 < (det)^2，但这样计算可能会溢出？）
为了避免平方，我们可以用绝对值：abs(det_t) < abs(det)
同理，检查s：det_s*det>0 且 abs(det_s)<abs(det)
4. 验证第三个方程：A.z * det + det_t * (B.z-A.z) == C.z * det + det_s * (D.z-C.z)
如果以上条件都满足，则两条线段在非端点处相交。
注意：由于我们使用
整数运算，所以没有浮点误差。
但是，还有一个问题：当det=0时，我们直接认为不相交？前面已经判断了共线的情况，所以这
里的不共线情况下，如果二维行列式det=0，则说明两线段在xy平面上的投影平行，所以它们不相交（因为三维空间中共面，但方向平行，所以不相交）。所以正确。
然而，我们选择哪两个方程？我们可以选择任意两个方程，但为了避免分母为0（即det=0），我们也可以选择其他两个方程（比如x,z或y,z）？但这样我们需要处理三种情况。为了简单，我们可以选择投影面积最大的平面（即法向量长度最大的平面）？但这样计算复杂。
一个简单的方法是：尝试所有三个平面（xy, xz, yz），如果其中一个平面的行列式不为0，就用这个平面。如果三个平面都不为0？实际上，由于共面且不共线，三个平面中至少有一个平面的行列式不为0（因为法向量在某个平面上的投影不为0）。所以我们可以：
如果xy平面的det_xy!=0，则用xy平面；
否则，如果xz平面的det_xz!=0，则用xz平面；
否则，用yz平面（此时一定不为0，因为共面且不共线，所以法向量至少在一个平面上投影非零）。
但是，为了简化，我们也可以只用一个平面（比如xy平面），如果xy平面的det_xy为0，则说明两线段在xy平面上的投影平行，那么它们可能垂直xy平面？但注意，共面条件已经满足，所以它们在三维空间中相交当且仅当在xy平面上的投影相交？不，投影平行不代表在三维空间中不相交，因为可能不在一个平面上？不对，我们已经共面，所以如果投影平行，则两线段平行（在三维空间中），但是前面已经判断了不共线（即叉积不为0），所以这
里不可能出现平行？不对，共面且叉积不为0，说明两线段不共线，但可能平行吗？在三维空间中，两线段共面且不共线，它们可能相交或平行。而平行的条件是方向向量成比例，即AB×CD=0向量，但我们在前面已经判断了共线（即叉积为0向量）的情况，所以这
里的不共线就意味着叉积不为0，即方向向量不成比例，所以不平行。因此，在共面且不共线（叉积非零）的情况下，两线段一定相交？不对，也可能不相交（异面？但共面就不会异面）。共面两直线（无限直线）要么相交要么平行。而这
里不平行（因为叉积非零），所以它们一定相交（在无限直线上有一个交点），但交点不一定在线段上（即t,s不在[0,1]内）。所以，我们只需要用任意一个平面解出t,s，然后判断t,s是否在(0,1)内（开区间），并且验证第三个方程（因为共面，所以第三个方程应该满足，但因为我们用两个方程解出的，所以第三个方程需要验证？实际上，共面条件已经保证了第三个方程与这两个方程线性相关，所以解出的t,s代入第三个方程应该满足。但是，由于我们使用
整数运算，可能会有
整数除法的整除问题？所以我们需要验证第三个方程。
因此，我们可以这样：在共面且不共线的情况下，我们使用xy平面（如果xy平面的行列式不为0）解t,s；如果xy平面的行列式为0，则说明在xy平面上的投影平行，但这是不可能的（因为不共线且共面，则必然相交于一点，投影不可能平行）？所以实际上，在共面且不共线的情况下，xy平面的行列式一定不为0？因为共面且不共线，则两线段的方向向量不共线，所以它们在某个平面上的投影一定不平行。而xy平面的行列式等于(AB×CD)的z分量的相反数？不对，我们定义的二维行列式是三维叉积的z分量（的绝对值？）。实际上，三维叉积AB×CD的z分量 = (B.x-A.x)*(D.y-C.y) - (B.y-A.y)*(D.x-C.x) = 我们定义的二维行列式（但符号可能相反）？所以，如果三维叉积非零，则它的三个分量不全为0，所以至少有一个平面上的行列式不为0。因此，我们可以选择z分量最大的平面（即|AB×CD|的z分量最大）？但这样需要计算叉积。我们可以选择三个平面中行列式绝对值最大的平面，这样精度更高。
但为了简单，我们可以固定使用一个平面（比如xy平面），如果xy平面的行列式det_xy为0，则换用xz平面；如果xz平面也为0，则用yz平面（此时一定不为0）。因为三个平面的行列式分别是三维叉积的三个分量的线性组合（实际上，xy平面的行列式就是叉积的z分量，xz平面的行列式是y分量？需要验证）。
实际上，三维叉积：
AB×CD = ( (B.y-A.y)*(D.z-C.z) - (B.z-A.z)*(D.y-C.y),
(B.z-A.z)*(D.x-C.x) - (B.x-A.x)*(D.z-C.z),
(B.x-A.x)*(D.y-C.y) - (B.y-A.y)*(D.x-C.x) )
所以，xy平面的行列式（我们之前定义的）是最后一项（即z分量）的相反数？因为我们之前定义：
det_xy = (B.x-A.x)*(C.y-D.y) + (D.x-C.x)*(B.y-A.y)
= (B.x-A.x)*(-(D.y-C.y)) + (D.x-C.x)*(B.y-A.y)
= -[ (B.x-A.x)*(D.y-C.y) - (B.y-A.y)*(D.x-C.x) ]
所以，det_xy = - (AB×CD).z
同样，xz平面的行列式（用x,z分量）：
方程组：x和z
det_xz = (B.x-A.x)*(C.z-D.z) + (D.x-C.x)*(B.z-A.z)
= -[ (B.x-A.x)*(D.z-C.z) - (B.z-A.z)*(D.x-C.x) ]
= - (AB×CD).y
yz平面的行列式（用y,z分量）：
det_yz = (B.y-A.y)*(C.z-D.z) + (D.y-C.y)*(B.z-A.z)
= (B.y-A.y)*(D.z-C.z) - (B.z-A.z)*(D.y-C.y) [注意符号]
= (AB×CD).x
所以，三个平面的行列式等于叉积的三个分量（或相反数）。由于叉积非零，所以至少有一个分量非零，因此我们可以选择绝对值最大的那个平面（为了减小
整数运算的溢出风险？但这
里最大只有
10^6级别，不会溢出）。
因此，我们可以：
计算三维叉积：cross = AB×CD
然后选择绝对值最大的分量，假设是x分量（cross.x），则使用yz平面（因为yz平面的行列式等于cross.x）；如果y分量最大，则使用xz平面（行列式等于-cross.y，但符号不影响，因为我们只关心行列式是否为0以及绝对值大小）；如果z分量最大，则使用xy平面（行列式等于-cross.z）。
但是，为了代码简单，我们也可以直接使用xy平面（因为题目没有特殊要求），如果xy平面的行列式（即cross.z）为0，则换用其他平面。
然而，我们前面已经计算了混合积（即(AB×CD)·AC），而混合积=0是共面的条件，但叉积AB×CD我们还没有计算。所以，我们可以先计算叉积AB×CD，然后判断混合积是否为0（即叉积点乘AC是否为0）。然后，如果叉积不为0（即不共线），则选择叉积中绝对值最大的分量对应的平面。
但是，为了节省计算，我们可以先计算叉积AB×CD，然后混合积=叉积·AC，然后判断混合积是否为0（共面）。然后，如果共面且叉积不为0（不共线），则选择叉积中绝对值最大的分量对应的平面。
因此，步骤：
对于两条线段AB, CD：
向量AB = (b1x, b1y, b1z) = (B.x-A.x, B.y-A.y, B.z-A.z)
向量CD = (b2x, b2y, b2z) = (D.x-C.x, D.y-C.y, D.z-C.z)
向量AC = (cx, cy, cz) = (C.x-A.x, C.y-A.y, C.z-A.z)
叉积 cross = AB × CD = ( b1y*b2z - b1z*b2y, b1z*b2x - b1x*b2z, b1x*b2y - b1y*b2x )
混合积 = cross·AC = cross.x*cx + cross.y*cy + cross.z*cz
如果混合积 != 0，则不相交（不共面）。
如果混合积==0：
如果cross是零向量（即cross.x==0 && cross.y==0 && cross.z==0），则共线：
则按共线情况处理（投影到AB直线上，计算t_C, t_D，然后判断投影区间是否重叠且重叠部分长度>0）。
否则（不共线）：
选择平面：取max(|cross.x|, |cross.y|, |cross.z|)，假设最大值是|cross.x|，则使用yz平面（即用y,z分量建立方程组）；如果最大值是|cross.y|，则使用xz平面；如果最大值是|cross.z|，则使用xy平面。
然后，在选择的平面上建立方程组，计算行列式det（即该平面对应的叉积分量，注意符号，但绝对值不影响）：
- 如果选择yz平面，则使用y,z分量：方程组（y和z）：
t*(B.y-A.y) + s*(C.y-D.y) = C.y - A.y [注意：这
里写标准形式：t*AB.y + s*(C.y-D.y) = C.y-A.y? 不对，应该是：t*AB.y - s*CD.y = C.y-A.y?]
实际上，方程：
A.y + t*AB.y = C.y + s*CD.y
=> t*AB.y - s*CD.y = C.y - A.y
同样，z分量：t*AB.z - s*CD.z = C.z - A.z
则行列式 det = AB.y * (-CD.z) - (-CD.y)*AB.z = - (AB.y*CD.z - CD.y*AB.z)
而叉积的x分量：AB.y*CD.z - AB.z*CD.y = cross.x
所以 det = - cross.x
因此，行列式的绝对值等于|cross.x|。
然后，计算t和s的分子：
det_t = (C.y-A.y)*(-CD.z) - (C.z-A.z)*(-CD.y) = -(C.y-A.y)*CD.z + (C.z-A.z)*CD.y
det_s = AB.y*(C.z-A.z) - AB.z*(C.y-A.y) [注意：方程组中s的系数是-CD.y和-CD.z，所以克莱姆法则中，s的分子是替换第二列（即s的系数所在列）为常数项]
= AB.y*(C.z-A.z) - AB.z*(C.y-A.y)
然后，检查t和s是否在(0,1)内（同前），并验证第三个方程（x分量）：
A.x * det + det_t * AB.x = C.x * det + det_s * CD.x [注意：这
里第三个方程是x分量，所以是A.x + t*AB.x = C.x + s*CD.x，然后乘以det]
即：det * (A.x - C.x) + det_t * AB.x - det_s * CD.x = 0 （注意移项）
由于混合积为0保证了第三个方程成立，所以理论上，只要t,s满足，第三个方程一定成立？但为了避免
整数运算的截断，我们仍然需要验证。
但是，这样处理比较复杂。由于题目
数据范围小，我们可以直接使用xy平面（即z分量）来解，如果det_xy=0（即cross.z=0），则换用xz平面（即y分量）或yz平面（即x分量）。我们可以在代码中尝试三个平面，直到找到一个非零行列式。
为了简化代码，我们选择固定顺序：先xy，再xz，再yz。
具体实现：
for (int plane=0; plane<3; plane++) {
选择平面（0:xy, 1:xz, 2:yz）
根据平面选择两个坐标分量（例如，xy平面：用0:x,1:y；xz平面：用0:x,1:z；yz平面：用1:y,2:z）
计算行列式：
设分量1为p，分量2为q。
则向量AB的p分量=AB_p，q分量=AB_q
向量CD的p分量=CD_p，q分量=CD_q
常数项：d_p = C.p - A.p, d_q = C.q - A.q
行列式 det = AB_p * (-CD_q) + CD_p * AB_q [注意：方程：t*AB_p - s*CD_p = d_p; t*AB_q - s*CD_q = d_q]
= - (AB_p * CD_q - AB_q * CD_p) [这个值等于叉积在另一个分量上的值（带符号）]
如果det!=0，则用这个平面解t,s。
计算det_t = d_p*(-CD_q) - d_q*(-CD_p) = -d_p*CD_q + d_q*CD_p
计算det_s = AB_p*d_q - AB_q*d_p
然后检查t和s是否在(0,1)内（开区间），并验证第三个分量（即没有使用的那个分量）的方程：
设分量为r（即平面外的那个分量），则方程为：
A.r * det + det_t * AB_r = C.r * det + det_s * CD_r
如果成立，则相交。
如果这个平面解出的t,s满足条件，则返回相交（true）。
}
如果三个平面都没有解（即三个平面的行列式都为0），则说明两线段平行（但这是不可能的，因为共线的情况已经单独处理了，所以这
里应该不会出现）？所以返回不相交。
注意：这
里我们循环三个平面，只要有一个平面解出t,s在(0,1)内且第三个方程满足，就返回true。
但是，有可能在某个平面上行列式为0，则跳过；或者行列式不为0但解不在(0,1)内，则继续下一个平面？不对，因为共面，所以三个平面中行列式不为0的平面解出的t,s是唯一的，所以如果不在(0,1)内，那么其他平面也会得到相同的t,s（只是用不同的方程表示），所以其他平面解出的t,s也不在(0,1)内。因此，我们只要找到一个平面行列式不为0，然后解出t,s，然后判断即可。所以，我们找到第一个行列式不为0的平面，然后计算t,s，然后判断t,s是否在(0,1)内以及第三个方程，如果满足则返回true；否则，返回false（不相交）。
因此，代码步骤：
共面且不共线的情况下：
for (int iter=0; iter<3; iter++) {
选择平面（0:xy, 1:xz, 2:yz）
计算行列式det，如果det==0，则continue。
计算det_t, det_s。
检查t和s是否在(0,1)内（开区间）：
if ( (det_t*det>0) && (abs(det_t) < abs(det)) && (det_s*det>0) && (abs(det_s)<abs(det)) ) {
验证第三个分量方程（
整数等式）：
设第三个分量为r（即平面中未使用的那个分量），则：
A.r * det + det_t * AB.r = C.r * det + det_s * CD.r （注意：这
里AB.r和CD.r是向量在r分量上的值）
如果等式成立，则返回true（相交）。
}
}
返回false（不相交）。
注意：第三个分量的方程也可以不验证？因为共面条件已经满足，理论上成立。但
整数运算可能溢出？所以最好验证。
但是，由于我们使用
整数运算，并且等式两边乘以了det（非零），所以等式应该成立。但为了保险，我们验证。
综上所述，整个
算法框架：
函数：bool segIntersect(Point A, Point B, Point C, Point D)
向量AB = B-A, CD = D-C, AC = C-A
计算叉积 cross = AB × CD
计算混合积 = cross · AC
如果混合积 != 0，则不相交（返回false）。
如果混合积==0：
如果cross是零向量（AB×CD=0），则共线：
将线段AB和CD投影到AB直线（或CD直线）上，计算投影区间。
具体：
将点C和D投影到直线AB上，计算参数t_C和t_D（相对于A点，方向AB）：
t_C = ( (C-A) · AB ) / (AB·AB)
t_D = ( (D-A) · AB ) / (AB·AB)
但是，为了避免浮点数，我们可以用分数表示。
设分母 denom = AB·AB
分子 numC = (C-A)·AB, numD = (D-A)·AB
则C的投影参数为 [numC, denom]，D的投影参数为 [numD, denom]。
线段AB在直线上的投影区间为 [0, denom]（因为A点对应0，B点对应denom）。
线段CD在直线上的投影区间为 [min(numC, numD), max(numC, numD)]。
然后，计算两个区间的交集：
left = max(0, min(numC, numD))
right = min(denom, max(numC, numD))
但是，注意：这
里区间是[0, denom]和[min(numC,numD), max(numC,numD)]，所以交集为 [left, right]。
然后，我们要求交集长度大于0，即 right > left（严格大于），并且交集区间不能仅仅是端点？但注意，题目要求非端点相交，所以交集中的点必须包含非端点的点。
然而，在共线情况下，交集区间长度大于0（即right>left）就说明有无数个交点，且一定包含非端点的点（因为区间长度大于0，则区间内一定存在点不是A,B,C,D）。但是，注意：区间端点可能是线段的端点，但区间内部（开区间）的点一定不是端点。所以，只要right>left，则存在非端点的交点。
但是，这
里我们使用
整数，所以right>left就表示有重叠部分（长度>0）。
因此，如果 right>left，则返回true；否则false。
否则（不共线）：
循环三个平面（xy, xz, yz）：
设平面（用两个坐标轴，第三个坐标轴作为验证）：
平面xy: 坐标分量0:x, 1:y, 验证分量2:z
平面xz: 坐标分量0:x, 1:z, 验证分量1:y
平面yz: 坐标分量1:y, 2:z, 验证分量0:x
对于平面，设p分量和q分量：
p_comp, q_comp, r_comp (验证分量)
定义：
AB_p = AB的p分量, AB_q = AB的q分量
CD_p = CD的p分量, CD_q = CD的q分量
d_p = (C的p分量 - A的p分量)
d_q = (C的q分量 - A的q分量)
行列式 det = - (AB_p * CD_q - AB_q * CD_p) [因为方程：t*AB_p - s*CD_p = d_p; t*AB_q - s*CD_q = d_q]
= AB_q*CD_p - AB_p*CD_q
如果det==0，跳过。
计算：
det_t = d_p*(-CD_q) + d_q*CD_p = -d_p*CD_q + d_q*CD_p
det_s = AB_p*d_q - AB_q*d_p
检查t和s是否在(0,1)内（开区间）：
条件1：det_t与det同号（即det_t*det>0）且abs(det_t) < abs(det)
条件2：det_s与det同号（即det_s*det>0）且abs(det_s) < abs(det)
如果满足，则验证r分量：
等式： (A.r * det + det_t * AB.r) == (C.r * det + det_s * CD.r)
如果成立，返回true。
循环结束，返回false。
注意：在计算点积和叉积时，注意
整数范围。
最后，主函数：
读入n
读入n条线段
初始化flag = false
对每两条线段（i<j），调用segIntersect，如果相交，则flag=true，并跳出循环（或者继续，因为题目要求存在一对即可，但注意一旦找到一对就可以跳出，但题目要求所有都不相交才输出"No"，所以找到一对就可以输出"Yes"并结束）
如果找到一对相交，输出"Yes"，否则输出"No"
注意：线段存储：用数组，每个线段两个端点（6个
整数）。
由于n最大
100，所以O(n^2)是
10000，可以接受。
但是，注意：在共线投影时，我们使用了分数，但没有约分，所以比较时用
整数比较（即交叉相乘）：
left = max(0, min(numC, numD)) -> 这
里left和right是分子，分母都是denom（AB·AB）
所以，right>left -> 分子上：right>left，因为分母denom>0（因为AB不是零向量，因为线段两个端点不同，但题目没说端点相同？题目保证线段两个端点不同吗？）
题目没有说端点相同，所以我们需要处理线段退化为点的情况。但题目是光束，应该两个端点不同。所以假设所有线段的两个端点不重合。
因此，AB·AB>0，所以分母为正。
但是，在计算投影时，numC和numD可能是负数，所以投影区间可能为[min(numC,numD), max(numC,numD)]，而AB的投影区间为[0, denom]（因为t从0到1，对应分子0到denom）。
所以，left = max(0, min(numC, numD, 0))? 不对，应该是：
left = max(0, min(numC, numD))
right = min(denom, max(numC, numD))
然后判断 right>left
但是，注意：如果线段CD在AB的延长线上（比如numC和numD都大于denom或都小于0），则left=0, right=0（如果都小于0）或left=denom, right=denom（如果都大于denom），则right=left，所以不相交。
因此，共线情况下的投影区间计算正确。
代码实现：
定义点结构体：
struct Point {
int x, y, z;
Point(int x=0, int y=0, int z=0):x(x),y(y),z(z) {}
};
定义向量运算：
Point operator - (const Point& a, const Point& b) {
return Point(a.x-b.x, a.y-b.y, a.z-b.z);
}
Point operator + (const Point& a, const Point& b) { ... }
int dot(const Point& a, const Point& b) {
return a.x*b.x + a.y*b.y + a.z*b.z;
}
Point cross(const Point& a, const Point& b) {
return Point(
a.y*b.z - a.z*b.y,
a.z*b.x - a.x*b.z,
a.x*b.y - a.y*b.x
);
}
然后，线段：用两个点表示。
注意：在共线投影时，我们计算：
denom = dot(AB, AB);
numC = dot(AC, AB); // AC = C-A
numD = dot(AD, AB); // AD = D-A
然后，区间1: [0, denom]（对应AB线段）
区间2: [min(numC, numD), max(numC, numD)]（对应CD线段）
交集：left = max(0, min(numC, numD));
right = min(denom, max(numC, numD));
if (right > left) return true;
注意：这
里right和left是
整数，所以直接比较。
但是，这
里没有考虑分母，实际上，投影参数t_C = numC/denom，但区间比较时，由于分母相同，所以直接用分子比较即可。
因此，代码实现如下。
由于题目要求非端点相交，所以共线情况下的重叠部分长度>0（即right>left）就满足。
注意：在共线情况下，我们只考虑了投影到AB直线，但也可以投影到CD直线？但是，结果是一样的。因为投影区间重叠的长度>0是等价的。
最后，注意：两条线段可能完全相同，那么重叠部分就是整个线段，所以right>left成立，返回true。
因此，按照上述思路编写代码。
但是，由于时间关系，我们直接编写代码，并注意边界。
由于题目
数据范围小，我们可以用int，注意乘法可能溢出？最大坐标
1000，所以点积最大
1000*
1000*3=3e6，而叉积最大
1000*
1000=1e6，混合积最大1e6*
1000=1e9，还在int范围内（int最大2e9）。所以安全。
编写函数：bool intersect(Point A, Point B, Point C, Point D)
然后主函数：
vector<Point> segs; // 实际上，每条线段两个端点，所以用vector<pair<Point,Point>> 或两个数组
读入n，然后n行，每行6个
整数，构造两个Point，存入数组。
然后：
for (int i=0; i<n; i++) {
for (int j=i+1; j<n; j++) {
if (intersect(segs[i].A, segs[i].B, segs[j].A, segs[j].B)) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
注意：在共线投影时，分母denom=0怎么办？如果AB是零向量（即A=B），那么denom=0，但题目保证线段两个端点不同吗？题目没有明确，但通常不会相同。所以假设A!=B。
因此，我们假设所有线段的两个端点不重合。
下面编写代码，注意细节。
由于代码较长，我们分函数实现。
注意：在共线投影时，我们计算numC和numD时，用点积，注意AC和AB的点积。
代码实现：
注意：在共线情况下，我们使用AB直线投影，但CD线段可能完全不在AB线段上（即使共线），所以用投影区间判断。
下面开始编写C++代码。</think>以下是针对编程题目"森罗殿的光束交错"的C++解法。该问题要求判断三维空间中多条线段（光束）是否存在非端点相交的情况。通过计算线段间的共面性和交点位置，使用
整数运算避免浮点精度问题。
### 解法思路
1. **输入处理**：读入线段数量，每条线段的两个端点坐标。
2. **两两检测**：对每对线段进行相交检测（O(n²)复杂度）。
3. **共面判断**：计算混合积判断两线段是否共面。
4. **共线处理**：若线段共线，投影到直线上判断重叠区间长度。
5. **非共线处理**：在共面基础上，选择合适平面求解参数方程，验证交点是否在线段内部。
6. **结果输出**：发现任意相交对输出"Yes"，否则输出"No"。
### C++代码实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
struct Point {
int x, y, z;
Point() : x(0), y(0), z(0) {}
Point(int x, int y, int z) : x(x), y(y), z(z) {}
};
Point operator - (const Point& a, const Point& b) {
return Point(a.x - b.x, a.y - b.y, a.z - b.z);
}
Point operator + (const Point& a, const Point& b) {
return Point(a.x + b.x, a.y + b.y, a.z + b.z);
}
int dot(const Point& a, const Point& b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
Point cross(const Point& a, const Point& b) {
return Point(
a.y * b.z - a.z * b.y,
a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x
);
}
bool isCollinearIntersect(Point A, Point B, Point C, Point D) {
Point AB = B - A;
int denom = dot(AB, AB);
if (denom == 0) return false; // 线段退化为点
Point AC = C - A;
Point AD = D - A;
int numC = dot(AC, AB);
int numD = dot(AD, AB);
int minCD = min(numC, numD);
int maxCD = max(numC, numD);
int left = max(0, minCD);
int right = min(denom, maxCD);
return (right > left);
}
bool intersect(Point A, Point B, Point C, Point D) {
Point AB = B - A;
Point CD = D - C;
Point AC = C - A;
Point crossABC = cross(AB, CD);
int mixedProduct = dot(crossABC, AC);
if (mixedProduct != 0) return false; // 不共面
// 检查叉积是否为零向量（共线）
if (crossABC.x == 0 && crossABC.y == 0 && crossABC.z == 0) {
return isCollinearIntersect(A, B, C, D);
}
// 尝试三个平面：xy, xz, yz
int planes[3][3] = {{0, 1, 2}, {0, 2, 1}, {1, 2, 0}}; // [p, q, r]分量索引
for (int i = 0; i < 3; ++i) {
int p = planes[i][0];
int q = planes[i][1];
int r = planes[i][2]; // 验证的分量
// 获取分量函数
auto getComp = [](const Point& pt, int comp) -> int {
if (comp == 0) return pt.x;
if (comp == 1) return pt.y;
return pt.z;
};
int AB_p = getComp(AB, p);
int AB_q = getComp(AB, q);
int CD_p = getComp(CD, p);
int CD_q = getComp(CD, q);
int d_p = getComp(C, p) - getComp(A, p);
int d_q = getComp(C, q) - getComp(A, q);
int det = AB_p * (-CD_q) + CD_p * AB_q; // 行列式
if (det == 0) continue;
int det_t = d_p * (-CD_q) + d_q * CD_p;
int det_s = AB_p * d_q - AB_q * d_p;
// 检查t,s是否在(0,1)开区间内
if (det > 0) {
if (det_t <= 0 || det_t >= det) continue;
if (det_s <= 0 || det_s >= det) continue;
} else {
if (det_t >= 0 || det_t <= det) continue;
if (det_s >= 0 || det_s <= det) continue;
}
// 验证第三个分量
int A_r = getComp(A, r);
int B_r = getComp(B, r);
int C_r = getComp(C, r);
int D_r = getComp(D, r);
int AB_r = B_r - A_r;
int CD_r = D_r - C_r;
long left_val = static_cast<long>(A_r) * det + static_cast<long>(det_t) * AB_r;
long right_val = static_cast<long>(C_r) * det + static_cast<long>(det_s) * CD_r;
if (left_val == right_val) return true;
}
return false;
}
int main() {
int n;
cin >> n;
vector<pair<Point, Point>> segs(n);
for (int i = 0; i < n; ++i) {
int x1, y1, z1, x2, y2, z2;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
segs[i] = {Point(x1, y1, z1), Point(x2, y2, z2)};
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
Point A1 = segs[i].first, B1 = segs[i].second;
Point A2 = segs[j].first, B2 = segs[j].second;
if (intersect(A1, B1, A2, B2) ||
intersect(A1, B1, B2, A2) ||
intersect(B1, A1, A2, B2) ||
intersect(B1, A1, B2, A2)) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
}
```
### 代码说明
1. **
数据结构**：`Point`结构存储三维坐标，支持向量运算。
2. **共面判断**：通过混合积(AB×CD)·AC是否为0判断共面。
3. **共线处理**：投影到线段所在直线，计算区间重叠（长度>0即相交）。
4. **非共线处理**：在三个坐标平面（xy/xz/yz）中
选取行列式非零者求解参数方程，验证交点在线段内部。
5. **精度保障**：全程
整数运算避免浮点误差，使用`long`防止乘法溢出。
### 相关问题
1. 如何优化线段相交检测的时间复杂度？
2. 如何处理浮点坐标下的线段相交问题？
3. 在图形学中线段相交检测有哪些应用场景？[^1]
[^1]: 参考计算几何基础理论，如扫描线
算法等优化技术。
本文探讨了在大规模整数数组中寻找第k大元素的不同算法，包括递归快速排序算法、基于位查找的算法等，同时也讨论了在不同内存限制下的解决方案。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
