Language: C++

/**
 * @brief 線分を扱います
 * @date  2016/03/19 ~ 2016/05/16
 */



//****************************************
// 必要なヘッダファイルのインクルード
//****************************************

#include <vector>
#include <algorithm>
#include <cmath>



//****************************************
// オブジェクト形式マクロの定義
//****************************************

//#define GEOMETRY_BEGIN namespace geom {
//#define GEOMETRY_END }



//****************************************
// 型シノニム
//****************************************

using coord_t    = long double;
using index_t    = std::int32_t;
using indices_t  = std::vector<index_t>;



//****************************************
// 構造体の定義
//****************************************

struct point {
    coord_t x, y;
    point() : x(0), y(0) {}
    point(coord_t x, coord_t y) : x(x), y(y) {}

    point& operator+=(const point& p)  { x += p.x; y += p.y; return *this; }
    point& operator-=(const point& p)  { x -= p.x; y -= p.y; return *this; }
    point& operator*=(const coord_t d) { x *= d; y *= d; return *this;}

    point operator+(const point& p)  const { return point(*this) += p; }
    point operator-(const point& p)  const { return point(*this) -= p; }
    point operator*(const coord_t d) const { return point(*this) *= d; }
};


struct segment {
    point ps;  // 線分の始点
    point pd;  // 線分の終点
};



namespace limits {
    constexpr auto pi  = 3.141592653589793238;
    constexpr auto eps = 1e-10;
    constexpr auto inf = 1e12;
}


/**
 * @brief   与えられた3点a, b, cをa -> b -> cと進むとき、
 * @details a -> bで時計方向に折れてb -> c (cw)
 *          a -> bで反時計方向に折れてb -> c (ccw)
 *          a -> bで逆を向いてaを通り越してb -> c (back)
 *          a -> bでそのままb -> c (front)
 *          a -> bで逆を向いてb -> cまたは、b == c (on)
 */
enum struct orientation {
    cw    = -1,
    ccw   = +1,
    back  = +2,
    front = -2,
    on    = 0,
};



/**
 * @brief 述語オブジェクト
 */
struct cmp_x { bool operator()(const point& pi, const point& pj) { return pi.x < pj.x; } };
struct cmp_y { bool operator()(const point& pi, const point& pj) { return pi.y < pj.y; } };



//****************************************
// 型シノニムその2
//****************************************

using vector_t   = point;
using polygon_t  = std::vector<point>;
using segments_t = std::vector<segment>;



//****************************************
// 関数の定義
//****************************************

/**
 * @brief  2つのベクトルa, bからなる行列A = (a, b)の行列式(determinant)を返します
 * @param  const vector_t& a ベクトルa
 * @param  const vector_t& b ベクトルb
 * @return coord_t det(A)    行列式|(a, b)|
 */
static constexpr coord_t det(const vector_t& a, const vector_t& b)
{
    return a.x * b.y - a.y * b.x;
}


/**
 * @brief  2つのベクトルa, bのクロス積(cross product)a x bを返します
 * @param  const vector_t& a  ベクトルa
 * @param  const vector_t& b  ベクトルb
 * @return coord_t a x b      クロス積a x b
 */
static constexpr coord_t cross(const vector_t& a, const vector_t& b)
{
    return a.x * b.y - a.y * b.x;
    //return det(a, b);
}


/**
 * @brief  2つのベクトルa, bのドット積(dot product)a・bを返します
 * @param  const vector_t& a  ベクトルa
 * @param  const vector_t& b  ベクトルb
 * @return coord_t a・b       ドット積a・b
 */
static constexpr coord_t dot(const vector_t& a, const vector_t& b)
{
    return a.x * b.x + a.y * b.y;
}


/**
 * @brief  ベクトルvの大きさの2乗を返します
 * @param  const vector_t& v
 * @return coord_t norm(v);
 */
static constexpr coord_t abs2(const vector_t& v)
{
    return v.x * v.x + v.y * v.y;
    // return dot(v, v);
}


/**
 * @brief  ベクトルvの大きさ|v|(原点からの距離)を返します
 * @param  const vector_t& v
 * @return coord_t sqrt(norm(v))
 */
static inline coord_t abs(const vector_t& v)
{
    return std::sqrt(abs2(v));
}


/**
 * @brief  点pから線分sに下ろした垂線と線分sの交点を返します
 * @param  const segment& s 線分s
 * @param  const point& p   点p
 * @return 垂線と線分の交点
 */
static inline point proj(const segment& s, const point& p)
{
    vector_t base = s.pd - s.ps;
    vector_t hypo = p - s.ps;
    coord_t r = dot(hypo, base) / abs2(base);
    return s.ps + base * r;
}


/**
 * @brief  点pと線対称の位置に存在する点を返します
 * @param  cosnt segment& s 線分s
 * @param  const point&   p 点p
 * @param  pと線対称な点
 */
static inline point reflect(const segment& s, const point p)
{
    return p + (proj(s, p) - p) * 2.0;
}


/**
 * @brief COMBINED-TOLERANCE-COMPAREより少ない労力で行える近似的な判定
 */
static inline bool approximate_combined_tolerance_compare(coord_t x, coord_t y) noexcept
{
    return std::fabs(x - y) <= limits::eps * (std::fabs(x) + std::fabs(y) + 1.0);
}


/**
 * @brief 手続きAPPROXIMATE-COMBINED-TOLERANCE-COMPAREの短い名前
 */
static inline bool eq(coord_t x, coord_t y)
{
    return approximate_combined_tolerance_compare(x, y);
}


/**
 * @brief 述語オブジェクト
 */
struct cmp_xy { bool operator()(const point& pi, const point& pj) { return pi.x < pj.x || (eq(pi.x, pj.x) && pi.y < pj.y); } };


/**
 * @brinf 2点(p1, p2)のp0に関する偏角(polar angle)から、
 *        p0から見た2つのベクトルp0p1↑, p0p2↑の方向を返す
 */
static inline orientation ccw(point p0, point p1, point p2)
{
    p1 -= p0; p2 -= p0;

    if (cross(p1, p2) > limits::eps)  { return orientation::ccw;  }  // クロス積(p1-p0)x(p2-p0)が正の場合、ccw  ...(*1)
    if (cross(p1, p2) < -limits::eps) { return orientation::cw;   }  // クロス積(p1-p0)x(p2-p0)が負の場合、cw   ...(*2)


    // (*1), (*2)に当てはまらないとき、p2は直線p0p1|上(線分p0p1↑上とは限らない)に存在する

    if (dot(p1, p2) < -limits::eps)   { return orientation::back;  }  // ドット積(p1-p0)・(p2-p0)が負の場合、p2->p0->p1(back) ...(*3)

    // (*3)に当てはまらないとき、p2はp0->p1->p2またはp0->p2->p1の位置に存在する

    if (eq(abs2(p1), abs2(p2)))       { return orientation::front; }  // p0p2↑の大きさがp0p1↑の大きさより大きい場合、p0->p1->p2(front) ...(*4)

    // (*4)に当てはまらないとき、p0->p2->p1(on)
    return orientation::on;
}



/**
 * @brief  3点(pi, pj, pk)を引数に取り、クロス積(pk - pi) x (pj - pi)を返す
 * @note   direction > epsのとき、cw(clockwise)...ただし、定義によってはccw
 *         direction < -epsのとき、ccw(counterclockwise)...ただし、定義によってはcw
 *         それ以外のとき、0であり、境界条件が発生する. このとき、ベクトルは同一直線上(colinear)にあり、
 *         それらの方向は同じか互いに逆である     
 */
coord_t direction(const point& pi, const point& pj, const point& pk)
{
    return cross(pk - pi, pj - pi);
}


/**
 * @brief  pkがpipj|の端点の間にあるか否かを判定する
 *
 * @note   この手続きは、pkが線分pipj|と同一直線上にあると仮定する
 */
bool on_segment(const point& pi, const point& pj, const point& pk)
{  
    return std::min(pi.x, pj.x) <= pk.x && pk.x <= std::max(pi.x, pj.x)
        && std::min(pi.y, pj.y) <= pk.y && pk.y <= std::max(pi.y, pj.y);
}


/**
 * @brief  2本の線分の交差判定
 *
 * @note   2本の線分の交差性を判定するために、各線分が他方を含む直線を跨ぐか否か調べる
 *         線分p1p2|がある直線を跨ぐ(straddle)のは、点p1がこの直線の一方の側にあり、
 *         点p2が他方の側にあるときである. 境界となるのは、p1かp2が直線上にある場合である
 *         2本の線分が交差するための必要十分条件は次の条件の一方(あるいは両方)が成り立つときである
 *
 *           1. どちらの線分も他方を含む直線を跨ぐ
 *           2. 一方の線分の端点が線分上にある(この条件は境界上にある場合から発生する)
 *
 * @note   このアイデアを次の手続きで実現する. SEGMENT-INTERSECTは、線分p1p2|と線分p3p4|が交差するときに
 *         TRUEを返し、そうでないときはFALSEを返す. この手続きは、サブルーチンDIRECTIONを呼び出して
 *         クロス積法を用いて相対的な方向を求め、ON-SEGMENTを呼び出して、線分を含む直線上にあることが分かっている点が
 *         この線分上にあるかどうかを判定する
 */
bool segment_intersect(const point& p1, const point& p2,
                       const point& p3, const point& p4)
{
    coord_t d1 = direction(p3, p4, p1);
    coord_t d2 = direction(p3, p4, p2);
    coord_t d3 = direction(p1, p2, p3);
    coord_t d4 = direction(p1, p2, p4);

    // 線分p1p2↑と線分p3p4↑が互いに他方の直線を跨ぐ場合
    if (   ((d1 > limits::eps && d2 < -limits::eps) || (d1 < -limits::eps && d2 > limits::eps))
        && ((d3 > limits::eps && d4 < -limits::eps) || (d3 < -limits::eps && d4 > limits::eps)))  {
        // p1p2|がp3p4|を含む直線を跨ぐから、クロス積(p1-p3)x(p2-p1)と(p4-p2)x(p2-p3)の符号は異なる
        // p3p4|がp1p2|を含む直線を跨ぐから、クロス積(p3-p1)x(p2-p1)と(p4-p1)x(p2-p1)の符号は異なる
        return true;
    }

    // そうではないとき、これらの線分が互いに他方を跨ぐことはないが、端点が他方の線分上にある余地は残る
    // どの相対的な方向も0でなければこの可能性は消える

    // ある相対的方向dkが0のときには、pkは他方の線分と同一直線上にある
    // pkがこの線分上にあるための必要十分条件は、これがこの線分の端点の間にあることである

    // ON-SEGMENT呼び出しにおいて、この線分は、第一引数を端点とする線分と異なる方の線分である

    else if (eq(d1, 0) && on_segment(p3, p4, p1)) {
        return true;
    }

    else if (eq(d2, 0) && on_segment(p3, p4, p2)) {
        return true;
    }

    else if (eq(d3, 0) && on_segment(p1, p2, p3)) {
        return true;
    }

    else if (eq(d4, 0) && on_segment(p1, p2, p4)) {
        return true;
    }

    else {
        return false;  // 0判定はすべて失敗し、FALSEを返す
    }
}


/**
 * @brief  線分交差検出を行う
 * 
 * @note   n本の線分の集合をSとし、Sの中で交差している線分の数を返す
 */
std::size_t any_segments_intersect(segments_t& S)
{
    // struct cmp { bool operator () (const segment& s1, const segment& s2) {
    //     return (s1.ps.x - s2.ps.x) * (s2.pd.y - s2.ps.y)
    //         <  (s1.ps.y - s2.ps.y) * (s2.pd.x - s2.ps.x);
    // } };
    
    std::set<index_t> T;  // 全擬順序Tを空に初期化する
    
    index_t n = S.size();
    event_points Q;      // イベントキューQを空に初期化する
    
    for (index_t i = 0; i < n; i++) {
        // 端点ps, pdが左下を基準に並ぶように調整する
        if (eq(S[i].ps.y, S[i].pd.y)) {
            if (S[i].ps.x > S[i].pd.x)  { std::swap(S[i].ps, S[i].pd); }
        }
        else if (S[i].ps.y > S[i].pd.y) { std::swap(S[i].ps, S[i].pd); }

        Q.emplace_back(S[i].ps, i, event_type::left);
        Q.emplace_back(S[i].pd, i, event_type::right);
    }

    // Sの線分の端点を左から右にソートする
    std::sort(Q.begin(), Q.end());

    std::size_t count = 0;
    for (index_t i = 0; i < 2 * n; i++) {   // イベント点の個数は2nだからループの繰り返しは2n

        if (Q[i].e == event_type::left)  {  // pが線分sの左端点

            for (index_t s : T) {
                if (segment_intersect(S[Q[i].seg].ps, S[Q[i].seg].pd,
                                      S[s].ps, S[s].pd)) {
                    count = count + 1;
                }
            }         
            T.insert(Q[i].seg);
        }
        if (Q[i].e == event_type::right) {  // pが線分sの右端点
            T.erase(Q[i].seg);
        }
    }

    return count;
}


//****************************************
// エントリポイント
//****************************************


int main()
{
    using namespace std;
    
    int q;
    cin >> q;

    const int points_num = 4;
    while (q) {
        polygon_t p(points_num);
        int x, y;
        for (int i = 0; i < points_num; i++) {
            cin >> x >> y;
            p[i] = point(x, y);
        }
        cout << segment_intersect(p[0], p[1], p[2], p[3]) << endl;
        q--;
    }

    return 0;
}

Compiler output:
a.cc:32:25: error: 'int32_t' in namespace 'std' does not name a type
   32 | using index_t    = std::int32_t;
      |                         ^~~~~~~
a.cc:33:32: error: 'index_t' was not declared in this scope
   33 | using indices_t  = std::vector<index_t>;
      |                                ^~~~~~~
a.cc:33:39: error: template argument 1 is invalid
   33 | using indices_t  = std::vector<index_t>;
      |                                       ^
a.cc:33:39: error: template argument 2 is invalid
a.cc: In function 'std::size_t any_segments_intersect(segments_t&)':
a.cc:346:10: error: 'set' is not a member of 'std'
  346 |     std::set<index_t> T;  // 全擬順序Tを空に初期化する
      |          ^~~
a.cc:15:1: note: 'std::set' is defined in header '<set>'; this is probably fixable by adding '#include <set>'
   14 | #include <cmath>
  +++ |+#include <set>
   15 | 
a.cc:346:14: error: 'index_t' was not declared in this scope
  346 |     std::set<index_t> T;  // 全擬順序Tを空に初期化する
      |              ^~~~~~~
a.cc:346:23: error: 'T' was not declared in this scope
  346 |     std::set<index_t> T;  // 全擬順序Tを空に初期化する
      |                       ^
a.cc:348:12: error: expected ';' before 'n'
  348 |     index_t n = S.size();
      |            ^~
      |            ;
a.cc:349:5: error: 'event_points' was not declared in this scope
  349 |     event_points Q;      // イベントキューQを空に初期化する
      |     ^~~~~~~~~~~~
a.cc:351:17: error: expected ';' before 'i'
  351 |     for (index_t i = 0; i < n; i++) {
      |                 ^~
      |                 ;
a.cc:351:25: error: 'i' was not declared in this scope
  351 |     for (index_t i = 0; i < n; i++) {
      |                         ^
a.cc:351:29: error: 'n' was not declared in this scope
  351 |     for (index_t i = 0; i < n; i++) {
      |                             ^
a.cc:358:9: error: 'Q' was not declared in this scope
  358 |         Q.emplace_back(S[i].ps, i, event_type::left);
      |         ^
a.cc:358:36: error: 'event_type' has not been declared
  358 |         Q.emplace_back(S[i].ps, i, event_type::left);
      |                                    ^~~~~~~~~~
a.cc:359:36: error: 'event_type' has not been declared
  359 |         Q.emplace_back(S[i].pd, i, event_type::right);
      |                                    ^~~~~~~~~~
a.cc:363:15: error: 'Q' was not declared in this scope
  363 |     std::sort(Q.begin(), Q.end());
      |               ^
a.cc:366:17: error: expected ';' before 'i'
  366 |     for (index_t i = 0; i < 2 * n; i++) {   // イベント点の個数は2nだからループの繰り返しは2n
      |                 ^~
      |                 ;
a.cc:366:25: error: 'i' was not declared in this scope
  366 |     for (index_t i = 0; i < 2 * n; i++) {   // イベント点の個数は2nだからループの繰り返しは2n
      |                         ^
a.cc:366:33: error: 'n' was not declared in this scope
  366 |     for (index_t i = 0; i < 2 * n; i++) {   // イベント点の個数は2nだからループの繰り返しは2n
      |                                 ^
a.cc:368:23: error: 'event_type' has not been declared
  368 |         if (Q[i].e == event_type::left)  {  // pが線分sの左端点
      |                       ^~~~~~~~~~
a.cc:370:25: error: expected ';' before 's'
  370 |             for (index_t s : T) {
      |                         ^~
      |                         ;
a.cc:377:9: error: expected primary-expression before '}' token
  377 |         }
      |         ^
a.cc:376:32: error: expected ')' before '}' token
  376 |             T.insert(Q[i].seg);
      |                                ^
      |                                )
  377 |         }
      |         ~                       
a.cc:370:17: note: to match this '('
  370 |             for (index_t s : T) {
      |                 ^
a.cc:377:9: error: expected primary-expression before '}' token
  377 |         }
      |         ^
a.cc:378:23: error: 'event_type' has not been declared
  378 |         if (Q[i].e == event_type::right) {  // pが線分sの右端点
      |                       ^~~~~~~~~~
a.cc: In function 'int main()':
a.cc:397:5: error: 'cin' was not declared in this scope
  397 |     cin >> q;
      |     ^~~
a.cc:15:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
   14 | #include <cmath>
  +++ |+#include <iostream>
   15 | 
a.cc:407:9: error: 'cout' was not declared in this scope
  407 |         cout << segment_intersect(p[0], p[1], p[2], p[3]) << endl;
      |         ^~~~
a.cc:407:9: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:407:62: error: 'endl' was not declared in this scope
  407 |         cout << segment_intersect(p[0], p[1], p[2], p[3]) << endl;
      |                                                              ^~~~
a.cc:15:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
   14 | #include <cmath>
  +++ |+#include <ostream>
   15 |