2023-05-01

AOJ 2828 マトリョーシカ (JAG 模擬国内 2017 F) (550 点)

DAG の最小パス被覆、忘れた頃に出て来るイメージ！

問題概要

$N$ 個の直方体があり、 $i$ 番目の直方体の大きさは $x_{i} \times y_{i} \times z_{i}$ である。

今、ある直方体の中に他のある直方体を入れたりすることで、外部から見えている直方体の体積を小さくしたい。ただし、

直方体のそれぞれの辺は，他方の直方体のいずれかの辺に平行
回転後，対応する辺同士の長さそれぞれについて，収納される側の人形の長さの方が短い
1 個の直方体の中に直接収納できる直方体の数は高々 1 個

これらの作業を実施後の、外部から見えている直方体の体積の総和の最小値を求めよ。

制約

$1 \le N \le 100$
$1 \le x_{i}, y_{i}, z_{i} \le 100$

考えたこと

出た！！　DAG の最小パス被覆問題！！

簡単のため、まず「外部から見えている直方体の個数」を最小化する問題を考えよう。その問題が解ければ、「外部から見えている直方体の体積の総和」を最小化する問題は、それに重みを乗せるだけで解けるはず。

まず、各直方体を頂点とし、直方体の包含関係を有向辺としたグラフを考えよう。辺 $(u, v)$ は、直方体 $u$ が直方体 $v$ を内部に含めることが可能であることを表す。このグラフは DAG になる。

そして、「外部から見えている直方体の個数」するとは、つまり、この DAG の最小パス被覆 (互いに頂点を共有しない最小本数のパスですべての頂点を被覆する問題) を求める問題に他ならない。

DAG の最小パス被覆

DAG の最小パス被覆は、蟻本にも載ってる。下図のように「二部グラフの最大マッチング問題」に帰着される。

左側の DAG は、

頂点 0 → 頂点 1 → 頂点 7
頂点 4 → 頂点 2 → 頂点 3
頂点 6 → 頂点 5

という 3 本のパスで被覆されている。これは右側の二部グラフでは、8 - 3 = 5 本のマッチング辺に対応している。

よくみると、左側の 3 本のパスの始点をなす頂点 0, 4, 6 は、右側の二部グラフでは右側ノードでマッチングの端点になっていない頂点たちに対応している。

そんなわけで、「DAG の最小パス被覆の本数」は「頂点数 - 二部グラフの最大マッチングの本数」に一致する。

重みがあっても

今回は、各頂点に「体積」という重みがあるような問題と考えられる。そして、DAG のパス被覆のうち、各パスの始点の重みの総和を最小化する問題となる。

その場合は、二部グラフの各辺 $(u, v)$ に、直方体 $v$ の重みを乗せて、重み付き最大マッチングを求めれば良い。

その値が「隠れる直方体の体積の総和の最大値」になる。最後に、全直方体の体積の総和から引けばよい。

提出コード

計算量は $O(N^{3})$ となった。

#include <bits/stdc++.h>
using namespace std;

// edge class (for network-flow)
template<class FLOWTYPE, class COSTTYPE> struct Edge {
    int rev, from, to, id;
    FLOWTYPE cap, icap;
    COSTTYPE cost;
    Edge(int r, int f, int t, FLOWTYPE ca, COSTTYPE co, int id = -1) :
        rev(r), from(f), to(t), cap(ca), icap(ca), cost(co), id(id) {}
    friend ostream& operator << (ostream& s, const Edge& E) {
        if (E.cap > 0)
            return s << E.from << "->" << E.to <<
                '(' << E.cap << ',' << E.cost << ')';
        else return s;
    }
};

// graph class (for network-flow)
template<class FLOWTYPE, class COSTTYPE> struct Graph {
    vector<vector<Edge<FLOWTYPE, COSTTYPE> > > list;
    
    Graph(int n = 0) : list(n) { }
    void init(int n = 0) { list.clear(); list.resize(n); }
    void reset() { for (int i = 0; i < (int)list.size(); ++i) for (int j = 0; j < list[i].size(); ++j) list[i][j].cap = list[i][j].icap; }
    inline vector<Edge<FLOWTYPE, COSTTYPE> >& operator [] (int i) { return list[i]; }
    inline const size_t size() const { return list.size(); }
    
    inline Edge<FLOWTYPE, COSTTYPE> &redge(const Edge<FLOWTYPE, COSTTYPE> &e) {
        if (e.from != e.to) return list[e.to][e.rev];
        else return list[e.to][e.rev + 1];
    }
    
    void addedge(int from, int to, FLOWTYPE cap, COSTTYPE cost, int id = -1) {
        list[from].push_back(Edge<FLOWTYPE, COSTTYPE>((int)list[to].size(), from, to, cap, cost, id));
        list[to].push_back(Edge<FLOWTYPE, COSTTYPE>((int)list[from].size() - 1, to, from, 0, -cost));
    }
    
    void add_undirected_edge(int from, int to, FLOWTYPE cap, COSTTYPE cost, int id = -1) {
        list[from].push_back(Edge<FLOWTYPE, COSTTYPE>((int)list[to].size(), from, to, cap, cost, id));
        list[to].push_back(Edge<FLOWTYPE, COSTTYPE>((int)list[from].size() - 1, to, from, cap, cost, id));
    }

    friend ostream& operator << (ostream& s, const Graph& G) {
        s << endl;
        for (int i = 0; i < G.size(); ++i) {
            s << i << ":";
            for (auto e : G.list[i]) s << " " << e;
            s << endl;
        }
        return s;
    }
};

// min-cost flow (by primal-dual)
template<class FLOWTYPE, class COSTTYPE> COSTTYPE MinCostFlow
(Graph<FLOWTYPE, COSTTYPE> &G, int s, int t, FLOWTYPE f) {
    int n = (int)G.size();
    vector<COSTTYPE> dist(n, -1);
    vector<int> prevv(n), preve(n), seen(n, 0);
    COSTTYPE res = 0;
    while (f > 0) {
        seen.assign(n, 0);
        dist[s] = 0;
        seen[s] = true;
        while (true) {
            bool update = false;
            for (int v = 0; v < n; ++v) {
                if (!seen[v]) continue;
                for (int i = 0; i < G[v].size(); ++i) {
                    Edge<FLOWTYPE, COSTTYPE> &e = G[v][i];
                    if (e.cap > 0 && (!seen[e.to] || dist[e.to] > dist[v] + e.cost)) {
                        dist[e.to] = dist[v] + e.cost;
                        prevv[e.to] = v;
                        preve[e.to] = i;
                        seen[e.to] = true;
                        update = true;
                    }
                }
            }
            if (!update) break;
        }
        if (!seen[t]) return -1;
        FLOWTYPE d = f;
        for (int v = t; v != s; v = prevv[v]) {
            d = min(d, G[prevv[v]][preve[v]].cap);
        }
        f -= d;
        res += dist[t] * d;
        for (int v = t; v != s; v = prevv[v]) {
            Edge<FLOWTYPE, COSTTYPE> &e = G[prevv[v]][preve[v]];
            Edge<FLOWTYPE, COSTTYPE> &re = G.redge(e);
            e.cap -= d;
            re.cap += d;
        }
    }
    return res;
}

int main() {
    long long N;
    while (cin >> N, N) {
        long long sum = 0;
        vector<vector<long long>> box(N, vector<long long>(3));
        for (int i = 0; i < N; ++i) {
            cin >> box[i][0] >> box[i][1] >> box[i][2];
            sort(box[i].begin(), box[i].end());
            sum += box[i][0] * box[i][1] * box[i][2];
        }
        
        // ネットワークフロー
        int source = N*2, sink = N*2+1;
        Graph<long long, long long> G(N*2+2);
        G.addedge(source, sink, N, 0);  // 流量任意にするため
        for (int i = 0; i < N; ++i) {
            G.addedge(source, i, 1, 0);
            G.addedge(i+N, sink, 1, 0);
        }
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                if (box[i][0] > box[j][0] && box[i][1] > box[j][1] && box[i][2] > box[j][2]) {
                    G.addedge(i, j+N, 1, -box[j][0] * box[j][1] * box[j][2]);
                }
            }
        }
        long long res = sum + MinCostFlow(G, source, sink, N);
        cout << res << endl;
    }
}