洛谷P4486 Kakuro

题意：你有一个棋盘，某些格子是限制条件，形如"从这里开始下面所有连续空格的和为a"或"从这里开始向右的所有连续空格之和为b"一个格子可以同时拥有两个限制条件。

每个数都必须是正整数。

现在你可以把某些格子加/减1，并花费相应的代价。可以操作无数次。求把棋盘变得合法的最小代价。

解：没想出来，看了题解......

一开始想了数字和条件构成二分图，又想了行列连边，但是始终建不出图来。

行列连边。

因为既可以加又可以减不好搞，我们可以先全部转换成满足条件的最小值，然后往上加。

从最小值到初始值的时候，边权为负。之后边权为正。

不可修改的地方边权为INF。

然后跑一个最小费用可行流就是答案。

如何判断无解？

考虑每条边，如果有的边费用为INF但是有流量，就不合法。

#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>

typedef long long LL;
const LL N = 2000, M = 1000010, INF = 0x3f3f3f3f, J = 35;

struct Edge {
    LL nex, v, c, len;
}edge[N << 1]; LL top = 1;

LL e[N], d[N], vis[N], pre[N], flow[N];
std::queue<LL> Q;
LL fr[J][J], val[J][J], v2[J][J], cst[J][J], c2[J][J], m;

inline void add(LL x, LL y, LL z, LL w) {
    top++;
    edge[top].v = y;
    edge[top].c = z;
    edge[top].len = w;
    edge[top].nex = e[x];
    e[x] = top;

    top++;
    edge[top].v = x;
    edge[top].c = 0;
    edge[top].len = -w;
    edge[top].nex = e[y];
    e[y] = top;
    return;
}

inline bool SPFA(LL s, LL t) {
    memset(d, 0x3f, sizeof(d));
    d[s] = 0;
    flow[s] = INF;
    vis[s] = 1;
    Q.push(s);
    while(!Q.empty()) {
        LL x = Q.front();
        Q.pop();
        vis[x] = 0;
        for(LL i = e[x]; i; i = edge[i].nex) {
            LL y = edge[i].v;
            if(edge[i].c && d[y] > d[x] + edge[i].len) {
                d[y] = d[x] + edge[i].len;
                pre[y] = i;
                flow[y] = std::min(flow[x], edge[i].c);
                if(!vis[y]) {
                    vis[y] = 1;
                    Q.push(y);
                }
            }
        }
    }
    return d[t] < INF;
}

inline void update(LL s, LL t) {
    LL temp = flow[t];
    while(t != s) {
        LL i = pre[t];
        edge[i].c -= temp;
        edge[i ^ 1].c += temp;
        t = edge[i ^ 1].v;
    }
    return;
}

inline LL solve(LL s, LL t, LL &cost) {
    LL ans = 0;
    cost = 0;
    while(SPFA(s, t)) {
        if(d[t] > 0) {
            break;
        }
        ans += flow[t];
        cost += flow[t] * d[t];
        update(s, t);
    }
    return ans;
}

inline LL id(LL x, LL y) {
    return (x - 1) * m + y;
}

int main() {
    LL n, use = 0;
    scanf("%lld%lld", &n, &m);
    for(LL i = 1; i <= n; i++) {
        for(LL j = 1; j <= m; j++) {
            scanf("%lld", &fr[i][j]);
        }
    }
    for(LL i = 1; i <= n; i++) {
        for(LL j = 1; j <= m; j++) {
            if(fr[i][j] == 0) {
                continue;
            }
            else if(fr[i][j] == 1) {
                scanf("%lld", &val[i][j]);
            }
            else if(fr[i][j] == 2) {
                scanf("%lld", &v2[i][j]);
            }
            else if(fr[i][j] == 3) {
                scanf("%lld%lld", &val[i][j], &v2[i][j]);
            }
            else {
                scanf("%lld", &val[i][j]);
            }
        }
    }
    for(LL i = 1; i <= n; i++) {
        for(LL j = 1; j <= n; j++) {
            if(fr[i][j] == 0) {
                continue;
            }
            else if(fr[i][j] == 1) {
                scanf("%lld", &cst[i][j]);
            }
            else if(fr[i][j] == 2) {
                scanf("%lld", &c2[i][j]);
            }
            else if(fr[i][j] == 3) {
                scanf("%lld%lld", &cst[i][j], &c2[i][j]);
            }
            else {
                scanf("%lld", &cst[i][j]);
            }
            if(cst[i][j] == -1) {
                cst[i][j] = INF;
            }
            if(c2[i][j] == -1) {
                c2[i][j] = INF;
            }
        }
    }
    // read over
    LL lm = n * m;
    LL s = lm * 2 + 1;
    LL t = s + 1;
    for(LL i = 1; i <= n; i++) {
        for(LL j = 1; j <= m; j++) {
            if(fr[i][j] == 0) {
                continue;
            }
            if(fr[i][j] == 1 || fr[i][j] == 3) {
                // id(i, j)
                LL cnt = 0;
                for(LL k = i + 1; k <= n; k++) {
                    if(fr[k][j] == 4) {
                        cnt++;
                    }
                    else {
                        break;
                    }
                }
                // val[i][j] - cnt
                if(val[i][j] > cnt) {
                    add(s, id(i, j), val[i][j] - cnt, -cst[i][j]);
                }
                add(s, id(i, j), INF, cst[i][j]);
                use += cst[i][j] * abs(val[i][j] - cnt);
            }
            if(fr[i][j] == 2 || fr[i][j] == 3) {
                LL cnt = 0;
                for(LL k = j + 1; k <= m; k++) {
                    if(fr[i][k] == 4) {
                        cnt++;
                    }
                    else {
                        break;
                    }
                }
                if(v2[i][j] > cnt) {
                    add(id(i, j) + lm, t, v2[i][j] - cnt, -c2[i][j]);
                }
                add(id(i, j) + lm, t, INF, c2[i][j]);
                use += c2[i][j] * abs(v2[i][j] - cnt);
            }
            if(fr[i][j] == 4) {
                LL a, b;
                for(LL k = i - 1; k >= 1; k--) {
                    if(fr[k][j] == 1 || fr[k][j] == 3) {
                        a = id(k, j);
                        break;
                    }
                }
                for(LL k = j - 1; k >= 1; k--) {
                    if(fr[i][k] == 2 || fr[i][k] == 3) {
                        b = id(i, k) + lm;
                        break;
                    }
                }
                if(val[i][j] > 1) {
                    add(a, b, val[i][j] - 1, -cst[i][j]);
                }
                add(a, b, INF, cst[i][j]);
                use += cst[i][j] * abs(val[i][j] - 1);
            }
        }
    }

    LL ans;
    solve(s, t, ans);
    ans += use;

    /*if(ans >= INF) {
        puts("-1");
        return 0;
    }*/
    for(int i = 2; i <= top; i += 2) {
        if(abs(edge[i].len) == INF && (edge[i].c && edge[i ^ 1].c)) {
            puts("-1");
            return 0;
        }
    }

    printf("%lld", ans);
    return 0;
}

思考：能否不转换为最小？好像无法判断是否合法...