线段树模板

const int maxn = 1e5 + 7;
class segment {
public:
	typedef long long int ll;
	const int mod = 1;
	segment() {
		memset(m_data, 0, sizeof(m_data));
		memset(m_lazy, 0, sizeof(m_lazy));
	}
	void build(int l, int r, int *arr, int idx) {
		if (l == r) {
			m_data[idx] = arr[l] % mod;
			return;
		}
		int mid = (l + r) >> 1;
		int lson = idx * 2, rson = lson + 1;
		build(l, mid, arr, lson);
		build(mid + 1, r, arr, rson);
		push_up(idx);
	}
	void push_up(int idx) {
		m_data[idx] = m_data[idx << 1] + m_data[idx << 1 | 1];
	}
	void push_down(int l, int r, int idx) {
		if (!m_lazy[idx])return;
		ll lson = idx * 2, rson = lson + 1, val = m_lazy[idx];
		int mid = (l + r) >> 1, lcnt = mid - l + 1, rcnt = r - mid;
		m_lazy[lson] = (m_lazy[lson] + val) % mod;
		m_lazy[rson] = (m_lazy[rson] + val) % mod;
		m_data[lson] = (m_data[lson] + val * lcnt) % mod;
		m_data[rson] = (m_data[rson] + val * rcnt) % mod;
		m_lazy[idx] = 0;
	}

	void _modify(int l, int r, int idx, int cl, int cr, int val) {
		if (l > cr || r < cl) return;
		if (l >= cl && r <= cr) {
			m_data[idx] = (m_data[idx] + val * (r - l + 1)) % mod;
			m_lazy[idx] = (m_lazy[idx] + val) % mod;
			return;
		}
		push_down(l, r, idx);
		int mid = (l + r) >> 1, lson = idx * 2, rson = lson + 1;

		if (mid >= cl) _modify(l, mid, lson, cl, cr, val);
		if (mid < cr) _modify(mid + 1, r, rson, cl, cr, val);
		push_up(idx);
	}
	void modify(int l, int r, int val) {
		_modify(1, cnt, 1, l, r, val);
	}

	ll _query(int l, int r, int idx, int ql, int qr) {
		if (l > qr || r < ql) return 0;
		if (l >= ql && r <= qr) {
			return m_data[idx];
		}
		push_down(l, r, idx);
		int mid = (l + r) >> 1, lson = idx * 2, rson = lson + 1;
		ll ans = 0;

		if (mid >= ql) ans = (ans + _query(l, mid, lson, ql, qr)) % mod;
		if (mid < qr) ans = (ans + _query(mid + 1, r, rson, ql, qr)) % mod;
		return ans;
	}
	ll query(int l, int r) {
		return _query(1, cnt, 1, l, r);
	}
public:
	ll m_data[maxn << 2];
	ll m_lazy[maxn << 2];
	int cnt;
};
segment tree;

class segment {
public:
	typedef long long int ll;
	const int mod = 1;
	segment() {}
    void init(int c){
        cnt = c;
        m_data.assign(cnt << 2,vector<long long>(4,0));
    }
	void build(int l, int r, vector<int> &arr, int idx) {
		if (l == r) {
			m_data[idx][3] = max(0,arr[l]);
			return;
		}
		int mid = (l + r) >> 1;
		int lson = idx * 2, rson = lson + 1;
		build(l, mid, arr, lson);
		build(mid + 1, r, arr, rson);
		push_up(idx);
	}
	void push_up(int idx) {
        vector<long long> &a = m_data[idx << 1],&b = m_data[idx << 1 | 1];
        m_data[idx] = {
            max(a[0] + b[2], a[1] + b[0]),
            max(a[0] + b[3], a[1] + b[1]),
            max(a[2] + b[2], a[3] + b[0]),
            max(a[2] + b[3], a[3] + b[1]),
        };
	}
	void push_down(int l, int r, int idx) {

	}

	void _modify(int l, int r, int idx, int cl, int cr, int val) {
		if (l == r) {
			m_data[idx][3] = max(val,0);
			return;
		}
		push_down(l, r, idx);
		int mid = (l + r) >> 1, lson = idx * 2, rson = lson + 1;

		if (mid >= cl) _modify(l, mid, lson, cl, cr, val);
		if (mid < cr) _modify(mid + 1, r, rson, cl, cr, val);
		push_up(idx);
	}
	void modify(int l, int r, int val) {
		_modify(0, cnt - 1, 1, l, r, val);
	}
public:
	vector<vector<long long >> m_data;
	int cnt;
};
segment tree;