oj.uz

Submission #1005224

# Submission time Handle Problem Language Result Execution time Memory
1005224 2024-06-22T09:06:38 Z coolboy19521 Horses (IOI15_horses) C++17
17 / 100
 1500 ms 225364 KB 
#include"bits/stdc++.h"
#include"horses.h"
#define ld long double
#define i64 __int128

using namespace std;

const i64 sz = 1e6 + 25;
const i64 md = 1e9 + 7;

i64 lz1m[sz * 4], lz1d[sz * 4];
i64 st1[sz * 4];
ld lz2m[sz * 4], lz2d[sz * 4];
pair<ld,i64> st2[sz * 4];
ld d[sz];
i64 a[sz], b[sz], c[sz];
i64 n;

i64 bp(i64 x, i64 b) {
	if (0 == b) return 1;
	i64 r = bp(x, b / 2) % md;
	if (b % 2) return (r * r % md) * x % md;
	return r * r % md;
}

void build1(i64 le, i64 ri, i64 v) {
	lz1m[v] = 1;
	lz1d[v] = 1;
	if (le == ri) {
		st1[v] = c[le] * b[le] % md;
		return;
	}
	i64 mi = le + (ri - le) / 2;
	build1(le, mi, v * 2);
	build1(mi + 1, ri, v * 2 + 1);
}

void relax1(i64 v) {
	(st1[v] *= lz1m[v]) %= md;
	(st1[v] *= bp(lz1d[v], md - 2)) %= md;
	if (v * 2 < sz * 4) {
		lz1m[v * 2] *= lz1m[v];
		lz1m[v * 2 + 1] *= lz1m[v];
		lz1d[v * 2] *= lz1d[v];
		lz1d[v * 2 + 1] *= lz1d[v];
	}
	lz1m[v] = 1;
	lz1d[v] = 1;
}

void rupdate1(i64 le, i64 ri, i64 ql, i64 qr, i64 v, i64 m, i64 d) {
	if (le > qr || ri < ql) return;
	if (ql <= le && ri <= qr) {
		lz1m[v] *= m;
		lz1d[v] *= d;
		relax1(v);
		return;
	}
	i64 mi = le + (ri - le) / 2;
	rupdate1(le, mi, ql, qr, v * 2, m, d);
	rupdate1(mi + 1, ri, ql, qr, v * 2 + 1, m, d);
}

void pupdate1(i64 le, i64 ri, i64 ix, i64 v, i64 m, i64 d) {
	if (le > ix || ri < ix) return;
	if (le == ix && ix == ri) {
		(st1[v] *= m) %= md;
		(st1[v] *= bp(d, md - 2)) %= md;
		return;
	}
	i64 mi = le + (ri - le) / 2;
	pupdate1(le, mi, ix, v * 2, m, d);
	pupdate1(mi + 1, ri, ix, v * 2 + 1, m, d);
}

i64 query1(i64 le, i64 ri, i64 ix, i64 v) {
	if (1 <= lz1m[v] || 1 <= lz1d[v]) {
		relax1(v);
	}
	if (le > ix || ri < ix) return 0;
	if (le == ix && ix == ri) {
		return st1[v] % md;
	}
	i64 mi = le + (ri - le) / 2;
	i64 lq = query1(le, mi, ix, v * 2);
	i64 rq = query1(mi + 1, ri, ix, v * 2 + 1);
	return lq + rq;
}

pair<ld,i64> marj(i64 v) {
	auto le = st2[v * 2];
	auto ri = st2[v * 2 + 1];
	if (le.first > ri.first) {
		return le;
	}
	return ri;
}

void build2(i64 le, i64 ri, i64 v) {
	if (le == ri) {
		st2[v] = make_pair(d[le] + log10l(b[le]), le);
		return;
	}
	i64 mi = le + (ri - le) / 2;
	build2(le, mi, v * 2);
	build2(mi + 1, ri, v * 2 + 1);
	st2[v] = marj(v);
}

void relax2(i64 v) {
	st2[v].first += lz2m[v];
	st2[v].first -= lz2d[v];
	if (v * 2 < sz * 4) {
		lz2m[v * 2] += lz2m[v];
		lz2m[v * 2 + 1] += lz2m[v];
		lz2d[v * 2] += lz2d[v];
		lz2d[v * 2 + 1] += lz2d[v];
	}
	lz2m[v] = 0;
	lz2d[v] = 0;
}

void rupdate2(i64 le, i64 ri, i64 ql, i64 qr, i64 v, ld m, ld d) {
	relax2(v);
	if (le > qr || ri < ql) return;
	if (ql <= le && ri <= qr) {
		lz2m[v] += m;
		lz2d[v] += d;
		relax2(v);
		return;
	}
	i64 mi = le + (ri - le) / 2;
	rupdate2(le, mi, ql, qr, v * 2, m, d);
	rupdate2(mi + 1, ri, ql, qr, v * 2 + 1, m, d);
	st2[v] = marj(v);
}

void pupdate2(i64 le, i64 ri, i64 ix, i64 v, ld m, ld d) {
	relax2(v);
	if (le > ix || ri < ix) return;
	if (le == ix && ri == ix) {
		st2[v].first += m;
		st2[v].first -= d;
		return;
	}
	i64 mi = le + (ri - le) / 2;
	pupdate2(le, mi, ix, v * 2, m, d);
	pupdate2(mi + 1, ri, ix, v * 2 + 1, m, d);
	st2[v] = marj(v);
}

int init(int N, int x[], int y[]) {
	n = N;
	c[0] = 1;

	for (i64 i = 1; i <= n; i ++) {
		a[i] = x[i - 1];
		b[i] = y[i - 1];
		c[i] = c[i - 1] * a[i] % md;
		d[i] = d[i - 1] + log10l(a[i]);
	}

	build1(1, n, 1);
	build2(1, n, 1);

	i64 ix = st2[1].second;

	return query1(1, n, ix, 1);
}

int updateX(int pos, int val) {
	pos ++;
	rupdate1(1, n, pos, n, 1, val, a[pos]);
	rupdate2(1, n, pos, n, 1, log10l(val), log10l(a[pos]));
	a[pos] = val;
	relax2(1);
	i64 ix = st2[1].second;

	return query1(1, n, ix, 1);
}

int updateY(int pos, int val) {
	pos ++;
	pupdate1(1, n, pos, 1, val, b[pos]);
	pupdate2(1, n, pos, 1, log10l(val), log10l(b[pos]));
	b[pos] = val;
	relax2(1);
	i64 ix = st2[1].second;

	return query1(1, n, ix, 1);
}

Compilation message

horses.cpp: In function '__int128 bp(__int128, __int128)':
horses.cpp:19:19: warning: declaration of 'b' shadows a global declaration [-Wshadow]
   19 | i64 bp(i64 x, i64 b) {
      |                   ^
horses.cpp:16:12: note: shadowed declaration is here
   16 | i64 a[sz], b[sz], c[sz];
      |            ^
horses.cpp: In function 'void rupdate1(__int128, __int128, __int128, __int128, __int128, __int128, __int128)':
horses.cpp:51:65: warning: declaration of 'd' shadows a global declaration [-Wshadow]
   51 | void rupdate1(i64 le, i64 ri, i64 ql, i64 qr, i64 v, i64 m, i64 d) {
      |                                                                 ^
horses.cpp:15:4: note: shadowed declaration is here
   15 | ld d[sz];
      |    ^
horses.cpp: In function 'void pupdate1(__int128, __int128, __int128, __int128, __int128, __int128)':
horses.cpp:64:57: warning: declaration of 'd' shadows a global declaration [-Wshadow]
   64 | void pupdate1(i64 le, i64 ri, i64 ix, i64 v, i64 m, i64 d) {
      |                                                         ^
horses.cpp:15:4: note: shadowed declaration is here
   15 | ld d[sz];
      |    ^
horses.cpp: In function 'void build2(__int128, __int128, __int128)':
horses.cpp:101:41: warning: conversion from '__int128' to 'long double' may change value [-Wconversion]
  101 |   st2[v] = make_pair(d[le] + log10l(b[le]), le);
      |                                     ~~~~^
horses.cpp: In function 'void rupdate2(__int128, __int128, __int128, __int128, __int128, long double, long double)':
horses.cpp:123:63: warning: declaration of 'd' shadows a global declaration [-Wshadow]
  123 | void rupdate2(i64 le, i64 ri, i64 ql, i64 qr, i64 v, ld m, ld d) {
      |                                                               ^
horses.cpp:15:4: note: shadowed declaration is here
   15 | ld d[sz];
      |    ^
horses.cpp: In function 'void pupdate2(__int128, __int128, __int128, __int128, long double, long double)':
horses.cpp:138:55: warning: declaration of 'd' shadows a global declaration [-Wshadow]
  138 | void pupdate2(i64 le, i64 ri, i64 ix, i64 v, ld m, ld d) {
      |                                                       ^
horses.cpp:15:4: note: shadowed declaration is here
   15 | ld d[sz];
      |    ^
horses.cpp: In function 'int init(int, int*, int*)':
horses.cpp:160:31: warning: conversion from '__int128' to 'long double' may change value [-Wconversion]
  160 |   d[i] = d[i - 1] + log10l(a[i]);
      |                            ~~~^
horses.cpp:168:15: warning: conversion from '__int128' to 'int' may change value [-Wconversion]
  168 |  return query1(1, n, ix, 1);
      |         ~~~~~~^~~~~~~~~~~~~
horses.cpp: In function 'int updateX(int, int)':
horses.cpp:174:53: warning: conversion from '__int128' to 'long double' may change value [-Wconversion]
  174 |  rupdate2(1, n, pos, n, 1, log10l(val), log10l(a[pos]));
      |                                                ~~~~~^
horses.cpp:179:15: warning: conversion from '__int128' to 'int' may change value [-Wconversion]
  179 |  return query1(1, n, ix, 1);
      |         ~~~~~~^~~~~~~~~~~~~
horses.cpp: In function 'int updateY(int, int)':
horses.cpp:185:50: warning: conversion from '__int128' to 'long double' may change value [-Wconversion]
  185 |  pupdate2(1, n, pos, 1, log10l(val), log10l(b[pos]));
      |                                             ~~~~~^
horses.cpp:190:15: warning: conversion from '__int128' to 'int' may change value [-Wconversion]
  190 |  return query1(1, n, ix, 1);
      |         ~~~~~~^~~~~~~~~~~~~

Subtask #1
17.0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 12636 KB Output is correct
2 Correct 1 ms 12636 KB Output is correct
3 Correct 1 ms 12636 KB Output is correct
4 Correct 1 ms 12636 KB Output is correct
5 Correct 1 ms 12636 KB Output is correct
6 Correct 1 ms 12636 KB Output is correct
7 Correct 1 ms 12636 KB Output is correct
8 Correct 1 ms 12636 KB Output is correct
9 Correct 1 ms 12636 KB Output is correct
10 Correct 1 ms 12636 KB Output is correct
11 Correct 2 ms 12636 KB Output is correct
12 Correct 1 ms 12636 KB Output is correct
13 Correct 1 ms 12636 KB Output is correct
14 Correct 1 ms 12636 KB Output is correct
15 Correct 1 ms 12636 KB Output is correct
16 Correct 1 ms 12636 KB Output is correct
17 Correct 2 ms 12636 KB Output is correct
18 Correct 1 ms 12636 KB Output is correct
19 Correct 1 ms 12636 KB Output is correct
20 Correct 1 ms 12636 KB Output is correct

Subtask #2
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 12636 KB Output is correct
2 Correct 1 ms 12636 KB Output is correct
3 Correct 1 ms 12636 KB Output is correct
4 Correct 1 ms 12632 KB Output is correct
5 Correct 1 ms 12632 KB Output is correct
6 Correct 1 ms 12636 KB Output is correct
7 Correct 1 ms 12636 KB Output is correct
8 Correct 1 ms 12636 KB Output is correct
9 Correct 1 ms 12636 KB Output is correct
10 Correct 1 ms 12636 KB Output is correct
11 Correct 1 ms 12636 KB Output is correct
12 Correct 1 ms 12636 KB Output is correct
13 Correct 1 ms 12636 KB Output is correct
14 Correct 1 ms 12636 KB Output is correct
15 Correct 1 ms 12636 KB Output is correct
16 Correct 1 ms 12636 KB Output is correct
17 Correct 1 ms 12636 KB Output is correct
18 Correct 1 ms 12636 KB Output is correct
19 Correct 1 ms 12636 KB Output is correct
20 Correct 1 ms 12636 KB Output is correct
21 Correct 1 ms 12636 KB Output is correct
22 Correct 1 ms 12636 KB Output is correct
23 Incorrect 10 ms 12960 KB Output isn't correct
24 Halted 0 ms 0 KB -

Subtask #3
0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 1402 ms 127060 KB Output is correct
2 Execution timed out 1547 ms 225364 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #4
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 12632 KB Output is correct
2 Correct 1 ms 12636 KB Output is correct
3 Correct 1 ms 12636 KB Output is correct
4 Correct 1 ms 12636 KB Output is correct
5 Correct 1 ms 12636 KB Output is correct
6 Correct 1 ms 12636 KB Output is correct
7 Correct 2 ms 12632 KB Output is correct
8 Correct 1 ms 12636 KB Output is correct
9 Correct 1 ms 12636 KB Output is correct
10 Correct 2 ms 12636 KB Output is correct
11 Correct 1 ms 12636 KB Output is correct
12 Correct 1 ms 12632 KB Output is correct
13 Correct 1 ms 12632 KB Output is correct
14 Correct 2 ms 12636 KB Output is correct
15 Correct 1 ms 12636 KB Output is correct
16 Correct 1 ms 12636 KB Output is correct
17 Correct 1 ms 12632 KB Output is correct
18 Correct 1 ms 12636 KB Output is correct
19 Correct 1 ms 12636 KB Output is correct
20 Correct 1 ms 12636 KB Output is correct
21 Correct 1 ms 12660 KB Output is correct
22 Correct 1 ms 12636 KB Output is correct
23 Incorrect 9 ms 12892 KB Output isn't correct
24 Halted 0 ms 0 KB -

Subtask #5
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 12632 KB Output is correct
2 Correct 1 ms 12636 KB Output is correct
3 Correct 1 ms 12636 KB Output is correct
4 Correct 1 ms 12636 KB Output is correct
5 Correct 2 ms 12632 KB Output is correct
6 Correct 2 ms 12636 KB Output is correct
7 Correct 2 ms 12636 KB Output is correct
8 Correct 1 ms 12636 KB Output is correct
9 Correct 2 ms 12636 KB Output is correct
10 Correct 1 ms 12636 KB Output is correct
11 Correct 1 ms 12636 KB Output is correct
12 Correct 1 ms 12636 KB Output is correct
13 Correct 1 ms 12636 KB Output is correct
14 Correct 1 ms 12764 KB Output is correct
15 Correct 1 ms 12740 KB Output is correct
16 Correct 1 ms 12636 KB Output is correct
17 Correct 1 ms 12636 KB Output is correct
18 Correct 1 ms 12636 KB Output is correct
19 Correct 1 ms 12636 KB Output is correct
20 Correct 2 ms 12632 KB Output is correct
21 Correct 1 ms 12636 KB Output is correct
22 Correct 1 ms 12636 KB Output is correct
23 Incorrect 9 ms 12892 KB Output isn't correct
24 Halted 0 ms 0 KB -