oj.uz

Submission #959645

# Submission time Handle Problem Language Result Execution time Memory
959645 2024-04-08T14:57:21 Z vjudge1 Wall (IOI14_wall) C++17
61 / 100
 675 ms 262144 KB 
#include "wall.h"
#include <bits/stdc++.h>
using namespace std;

using ll = long long;

const int MAXN = 2e6+6;  // 1-based

int N;

struct Node {
	ll sum;   // Sum tag
	ll max1;  // Max value
	ll max2;  // Second Max value
	ll maxc;  // Max value count
	ll min1;  // Min value
	ll min2;  // Second Min value
	ll minc;  // Min value count
	ll lazy;  // Lazy tag
} T[MAXN*4];

void merge(int t) {
	// sum
	T[t].sum = T[t << 1].sum + T[t << 1 | 1].sum;

	// max
	if (T[t << 1].max1 == T[t << 1 | 1].max1) {
		T[t].max1 = T[t << 1].max1;
		T[t].max2 = max(T[t << 1].max2, T[t << 1 | 1].max2);
		T[t].maxc = T[t << 1].maxc + T[t << 1 | 1].maxc;
	} else {
		if (T[t << 1].max1 > T[t << 1 | 1].max1) {
			T[t].max1 = T[t << 1].max1;
			T[t].max2 = max(T[t << 1].max2, T[t << 1 | 1].max1);
			T[t].maxc = T[t << 1].maxc;
		} else {
			T[t].max1 = T[t << 1 | 1].max1;
			T[t].max2 = max(T[t << 1].max1, T[t << 1 | 1].max2);
			T[t].maxc = T[t << 1 | 1].maxc;
		}
	}

	// min
	if (T[t << 1].min1 == T[t << 1 | 1].min1) {
		T[t].min1 = T[t << 1].min1;
		T[t].min2 = min(T[t << 1].min2, T[t << 1 | 1].min2);
		T[t].minc = T[t << 1].minc + T[t << 1 | 1].minc;
	} else {
		if (T[t << 1].min1 < T[t << 1 | 1].min1) {
			T[t].min1 = T[t << 1].min1;
			T[t].min2 = min(T[t << 1].min2, T[t << 1 | 1].min1);
			T[t].minc = T[t << 1].minc;
		} else {
			T[t].min1 = T[t << 1 | 1].min1;
			T[t].min2 = min(T[t << 1].min1, T[t << 1 | 1].min2);
			T[t].minc = T[t << 1 | 1].minc;
		}
	}
}

void push_add(int t, int tl, int tr, ll v) {
	if (v == 0) { return; }
	T[t].sum += (tr - tl + 1) * v;
	T[t].max1 += v;
	if (T[t].max2 != -LLONG_MAX) { T[t].max2 += v; }
	T[t].min1 += v;
	if (T[t].min2 != LLONG_MAX) { T[t].min2 += v; }
	T[t].lazy += v;
}

// corresponds to a chmin update
void push_max(int t, ll v, bool l) {
	if (v >= T[t].max1) { return; }
	T[t].sum -= T[t].max1 * T[t].maxc;
	T[t].max1 = v;
	T[t].sum += T[t].max1 * T[t].maxc;
	if (l) {
		T[t].min1 = T[t].max1;
	} else {
		if (v <= T[t].min1) {
			T[t].min1 = v;
		} else if (v < T[t].min2) {
			T[t].min2 = v;
		}
	}
}

// corresponds to a chmax update
void push_min(int t, ll v, bool l) {
	if (v <= T[t].min1) { return; }
	T[t].sum -= T[t].min1 * T[t].minc;
	T[t].min1 = v;
	T[t].sum += T[t].min1 * T[t].minc;
	if (l) {
		T[t].max1 = T[t].min1;
	} else {
		if (v >= T[t].max1) {
			T[t].max1 = v;
		} else if (v > T[t].max2) {
			T[t].max2 = v;
		}
	}
}

void pushdown(int t, int tl, int tr) {
	if (tl == tr) return;
	// sum
	int tm = (tl + tr) >> 1;
	push_add(t << 1, tl, tm, T[t].lazy);
	push_add(t << 1 | 1, tm + 1, tr, T[t].lazy);
	T[t].lazy = 0;

	// max
	push_max(t << 1, T[t].max1, tl == tm);
	push_max(t << 1 | 1, T[t].max1, tm + 1 == tr);

	// min
	push_min(t << 1, T[t].min1, tl == tm);
	push_min(t << 1 | 1, T[t].min1, tm + 1 == tr);
}

void build(int t = 1, int tl = 0, int tr = N - 1) {
	T[t].lazy = 0;
	if (tl == tr) {
		T[t].sum = T[t].max1 = T[t].min1 = 0;
		T[t].maxc = T[t].minc = 1;
		T[t].max2 = -LLONG_MAX;
		T[t].min2 = LLONG_MAX;
		return;
	}

	int tm = (tl + tr) >> 1;
	build(t << 1, tl, tm);
	build(t << 1 | 1, tm + 1, tr);
	merge(t);
}

void update_add(int l, int r, ll v, int t = 1, int tl = 0, int tr = N - 1) {
	if (r < tl || tr < l) { return; }
	if (l <= tl && tr <= r) {
		push_add(t, tl, tr, v);
		return;
	}
	pushdown(t, tl, tr);

	int tm = (tl + tr) >> 1;
	update_add(l, r, v, t << 1, tl, tm);
	update_add(l, r, v, t << 1 | 1, tm + 1, tr);
	merge(t);
}

void update_chmin(int l, int r, ll v, int t = 1, int tl = 0, int tr = N - 1) {
	if (r < tl || tr < l || v >= T[t].max1) { return; }
	if (l <= tl && tr <= r && v > T[t].max2) {
		push_max(t, v, tl == tr);
		return;
	}
	pushdown(t, tl, tr);

	int tm = (tl + tr) >> 1;
	update_chmin(l, r, v, t << 1, tl, tm);
	update_chmin(l, r, v, t << 1 | 1, tm + 1, tr);
	merge(t);
}

void update_chmax(int l, int r, ll v, int t = 1, int tl = 0, int tr = N - 1) {
	if (r < tl || tr < l || v <= T[t].min1) { return; }
	if (l <= tl && tr <= r && v < T[t].min2) {
		push_min(t, v, tl == tr);
		return;
	}
	pushdown(t, tl, tr);

	int tm = (tl + tr) >> 1;
	update_chmax(l, r, v, t << 1, tl, tm);
	update_chmax(l, r, v, t << 1 | 1, tm + 1, tr);
	merge(t);
}

ll query_sum(int l, int r, int t = 1, int tl = 0, int tr = N - 1) {
	if (r < tl || tr < l) { return 0; }
	if (l <= tl && tr <= r) { return T[t].sum; }
	pushdown(t, tl, tr);

	int tm = (tl + tr) >> 1;
	return query_sum(l, r, t << 1, tl, tm) +
	       query_sum(l, r, t << 1 | 1, tm + 1, tr);
}

void buildWall(int NN, int k, int op[], int left[], int right[], int height[], int finalHeight[]){
  N = NN;

  build();
  for (int i = 0; i < k; i++) {
    if (op[i] == 1) update_chmax(left[i], right[i], height[i]);
    else update_chmin(left[i], right[i], height[i]);
  }

  for (int i = 0; i < N; i++) {
    finalHeight[i] = query_sum(i, i);
  }
}

Subtask #1
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 348 KB Output is correct
2 Correct 2 ms 348 KB Output is correct
3 Correct 2 ms 444 KB Output is correct
4 Correct 9 ms 2652 KB Output is correct
5 Correct 7 ms 2648 KB Output is correct
6 Correct 7 ms 2652 KB Output is correct

Subtask #2
24.0 / 24.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 114 ms 8172 KB Output is correct
3 Correct 65 ms 7764 KB Output is correct
4 Correct 164 ms 25204 KB Output is correct
5 Correct 185 ms 25684 KB Output is correct
6 Correct 216 ms 25540 KB Output is correct

Subtask #3
29.0 / 29.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 348 KB Output is correct
2 Correct 1 ms 348 KB Output is correct
3 Correct 2 ms 348 KB Output is correct
4 Correct 8 ms 2652 KB Output is correct
5 Correct 7 ms 2608 KB Output is correct
6 Correct 8 ms 2652 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 124 ms 8252 KB Output is correct
9 Correct 60 ms 7688 KB Output is correct
10 Correct 175 ms 25068 KB Output is correct
11 Correct 185 ms 25652 KB Output is correct
12 Correct 243 ms 30324 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 116 ms 11604 KB Output is correct
15 Correct 38 ms 5540 KB Output is correct
16 Correct 651 ms 30868 KB Output is correct
17 Correct 355 ms 30372 KB Output is correct
18 Correct 374 ms 30552 KB Output is correct

Subtask #4
0 / 39.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 2 ms 584 KB Output is correct
3 Correct 2 ms 348 KB Output is correct
4 Correct 10 ms 2652 KB Output is correct
5 Correct 9 ms 2652 KB Output is correct
6 Correct 9 ms 2652 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 110 ms 11488 KB Output is correct
9 Correct 62 ms 10136 KB Output is correct
10 Correct 170 ms 30644 KB Output is correct
11 Correct 190 ms 31056 KB Output is correct
12 Correct 227 ms 30296 KB Output is correct
13 Correct 1 ms 348 KB Output is correct
14 Correct 113 ms 11364 KB Output is correct
15 Correct 37 ms 5468 KB Output is correct
16 Correct 675 ms 30836 KB Output is correct
17 Correct 360 ms 30476 KB Output is correct
18 Correct 352 ms 30324 KB Output is correct
19 Runtime error 288 ms 262144 KB Execution killed with signal 9
20 Halted 0 ms 0 KB -