【UVALive

Description

A prominent microprocessor company has enlisted your help to lay out some interchangeable components
(widgets) on some of their computer chips. Each chip’s design is an N × N square of slots. One
slot can hold a single component, and you are to try to fit in as many widgets as possible.
Modern processor designs are complex, of course. You unfortunately have several restrictions:
• Some of the slots are disabled.
• Some of the slots are already occupied by other components and cannot be used for widgets.
• There are sibling memory buses connected to the horizontal and vertical edges of the chip and
their bandwidth loads need to match. As such, there must be exactly as many components in
the first row as in the first column, exactly as many in the second row as in the second column,
and so on. Component counts include both the components already specified on the chip and the
added widgets.
• Similarly, the power supply is connected at the end of each row and column. To avoid hot spots,
any given row or column must have no more than A/B of the total components on the chip for
a given A and B.
A specification for a chip is N lines of N characters, where ‘.’ indicates an open slot, ‘/’ indicates
a disabled slot, and ‘C’ indicates a slot already occupied by a component. For example:
CC/..
././/
..C.C
/.C..
/./C/
If no more than 3/10 of the components may be in any one row or column, the maximum number of
widgets that can be added to this 5 × 5 chip is 7. A possible arrangement is below, where ‘W’ indicates
a widget added in an open slot.
CC/W.
W/W//
W.C.C
/.CWW
/W/C/erb

Input
The input consists of several test cases. Each case starts with a line containing three integers: The size
of the chip N (1 ≤ N ≤ 40), and A and B (1 ≤ B ≤ 1000, 0 ≤ A ≤ B) as described above. Each of the
following N lines contains N characters describing the slots, one of ‘.’, ‘/’ or ‘C’, as described above.
The last test case is followed by a line containing three zeros.

Output
For each test case, display a single line beginning with the case number. If there is a solution, display
the maximum number of widgets that can be added to the chip. Display ‘impossible’ if there is no
solution.
Follow the format of the sample output.

Sample Input
2 1 1
/.
//
2 50 100
/.
C/
2 100 100
./
C.
5 3 10
CC/..
././/
..C.C
/.C..
/./C/
5 2 10
CC/..
././/
..C.C
/.C..
/./C/
0 0 0

Sample Output
Case 1: 0
Case 2: 1
Case 3: impossible
Case 4: 7
Case 5: impossible

【题意】

　　有一个n*n的矩阵(n<=40)，每个位置有三种情况，/表示不能用，C表示这个位置有一个芯片，'.'表示这个位置可以放芯片，要求第i行的芯片总数等于第i列的芯片总数，每行或的每列的芯片总数不能超过总芯片数的A/B。

【分析】

　　没有行列约束的时候直接行列建边。对于A/B的约束其实可以枚举行列的最大值然后加限制跑最大流（因为行很少）。不过有行等于列的约束，于是再建一条列到行的反向边，上限定为你枚举的约束，做循环流。因为循环流要加边而且判满流，所以要加一个费用才能计算，于是就是上下界循环费用流了。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define Maxn 10100
#define Maxm 1001000
#define INF 0xfffffff

int map[50][50];
int first[Maxn],dis[Maxn],pre[Maxn],flow[Maxn];
char s[50];
bool inq[Maxn];

int st,ed,sum,h;
int n,A,B;

struct node
{
    int x,y,f,c,o,next;
}t[Maxm];int len;

int mymax(int x,int y) {return x>y?x:y;}
int mymin(int x,int y) {return x<y?x:y;}

void ins(int x,int y,int f,int c)
{
    if(f==0) return;
    if(x==st) sum+=f;
    t[++len].x=x;t[len].y=y;t[len].f=f;t[len].c=c;
    t[len].next=first[x];first[x]=len;t[len].o=len+1;
    t[++len].x=y;t[len].y=x;t[len].f=0;t[len].c=-c;
    t[len].next=first[y];first[y]=len;t[len].o=len-1;
}


void make_edge(int x,int y,int k1,int k2,int c)
{
    ins(st,y,k2,0);
    ins(x,ed,k2,c);
    ins(y,x,k2-k1,-c);
}

queue<int > q;
bool bfs(int f1,int f2)
{
    while(!q.empty()) q.pop();
    memset(dis,-63,sizeof(dis));
    memset(inq,0,sizeof(inq));
    memset(pre,-1,sizeof(pre));
    inq[f1]=1;q.push(f1);flow[f1]=INF;pre[f1]=0;dis[st]=0;
    while(!q.empty())
    {
        int x=q.front();q.pop();
        for(int i=first[x];i;i=t[i].next) if(t[i].f>0)
        {
            int y=t[i].y;
            if(dis[y]<dis[x]+t[i].c)
            {
                dis[y]=dis[x]+t[i].c;
                if(!inq[y]) {q.push(y);inq[y]=1;}
                pre[y]=i;
                flow[y]=mymin(flow[x],t[i].f);
            }
        }
        inq[x]=0;
    }
    if(pre[f2]==-1) return 0;
    return flow[f2];
}

int ffind(int x,int y)
{
    int a,sc=0,now;h=0;
    while(a=bfs(st,ed))
    {
        now=y;sc+=a*dis[y];
        h+=a;
        while(now!=x)
        {
            t[pre[now]].f-=a;
            t[t[pre[now]].o].f+=a;
            now=t[pre[now]].x;
        }
    }
    return sc;
}

int get_ans(int x)
{
    st=2*n+1,ed=st+1;
    len=0;sum=0;
    memset(first,0,sizeof(first));
    for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
      {
          if(map[i][j]==2) make_edge(i,j+n,1,1,1);
          else if(map[i][j]==1) ins(i,j+n,1,1);
      }
     for(int i=1;i<=n;i++) make_edge(i+n,i,0,x,0);
    int a=ffind(st,ed);
    if(h!=sum) return -1;
    if(x*B<=a*A) return a;
    return -1;
}

int main()
{
    int kase=0;
    while(1)
    {
        scanf("%d%d%d",&n,&A,&B);
        if(n==0&&A==0&&B==0) break;
        bool ok=1;
        int sc=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s);
            for(int j=0;j<n;j++)
            {
                if(s[j]=='/') map[i][j+1]=0;
                else if(s[j]=='.') map[i][j+1]=1;
                else map[i][j+1]=2,sc++;
            }
        }
        for(int i=1;i<=n;i++)
        {
            int s1=0,s2=0;
            for(int j=1;j<=n;j++)
            {
                if(map[i][j]==2) s1++;
                if(map[j][i]==2) s2++;
            }
            if(s1!=s2||s1*B>sc*A||s2*B>sc*A) {ok=0;break;}
        }
        printf("Case %d: ",++kase);
        int maxx=-1;
        if(ok) maxx=sc;
        for(int i=1;i<=n;i++)
        {
            maxx=mymax(maxx,get_ans(i));
            
        }
        if(maxx!=-1) maxx-=sc;
        if(maxx==-1) printf("impossible
");
        else printf("%d
",maxx);
    }
    return 0;
}

2016-06-04 13:27:29