backup
This commit is contained in:
parent
3f48d4b954
commit
d82e0e4b5c
SSH Key Fingerprint:
SHA256:dFPFi68d8C87YkFkEBU4TkcrYRySWpekRR1hbnDWUCw
BIN
src/bin/a.out
BIN
src/bin/a.out
Binary file not shown.
|
|
@ -1,8 +1,8 @@
|
|||
/**
|
||||
* Author: subcrip
|
||||
* Created: 2024-05-31 23:31:18
|
||||
* Modified: 2024-06-01 00:53:27
|
||||
* Elapsed: 82 minutes
|
||||
* Created: 2024-06-01 13:45:49
|
||||
* Modified: 2024-06-01 15:48:33
|
||||
* Elapsed: 122 minutes
|
||||
*/
|
||||
|
||||
#pragma GCC optimize("Ofast")
|
||||
|
|
@ -485,7 +485,7 @@ template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container)
|
|||
}
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
// #define SINGLE_TEST_CASE
|
||||
#define SINGLE_TEST_CASE
|
||||
// #define DUMP_TEST_CASE 7219
|
||||
// #define TOT_TEST_CASE 10000
|
||||
|
||||
|
|
@ -496,177 +496,121 @@ void dump_ignore() {}
|
|||
void prep() {
|
||||
}
|
||||
|
||||
template<typename Addable_Info_t, typename Tag_t, typename Sequence = std::vector<Addable_Info_t>> class segtree {
|
||||
private:
|
||||
using size_type = uint64_t;
|
||||
using info_type = Addable_Info_t;
|
||||
using tag_type = Tag_t;
|
||||
size_type _max;
|
||||
vector<info_type> d;
|
||||
vector<tag_type> b;
|
||||
void pull(size_type p) {
|
||||
d[p] = d[p * 2] + d[p * 2 + 1];
|
||||
}
|
||||
void push(size_type p, size_type left_len, size_type right_len) {
|
||||
d[p * 2].apply(b[p], left_len), d[p * 2 + 1].apply(b[p], right_len);
|
||||
b[p * 2].apply(b[p]), b[p * 2 + 1].apply(b[p]);
|
||||
b[p] = tag_type();
|
||||
}
|
||||
void set(size_type s, size_type t, size_type p, size_type x, const info_type& c) {
|
||||
if (s == t) {
|
||||
d[p] = c;
|
||||
return;
|
||||
}
|
||||
size_type m = s + (t - s >> 1);
|
||||
if (s != t) push(p, m - s + 1, t - m);
|
||||
if (x <= m) set(s, m, p * 2, x, c);
|
||||
else set(m + 1, t, p * 2 + 1, x, c);
|
||||
pull(p);
|
||||
}
|
||||
|
||||
void range_apply(size_type s, size_type t, size_type p, size_type l, size_type r, const tag_type& c) {
|
||||
if (l <= s && t <= r) {
|
||||
d[p].apply(c, t - s + 1);
|
||||
b[p].apply(c);
|
||||
return;
|
||||
}
|
||||
size_type m = s + (t - s >> 1);
|
||||
push(p, m - s + 1, t - m);
|
||||
if (l <= m) range_apply(s, m, p * 2, l, r, c);
|
||||
if (r > m) range_apply(m + 1, t, p * 2 + 1, l, r, c);
|
||||
pull(p);
|
||||
}
|
||||
info_type range_query(size_type s, size_type t, size_type p, size_type l, size_type r) {
|
||||
if (l <= s && t <= r) {
|
||||
return d[p];
|
||||
}
|
||||
size_type m = s + (t - s >> 1);
|
||||
info_type res = {};
|
||||
push(p, m - s + 1, t - m);
|
||||
if (l <= m) res = res + range_query(s, m, p * 2, l, r);
|
||||
if (r > m) res = res + range_query(m + 1, t, p * 2 + 1, l, r);
|
||||
return res;
|
||||
}
|
||||
void build(const Sequence& a, size_type s, size_type t, size_type p) {
|
||||
if (s == t) {
|
||||
d[p] = a[s];
|
||||
return;
|
||||
}
|
||||
int m = s + (t - s >> 1);
|
||||
build(a, s, m, p * 2);
|
||||
build(a, m + 1, t, p * 2 + 1);
|
||||
pull(p);
|
||||
}
|
||||
public:
|
||||
segtree(size_type __max) : d(4 * __max), b(4 * __max), _max(__max - 1) {}
|
||||
segtree(const Sequence& a) : segtree(a.size()) {
|
||||
build(a, {}, _max, 1);
|
||||
}
|
||||
void set(size_type i, const info_type& c) {
|
||||
set({}, _max, 1, i, c);
|
||||
}
|
||||
|
||||
void range_apply(size_type l, size_type r, const tag_type& c) {
|
||||
range_apply({}, _max, 1, l, r, c);
|
||||
}
|
||||
void apply(size_type i, const tag_type& c) {
|
||||
range_apply(i, i, c);
|
||||
}
|
||||
info_type range_query(size_type l, size_type r) {
|
||||
return range_query({}, _max, 1, l, r);
|
||||
}
|
||||
info_type query(size_type i) {
|
||||
return range_query(i, i);
|
||||
}
|
||||
Sequence serialize() {
|
||||
Sequence res = {};
|
||||
for (size_type i = 0; i <= _max; ++i) {
|
||||
res.push_back(query(i));
|
||||
}
|
||||
return res;
|
||||
}
|
||||
const vector<info_type>& get_d() {
|
||||
return d;
|
||||
}
|
||||
};
|
||||
struct MaxTag {
|
||||
ll val = -INFLL;
|
||||
void apply(const MaxTag& rhs) {
|
||||
if (rhs.val != -INFLL)
|
||||
val = rhs.val;
|
||||
}
|
||||
};
|
||||
struct MaxInfo {
|
||||
ll val = -INFLL;
|
||||
void apply(const MaxTag& rhs, size_t len) {
|
||||
if (rhs.val != -INFLL)
|
||||
val = rhs.val * len;
|
||||
}
|
||||
};
|
||||
MaxInfo operator+(const MaxInfo &a, const MaxInfo &b) {
|
||||
return {max(a.val, b.val)};
|
||||
}
|
||||
|
||||
void solve() {
|
||||
read(int, n, m, k);
|
||||
readvec1(ll, a, n);
|
||||
vector<map<int, vector<tiii>>> raw_ld(n + 1);
|
||||
vector<int> sz(n + 1);
|
||||
vector<set<int>> st(n + 1);
|
||||
vector<unordered_map<int, int, safe_hash>> mp(n + 1);
|
||||
vector<vector<short>> grid(n + 1, vector<short>(m + 1));
|
||||
vector<vector<short>> x_diff(n + 1, vector<short>(m + 2)), y_diff(m + 1, vector<short>(n + 2));
|
||||
while (k--) {
|
||||
read(int, x1, y1, x2, y2, c);
|
||||
raw_ld[x2][y2].emplace_back(x1, y1, c);
|
||||
st[x1].emplace(y1);
|
||||
st[x2].emplace(y2);
|
||||
read(short, x1, y1, x2, y2);
|
||||
if (x1 == x2) {
|
||||
if (y1 > y2) swap(y1, y2);
|
||||
x_diff[x1][y1] += 1;
|
||||
x_diff[x1][y2 + 1] -= 1;
|
||||
} else if (y1 == y2) {
|
||||
if (x1 > x2) swap(x1, x2);
|
||||
y_diff[y1][x1] += 1;
|
||||
y_diff[y1][x2 + 1] -= 1;
|
||||
}
|
||||
}
|
||||
st[1].emplace(1);
|
||||
// tuple(y, x', y', profit)
|
||||
vector<vector<pair<int, vector<tiii>>>> ld(n + 1);
|
||||
vector<segtree<MaxInfo, MaxTag>> right_tr = {{0}}, left_tr = {{0}};
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
for (auto&& [y, v] : raw_ld[i]) {
|
||||
ld[i].emplace_back(y, v);
|
||||
int curr = 0;
|
||||
for (int j = 1; j <= m; ++j) {
|
||||
curr += x_diff[i][j];
|
||||
if (curr) grid[i][j] = 1;
|
||||
}
|
||||
int N = 0;
|
||||
for (auto&& x : st[i]) mp[i][x] = ++N;
|
||||
sz[i] = N;
|
||||
right_tr.push_back(segtree<MaxInfo, MaxTag>(sz[i] + 1));
|
||||
left_tr.push_back(segtree<MaxInfo, MaxTag>(sz[i] + 1));
|
||||
}
|
||||
left_tr[1].set(1, {a[1]});
|
||||
right_tr[1].set(1, {-a[1]});
|
||||
ll res = -INFLL;
|
||||
for (int i = 2; i <= n; ++i) {
|
||||
for (auto&& [y, v] : ld[i]) {
|
||||
ll mx = -INFLL;
|
||||
for (auto&& [x1, y1, profit] : v) {
|
||||
// left
|
||||
ll left = left_tr[x1].range_query(0, mp[x1][y1]).val;
|
||||
if (left != -INFLL) {
|
||||
mx = max(mx, left - a[x1] * y1 + profit);
|
||||
}
|
||||
// right
|
||||
ll right = right_tr[x1].range_query(mp[x1][y1], sz[x1]).val;
|
||||
if (right != -INFLL) {
|
||||
mx = max(mx, right + a[x1] * y1 + profit);
|
||||
for (int i = 1; i <= m; ++i) {
|
||||
int curr = 0;
|
||||
for (int j = 1; j <= n; ++j) {
|
||||
curr += y_diff[i][j];
|
||||
if (curr) grid[j][i] = 1;
|
||||
}
|
||||
}
|
||||
// for (int i = 1; i <= n; ++i) {
|
||||
// for (int j = 1; j <= m; ++j) {
|
||||
// cerr << grid[i][j] << " \n"[j == m];
|
||||
// }
|
||||
// }
|
||||
// cerr << endl;
|
||||
read(short, sx, sy);
|
||||
grid[sx][sy] = 2;
|
||||
deque<pair<short, short>> q, nq;
|
||||
q.emplace_back(sx, sy);
|
||||
vector<vector<short>> t(n + 1, vector<short>(m + 1));
|
||||
vector<vector<bool>> v(n + 1, vector<bool>(m + 1));
|
||||
while (1) {
|
||||
int f = 0;
|
||||
// debug(endl);
|
||||
while (q.size()) {
|
||||
popfront(q, x, y);
|
||||
// debug(make_tuple(x, y));
|
||||
grid[x][y] = 2;
|
||||
if (x - 1 >= 1) {
|
||||
if (v[x - 1][y] == 0) {
|
||||
if (grid[x - 1][y] == 0) {
|
||||
q.emplace_back(x - 1, y);
|
||||
} else if (grid[x - 1][y] == 1) {
|
||||
nq.emplace_back(x - 1, y);
|
||||
}
|
||||
v[x - 1][y] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (mx == -INFLL) continue;
|
||||
ll raw_left = left_tr[i].query(mp[i][y]).val;
|
||||
left_tr[i].set(mp[i][y], {max(raw_left, mx + y * a[i])});
|
||||
ll raw_right = right_tr[i].query(mp[i][y]).val;
|
||||
right_tr[i].set(mp[i][y], {max(raw_right, mx - y * a[i])});
|
||||
if (i == n) {
|
||||
res = max(res, mx - (m - y) * a[i]);
|
||||
if (x + 1 <= n) {
|
||||
if (v[x + 1][y] == 0) {
|
||||
if (grid[x + 1][y] == 0) {
|
||||
q.emplace_back(x + 1, y);
|
||||
} else if (grid[x + 1][y] == 1) {
|
||||
nq.emplace_back(x + 1, y);
|
||||
}
|
||||
v[x + 1][y] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (y + 1 <= m) {
|
||||
if (v[x][y + 1] == 0) {
|
||||
if (grid[x][y + 1] == 0) {
|
||||
q.emplace_back(x, y + 1);
|
||||
} else if (grid[x][y + 1] == 1) {
|
||||
nq.emplace_back(x, y + 1);
|
||||
}
|
||||
v[x][y + 1] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (y - 1 >= 1) {
|
||||
if (v[x][y - 1] == 0) {
|
||||
if (grid[x][y - 1] == 0) {
|
||||
q.emplace_back(x, y - 1);
|
||||
} else if (grid[x][y - 1] == 1) {
|
||||
nq.emplace_back(x, y - 1);
|
||||
}
|
||||
v[x][y - 1] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
|
||||
}
|
||||
if (f) {
|
||||
break;
|
||||
} else {
|
||||
swap(q, nq);
|
||||
}
|
||||
}
|
||||
int res = 0;
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
for (int j = 1; j <= m; ++j) {
|
||||
// cerr << grid[i][j] << " \n"[j == m];
|
||||
if (grid[i][j] == 0) {
|
||||
res += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (res == -INFLL) {
|
||||
cout << "NO ESCAPE\n";
|
||||
} else {
|
||||
cout << -res << '\n';
|
||||
}
|
||||
cout << res << '\n';
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
|
|
|||
|
|
@ -1,22 +1,16 @@
|
|||
4
|
||||
5 3 3
|
||||
5 17 8 1 4
|
||||
1 3 3 3 4
|
||||
3 1 5 2 5
|
||||
3 2 5 1 6
|
||||
6 3 3
|
||||
5 17 8 1 4 2
|
||||
1 3 3 3 4
|
||||
3 1 5 2 5
|
||||
3 2 5 1 6
|
||||
5 3 1
|
||||
5 17 8 1 4
|
||||
1 3 5 3 100
|
||||
5 5 5
|
||||
3 2 3 7 5
|
||||
3 5 4 2 1
|
||||
2 2 5 4 5
|
||||
4 4 5 2 3
|
||||
1 2 4 2 2
|
||||
3 3 5 2 4
|
||||
|
||||
17 17 14
|
||||
2 2 2 13
|
||||
2 2 7 2
|
||||
2 7 9 7
|
||||
7 2 7 7
|
||||
9 7 9 13
|
||||
2 13 9 13
|
||||
11 2 11 7
|
||||
11 2 16 2
|
||||
16 2 16 7
|
||||
16 7 11 7
|
||||
4 15 4 17
|
||||
4 15 12 15
|
||||
12 15 12 9
|
||||
12 9 17 9
|
||||
8 9
|
||||
|
|
|
|||
|
|
@ -496,7 +496,7 @@ int main() {
|
|||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||
assert(false && "incompatible compiler variant detected.");
|
||||
#endif
|
||||
untie, cout.tie(NULL);
|
||||
untie;
|
||||
prep();
|
||||
#ifdef SINGLE_TEST_CASE
|
||||
solve();
|
||||
|
|
|
|||
151
src/bin/test.cc
151
src/bin/test.cc
|
|
@ -1,3 +1,10 @@
|
|||
/**
|
||||
* Author: subcrip
|
||||
* Created: 2024-06-01 13:45:49
|
||||
* Modified: 2024-06-01 15:48:33
|
||||
* Elapsed: 122 minutes
|
||||
*/
|
||||
|
||||
#pragma GCC optimize("Ofast")
|
||||
/////////////////////////////////////////////////////////
|
||||
/**
|
||||
|
|
@ -173,6 +180,7 @@ struct array_hash {
|
|||
};
|
||||
|
||||
/* build data structures */
|
||||
#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);)
|
||||
#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];)
|
||||
#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];)
|
||||
#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);)
|
||||
|
|
@ -428,6 +436,9 @@ istream& operator>>(istream& in, MLLd& num) {
|
|||
}
|
||||
|
||||
// miscancellous
|
||||
#define functor(func) [&](auto&&... val) \
|
||||
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||
{return func(std::forward<decltype(val)>(val)...);}
|
||||
template <typename Func, typename RandomIt> void sort_by_key(RandomIt first, RandomIt last, Func extractor) {
|
||||
std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); });
|
||||
}
|
||||
|
|
@ -472,12 +483,9 @@ public:
|
|||
template <typename T> vector<pair<int, T>> enumerate(const vector<T>& container) {
|
||||
return zip<int, T>(ArithmeticIterator<int>(0), ArithmeticIterator<int>(INT_MAX), container.begin(), container.end());
|
||||
}
|
||||
#define functor(func) [&](auto&&... val) \
|
||||
noexcept(noexcept(func(std::forward<decltype(val)>(val)...))) -> decltype(auto) \
|
||||
{return func(std::forward<decltype(val)>(val)...);}
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
// #define SINGLE_TEST_CASE
|
||||
#define SINGLE_TEST_CASE
|
||||
// #define DUMP_TEST_CASE 7219
|
||||
// #define TOT_TEST_CASE 10000
|
||||
|
||||
|
|
@ -488,32 +496,121 @@ void dump_ignore() {}
|
|||
void prep() {
|
||||
}
|
||||
|
||||
vector<int> factcount(int n) {
|
||||
vector<bool> not_prime(n + 1);
|
||||
vector<int> res(n + 1), num(n + 1);
|
||||
res[1] = 1;
|
||||
for (int i = 2; i <= n; ++i) {
|
||||
if (not not_prime[i]) {
|
||||
res[i] = 2;
|
||||
num[i] = 1;
|
||||
}
|
||||
for (auto&& x : res) {
|
||||
if (i * x > n) break;
|
||||
not_prime[i * x] = 1;
|
||||
if (i % x == 0) {
|
||||
num[i * x] = num[i] + 1;
|
||||
res[i * x] = res[i] / num[i * x] * (num[i * x] + 1);
|
||||
break;
|
||||
}
|
||||
num[i * x] = 1;
|
||||
res[i * x] = res[i] * 2;
|
||||
void solve() {
|
||||
read(int, n, m, k);
|
||||
vector<vector<short>> grid(n + 1, vector<short>(m + 1));
|
||||
vector<vector<short>> x_diff(n + 1, vector<short>(m + 2)), y_diff(m + 1, vector<short>(n + 2));
|
||||
while (k--) {
|
||||
read(short, x1, y1, x2, y2);
|
||||
if (x1 == x2) {
|
||||
if (y1 > y2) swap(y1, y2);
|
||||
x_diff[x1][y1] += 1;
|
||||
x_diff[x1][y2 + 1] -= 1;
|
||||
} else if (y1 == y2) {
|
||||
if (x1 > x2) swap(x1, x2);
|
||||
y_diff[y1][x1] += 1;
|
||||
y_diff[y1][x2 + 1] -= 1;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
int curr = 0;
|
||||
for (int j = 1; j <= m; ++j) {
|
||||
curr += x_diff[i][j];
|
||||
if (curr) grid[i][j] = 1;
|
||||
}
|
||||
}
|
||||
for (int i = 1; i <= m; ++i) {
|
||||
int curr = 0;
|
||||
for (int j = 1; j <= n; ++j) {
|
||||
curr += y_diff[i][j];
|
||||
if (curr) grid[j][i] = 1;
|
||||
}
|
||||
}
|
||||
// for (int i = 1; i <= n; ++i) {
|
||||
// for (int j = 1; j <= m; ++j) {
|
||||
// cerr << grid[i][j] << " \n"[j == m];
|
||||
// }
|
||||
// }
|
||||
// cerr << endl;
|
||||
read(short, sx, sy);
|
||||
grid[sx][sy] = 2;
|
||||
deque<pair<short, short>> q, nq;
|
||||
q.emplace_back(sx, sy);
|
||||
vector<vector<short>> t(n + 1, vector<short>(m + 1));
|
||||
vector<vector<bool>> v(n + 1, vector<bool>(m + 1));
|
||||
while (1) {
|
||||
int f = 0;
|
||||
// debug(endl);
|
||||
while (q.size()) {
|
||||
popfront(q, x, y);
|
||||
// debug(make_tuple(x, y));
|
||||
grid[x][y] = 2;
|
||||
if (x - 1 >= 1) {
|
||||
if (v[x - 1][y] == 0) {
|
||||
if (grid[x - 1][y] == 0) {
|
||||
q.emplace_back(x - 1, y);
|
||||
} else if (grid[x - 1][y] == 1) {
|
||||
nq.emplace_back(x - 1, y);
|
||||
}
|
||||
v[x - 1][y] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (x + 1 <= n) {
|
||||
if (v[x + 1][y] == 0) {
|
||||
if (grid[x + 1][y] == 0) {
|
||||
q.emplace_back(x + 1, y);
|
||||
} else if (grid[x + 1][y] == 1) {
|
||||
nq.emplace_back(x + 1, y);
|
||||
}
|
||||
v[x + 1][y] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (y + 1 <= m) {
|
||||
if (v[x][y + 1] == 0) {
|
||||
if (grid[x][y + 1] == 0) {
|
||||
q.emplace_back(x, y + 1);
|
||||
} else if (grid[x][y + 1] == 1) {
|
||||
nq.emplace_back(x, y + 1);
|
||||
}
|
||||
v[x][y + 1] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
if (y - 1 >= 1) {
|
||||
if (v[x][y - 1] == 0) {
|
||||
if (grid[x][y - 1] == 0) {
|
||||
q.emplace_back(x, y - 1);
|
||||
} else if (grid[x][y - 1] == 1) {
|
||||
nq.emplace_back(x, y - 1);
|
||||
}
|
||||
v[x][y - 1] = 1;
|
||||
}
|
||||
} else {
|
||||
f = 1;
|
||||
}
|
||||
|
||||
void solve() {
|
||||
cout << functor(std::min<int>)(1, 2);
|
||||
}
|
||||
if (f) {
|
||||
break;
|
||||
} else {
|
||||
swap(q, nq);
|
||||
}
|
||||
}
|
||||
int res = 0;
|
||||
for (int i = 1; i <= n; ++i) {
|
||||
for (int j = 1; j <= m; ++j) {
|
||||
// cerr << grid[i][j] << " \n"[j == m];
|
||||
if (grid[i][j] == 0) {
|
||||
res += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
cout << res << '\n';
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
|
|
|||
Loading…
Reference in New Issue