提出 #18766613

ソースコード 拡げる

#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>


#include <algorithm>
#include <utility>
#include <vector>

namespace atcoder {
namespace internal {

template <class E> struct csr {
    std::vector<int> start;
    std::vector<E> elist;
    csr(int n, const std::vector<std::pair<int, E>>& edges)
        : start(n + 1), elist(edges.size()) {
        for (auto e : edges) {
            start[e.first + 1]++;
        }
        for (int i = 1; i <= n; i++) {
            start[i] += start[i - 1];
        }
        auto counter = start;
        for (auto e : edges) {
            elist[counter[e.first]++] = e.second;
        }
    }
};

}  // namespace internal

}  // namespace atcoder


#include <vector>

namespace atcoder {

namespace internal {

template <class T> struct simple_queue {
    std::vector<T> payload;
    int pos = 0;
    void reserve(int n) { payload.reserve(n); }
    int size() const { return int(payload.size()) - pos; }
    bool empty() const { return pos == int(payload.size()); }
    void push(const T& t) { payload.push_back(t); }
    T& front() { return payload[pos]; }
    void clear() {
        payload.clear();
        pos = 0;
    }
    void pop() { pos++; }
};

}  // namespace internal

}  // namespace atcoder


namespace atcoder {

template <class Cap, class Cost> struct mcf_graph {
  public:
    mcf_graph() {}
    mcf_graph(int n) : _n(n) {}

    int add_edge(int from, int to, Cap cap, Cost cost) {
        assert(0 <= from && from < _n);
        assert(0 <= to && to < _n);
        assert(0 <= cap);
        assert(0 <= cost);
        int m = int(_edges.size());
        _edges.push_back({from, to, cap, 0, cost});
        return m;
    }

    struct edge {
        int from, to;
        Cap cap, flow;
        Cost cost;
    };

    edge get_edge(int i) {
        int m = int(_edges.size());
        assert(0 <= i && i < m);
        return _edges[i];
    }
    std::vector<edge> edges() { return _edges; }

    std::pair<Cap, Cost> flow(int s, int t) {
        return flow(s, t, std::numeric_limits<Cap>::max());
    }
    std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
        return slope(s, t, flow_limit).back();        
    }
    std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
        return slope(s, t, std::numeric_limits<Cap>::max());
    }
    std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
        assert(0 <= s && s < _n);
        assert(0 <= t && t < _n);
        assert(s != t);

        int m = int(_edges.size());
        std::vector<int> edge_idx(m);

        auto g = [&]() {
            std::vector<int> degree(_n), redge_idx(m);
            std::vector<std::pair<int, _edge>> elist;
            elist.reserve(2 * m);
            for (int i = 0; i < m; i++) {
                auto e = _edges[i];
                edge_idx[i] = degree[e.from]++;
                redge_idx[i] = degree[e.to]++;
                elist.push_back({e.from, {e.to, -1, e.cap - e.flow, e.cost}});
                elist.push_back({e.to, {e.from, -1, e.flow, -e.cost}});
            }
            auto _g = internal::csr<_edge>(_n, elist);
            for (int i = 0; i < m; i++) {
                auto e = _edges[i];
                edge_idx[i] += _g.start[e.from];
                redge_idx[i] += _g.start[e.to];
                _g.elist[edge_idx[i]].rev = redge_idx[i];
                _g.elist[redge_idx[i]].rev = edge_idx[i];
            }
            return _g;
        }();

        auto result = slope(g, s, t, flow_limit);

        for (int i = 0; i < m; i++) {
            auto e = g.elist[edge_idx[i]];
            _edges[i].flow = _edges[i].cap - e.cap;
        }

        return result;
    }

  private:
    int _n;
    std::vector<edge> _edges;

    struct _edge {
        int to, rev;
        Cap cap;
        Cost cost;
    };

    std::vector<std::pair<Cap, Cost>> slope(internal::csr<_edge>& g,
                                            int s,
                                            int t,
                                            Cap flow_limit) {

        std::vector<std::pair<Cost, Cost>> dual_dist(_n);
        std::vector<int> prev_e(_n);
        std::vector<bool> vis(_n);
        struct Q {
            Cost key;
            int to;
            bool operator<(Q r) const { return key > r.key; }
        };
        std::vector<int> que_min;
        std::vector<Q> que;
        auto dual_ref = [&]() {
            for (int i = 0; i < _n; i++) {
                dual_dist[i].second = std::numeric_limits<Cost>::max();
            }
            std::fill(vis.begin(), vis.end(), false);
            que_min.clear();
            que.clear();

            size_t heap_r = 0;

            dual_dist[s].second = 0;
            que_min.push_back(s);
            while (!que_min.empty() || !que.empty()) {
                int v;
                if (!que_min.empty()) {
                    v = que_min.back();
                    que_min.pop_back();
                } else {
                    while (heap_r < que.size()) {
                        heap_r++;
                        std::push_heap(que.begin(), que.begin() + heap_r);
                    }
                    v = que.front().to;
                    std::pop_heap(que.begin(), que.end());
                    que.pop_back();
                    heap_r--;
                }
                if (vis[v]) continue;
                vis[v] = true;
                if (v == t) break;
                Cost dual_v = dual_dist[v].first, dist_v = dual_dist[v].second;
                for (int i = g.start[v]; i < g.start[v + 1]; i++) {
                    auto e = g.elist[i];
                    if (!e.cap) continue;
                    Cost cost = e.cost - dual_dist[e.to].first + dual_v;
                    if (dual_dist[e.to].second - dist_v > cost) {
                        Cost dist_to = dist_v + cost;
                        dual_dist[e.to].second = dist_to;
                        prev_e[e.to] = e.rev;
                        if (dist_to == dist_v) {
                            que_min.push_back(e.to);
                        } else {
                            que.push_back(Q{dist_to, e.to});
                        }
                    }
                }
            }
            if (!vis[t]) {
                return false;
            }

            for (int v = 0; v < _n; v++) {
                if (!vis[v]) continue;
                dual_dist[v].first -= dual_dist[t].second - dual_dist[v].second;
            }
            return true;
        };
        Cap flow = 0;
        Cost cost = 0, prev_cost_per_flow = -1;
        std::vector<std::pair<Cap, Cost>> result = {{Cap(0), Cost(0)}};
        while (flow < flow_limit) {
            if (!dual_ref()) break;
            Cap c = flow_limit - flow;
            for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
                c = std::min(c, g.elist[g.elist[prev_e[v]].rev].cap);
            }
            for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
                auto& e = g.elist[prev_e[v]];
                e.cap += c;
                g.elist[e.rev].cap -= c;
            }
            Cost d = -dual_dist[s].first;
            flow += c;
            cost += c * d;
            if (prev_cost_per_flow == d) {
                result.pop_back();
            }
            result.push_back({flow, cost});
            prev_cost_per_flow = d;
        }
        return result;
    }
};

}  // namespace atcoder

#include <iostream>

using namespace std;
using namespace atcoder;

const long long BIG = 1'000'000'000;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;

    mcf_graph<int, long long> g(1 + n + 4 + n + 1);
    int sv = 0, le_st = 1, mid_st = 1 + n, ri_st = 1 + n + 4, tv = 1 + n + 4 + n;

    long long base = 0;
    const long long OFF = 2 * BIG;

    for (int i = 0; i < n; i++) {
        long long x, y;
        int z;
        cin >> x >> y >> z;

        base += z * OFF;
        g.add_edge(sv, le_st + i, z, 0);
        g.add_edge(le_st + i, mid_st + 0, z, OFF + x + y);
        g.add_edge(le_st + i, mid_st + 1, z, OFF + x - y);
        g.add_edge(le_st + i, mid_st + 2, z, OFF - x + y);
        g.add_edge(le_st + i, mid_st + 3, z, OFF - x - y);
    }

    for (int i = 0; i < n; i++) {
        long long x, y;
        int z;
        cin >> x >> y >> z;

        base += z * OFF;
        g.add_edge(mid_st + 0, ri_st + i, z, OFF - x - y);
        g.add_edge(mid_st + 1, ri_st + i, z, OFF - x + y);
        g.add_edge(mid_st + 2, ri_st + i, z, OFF + x - y);
        g.add_edge(mid_st + 3, ri_st + i, z, OFF + x + y);
        g.add_edge(ri_st + i, tv, z, 0);
    }

    cout << base - g.flow(sv, tv).second << endl;
    return 0;
}

提出情報

提出日時
問題 D - Manhattan Max Matching
ユーザ yosupo
言語 C++ (GCC 9.2.1)
得点 1200
コード長 9092 Byte
結果 AC
実行時間 226 ms
メモリ 4756 KiB

ジャッジ結果

セット名 Sample All
得点 / 配点 0 / 0 1200 / 1200
結果
AC × 3
AC × 36
セット名 テストケース
Sample sample-01.txt, sample-02.txt, sample-03.txt
All 01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 01-09.txt, 01-10.txt, 01-11.txt, 01-12.txt, 01-13.txt, 01-14.txt, 01-15.txt, 01-16.txt, 01-17.txt, 01-18.txt, 01-19.txt, 01-20.txt, 01-21.txt, 01-22.txt, 01-23.txt, 01-24.txt, 01-25.txt, 01-26.txt, 01-27.txt, 01-28.txt, 01-29.txt, 01-30.txt, 01-31.txt, 01-32.txt, 01-33.txt, sample-01.txt, sample-02.txt, sample-03.txt
ケース名 結果 実行時間 メモリ
01-01.txt AC 6 ms 3504 KiB
01-02.txt AC 140 ms 4488 KiB
01-03.txt AC 37 ms 4624 KiB
01-04.txt AC 118 ms 4684 KiB
01-05.txt AC 150 ms 4528 KiB
01-06.txt AC 157 ms 4588 KiB
01-07.txt AC 118 ms 4624 KiB
01-08.txt AC 160 ms 4756 KiB
01-09.txt AC 146 ms 4752 KiB
01-10.txt AC 140 ms 4688 KiB
01-11.txt AC 201 ms 4752 KiB
01-12.txt AC 183 ms 4540 KiB
01-13.txt AC 130 ms 4544 KiB
01-14.txt AC 101 ms 4624 KiB
01-15.txt AC 106 ms 4572 KiB
01-16.txt AC 189 ms 4684 KiB
01-17.txt AC 219 ms 4624 KiB
01-18.txt AC 155 ms 4592 KiB
01-19.txt AC 48 ms 4568 KiB
01-20.txt AC 125 ms 4592 KiB
01-21.txt AC 152 ms 4748 KiB
01-22.txt AC 171 ms 4572 KiB
01-23.txt AC 120 ms 4588 KiB
01-24.txt AC 162 ms 4540 KiB
01-25.txt AC 152 ms 4560 KiB
01-26.txt AC 141 ms 4588 KiB
01-27.txt AC 213 ms 4752 KiB
01-28.txt AC 191 ms 4692 KiB
01-29.txt AC 139 ms 4592 KiB
01-30.txt AC 130 ms 4692 KiB
01-31.txt AC 115 ms 4676 KiB
01-32.txt AC 197 ms 4568 KiB
01-33.txt AC 226 ms 4588 KiB
sample-01.txt AC 2 ms 3616 KiB
sample-02.txt AC 2 ms 3460 KiB
sample-03.txt AC 2 ms 3568 KiB