#include "bits/stdc++.h"
using namespace std;
#define int long long
#define i_1 jakcjacjl
struct Fish {
int col, row;
int weight;
};
bool operator < (const Fish& a, const Fish& b) {
if (a.col != b.col) return a.col < b.col;
return a.row < b.row;
}
void upMax(int& f, int val) {
if (val > f) f = val;
}
// sub1 - 3 {{{
// fishes are on even columns -> build piers on odd columns
// & catch all fishes
int sub1(const std::vector<Fish>& fishes) {
int res = 0;
for (const auto& fish : fishes) {
res += fish.weight;
}
return res;
}
// fishes are on first 2 columns
int sub2(int n, const std::vector<Fish>& fishes) {
std::vector<int> zeroes(n); // prefix sum of fish weights at column == 0
std::vector<int> ones(n); // prefix sum of fish weights at column == 1
for (const auto& fish : fishes) {
if (fish.col == 0) zeroes[fish.row] += fish.weight;
if (fish.col == 1) ones[fish.row] += fish.weight;
}
std::partial_sum(zeroes.begin(), zeroes.end(), zeroes.begin());
std::partial_sum(ones.begin(), ones.end(), ones.begin());
int res = ones.back(); // init: only catch fishes at column == 1
for (int i = 0; i < n; ++i) {
// build pier until at column 1, row 0-i
if (n == 2) upMax(res, zeroes[i]);
else upMax(res, zeroes[i] + ones.back() - ones[i]);
}
return res;
}
// all fishes are on row == 0
int sub3(int n, const std::vector<Fish>& fishes) {
std::vector<int> weights(n); // weights[i] = weight of fish at column i
for (const auto& fish : fishes) {
weights[fish.col] += fish.weight;
}
// f[i] = best strategy if we BUILD PIER AT i, only considering col 0..i
// i-4 i-3 i-2 i-1 i
std::vector<int> f(n);
f[0] = 0;
for (int i = 1; i < n; ++i) {
f[i] = std::max(f[i-1], weights[i-1]);
if (i >= 2) {
upMax(f[i], f[i-2] + weights[i-1]);
}
if (i >= 3) {
upMax(f[i], f[i-3] + weights[i-2] + weights[i-1]);
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
int cur = f[i];
if (i + 1 < n) cur += weights[i+1];
upMax(res, cur);
}
return res;
}
// }}}
// sub 5 N <= 300 {{{
int sub5(int n, const std::vector<Fish>& fishes) {
// Init weights[i][j] = sum of fish on column i, from row 0 -> row j
std::vector<std::vector<int>> weights(n, std::vector<int> (n, 0));
for (const auto& fish : fishes) {
weights[fish.col][fish.row] += fish.weight;
}
for (int col = 0; col < n; ++col) {
std::partial_sum(weights[col].begin(), weights[col].end(), weights[col].begin());
}
// f[c][r] = best strategy if we last BUILD PIER AT column c, row r
// only considering fishes <= (c, r)
// g[c][r] = similar to f[c][r] but consider fishes at column c, in row [r, n-1]
std::vector<std::vector<int>> f(n, std::vector<int> (n, 0)),
g(n, std::vector<int> (n, 0));
// f <= g
for (int c = 1; c < n; ++c) {
for (int r = 0; r < n; ++r) {
// this is first pier
f[c][r] = g[c][r] = weights[c-1][r];
// last pier at column i-1
for (int lastRow = 0; lastRow < n; ++lastRow) {
if (lastRow <= r) {
int cur = std::max(
f[c-1][lastRow] + weights[c-1][r] - weights[c-1][lastRow],
g[c-1][lastRow]);
upMax(f[c][r], cur);
upMax(g[c][r], cur);
} else {
upMax(f[c][r], g[c-1][lastRow]);
upMax(g[c][r], g[c-1][lastRow] + weights[c][lastRow] - weights[c][r]);
}
}
// last pier at column i-2
if (c >= 2) {
for (int lastRow = 0; lastRow < n; ++lastRow) {
int cur = g[c-2][lastRow] + weights[c-1][std::max(lastRow, r)];
upMax(f[c][r], cur);
upMax(g[c][r], cur);
}
}
// last pier at column i-3
if (c >= 3) {
for (int lastRow = 0; lastRow < n; ++lastRow) {
int cur = g[c-3][lastRow] + weights[c-2][lastRow] + weights[c-1][r];
upMax(f[c][r], cur);
upMax(g[c][r], cur);
}
}
}
}
int res = 0;
for (int c = 0; c < n; ++c) {
for (int r = 0; r < n; ++r) {
assert(g[c][r] >= f[c][r]);
int cur = g[c][r];
if (c + 1 < n) {
cur += weights[c+1][r];
}
upMax(res, cur);
}
}
return res;
}
// }}}
// SegTree, copied from AtCoder library {{{
// AtCoder doc: https://atcoder.github.io/ac-library/master/document_en/segtree.html
//
// Notes:
// - Index of elements from 0 -> n-1
// - Range queries are [l, r-1]
//
// Tested:
// - (binary search) https://atcoder.jp/contests/practice2/tasks/practice2_j
// - https://oj.vnoi.info/problem/gss
// - https://oj.vnoi.info/problem/nklineup
// - (max_right & min_left for delete position queries) https://oj.vnoi.info/problem/segtree_itstr
// - https://judge.yosupo.jp/problem/point_add_range_sum
// - https://judge.yosupo.jp/problem/point_set_range_composite
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
template<
class T, // data type for nodes
T (*op) (T, T), // operator to combine 2 nodes
T (*e)() // identity element
>
struct SegTree {
SegTree() : SegTree(0) {}
explicit SegTree(int n) : SegTree(vector<T> (n, e())) {}
explicit SegTree(const vector<T>& v) : _n((int) v.size()) {
log = ceil_pow2(_n);
size = 1<<log;
d = vector<T> (2*size, e());
for (int i = 0; i < _n; i++) d[size+i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
// 0 <= p < n
void set(int p, T x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
// 0 <= p < n
T get(int p) const {
assert(0 <= p && p < _n);
return d[p + size];
}
// Get product in range [l, r-1]
// 0 <= l <= r <= n
// For empty segment (l == r) -> return e()
T prod(int l, int r) const {
assert(0 <= l && l <= r && r <= _n);
T sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
T all_prod() const {
return d[1];
}
// Binary search on SegTree to find largest r:
// f(op(a[l] .. a[r-1])) = true (assuming empty array is always true)
// f(op(a[l] .. a[r])) = false (assuming op(..., a[n]), which is out of bound, is always false)
template <bool (*f)(T)> int max_right(int l) const {
return max_right(l, [](T x) { return f(x); });
}
template <class F> int max_right(int l, F f) const {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n) return _n;
l += size;
T sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
// Binary search on SegTree to find smallest l:
// f(op(a[l] .. a[r-1])) = true (assuming empty array is always true)
// f(op(a[l-1] .. a[r-1])) = false (assuming op(a[-1], ..), which is out of bound, is always false)
template <bool (*f)(T)> int min_left(int r) const {
return min_left(r, [](T x) { return f(x); });
}
template <class F> int min_left(int r, F f) const {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0) return 0;
r += size;
T sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
vector<T> d;
void update(int k) {
d[k] = op(d[2*k], d[2*k+1]);
}
};
// }}}
struct MaxSegTreeOp {
static int op(int x, int y) {
return max(x, y);
}
static int e() {
return 0;
}
};
// RMQ {{{
//
// Sparse table
// Usage:
// RMQ<int, _min> st(v);
//
// Note:
// - doesn't work for empty range
//
// Tested:
// - https://judge.yosupo.jp/problem/staticrmq
template<class T, T (*op) (T, T)> struct RMQ {
RMQ() = default;
RMQ(const vector<T>& v) : t{v}, n{(int) v.size()} {
for (int k = 1; (1<<k) <= n; ++k) {
t.emplace_back(n - (1<<k) + 1);
for (int i = 0; i + (1<<k) <= n; ++i) {
t[k][i] = op(t[k-1][i], t[k-1][i + (1<<(k-1))]);
}
}
}
// get range [l, r-1]
// doesn't work for empty range
T get(int l, int r) const {
assert(0 <= l && l < r && r <= n);
int k = __lg(r - l);
return op(t[k][l], t[k][r - (1<<k)]);
}
private:
vector<vector<T>> t;
int n;
};
template<class T> T _min(T a, T b) { return b < a ? b : a; }
template<class T> T _max(T a, T b) { return a < b ? b : a; }
// }}}
// N <= 3000 {{{
int sub6(int n, const std::vector<Fish>& fishes) {
// Init weights[i][j] = sum of fish on column i, from row 0 -> row j
std::vector<std::vector<int>> weights(n, std::vector<int> (n, 0));
for (const auto& fish : fishes) {
weights[fish.col][fish.row] += fish.weight;
}
for (int col = 0; col < n; ++col) {
std::partial_sum(weights[col].begin(), weights[col].end(), weights[col].begin());
}
// f[c][r] = best strategy if we last BUILD PIER AT column c, row r
// only considering fishes <= (c, r)
// g[c][r] = similar to f[c][r] but consider fishes at column c, in row [r, n-1]
std::vector<std::vector<int>> f(n, std::vector<int> (n, 0)),
g(n, std::vector<int> (n, 0)),
f_with_next_col_prefix_max(n, std::vector<int> (n, 0));
std::vector<int> g_with_next_col_prefix_max(n, 0);
std::vector<RMQ<int, _max>> st_g(n), st_g_with_next_col(n);
// f <= g
for (int c = 0; c < n; ++c) {
// compute {{{
if (c > 0) {
for (int r = 0; r < n; ++r) {
// this is first pier
f[c][r] = g[c][r] = weights[c-1][r];
// last pier at column i-1
if (c >= 1) {
// last row <= r
int cur = std::max(
st_g[c-1].get(0, r),
f_with_next_col_prefix_max[c-1][r] + weights[c-1][r]);
upMax(f[c][r], cur);
upMax(g[c][r], cur);
// last row > r
if (r + 1 < n) {
upMax(f[c][r], st_g[c-1].get(r+1, n-1));
upMax(g[c][r], st_g_with_next_col[c-1].get(r+1, n-1) - weights[c][r]);
}
}
// last pier at column i-2
if (c >= 2) {
int cur = std::max(
st_g[c-2].get(0, n-1) + weights[c-1][r],
st_g_with_next_col[c-2].get(0, n-1));
upMax(f[c][r], cur);
upMax(g[c][r], cur);
}
// last pier at column i-3
if (c >= 3) {
int cur = st_g_with_next_col[c-3].get(0, n-1) + weights[c-1][r];
upMax(f[c][r], cur);
upMax(g[c][r], cur);
}
}
}
// }}}
// aggregate {{{
st_g[c] = RMQ<int, _max> (g[c]);
auto MAX = [] (auto a, auto b) { return std::max(a, b); };
if (c + 1 < n) {
// g_with_next_col[c][r] = g[c][r] + weights[c+1][r]
std::vector<int> g_with_next_col(n);
for (int r = 0; r < n; ++r) {
g_with_next_col[r] = g[c][r] + weights[c+1][r];
}
st_g_with_next_col[c] = RMQ<int, _max> (g_with_next_col);
for (int r = 0; r < n; ++r) {
f_with_next_col_prefix_max[c][r] = f[c][r] - weights[c][r];
}
std::partial_sum(
f_with_next_col_prefix_max[c].begin(),
f_with_next_col_prefix_max[c].end(),
f_with_next_col_prefix_max[c].begin(),
MAX);
}
// }}}
}
int res = 0;
for (int c = 0; c < n; ++c) {
for (int r = 0; r < n; ++r) {
assert(g[c][r] >= f[c][r]);
int cur = g[c][r];
if (c + 1 < n) {
cur += weights[c+1][r];
}
upMax(res, cur);
}
}
return res;
}
// }}}
#undef int
long long max_weights(
int n, int nFish,
std::vector<int> xs,
std::vector<int> ys,
std::vector<int> ws) {
std::vector<Fish> fishes;
for (int i = 0; i < nFish; ++i) {
fishes.push_back({xs[i], ys[i], ws[i]});
}
if (std::all_of(xs.begin(), xs.end(), [] (int x) { return x % 2 == 0; })) {
return sub1(fishes);
}
if (*std::max_element(xs.begin(), xs.end()) <= 1) {
return sub2(n, fishes);
}
if (*std::max_element(ys.begin(), ys.end()) == 0) {
return sub3(n, fishes);
}
return sub6(n, fishes);
}
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
25 ms |
5804 KB |
Output is correct |
| 2 |
Correct |
29 ms |
6264 KB |
Output is correct |
| 3 |
Correct |
0 ms |
212 KB |
Output is correct |
| 4 |
Correct |
0 ms |
212 KB |
Output is correct |
| 5 |
Correct |
96 ms |
20396 KB |
Output is correct |
| 6 |
Correct |
100 ms |
20400 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
0 ms |
212 KB |
Output is correct |
| 2 |
Correct |
55 ms |
10844 KB |
Output is correct |
| 3 |
Correct |
66 ms |
11940 KB |
Output is correct |
| 4 |
Correct |
25 ms |
5716 KB |
Output is correct |
| 5 |
Correct |
31 ms |
6440 KB |
Output is correct |
| 6 |
Correct |
0 ms |
212 KB |
Output is correct |
| 7 |
Correct |
0 ms |
212 KB |
Output is correct |
| 8 |
Correct |
0 ms |
296 KB |
Output is correct |
| 9 |
Correct |
0 ms |
212 KB |
Output is correct |
| 10 |
Correct |
1 ms |
296 KB |
Output is correct |
| 11 |
Correct |
1 ms |
212 KB |
Output is correct |
| 12 |
Correct |
26 ms |
5692 KB |
Output is correct |
| 13 |
Correct |
32 ms |
6972 KB |
Output is correct |
| 14 |
Correct |
31 ms |
5720 KB |
Output is correct |
| 15 |
Correct |
30 ms |
6456 KB |
Output is correct |
| 16 |
Correct |
26 ms |
5792 KB |
Output is correct |
| 17 |
Correct |
29 ms |
6396 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
0 ms |
212 KB |
Output is correct |
| 2 |
Correct |
1 ms |
1876 KB |
Output is correct |
| 3 |
Correct |
18 ms |
4868 KB |
Output is correct |
| 4 |
Correct |
12 ms |
3928 KB |
Output is correct |
| 5 |
Correct |
34 ms |
6600 KB |
Output is correct |
| 6 |
Correct |
33 ms |
7104 KB |
Output is correct |
| 7 |
Correct |
31 ms |
7292 KB |
Output is correct |
| 8 |
Correct |
29 ms |
7272 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Runtime error |
1 ms |
340 KB |
Execution killed with signal 6 |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Runtime error |
1 ms |
340 KB |
Execution killed with signal 6 |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Runtime error |
1 ms |
340 KB |
Execution killed with signal 6 |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
0 ms |
212 KB |
Output is correct |
| 2 |
Correct |
1 ms |
1876 KB |
Output is correct |
| 3 |
Correct |
18 ms |
4868 KB |
Output is correct |
| 4 |
Correct |
12 ms |
3928 KB |
Output is correct |
| 5 |
Correct |
34 ms |
6600 KB |
Output is correct |
| 6 |
Correct |
33 ms |
7104 KB |
Output is correct |
| 7 |
Correct |
31 ms |
7292 KB |
Output is correct |
| 8 |
Correct |
29 ms |
7272 KB |
Output is correct |
| 9 |
Runtime error |
758 ms |
2097152 KB |
Execution killed with signal 9 |
| 10 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
25 ms |
5804 KB |
Output is correct |
| 2 |
Correct |
29 ms |
6264 KB |
Output is correct |
| 3 |
Correct |
0 ms |
212 KB |
Output is correct |
| 4 |
Correct |
0 ms |
212 KB |
Output is correct |
| 5 |
Correct |
96 ms |
20396 KB |
Output is correct |
| 6 |
Correct |
100 ms |
20400 KB |
Output is correct |
| 7 |
Correct |
0 ms |
212 KB |
Output is correct |
| 8 |
Correct |
55 ms |
10844 KB |
Output is correct |
| 9 |
Correct |
66 ms |
11940 KB |
Output is correct |
| 10 |
Correct |
25 ms |
5716 KB |
Output is correct |
| 11 |
Correct |
31 ms |
6440 KB |
Output is correct |
| 12 |
Correct |
0 ms |
212 KB |
Output is correct |
| 13 |
Correct |
0 ms |
212 KB |
Output is correct |
| 14 |
Correct |
0 ms |
296 KB |
Output is correct |
| 15 |
Correct |
0 ms |
212 KB |
Output is correct |
| 16 |
Correct |
1 ms |
296 KB |
Output is correct |
| 17 |
Correct |
1 ms |
212 KB |
Output is correct |
| 18 |
Correct |
26 ms |
5692 KB |
Output is correct |
| 19 |
Correct |
32 ms |
6972 KB |
Output is correct |
| 20 |
Correct |
31 ms |
5720 KB |
Output is correct |
| 21 |
Correct |
30 ms |
6456 KB |
Output is correct |
| 22 |
Correct |
26 ms |
5792 KB |
Output is correct |
| 23 |
Correct |
29 ms |
6396 KB |
Output is correct |
| 24 |
Correct |
0 ms |
212 KB |
Output is correct |
| 25 |
Correct |
1 ms |
1876 KB |
Output is correct |
| 26 |
Correct |
18 ms |
4868 KB |
Output is correct |
| 27 |
Correct |
12 ms |
3928 KB |
Output is correct |
| 28 |
Correct |
34 ms |
6600 KB |
Output is correct |
| 29 |
Correct |
33 ms |
7104 KB |
Output is correct |
| 30 |
Correct |
31 ms |
7292 KB |
Output is correct |
| 31 |
Correct |
29 ms |
7272 KB |
Output is correct |
| 32 |
Runtime error |
1 ms |
340 KB |
Execution killed with signal 6 |
| 33 |
Halted |
0 ms |
0 KB |
- |
