backup

src/bin/ctext_out.cc

@@ -1,8 +1,8 @@
 /**
  * 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")
@@ -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<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--) {
-        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 (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() {

src/bin/std.in

@@ -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
-

src/bin/template.cc

@@ -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();

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) {
+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) {
+            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() {