UVA1104 芯片难题 Chips Challenge

答案最多不会超过160，可以考虑枚举答案。

当我们枚举答案并且确定每行的最大限度$maxn$时，其实是可以放多于答案个芯片的。因为此时仍然合法，只是不优秀。

现在，我们考虑第$i$行/列有$t_i$个部件，那么我们知道$0 \le t_i \le maxn$同时，

$$t_i = a_{i,1} + a_{i,2} + \dots + a_{i,n}\\t_i = a_{1,i} + a_{2,i} + \dots + a_{n,i}$$

移个项，发现又是流量平衡的形式了。

所以我们考虑建立$A_i$表示第$i$行/列的第一个等式，$B_i$表示第二个。那么可以从$B_i \to A_i$连费用为 1 ，上界为$maxn$的边。

然后考虑对于$a_{i,j}$的确定。如果它已经确定是 部件 了，那么从$A_i \to B_j$连费用为 0 上下界均为 1 的边，如果确定不是，上下界都是 0 ，如果不确定，上界为 1 下界为 0 。

最后跑最大费用上下界可行流就好了。

关于各种流，这篇 Blog 感觉写的很好，安利一下。

但是写了很久发现上下界可行流挂掉了。。因为这题有环啊。。。

翻了翻题解，发现了一个很优秀的做法。首先建立两排点，分别表示第$i$行和第$i$列。然后从$i$行到$i$列连一个容量为 inf 的边，费用为 0 。然后从原点向第$i$行连容量为 lim 的边，费用为0，从第$i$列向汇点连容量为 lim 的边，费用也是 0 。这样我们从一开始就可以跑满流了。现在中间两个点之间的流量，其实是$maxn - t_i$。

然后考虑会出现$C$和$.$，首先如果出现了 . ，那么我们从第$i$行向第$j$列连一条容量为 1 费用为 1 的边。但是如果这里是$C$怎么办？按照原本的想法我们应当去连一条最小限度为 1 最大限度也是 1 的边。但是我们可以避免这样做，我们可以连一条容量为 1 ，费用为 1 + F 的边，其中 F 是一个极大值，是所有 1 的费用加起来也达不到的。这样的好处在于，我们会尽量满足$C$的点，并且还可以数出来满足了多少个$C$的点，如果数量不足则是无解。

cpp

#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "queue"
using namespace std;
#define MAXN 5006
#define inf 0x3f3f3f3f
const int QWQ = 3006;
class mincmaxf {
#define maxn 50005
public:
#define N 5010
#define M 100006
#define INF 0x3f3f3f3f
    int tot, lnk[N], cur[N], ter[M], nxt[M], cap[M], cost[M], dis[N], ret;
    bool vis[N];
    void init( ) { tot = 1; memset( lnk , 0 , sizeof lnk ) , memset( cur , 0 , sizeof cur ); ret = 0; }
    int add(int u, int v, int w, int c) {
        ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot, cap[tot] = w, cost[tot] = c;
        return tot;
    }
    int Ade(int u, int v, int w, int c) { add(v, u, 0, -c); return add(u, v, w, c); }
    bool spfa(int s, int t) {
        for( int i = 1 ; i < MAXN ; ++ i ) dis[i] = -INF;
        memcpy(cur, lnk, sizeof(lnk));
        std::queue<int> q;
        q.push(s), dis[s] = 0, vis[s] = 1;
        while (!q.empty()) {
            int u = q.front();
//            cout << u << endl;
            q.pop(), vis[u] = 0;
            for (int i = lnk[u]; i; i = nxt[i]) {
                int v = ter[i];
                if (cap[i] && dis[v] < dis[u] + cost[i]) {
                    dis[v] = dis[u] + cost[i];
                    if (!vis[v]) q.push(v), vis[v] = 1;
                }
            }
        }
        return dis[t] != -INF;
    }
    int dfs(int u, int t, int flow) {
        if (u == t) return flow;
        vis[u] = 1;
        int ans = 0;
        for (int &i = cur[u]; i && ans < flow; i = nxt[i]) {
            int v = ter[i];
            if (!vis[v] && cap[i] && dis[v] == dis[u] + cost[i]) {
                int x = dfs(v, t, std::min(cap[i], flow - ans));
                if (x) ret += x * cost[i], cap[i] -= x, cap[i ^ 1] += x, ans += x;
            }
        }
        vis[u] = 0;
        return ans;
    }
    int mcmf(int s, int t) {
        int ans = 0;
        while (spfa(s, t)) {
            int x;
            while ((x = dfs(s, t, INF))) ans += x;
        }
        return ret;
    }
} F ;
int n , a , b;
int s = 5001 , t = 5002;
char ch[MAXN][MAXN];
int main() {
//    freopen("6.in","r",stdin);
    int kase = 0;
    while( cin >> n >> a >> b ) {
        if( n == 0 && a == 0 && b == 0 ) return 0;
        for( int i = 1 ; i <= n ; ++ i ) scanf("%s",ch[i] + 1);
        for( int lim = n ; lim >= 0 ; -- lim ) {
            int c = 0;
            F.init( );
            for (int i = 1 ; i <= n ; ++ i) {
                F.Ade( i , i + n , lim , 0 );
                F.Ade( s , i , lim , 0 );
                F.Ade( i + n , t , lim , 0 );
                for (int j = 1; j <= n; ++j) {
                    if( ch[i][j] == '.' ) F.Ade( i , j + n , 1 , 1 );
                    if( ch[i][j] == 'C' ) F.Ade( i , j + n , 1 , QWQ + 1 ) , ++ c;
                }
            }
            int ans = F.mcmf( s , t );
            if( ans / QWQ < c ) { printf("Case %d: impossible\n",++ kase); break; }
            ans %= QWQ;
            if( ans * a >= lim * b ) { printf("Case %d: %d\n",++ kase , ans - c); break; }
        }
    }
}