Solution -「Gym 102759C」Economic One-way Roads

\(\mathcal{Description}\)

  Link.

  给定一个含 \(n\) 个点 \(m\) 条边的简单无向图，每条边的两种定向方法各有权值，求使得图强连通且定向权值和最小的方法。

  \(n\le 18\)。

\(\mathcal{Solution}\)

  涉及到叫做“耳分解”的知识点。

有向图 \(G=(V,E)\) 是否强连通有以下判别方法：

• 取任意 \(u\in V\)，令点集 \(S=\{u\}\)；
• 反复取 \(x,y\in S\)，以及连接 \(x,y\) 的一条有向路径 \(P=\lang x,u_1,\cdots,u_k,y\rang\)，满足 \(u_i\not\in S,~i\in[1,k]\)，并令 \(S\leftarrow S\cup\{u_1,\cdots,u_k\}\)。
• 若 \(S=V\)，则 \(G\) 强连通；否则即找不到增广路 \(P\)，\(G\) 非强连通。

其中 \(P\) 就是一个“耳”，这就是“耳分解”。

——当然“耳”貌似最初定义于无向图。

  知道了这个构造强连通图的 trick 就极简了，首先在双向边权中随便选一个预支付代价，并令 \(f(S)\) 表示在 \(S\) 的导出子图内使 \(S\) 强连通的最小代价，\(g(S,x,y,0/1)\) 表示点集 \(S\) 中，当前正在构造的“耳”从 \(x\) 出发，希望回到 \(y\)，不能/能 直接走 \(\lang x,y\rang\) 这条边。随便转移即可。复杂度上限是 \(\mathcal O(2^nn^3)\)，但算法本身和状态合法性带来了小常数√

\(\mathcal{Code}\)

/*~Rainybunny~*/

#include <cstdio>
#include <cstring>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

const int MAXN = 18, IINF = 0x3f3f3f3f;
int n, adj[MAXN + 5][MAXN + 5], f[1 << MAXN], g[1 << MAXN][MAXN][MAXN][2];

inline void chkmin( int& a, const int b ) { b < a && ( a = b ); }
inline int imin( const int a, const int b ) { return a < b ? a : b; }

int main() {
    // freopen( "data.in", "r", stdin );

    scanf( "%d", &n );
    rep ( i, 0, n - 1 ) rep ( j, 0, n - 1 ) scanf( "%d", &adj[i][j] );

    int ans = 0;
    rep ( i, 0, n - 1 ) rep ( j, i + 1, n - 1 ) {
        if ( ~adj[i][j] ) {
            int t = imin( adj[i][j], adj[j][i] );
            ans += t, adj[i][j] -= t, adj[j][i] -= t;
        }
    }

    memset( f, 0x3f, sizeof f ), memset( g, 0x3f, sizeof g ), f[1] = 0;
    rep ( S, 1, ( 1 << n ) - 1 ) if ( S & 1 ) {
        rep ( u, 0, n - 1 ) if ( S >> u & 1 ) {
            rep ( v, 0, n - 1 ) if ( S >> v & 1 && ~adj[u][v] ) {
                chkmin( f[S], g[S][u][v][1] + adj[u][v] );
            }
        }

        rep ( u, 0, n - 1 ) if ( S >> u & 1 ) {
            rep ( v, 0, n - 1 ) if ( S >> v & 1 ) {
                chkmin( g[S][u][v][0], f[S] );
            }
        }

        rep ( u, 0, n - 1 ) if ( S >> u & 1 ) {
            rep ( v, 0, n - 1 ) if ( S >> v & 1 ) {
                int* cur = g[S][u][v];
                if ( cur[0] != IINF ) {
                    rep ( w, 0, n - 1 ) if ( ~adj[u][w] && !( S >> w & 1 ) ) {
                        chkmin( g[S | 1 << w][w][v][u != v],
                          cur[0] + adj[u][w] );
                    }
                }
                if ( cur[1] != IINF ) {
                    rep ( w, 0, n - 1 ) if ( ~adj[u][w] && !( S >> w & 1 ) ) {
                        chkmin( g[S | 1 << w][w][v][1], cur[1] + adj[u][w] );
                    }
                }
            }
        }
    }

    printf( "%d\n", f[( 1 << n ) - 1] == IINF ? -1 : ans + f[( 1 << n ) - 1] );
    return 0;
}