題目連結

題解

費用流神題。

對於每一個方格延伸出去的每一根水管，有且僅有一個其他方格延伸出的水管與之相連，這樣就不會漏水。即：每根水管的容量為1$1$，且必須滿流。

然而即使產生了最優情況，整個管網也不一定是一整個聯通塊，而可能被分成若干塊。因此，我們要對每個格點染色，相鄰的兩個格點，一個連源點，一個連匯點，就可以強制使每兩個相鄰的方格上都產生流量了。

旋轉所花的步數即是費用。將一個方格拆成5$5$個點（上下左右中）,中間點連上源or$or$匯點，並根據水管情況向四周連容量1$1$，費用0$0$的邊。四周視作接觸點，與對應相鄰的另一個接觸點連容量1$1$，費用0$0$的邊。接下來，對於每一種形狀的格子，分類討論。

• 射線型：讓左、下、右接觸點直接連線上接觸點。左，右連上去，只轉一次，所以費用為1$1$。下面連上去費用就是2$2$。
• 直角型：旋轉一次後，發現上下切換or$or$左右切換。那麼上與下、左與右之間各建一條容量為1$1$，費用為1$1$的邊。
• 丁字型：與第一種情況類似，左、上、右接觸點直接連線下接觸點。左，右連下去，只轉一次，所以費用為1$1$。上面連下去費用就是2$2$。

至此，構圖已經完成，接下來只要套上模版即可。

程式碼

//「Luogu4003」Infinity Loop
#include <cstdio>
#include <cstring>
#include <iostream>
 

#include <queue>
using namespace std;
#define c(k) k + (sum << 2)
#define u(k) k + turn * sum
#define r(k) k + ((turn + 1) & 3) * sum
#define d(k) k + ((turn + 2) & 3) * sum
#define l(k) k + ((turn + 3) & 3) * sum
const int maxn = 100005;
const int maxm = 2000005;
const int inf = 1000000000;
bool
 
 vis[maxn];
int n, m, cnt, sum, src, snk, ans, dis[maxn];
int tot, ter[maxm], len[maxm], wei[maxm], nxt[maxm], lnk[maxn];
inline void add(int u, int v, int w0, int w1) {
    ter[tot] = v;
    len[tot] = w0;
    wei[tot] = w1;
    nxt[tot] = lnk[u];
    lnk[u] = tot++;
//  printf("(%d, %d): (%d, %d);\n", u, v, w0, w1);
}
void addedge(int u, int v, int w0, int w1, int type) {
    if (type) {
        swap(u, v);
    }
    add(u, v, w0, w1);
    add(v, u, 0, -w1);
}
bool spfa(int s, int t) {
    queue<int> que;
    que.push(s);
    memset(dis, 0x3f, sizeof(dis));
    dis[s] = 0, vis[s] = 1;
    int w0, w1;
    for (int u, v; !que.empty(); ) {
        u = que.front();
        que.pop();
        vis[u] = 0;
        for (int i = lnk[u]; ~i; i = nxt[i]) {
            v = ter[i], w0 = len[i], w1 = wei[i];
            if (w0 && dis[v] > dis[u] + w1) {
                dis[v] = dis[u] + w1;
                if (!vis[v]) {
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    return dis[t] < inf;
}
int find(int u, int lft) {
    if (u == snk) {
        return lft;
    }
    vis[u] = 1;
    int w0, w1, tmp, res = 0;
    for (int v, i = lnk[u]; ~i && res < lft; i = nxt[i]) {
        v = ter[i], w0 = len[i], w1 = wei[i];
        if (w0 && !vis[v] && dis[u] + w1 == dis[v]) {
            tmp = find(v, min(lft - res, w0));
            if (tmp) {
                ans += tmp * w1;
                len[i] -= tmp;
                len[i ^ 1] += tmp;
                res += tmp;
            }
        }
    }
    vis[u] = 0;
    return res;
}
int mcmf() {
    int tmp, res = 0;
    while (spfa(src, snk)) {
        tmp = find(src, inf);
        while (tmp) {
            res += tmp;
            tmp = find(src, inf);
        }
    }
    return res;
}
int main() {
    memset(lnk, -1, sizeof(lnk));
    scanf("%d %d", &n, &m);
    sum = n * m;
    src = 0;
    snk = sum * 5 + 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            int turn = 0, shape;
            int type = (i ^ j) & 1;
            int id = (i - 1) * m + j;
            scanf("%d", &shape);
            if (type) {
                addedge(src, c(id), inf, 0, 0);
            } else {
                addedge(c(id), snk, inf, 0, 0);
            }
            if (i > 1) {
                addedge(d(id - m), u(id), 1, 0, type);
            }
            if (j > 1) {
                addedge(r(id - 1), l(id), 1, 0, type);
            }
            if (shape & 1) {
                addedge(u(id), c(id), 1, 0, type);
                cnt++;
            }
            if (shape & 2) {
                addedge(r(id), c(id), 1, 0, type);
                cnt++;
            }
            if (shape & 4) {
                addedge(d(id), c(id), 1, 0, type);
                cnt++;
            }
            if (shape & 8) {
                addedge(l(id), c(id), 1, 0, type);
                cnt++;
            }
            switch (shape) {
            case 8:
                turn++;
            case 4:
                turn++;
            case 2:
                turn++;
            case 1:
                addedge(r(id), u(id), 1, 1, type);
                addedge(d(id), u(id), 1, 2, type);
                addedge(l(id), u(id), 1, 1, type);
                break;
            case 9:
                turn++;
            case 12:
                turn++;
            case 6:
                turn++;
            case 3:
                addedge(d(id), u(id), 1, 1, type);
                addedge(l(id), r(id), 1, 1, type);
                break;
            case 13:
                turn++;
            case 14:
                turn++;
            case 7:
                turn++;
            case 11:
                addedge(d(id), l(id), 1, 1, type);
                addedge(d(id), u(id), 1, 2, type);
                addedge(d(id), r(id), 1, 1, type);
                break;
            }
        }
    }
    cnt >>= 1;
    if (mcmf() == cnt) {
        printf("%d\n", ans);
    } else {
        puts("-1");
    }
    return 0;
}