Submission #1673328
Source Code Expand
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.datastructure.segtree;
immutable INF = 10L^^12;
int main() {
static long[3][3] calcE() {
long[3][3] e;
foreach (i; 0..3) {
e[i][] = INF;
e[i][2-i] = 0L;
}
return e;
}
static long[3][3] merge(long[3][3] a, long[3][3] b) {
long[3][3] c;
foreach (i; 0..3) c[i][] = INF;
foreach (i; 0..3) {
foreach (j; 0..3) {
foreach (k; 0..3) {
if (j+k < 2) continue;
foreach (l; 0..3) {
c[i][l] = min(c[i][l], a[i][j] + b[k][l]);
}
}
}
}
return c;
}
static long[3][3] makeS(long x) {
long[3][3] e;
foreach (i; 0..3) {
foreach (j; 0..3) {
e[i][j] = max(i, j) * x;
}
}
return e;
}
alias S = SimpleSeg!(long[3][3], merge, calcE());
Scanner sc = new Scanner(stdin);
int n;
sc.read(n);
int[] s;
sc.read(s);
auto seg = S(n);
foreach (i; 0..n) {
seg[i] = makeS(s[i]);
// seg[i] = [0, s[i], s[i], s[i]];
}
int q;
sc.read(q);
foreach (ph; 0..q) {
int p, x;
sc.read(p, x); p--;
// s[p] = x;
// seg[p] = [0, x, x, x];
seg[p] = makeS(x);
auto u = seg[0..n].sum;
// writeln(u);
long ans = INF;
foreach (i; 0..3) {
foreach (j; 0..3) {
if (i+j < 2) continue;
ans = min(ans, u[i][j]);
}
}
writeln(ans);
// writeln(2 * min(u[1], u[2], u[3]));
}
return 0;
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/foundation.d */
// module dcomp.foundation;
static if (__VERSION__ <= 2070) {
/*
Copied by https://github.com/dlang/phobos/blob/master/std/algorithm/iteration.d
Copyright: Andrei Alexandrescu 2008-.
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
*/
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
import std.algorithm : reduce;
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
import std.typecons : tuple;
return reduce!fun(tuple(seed), r);
}
}
}
}
version (X86) static if (__VERSION__ < 2071) {
import core.bitop : bsf, bsr, popcnt;
int bsf(ulong v) {
foreach (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int bsr(ulong v) {
foreach_reverse (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int popcnt(ulong v) {
int c = 0;
foreach (i; 0..64) {
if (v & (1UL << i)) c++;
}
return c;
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/datastructure/segtree.d */
// module dcomp.datastructure.segtree;
import std.traits;
struct SegTree(alias E, Args...) {
import std.conv : to;
import std.traits : ReturnType;
alias Engine = E!Args;
alias T = Engine.DataType;
alias L = Engine.LazyType;
Engine eng;
this(uint n) {
eng = Engine(n);
}
this(T[] first) {
eng = Engine(first);
}
@property size_t length() const { return eng.length(); }
@property size_t opDollar() const { return eng.length(); }
struct Range {
Engine* eng;
size_t start, end;
@property T sum() {
return eng.sum(start.to!uint, end.to!uint);
}
}
const(T) opIndex(size_t k) {
assert(0 <= k && k < eng.length());
return eng.single(k.to!uint);
}
void opIndexAssign(T x, size_t k) {
assert(0 <= k && k < eng.length());
eng.singleSet(k.to!uint, x);
}
size_t[2] opSlice(size_t dim)(size_t start, size_t end) {
assert(0 <= start && start <= end && end <= eng.length());
return [start, end];
}
Range opIndex(size_t[2] rng) {
return Range(&eng, rng[0].to!uint, rng[1].to!uint);
}
static if (!is(L == void)) {
void opIndexOpAssign(string op : "+")(L x, size_t[2] rng) {
eng.add(rng[0].to!uint, rng[1].to!uint, x);
}
}
}
template LazySeg(T, L, alias opTT, alias opTL, alias opLL, T eT, L eL, alias Engine = LazySegEngine) {
import std.functional : binaryFun;
alias LazySeg = SegTree!(Engine, T, L,
binaryFun!opTT, binaryFun!opTL, binaryFun!opLL, eT, eL);
}
template SimpleSeg(T, alias opTT, T eT, alias Engine = SimpleSegEngine) {
import std.functional : binaryFun;
alias SimpleSeg = SegTree!(Engine, T, binaryFun!opTT, eT);
}
struct LazySegEngine(T, L, alias opTT, alias opTL, alias opLL, T eT, L eL) {
import std.typecons : Tuple;
alias DataType = T;
alias LazyType = L;
alias S = Tuple!(T, "d", L, "lz");
uint n, sz, lg;
S[] s;
this(uint n) {
import std.conv : to;
import std.algorithm : each;
this.n = n;
uint lg = 0;
while ((2^^lg) < n) lg++;
this.lg = lg;
sz = 2^^lg;
s = new S[](2*sz);
s.each!((ref x) => x = S(eT, eL));
}
this(T[] first) {
import std.conv : to;
import std.algorithm : each;
n = first.length.to!uint;
uint lg = 0;
while ((2^^lg) < n) lg++;
this.lg = lg;
sz = 2^^lg;
s = new S[](2*sz);
s.each!((ref x) => x = S(eT, eL));
foreach (i; 0..n) {
s[sz+i].d = first[i];
}
foreach_reverse (i; 1..sz) {
update(i);
}
}
@property size_t length() const { return n; }
pragma(inline):
private void lzAdd(uint k, in L x) {
s[k].lz = opLL(s[k].lz, x);
s[k].d = opTL(s[k].d, x);
}
private void push(uint k) {
if (s[k].lz == eL) return;
lzAdd(2*k, s[k].lz);
lzAdd(2*k+1, s[k].lz);
s[k].lz = eL;
}
private void update(uint k) {
s[k].d = opTT(s[2*k].d, s[2*k+1].d);
}
T single(uint k) {
k += sz;
foreach_reverse (uint i; 1..lg+1) {
push(k>>i);
}
return s[k].d;
}
void singleSet(uint k, T x) {
k += sz;
foreach_reverse (uint i; 1..lg+1) {
push(k>>i);
}
s[k].d = x;
foreach (uint i; 1..lg+1) {
update(k>>i);
}
}
T sum(uint a, uint b) {
assert(0 <= a && a <= b && b <= n);
if (a == b) return eT;
a += sz; b--; b += sz;
uint tlg = lg;
while (true) {
uint k = a >> tlg;
if (a >> tlg != b >> tlg) {
tlg++;
break;
}
if (((a-1) >> tlg) + 2 == (b+1) >> tlg) return s[k].d;
push(k);
tlg--;
}
T sm = eT;
foreach_reverse (l; 0..tlg) {
uint k = a >> l;
if ((a-1)>>l != a>>l) {
sm = opTT(s[k].d, sm);
break;
}
push(k);
if (!((a >> (l-1)) & 1)) sm = opTT(s[2*k+1].d, sm);
}
foreach_reverse (l; 0..tlg) {
uint k = b >> l;
if (b>>l != (b+1)>>l) {
sm = opTT(sm, s[k].d);
break;
}
push(k);
if ((b >> (l-1)) & 1) sm = opTT(sm, s[2*k].d);
}
return sm;
}
void add(uint a, uint b, L x) {
assert(0 <= a && a <= b && b <= n);
if (a == b) return;
a += sz; b--; b += sz;
uint tlg = lg;
while (true) {
uint k = a >> tlg;
if (a >> tlg != b >> tlg) {
tlg++;
break;
}
if (((a-1) >> tlg) + 2 == (b+1) >> tlg) {
lzAdd(k, x);
foreach (l; tlg+1..lg+1) {
update(a >> l);
}
return;
}
push(k);
tlg--;
}
foreach_reverse (l; 0..tlg) {
uint k = a >> l;
if ((a-1)>>l != a>>l) {
lzAdd(k, x);
foreach (h; l+1..tlg) {
update(a >> h);
}
break;
}
push(k);
if (!((a >> (l-1)) & 1)) lzAdd(2*k+1, x);
}
foreach_reverse (l; 0..tlg) {
uint k = b >> l;
if (b>>l != (b+1)>>l) {
lzAdd(k, x);
foreach (h; l+1..tlg) {
update(b >> h);
}
break;
}
push(k);
if ((b >> (l-1)) & 1) lzAdd(2*k, x);
}
foreach (l; tlg..lg+1) {
update(a >> l);
}
}
}
struct SimpleSegEngine(T, alias opTT, T eT) {
alias DataType = T;
alias LazyType = void;
import std.functional : binaryFun;
uint n, sz, lg;
T[] d;
@property size_t length() const {return n;}
this(uint n) {
import std.algorithm : each;
uint lg = 0;
while ((2^^lg) < n) lg++;
this.n = n;
this.lg = lg;
sz = 2^^lg;
d = new T[](2*sz);
d.each!((ref x) => x = eT);
}
this(T[] first) {
import std.conv : to;
import std.algorithm : each;
n = first.length.to!uint;
if (n == 0) return;
uint lg = 0;
while ((2^^lg) < n) lg++;
this.lg = lg;
sz = 2^^lg;
d = new T[](2*sz);
d.each!((ref x) => x = eT);
foreach (i; 0..n) {
d[sz+i] = first[i];
}
foreach_reverse (i; 1..sz) {
update(i);
}
}
pragma(inline):
private void push(uint k) {}
void update(uint k) {
d[k] = opTT(d[2*k], d[2*k+1]);
}
T single(uint k) {
return d[k+sz];
}
void singleSet(uint k, T x) {
k += sz;
d[k] = x;
foreach (uint i; 1..lg+1) {
update(k>>i);
}
}
T sum(uint a, uint b) {
assert(0 <= a && a <= b && b <= n);
T sml = eT, smr = eT;
a += sz; b += sz;
while (a < b) {
if (a & 1) sml = opTT(sml, d[a++]);
if (b & 1) smr = opTT(d[--b], smr);
a >>= 1; b >>= 1;
}
return opTT(sml, smr);
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/scanner.d */
// module dcomp.scanner;
// import dcomp.array;
class Scanner {
import std.stdio : File;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeChar, isStaticArray, isArray;
import std.algorithm : map;
File f;
this(File f) {
this.f = f;
}
char[512] lineBuf;
char[] line;
private bool succW() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (!line.empty && line.front.isWhite) {
line.popFront;
}
return !line.empty;
}
private bool succ() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (true) {
while (!line.empty && line.front.isWhite) {
line.popFront;
}
if (!line.empty) break;
line = lineBuf[];
f.readln(line);
if (!line.length) return false;
}
return true;
}
private bool readSingle(T)(ref T x) {
import std.algorithm : findSplitBefore;
import std.string : strip;
import std.conv : parse;
if (!succ()) return false;
static if (isArray!T) {
alias E = ElementType!T;
static if (isSomeChar!E) {
auto r = line.findSplitBefore(" ");
x = r[0].strip.dup;
line = r[1];
} else static if (isStaticArray!T) {
foreach (i; 0..T.length) {
bool f = succW();
assert(f);
x[i] = line.parse!E;
}
} else {
FastAppender!(E[]) buf;
while (succW()) {
buf ~= line.parse!E;
}
x = buf.data;
}
} else {
x = line.parse!T;
}
return true;
}
int read(T, Args...)(ref T x, auto ref Args args) {
if (!readSingle(x)) return 0;
static if (args.length == 0) {
return 1;
} else {
return 1 + read(args);
}
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/array.d */
// module dcomp.array;
T[N] fixed(T, size_t N)(T[N] a) {return a;}
struct FastAppender(A, size_t MIN = 4) {
import std.algorithm : max;
import std.conv;
import std.range.primitives : ElementEncodingType;
import core.stdc.string : memcpy;
private alias T = ElementEncodingType!A;
private T* _data;
private uint len, cap;
@property size_t length() const {return len;}
bool empty() const { return len == 0; }
void reserve(size_t nlen) {
import core.memory : GC;
if (nlen <= cap) return;
void* nx = GC.malloc(nlen * T.sizeof);
cap = nlen.to!uint;
if (len) memcpy(nx, _data, len * T.sizeof);
_data = cast(T*)(nx);
}
void free() {
import core.memory : GC;
GC.free(_data);
}
void opOpAssign(string op : "~")(T item) {
if (len == cap) {
reserve(max(MIN, cap*2));
}
_data[len++] = item;
}
void insertBack(T item) {
this ~= item;
}
void removeBack() {
len--;
}
void clear() {
len = 0;
}
ref inout(T) back() inout { assert(len); return _data[len-1]; }
ref inout(T) opIndex(size_t i) inout { return _data[i]; }
T[] data() {
return (_data) ? _data[0..len] : null;
}
}
/*
This source code generated by dcomp and include dcomp's source code.
dcomp's Copyright: Copyright (c) 2016- Kohei Morita. (https://github.com/yosupo06/dcomp)
dcomp's License: MIT License(https://github.com/yosupo06/dcomp/blob/master/LICENSE.txt)
*/
Submission Info
Submission Time |
|
Task |
J - N個のバケツ |
User |
yosupo |
Language |
D (LDC 0.17.0) |
Score |
101 |
Code Size |
15220 Byte |
Status |
AC |
Exec Time |
302 ms |
Memory |
24628 KB |
Judge Result
Set Name |
Sample |
All |
Additional |
Score / Max Score |
0 / 0 |
100 / 100 |
1 / 1 |
Status |
|
|
|
Set Name |
Test Cases |
Sample |
sample-01.txt, sample-02.txt |
All |
sample-01.txt, sample-02.txt, 01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 01-09.txt, 01-10.txt, 01-11.txt, 01-12.txt, 01-13.txt, 01-14.txt, 01-15.txt, 01-16.txt, 01-17.txt, 01-18.txt, 01-19.txt, 01-20.txt, 01-21.txt, 01-22.txt, 01-23.txt, 01-24.txt, 01-25.txt |
Additional |
sample-01.txt, sample-02.txt, 01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 01-09.txt, 01-10.txt, 01-11.txt, 01-12.txt, 01-13.txt, 01-14.txt, 01-15.txt, 01-16.txt, 01-17.txt, 01-18.txt, 01-19.txt, 01-20.txt, 01-21.txt, 01-22.txt, 01-23.txt, 01-24.txt, 01-25.txt, 02-01.txt, 02-02.txt, 02-03.txt, 02-04.txt, 02-05.txt, 02-06.txt, 02-07.txt, 02-08.txt, 02-09.txt, 02-10.txt, 02-11.txt, 02-12.txt, 02-13.txt, 02-14.txt, 02-15.txt, 02-16.txt, sample-01.txt, sample-02.txt |
Case Name |
Status |
Exec Time |
Memory |
01-01.txt |
AC |
45 ms |
764 KB |
01-02.txt |
AC |
58 ms |
892 KB |
01-03.txt |
AC |
115 ms |
1276 KB |
01-04.txt |
AC |
284 ms |
23708 KB |
01-05.txt |
AC |
288 ms |
21660 KB |
01-06.txt |
AC |
294 ms |
23964 KB |
01-07.txt |
AC |
24 ms |
5628 KB |
01-08.txt |
AC |
291 ms |
24080 KB |
01-09.txt |
AC |
268 ms |
23988 KB |
01-10.txt |
AC |
277 ms |
20732 KB |
01-11.txt |
AC |
277 ms |
21116 KB |
01-12.txt |
AC |
276 ms |
22652 KB |
01-13.txt |
AC |
266 ms |
23728 KB |
01-14.txt |
AC |
277 ms |
22064 KB |
01-15.txt |
AC |
279 ms |
21904 KB |
01-16.txt |
AC |
284 ms |
23056 KB |
01-17.txt |
AC |
301 ms |
24464 KB |
01-18.txt |
AC |
295 ms |
24628 KB |
01-19.txt |
AC |
296 ms |
23092 KB |
01-20.txt |
AC |
291 ms |
24368 KB |
01-21.txt |
AC |
281 ms |
21116 KB |
01-22.txt |
AC |
42 ms |
508 KB |
01-23.txt |
AC |
45 ms |
892 KB |
01-24.txt |
AC |
49 ms |
508 KB |
01-25.txt |
AC |
48 ms |
508 KB |
02-01.txt |
AC |
44 ms |
508 KB |
02-02.txt |
AC |
47 ms |
764 KB |
02-03.txt |
AC |
52 ms |
508 KB |
02-04.txt |
AC |
53 ms |
892 KB |
02-05.txt |
AC |
57 ms |
892 KB |
02-06.txt |
AC |
55 ms |
508 KB |
02-07.txt |
AC |
66 ms |
608 KB |
02-08.txt |
AC |
81 ms |
636 KB |
02-09.txt |
AC |
136 ms |
1148 KB |
02-10.txt |
AC |
302 ms |
24476 KB |
02-11.txt |
AC |
299 ms |
23452 KB |
02-12.txt |
AC |
299 ms |
23312 KB |
02-13.txt |
AC |
292 ms |
20988 KB |
02-14.txt |
AC |
299 ms |
23988 KB |
02-15.txt |
AC |
302 ms |
22960 KB |
02-16.txt |
AC |
297 ms |
23804 KB |
sample-01.txt |
AC |
1 ms |
256 KB |
sample-02.txt |
AC |
1 ms |
256 KB |