Line Intersections

input/code.cpp: In constructor 'SegmentTree::SegmentTree(int)':
input/code.cpp:14:9: warning: 'SegmentTree::n' will be initialized after [-Wreorder]
   14 |     int n;
      |         ^
input/code.cpp:13:17: warning:   'std::vector<int> SegmentTree::tree' [-Wreorder]
   13 |     vector<int> tree, lazy;
      |                 ^~~~
input/code.cpp:17:5: warning:   when initialized here [-Wreorder]
   17 |     SegmentTree(int size):n(size), tree(4*size, 0), lazy(4*size, 0) {}
      |     ^~~~~~~~~~~

#include <bits/stdc++.h>
using namespace std;

struct Event {
    int x, y1, y2, type;
    Event(int x, int y1, int y2, int type) : x(x), y1(y1), y2(y2), type(type) {}
    bool operator<(const Event &e) const {
        return x < e.x || (x == e.x && type < e.type);
    }
};

class SegmentTree {
    vector<int> tree, lazy;
    int n;

public:
    SegmentTree(int size):n(size), tree(4*size, 0), lazy(4*size, 0) {}

    void update(int start, int end, int val, int l, int r, int node){
        if (lazy[node] != 0) {
            tree[node] += lazy[node];
            if (l != r) {
                lazy[node*2+1] += lazy[node];
                lazy[node*2+2] += lazy[node];
            }
            lazy[node] = 0;
        }
        if (start > r || end < l) return;
        if (start <= l && r <= end){
            tree[node] += val;
            if (l != r){
                lazy[node*2+1] += val;
                lazy[node*2+2] += val;
            }
            return;
        }
        int mid = (l+r)/2;
        update(start, end, val, l, mid, 2*node+1);
        update(start, end, val, mid+1, r, 2*node+2);
        tree[node] = max(tree[2*node+1], tree[2*node+2]);
    }

    int query(int start, int end, int l, int r, int node) {
        if (lazy[node] != 0) {
            tree[node] += lazy[node];
            if (l != r) {
                lazy[node*2+1] += lazy[node];
                lazy[node*2+2] += lazy[node];
            }
            lazy[node] = 0;
        }
        if (start > r || end < l) return 0;
        if (start <= l && r <= end) return tree[node];
        int mid = (l+r)/2;
        return max(query(start, end, l, mid, 2 * node + 1), query(start, end, mid+1, r, 2*node+2));
    }

    void update(int start, int end, int val){ 
        update(start, end, val, 0, n-1, 0); 
    }
    int query(int start, int end){ 
        return query(start, end, 0, n-1, 0); 
    }
};

int main() {
    cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(cin.failbit);

    int n;
    cin >> n;
    vector<Event> events;
    vector<int> y_coords;

    for (int i = 0; i < n; i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;

        // horizontal 
        if (y1 == y2) { 
            if (x1 > x2) swap(x1, x2);
            events.emplace_back(x1, y1, y1, 1);
            events.emplace_back(x2+1, y1, y1, -1);
            y_coords.push_back(y1);
        // vertical
        } else { 
            if (y1 > y2) swap(y1, y2);
            events.emplace_back(x1, y1, y2, 0); 
            y_coords.push_back(y1);
            y_coords.push_back(y2);
        }
    }

    // index compression
    sort(y_coords.begin(), y_coords.end());
    y_coords.erase(unique(y_coords.begin(), y_coords.end()), y_coords.end());

    auto getYIndex = [&](int y) {
        return lower_bound(y_coords.begin(), y_coords.end(), y) - y_coords.begin();
    };

    sort(events.begin(), events.end());

    SegmentTree segmentTree(y_coords.size());
    int count = 0;

    for (auto event : events) {
        if (event.type == 0) { 
            int y1 = getYIndex(event.y1);
            int y2 = getYIndex(event.y2);
            count += segmentTree.query(y1, y2);
        } else { 
            int y = getYIndex(event.y1);
            segmentTree.update(y, y, event.type);
        }
    }

    cout << count;
    return 0;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: WRONG ANSWER

Test 7

Verdict: ACCEPTED

Test 8

Verdict: WRONG ANSWER

Test 9

Verdict: ACCEPTED

Test 10

Verdict: WRONG ANSWER

Test 11

Verdict: WRONG ANSWER

Test 12

Verdict: WRONG ANSWER

Test 13

Verdict: WRONG ANSWER

Test 14

Verdict: ACCEPTED

Test 15

Verdict: WRONG ANSWER

Test 16

Verdict: WRONG ANSWER

Test 17

Verdict: WRONG ANSWER

Test 18

Verdict: WRONG ANSWER

Test 19

Verdict: WRONG ANSWER

Test 20

Verdict: WRONG ANSWER

Test 21

Verdict: WRONG ANSWER

Test 22

Verdict: WRONG ANSWER

Test 23

Verdict: WRONG ANSWER

Test 24

Verdict: WRONG ANSWER

Test 25

Verdict: WRONG ANSWER

Test 26

Verdict: WRONG ANSWER

Test 27

Verdict: WRONG ANSWER

Test 28

Verdict: WRONG ANSWER

Test 29

Verdict: WRONG ANSWER

Test 30

Verdict: WRONG ANSWER

Test 31

Verdict: WRONG ANSWER

Test 32

Verdict: WRONG ANSWER

Test 33

Verdict: WRONG ANSWER

Test 34

Verdict: WRONG ANSWER

Test 35

Verdict: WRONG ANSWER

Test 36

Verdict: WRONG ANSWER

Test 37

Verdict: WRONG ANSWER

Test 38

Verdict: WRONG ANSWER

Test 39

Verdict: WRONG ANSWER

Test 40

Verdict: WRONG ANSWER