diff --git a/solutions/platinum/baltic-15-editor.mdx b/solutions/platinum/baltic-15-editor.mdx index ce1abefc1e..9729d100a5 100644 --- a/solutions/platinum/baltic-15-editor.mdx +++ b/solutions/platinum/baltic-15-editor.mdx @@ -7,7 +7,7 @@ author: Benjamin Qi [Official Analysis](https://boi.cses.fi/files/boi2015_solutions.zip) -**Time Complexity:** $\mathcal O(N \log N)$. +## Explanation Let `lev[x]=max(0,-a[x])`. @@ -38,292 +38,101 @@ So the solution is to maintain the active path for every `i`. If there exists an operation with level 0 on the active path for `i`, then its state is the answer for `i`; otherwise, the answer for `i` is 0. -```cpp -#include -using namespace std; - -using ll = long long; -using ld = long double; -using db = double; -using str = string; // yay python! - -using pi = pair; -using pl = pair; -using pd = pair; - -using vi = vector; -using vb = vector; -using vl = vector; -using vd = vector; -using vs = vector; -using vpi = vector; -using vpl = vector; -using vpd = vector; - -#define tcT template using V = vector; -tcT, size_t SZ > using AR = array; -tcT > using PR = pair; - -// pairs -#define mp make_pair -#define f first -#define s second - -// vectors -// oops size(x), rbegin(x), rend(x) need C++17 -#define sz(x) int((x).size()) -#define bg(x) begin(x) -#define all(x) bg(x), end(x) -#define rall(x) x.rbegin(), x.rend() -#define sor(x) sort(all(x)) -#define rsz resize -#define ins insert -#define ft front() -#define bk back() -#define pb push_back -#define eb emplace_back -#define pf push_front - -#define lb lower_bound -#define ub upper_bound -tcT > int lwb(V &a, const T &b) { return int(lb(all(a), b) - bg(a)); } - -// loops -#define FOR(i, a, b) for (int i = (a); i < (b); ++i) -#define F0R(i, a) FOR(i, 0, a) -#define ROF(i, a, b) for (int i = (b) - 1; i >= (a); --i) -#define R0F(i, a) ROF(i, 0, a) -#define trav(a, x) for (auto &a : x) - -const int MOD = 1e9 + 7; // 998244353; -const int MX = 2e5 + 5; -const ll INF = 1e18; // not too close to LLONG_MAX -const ld PI = acos((ld)-1); -const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1}; // for every grid problem!! -mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); -template using pqg = priority_queue, greater>; - -// bitwise ops -// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html -constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set -constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until - // USACO updates ... - return x == 0 ? 0 : 31 - __builtin_clz(x); -} // floor(log2(x)) -constexpr int p2(int x) { return 1 << x; } -constexpr int msk2(int x) { return p2(x) - 1; } - -ll cdiv(ll a, ll b) { - return a / b + ((a ^ b) > 0 && a % b); -} // divide a by b rounded up -ll fdiv(ll a, ll b) { - return a / b - ((a ^ b) < 0 && a % b); -} // divide a by b rounded down - -tcT > bool ckmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; } // set a = min(a,b) -tcT > bool ckmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; } - -tcTU > T fstTrue(T lo, T hi, U f) { - hi++; - assert(lo <= hi); // assuming f is increasing - while (lo < hi) { // find first index such that f is true - T mid = lo + (hi - lo) / 2; - f(mid) ? hi = mid : lo = mid + 1; - } - return lo; -} -tcTU > T lstTrue(T lo, T hi, U f) { - lo--; - assert(lo <= hi); // assuming f is decreasing - while (lo < hi) { // find first index such that f is true - T mid = lo + (hi - lo + 1) / 2; - f(mid) ? lo = mid : hi = mid - 1; - } - return lo; -} -tcT > void remDup(vector &v) { // sort and remove duplicates - sort(all(v)); - v.erase(unique(all(v)), end(v)); -} -tcTU > void erase(T &t, const U &u) { // don't erase - auto it = t.find(u); - assert(it != end(t)); - t.erase(it); -} // element that doesn't exist from (multi)set - -// INPUT -#define tcTUU tcT, class... U -tcT > void re(complex &c); -tcTU > void re(pair &p); -tcT > void re(V &v); -tcT, size_t SZ > void re(AR &a); - -tcT > void re(T &x) { cin >> x; } -void re(db &d) { - str t; - re(t); - d = stod(t); -} -void re(ld &d) { - str t; - re(t); - d = stold(t); -} -tcTUU > void re(T &t, U &...u) { - re(t); - re(u...); -} +## Implementation -tcT > void re(complex &c) { - T a, b; - re(a, b); - c = {a, b}; -} -tcTU > void re(pair &p) { re(p.f, p.s); } -tcT > void re(V &x) { trav(a, x) re(a); } -tcT, size_t SZ > void re(AR &x) { trav(a, x) re(a); } -tcT > void rv(int n, V &x) { - x.rsz(n); - re(x); -} - -// TO_STRING -#define ts to_string -str ts(char c) { return str(1, c); } -str ts(const char *s) { return (str)s; } -str ts(str s) { return s; } -str ts(bool b) { -#ifdef LOCAL - return b ? "true" : "false"; -#else - return ts((int)b); -#endif -} -tcT > str ts(complex c) { - stringstream ss; - ss << c; - return ss.str(); -} -str ts(V v) { - str res = "{"; - F0R(i, sz(v)) res += char('0' + v[i]); - res += "}"; - return res; -} -template str ts(bitset b) { - str res = ""; - F0R(i, SZ) res += char('0' + b[i]); - return res; -} -tcTU > str ts(pair p); -tcT > str ts(T v) { // containers with begin(), end() -#ifdef LOCAL - bool fst = 1; - str res = "{"; - for (const auto &x : v) { - if (!fst) res += ", "; - fst = 0; - res += ts(x); - } - res += "}"; - return res; -#else - bool fst = 1; - str res = ""; - for (const auto &x : v) { - if (!fst) res += " "; - fst = 0; - res += ts(x); - } - return res; +**Time Complexity:** $\mathcal O(N \log N)$. -#endif -} -tcTU > str ts(pair p) { -#ifdef LOCAL - return "(" + ts(p.f) + ", " + ts(p.s) + ")"; -#else - return ts(p.f) + " " + ts(p.s); -#endif -} + + -// OUTPUT -tcT > void pr(T x) { cout << ts(x); } -tcTUU > void pr(const T &t, const U &...u) { - pr(t); - pr(u...); -} -void ps() { pr("\n"); } // print w/ spaces -tcTUU > void ps(const T &t, const U &...u) { - pr(t); - if (sizeof...(u)) pr(" "); - ps(u...); -} +```cpp +#include +#include -// DEBUG -void DBG() { cerr << "]" << endl; } -tcTUU > void DBG(const T &t, const U &...u) { - cerr << ts(t); - if (sizeof...(u)) cerr << ", "; - DBG(u...); -} -#ifdef LOCAL // compile with -DLOCAL, chk -> fake assert -#define dbg(...) \ - cerr << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__) -#define chk(...) \ - if (!(__VA_ARGS__)) \ - cerr << "Line(" << __LINE__ << ") -> function(" << __FUNCTION__ \ - << ") -> CHK FAILED: (" << #__VA_ARGS__ << ")" << "\n", \ - exit(0); -#else -#define dbg(...) 0 -#define chk(...) 0 -#endif - -void setPrec() { cout << fixed << setprecision(15); } -void unsyncIO() { cin.tie(0)->sync_with_stdio(0); } -// FILE I/O -void setIn(str s) { freopen(s.c_str(), "r", stdin); } -void setOut(str s) { freopen(s.c_str(), "w", stdout); } -void setIO(str s = "") { - unsyncIO(); - setPrec(); - // cin.exceptions(cin.failbit); - // throws exception when do smth illegal - // ex. try to read letter into int - if (sz(s)) setIn(s + ".in"), setOut(s + ".out"); // for USACO -} +const int MAX_N = 3e5 + 1; +const int MAX_D = 19; // ceil(log2(3*(10^5))) -int state[MX], par[MX][19], lev[MX]; +int state[MAX_N], par[MAX_N][MAX_D], lev[MAX_N]; -int getPar(int x, - int maxLev) { // get last op on active path of x with lev <= maxLev - if (lev[x] <= maxLev) return x; - R0F(i, 19) if (lev[par[x][i]] > maxLev) x = par[x][i]; +// get last op on active path of x with lev <= maxLev +int get_par(int x, int max_lev) { + if (lev[x] <= max_lev) { return x; } + for (int i = MAX_D - 1; i >= 0; i--) { + if (lev[par[x][i]] > max_lev) { x = par[x][i]; } + } return par[x][0]; } int main() { - setIO(); int n; - re(n); - FOR(y, 1, n + 1) { - re(state[y]); - if (state[y] < 0) { - lev[y] = -state[y]; - int z = getPar(y - 1, lev[y] - 1); + std::cin >> n; + for (int i = 1; i <= n; i++) { + std::cin >> state[i]; + if (state[i] < 0) { + lev[i] = -state[i]; + int z = get_par(i - 1, lev[i] - 1); assert(z); // must be something to undo - par[y][0] = getPar(z - 1, lev[y] - 1); - assert(lev[y] > lev[par[y][0]]); // levels of ops in active path - // are strictly decreasing - FOR(j, 1, 19) - par[y][j] = par[par[y][j - 1]][j - 1]; // prep binary jumps + par[i][0] = get_par(z - 1, lev[i] - 1); + + // levels of ops in active path are strictly decreasing + assert(lev[i] > lev[par[i][0]]); + + for (int j = 1; j < MAX_D; j++) { + par[i][j] = par[par[i][j - 1]][j - 1]; // prepare binary jumps + } } - ps(state[getPar(y, 0)]); - // current active path is y, par[y], par[par[y]], ... + std::cout << state[get_par(i, 0)] << '\n'; + // current active path is i, par[i], par[par[i]], ... } } ``` + + + + +```py +MAX_N = 300001 +MAX_D = 19 # ceil(log2(3 * (10^5))) + +state = [0] * MAX_N +par = [[0] * MAX_D for _ in range(MAX_N)] +lev = [0] * MAX_N + + +def get_par(x: int, max_lev: int) -> int: + # get last op on active path of x with lev <= maxLev + if lev[x] <= max_lev: + return x + for i in range(MAX_D - 1, -1, -1): + if lev[par[x][i]] > max_lev: + x = par[x][i] + return par[x][0] + + +n = int(input()) + +for i in range(1, n + 1): + state[i] = int(input()) + + if state[i] < 0: + lev[i] = -state[i] + z = get_par(i - 1, lev[i] - 1) + + # must be something to undo + assert z > 0 + + par[i][0] = get_par(z - 1, lev[i] - 1) + + # levels of ops in active path are strictly decreasing + assert lev[i] > lev[par[i][0]] + + # prepare binary jumps + for j in range(1, MAX_D): + par[i][j] = par[par[i][j - 1]][j - 1] + + # current active path is i, par[i], par[par[i]], ... + print(state[get_par(i, 0)]) +``` + + +