Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

update Baltic Editor #4987

Open
wants to merge 8 commits into
base: master
Choose a base branch
from
Open

update Baltic Editor #4987

Changes from 3 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
82df5cf
update baltic editor
Sosuke23 Dec 16, 2024
ea4bcd9
py sol for baltic editor
Sosuke23 Dec 16, 2024
04df7c2
[pre-commit.ci] auto fixes from pre-commit.com hooks
pre-commit-ci[bot] Dec 16, 2024
0fdf43b
Update solutions/platinum/baltic-15-editor.mdx
Sosuke23 Dec 16, 2024
c33a424
Merge branch 'cpinitiative:master' into fix
Sosuke23 Dec 17, 2024
cd3a8d3
update header file
Sosuke23 Dec 17, 2024
5657eff
[pre-commit.ci] auto fixes from pre-commit.com hooks
pre-commit-ci[bot] Dec 17, 2024
4beefd1
Merge branch 'cpinitiative:master' into fix
Sosuke23 Dec 25, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
357 changes: 83 additions & 274 deletions solutions/platinum/baltic-15-editor.mdx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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])`.

Expand Down Expand Up @@ -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 <bits/stdc++.h>
using namespace std;

using ll = long long;
using ld = long double;
using db = double;
using str = string; // yay python!

using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;

using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;

#define tcT template <class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT > using V = vector<T>;
tcT, size_t SZ > using AR = array<T, SZ>;
tcT > using PR = pair<T, T>;

// 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<T> &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 <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;

// 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<T> &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<T> &c);
tcTU > void re(pair<T, U> &p);
tcT > void re(V<T> &v);
tcT, size_t SZ > void re(AR<T, SZ> &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<T> &c) {
T a, b;
re(a, b);
c = {a, b};
}
tcTU > void re(pair<T, U> &p) { re(p.f, p.s); }
tcT > void re(V<T> &x) { trav(a, x) re(a); }
tcT, size_t SZ > void re(AR<T, SZ> &x) { trav(a, x) re(a); }
tcT > void rv(int n, V<T> &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<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str ts(V<bool> v) {
str res = "{";
F0R(i, sz(v)) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ> str ts(bitset<SZ> b) {
str res = "";
F0R(i, SZ) res += char('0' + b[i]);
return res;
}
tcTU > str ts(pair<T, U> 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<T, U> p) {
#ifdef LOCAL
return "(" + ts(p.f) + ", " + ts(p.s) + ")";
#else
return ts(p.f) + " " + ts(p.s);
#endif
}
<LanguageSection>
<CPPSection>

// 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 <assert.h>
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

use cassert instead

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

ok

#include <iostream>

// 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]], ...
}
}
```

</CPPSection>
<PySection>

```py
MAX_N = 300001
MAX_D = 19 # ceil(log2(3*(10^5)))
Sosuke23 marked this conversation as resolved.
Show resolved Hide resolved

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)])
```

</PySection>
</LanguageSection>
Loading