backup
This commit is contained in:
parent
3f48d4b954
commit
d82e0e4b5c
BIN
src/bin/a.out
BIN
src/bin/a.out
Binary file not shown.
|
@ -1,8 +1,8 @@
|
||||||
/**
|
/**
|
||||||
* Author: subcrip
|
* Author: subcrip
|
||||||
* Created: 2024-05-31 23:31:18
|
* Created: 2024-06-01 13:45:49
|
||||||
* Modified: 2024-06-01 00:53:27
|
* Modified: 2024-06-01 15:48:33
|
||||||
* Elapsed: 82 minutes
|
* Elapsed: 122 minutes
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#pragma GCC optimize("Ofast")
|
#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 DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -496,177 +496,121 @@ void dump_ignore() {}
|
||||||
void prep() {
|
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() {
|
void solve() {
|
||||||
read(int, n, m, k);
|
read(int, n, m, k);
|
||||||
readvec1(ll, a, n);
|
vector<vector<short>> grid(n + 1, vector<short>(m + 1));
|
||||||
vector<map<int, vector<tiii>>> raw_ld(n + 1);
|
vector<vector<short>> x_diff(n + 1, vector<short>(m + 2)), y_diff(m + 1, vector<short>(n + 2));
|
||||||
vector<int> sz(n + 1);
|
|
||||||
vector<set<int>> st(n + 1);
|
|
||||||
vector<unordered_map<int, int, safe_hash>> mp(n + 1);
|
|
||||||
while (k--) {
|
while (k--) {
|
||||||
read(int, x1, y1, x2, y2, c);
|
read(short, x1, y1, x2, y2);
|
||||||
raw_ld[x2][y2].emplace_back(x1, y1, c);
|
if (x1 == x2) {
|
||||||
st[x1].emplace(y1);
|
if (y1 > y2) swap(y1, y2);
|
||||||
st[x2].emplace(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 (int i = 1; i <= n; ++i) {
|
||||||
for (auto&& [y, v] : raw_ld[i]) {
|
int curr = 0;
|
||||||
ld[i].emplace_back(y, v);
|
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]});
|
for (int i = 1; i <= m; ++i) {
|
||||||
right_tr[1].set(1, {-a[1]});
|
int curr = 0;
|
||||||
ll res = -INFLL;
|
for (int j = 1; j <= n; ++j) {
|
||||||
for (int i = 2; i <= n; ++i) {
|
curr += y_diff[i][j];
|
||||||
for (auto&& [y, v] : ld[i]) {
|
if (curr) grid[j][i] = 1;
|
||||||
ll mx = -INFLL;
|
}
|
||||||
for (auto&& [x1, y1, profit] : v) {
|
}
|
||||||
// left
|
// for (int i = 1; i <= n; ++i) {
|
||||||
ll left = left_tr[x1].range_query(0, mp[x1][y1]).val;
|
// for (int j = 1; j <= m; ++j) {
|
||||||
if (left != -INFLL) {
|
// cerr << grid[i][j] << " \n"[j == m];
|
||||||
mx = max(mx, left - a[x1] * y1 + profit);
|
// }
|
||||||
}
|
// }
|
||||||
// right
|
// cerr << endl;
|
||||||
ll right = right_tr[x1].range_query(mp[x1][y1], sz[x1]).val;
|
read(short, sx, sy);
|
||||||
if (right != -INFLL) {
|
grid[sx][sy] = 2;
|
||||||
mx = max(mx, right + a[x1] * y1 + profit);
|
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;
|
if (x + 1 <= n) {
|
||||||
ll raw_left = left_tr[i].query(mp[i][y]).val;
|
if (v[x + 1][y] == 0) {
|
||||||
left_tr[i].set(mp[i][y], {max(raw_left, mx + y * a[i])});
|
if (grid[x + 1][y] == 0) {
|
||||||
ll raw_right = right_tr[i].query(mp[i][y]).val;
|
q.emplace_back(x + 1, y);
|
||||||
right_tr[i].set(mp[i][y], {max(raw_right, mx - y * a[i])});
|
} else if (grid[x + 1][y] == 1) {
|
||||||
if (i == n) {
|
nq.emplace_back(x + 1, y);
|
||||||
res = max(res, mx - (m - y) * a[i]);
|
}
|
||||||
|
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 << res << '\n';
|
||||||
cout << "NO ESCAPE\n";
|
|
||||||
} else {
|
|
||||||
cout << -res << '\n';
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
|
|
|
@ -1,22 +1,16 @@
|
||||||
4
|
17 17 14
|
||||||
5 3 3
|
2 2 2 13
|
||||||
5 17 8 1 4
|
2 2 7 2
|
||||||
1 3 3 3 4
|
2 7 9 7
|
||||||
3 1 5 2 5
|
7 2 7 7
|
||||||
3 2 5 1 6
|
9 7 9 13
|
||||||
6 3 3
|
2 13 9 13
|
||||||
5 17 8 1 4 2
|
11 2 11 7
|
||||||
1 3 3 3 4
|
11 2 16 2
|
||||||
3 1 5 2 5
|
16 2 16 7
|
||||||
3 2 5 1 6
|
16 7 11 7
|
||||||
5 3 1
|
4 15 4 17
|
||||||
5 17 8 1 4
|
4 15 12 15
|
||||||
1 3 5 3 100
|
12 15 12 9
|
||||||
5 5 5
|
12 9 17 9
|
||||||
3 2 3 7 5
|
8 9
|
||||||
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
|
|
||||||
|
|
||||||
|
|
|
@ -496,7 +496,7 @@ int main() {
|
||||||
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__)
|
||||||
assert(false && "incompatible compiler variant detected.");
|
assert(false && "incompatible compiler variant detected.");
|
||||||
#endif
|
#endif
|
||||||
untie, cout.tie(NULL);
|
untie;
|
||||||
prep();
|
prep();
|
||||||
#ifdef SINGLE_TEST_CASE
|
#ifdef SINGLE_TEST_CASE
|
||||||
solve();
|
solve();
|
||||||
|
|
153
src/bin/test.cc
153
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")
|
#pragma GCC optimize("Ofast")
|
||||||
/////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////
|
||||||
/**
|
/**
|
||||||
|
@ -173,6 +180,7 @@ struct array_hash {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* build data structures */
|
/* 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 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 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);)
|
#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
|
// 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) {
|
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)); });
|
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) {
|
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());
|
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 DUMP_TEST_CASE 7219
|
||||||
// #define TOT_TEST_CASE 10000
|
// #define TOT_TEST_CASE 10000
|
||||||
|
|
||||||
|
@ -488,32 +496,121 @@ void dump_ignore() {}
|
||||||
void prep() {
|
void prep() {
|
||||||
}
|
}
|
||||||
|
|
||||||
vector<int> factcount(int n) {
|
void solve() {
|
||||||
vector<bool> not_prime(n + 1);
|
read(int, n, m, k);
|
||||||
vector<int> res(n + 1), num(n + 1);
|
vector<vector<short>> grid(n + 1, vector<short>(m + 1));
|
||||||
res[1] = 1;
|
vector<vector<short>> x_diff(n + 1, vector<short>(m + 2)), y_diff(m + 1, vector<short>(n + 2));
|
||||||
for (int i = 2; i <= n; ++i) {
|
while (k--) {
|
||||||
if (not not_prime[i]) {
|
read(short, x1, y1, x2, y2);
|
||||||
res[i] = 2;
|
if (x1 == x2) {
|
||||||
num[i] = 1;
|
if (y1 > y2) swap(y1, y2);
|
||||||
}
|
x_diff[x1][y1] += 1;
|
||||||
for (auto&& x : res) {
|
x_diff[x1][y2 + 1] -= 1;
|
||||||
if (i * x > n) break;
|
} else if (y1 == y2) {
|
||||||
not_prime[i * x] = 1;
|
if (x1 > x2) swap(x1, x2);
|
||||||
if (i % x == 0) {
|
y_diff[y1][x1] += 1;
|
||||||
num[i * x] = num[i] + 1;
|
y_diff[y1][x2 + 1] -= 1;
|
||||||
res[i * x] = res[i] / num[i * x] * (num[i * x] + 1);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
num[i * x] = 1;
|
|
||||||
res[i * x] = res[i] * 2;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return res;
|
for (int i = 1; i <= n; ++i) {
|
||||||
}
|
int curr = 0;
|
||||||
|
for (int j = 1; j <= m; ++j) {
|
||||||
void solve() {
|
curr += x_diff[i][j];
|
||||||
cout << functor(std::min<int>)(1, 2);
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
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() {
|
int main() {
|
||||||
|
|
Loading…
Reference in New Issue