Aiuto segtree 40/100

[fantasy]

Sto cercando un input per cui questo codice non funzioni, ma non riesco a trovarlo, potreste aiutarmi?

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#include <bits/stdc++.h>

using namespace std;


struct Node {
	long long val;
	long long mi;
	long long lazySet;
	long long lazyAdd;
	int last;
	Node() : val(0), mi(LLONG_MAX), lazySet(LLONG_MIN), lazyAdd(0), last(-1) {};
	void join(Node &a, Node &b) {
		val = a.val + b.val;
		mi = min(a.mi, b.mi);
	}
};

int n, realSize;
vector<Node> segTree;
int last = -1;

void isLazy(int u, int left, int right) {
	if (segTree[u].lazySet != LLONG_MIN && segTree[u].lazyAdd != 0){
		if (segTree[u].last == 0){
			if (segTree[u].lazySet != LLONG_MIN) {
				segTree[u].val = (right - left) * segTree[u].lazySet;
				segTree[u].mi = segTree[u].lazySet;
				if ((u * 2) + 1 < segTree.size()) {
					segTree[u * 2].lazySet = segTree[u].lazySet;
					segTree[(u * 2) + 1].lazySet = segTree[u].lazySet;
				}
				segTree[u].lazySet = LLONG_MIN;
			}
			if (segTree[u].lazyAdd != 0) {
				segTree[u].val += (right - left) * segTree[u].lazyAdd;
				segTree[u].mi += segTree[u].lazyAdd;
				if ((u * 2) + 1 < segTree.size()) {
					segTree[u * 2].lazyAdd += segTree[u].lazyAdd;
					segTree[(u * 2) + 1].lazyAdd += segTree[u].lazyAdd;
					segTree[u*2].last = 0;
					segTree[u*2+1].last = 0;
				}
				segTree[u].lazyAdd = 0;
			}
		}else{
			if (segTree[u].lazyAdd != 0) {
				segTree[u].val += (right - left) * segTree[u].lazyAdd;
				segTree[u].mi += segTree[u].lazyAdd;
				if ((u * 2) + 1 < segTree.size()) {
					segTree[u * 2].lazyAdd += segTree[u].lazyAdd;
					segTree[(u * 2) + 1].lazyAdd += segTree[u].lazyAdd;
				}
				segTree[u].lazyAdd = 0;
			}
			if (segTree[u].lazySet != LLONG_MIN) {
				segTree[u].val = (right - left) * segTree[u].lazySet;
				segTree[u].mi = segTree[u].lazySet;
				if ((u * 2) + 1 < segTree.size()) {
					segTree[u * 2].lazySet = segTree[u].lazySet;
					segTree[(u * 2) + 1].lazySet = segTree[u].lazySet;
					segTree[u*2].last = 1;
					segTree[u*2+1].last = 1;
				}
				segTree[u].lazySet = LLONG_MIN;
			}
		}
		return;
	}
	if (segTree[u].lazyAdd != 0) {
		segTree[u].val += (right - left) * segTree[u].lazyAdd;
		segTree[u].mi += segTree[u].lazyAdd;
		if ((u * 2) + 1 < segTree.size()) {
			segTree[u * 2].lazyAdd += segTree[u].lazyAdd;
			segTree[(u * 2) + 1].lazyAdd += segTree[u].lazyAdd;
		}
		segTree[u].lazyAdd = 0;
	}
	if (segTree[u].lazySet != LLONG_MIN) {
		segTree[u].val = (right - left) * segTree[u].lazySet;
		segTree[u].mi = segTree[u].lazySet;
		if ((u * 2) + 1 < segTree.size()) {
			segTree[u * 2].lazySet = segTree[u].lazySet;
			segTree[(u * 2) + 1].lazySet = segTree[u].lazySet;
		}
		segTree[u].lazySet = LLONG_MIN;
	}
}


void build(int u, int l, int r, vector<long long> &dati);
void init(vector<long long> a) {
	n = a.size();
	realSize = 1;
	while (realSize < n) realSize *= 2;

	segTree.assign(realSize * 2, Node());
	build(1, 0, realSize, a);
}

void build(int u, int l, int r, vector<long long> &dati) {
	if (r - l <= 1) {
		if (l < dati.size()) {
			segTree[u].val = dati[l];
			segTree[u].mi = dati[l];
		}
	} else {
		build(u * 2, l, (l + r)/2, dati);
		build((u * 2) + 1, (l + r)/2, r, dati);
		segTree[u].join(segTree[u * 2], segTree[u * 2 + 1]);
	}
}

long long get_min(int u, int left, int right, int l, int r) {
	isLazy(u, left, right);
	if (r <= left || l >= right) return LLONG_MAX;
	if (left >= l && right <= r) return segTree[u].mi;
	return min(
			get_min(u * 2, left, (left + right) / 2, l, r),
			get_min((u * 2) + 1, (left + right) / 2, right, l, r)
			);
}
long long get_sum(int u, int left, int right, int l, int r) {
	isLazy(u, left, right);
	if (r <= left || l >= right) return 0;
	if (left >= l && right <= r) return segTree[u].val;

	return ( get_sum(u * 2, left, (left + right) / 2, l, r) +
			get_sum((u * 2) + 1, (left + right) / 2, right, l, r));
}

long long get_min(int l, int r) {return get_min(1, 0, realSize, l, r); }
long long get_sum(int l, int r) {return get_sum(1, 0, realSize, l, r); }

void set_range(int u, int left, int right, int l, int r, long long x) {
	isLazy(u, left, right);
	if (l >= right || r <= left) return;

	if (left >= l && right <= r) {
		segTree[u].val = (right - left) * x;
		segTree[u].mi = x;
		segTree[u].last = 1;
		if ((u * 2) + 1 < segTree.size()) {
			segTree[u * 2].lazySet = x;
			segTree[u * 2 + 1].lazySet = x;
			segTree[u * 2].last = 1;
			segTree[(u * 2) + 1].last = 1;
			segTree[u * 2].lazyAdd = 0;
			segTree[(u * 2) + 1].lazyAdd = 0;
		}
		return;
	}

	set_range(u * 2, left, (left + right)/2, l, r, x);
	set_range((u * 2) + 1, (left + right)/2, right, l, r, x);
	segTree[u].join(segTree[u * 2], segTree[u * 2 + 1]);
}
void set_range(int l, int r, long long x) {
	set_range(1, 0, realSize, l, r, x);
	last = 1;
}

void add(int u, int left, int right, int l, int r, long long x) {
	isLazy(u, left, right);
	if (l >= right || r <= left) return;
	if (left >= l && right <= r) {
		segTree[u].val += (right - left) * x;
		segTree[u].mi += x;
		segTree[u].last = 0;
		if ((u * 2) + 1 < segTree.size()) {
			segTree[u * 2].lazyAdd += x;
			segTree[(u * 2) + 1].lazyAdd += x;
			segTree[u * 2].last = 0;
			segTree[(u * 2) + 1].last = 0;
		}
		return;
	}
	add(u * 2, left, (left + right)/2, l, r, x);
	add((u * 2) + 1, (left + right)/2, right, l, r, x);
	segTree[u].join(segTree[u * 2], segTree[u * 2 + 1]);
}
void add(int l, int r, long long x) {
	if (x == 0) return;
	add(1, 0, realSize, l, r, x);
	last = 0;
}

int lower_bound(int u, int left, int right, int l, int r, long long x) {
	isLazy(u, left, right);
	if ((r <= left || l >= right) || segTree[u].mi > x) 
		return -1;

	if (right - left <= 1) 
		return left;

	int le = lower_bound(u * 2, left, (left + right) / 2, l, r, x);
	if (le != -1) return le;

	int ri = lower_bound((u * 2) + 1, (left + right) / 2, right, l, r, x);
	return ri;
}

int lower_bound(int l, int r, long long x) {
	return lower_bound(1, 0, realSize, l, r, x);
}