Special Fish

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 14 Accepted Submission(s): 9

Problem Description

There is a kind of special fish in the East Lake where is closed to campus of Wuhan University. It’s hard to say which gender of those fish are, because every fish believes itself as a male, and it may attack one of some other fish who is believed to be female by it.
A fish will spawn after it has been attacked. Each fish can attack one other fish and can only be attacked once. No matter a fish is attacked or not, it can still try to attack another fish which is believed to be female by it.
There is a value we assigned to each fish and the spawns that two fish spawned also have a value which can be calculated by XOR operator through the value of its parents.
We want to know the maximum possibility of the sum of the spawns.

Input

The input consists of multiply test cases. The first line of each test case contains an integer n (0 < n <= 100), which is the number of the fish. The next line consists of n integers, indicating the value (0 < value <= 100) of each fish. The next n lines, each line contains n integers, represent a 01 matrix. The i-th fish believes the j-th fish is female if and only if the value in row i and column j if 1.
The last test case is followed by a zero, which means the end of the input.

Output

Output the value for each test in a single line.

Sample Input

Sample Output

Author

momodi@whu

Source

The 5th Guangting Cup Central China Invitational Programming Contest

Recommend

notonlysuccess

/*
题意：有n条鱼，每条鱼最多只能攻击一次，被攻击一次，一次攻击产生的价值是val[i]^val[j],现在问你在满足条件的情况下能获得的最大价值
    是多少。

#初步思路：简化成最小割最大团问题，将0点设置成源点，tol+1设置成汇点，可以想到将一个点拆成两个点，i和i+n分别表示攻击边和被攻击边
    然后跑一下

#感悟：刚换了乌版图系统用的调了几天，终于正常的写代码哈哈哈。
*/
#include<bits/stdc++.h>
using namespace std;
int val[110];//用来存储每个鱼的价值
int n;
char mapn[110][110];//用来存储攻击关系
int tol=0;//要是总的可能的点数
/****************************************最小割最大流模板****************************************/
#define INF 1e9
using namespace std;
const int maxn=200+10;

struct Edge
{
    int from,to,cap,flow,cost;
    Edge(){}
    Edge(int f,int t,int c,int fl,int co):from(f),to(t),cap(c),flow(fl),cost(co){}
};

struct MCMF
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool inq[maxn];    
    int d[maxn];       
    int p[maxn];        
    int a[maxn];       


    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        for(int i=0;i<n;++i) G[i].clear();
    }


    void AddEdge(int from,int to,int cap,int cost)
    {
        edges.push_back(Edge(from,to,cap,0,cost));
        edges.push_back(Edge(to,from,0,0,-cost));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BellmanFord(int &flow, int &cost)
    {
        for(int i=0;i<n;++i) d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0, a[s]=INF, inq[s]=true, p[s]=0;
        queue<int> Q;
        Q.push(s);
        while(!Q.empty())
        {
            int u=Q.front(); Q.pop();
            inq[u]=false;
            for(int i=0;i<G[u].size();++i)
            {
                Edge &e=edges[G[u][i]];
                if(e.cap>e.flow && d[e.to]>d[u]+e.cost)
                {
                    d[e.to]= d[u]+e.cost;
                    p[e.to]=G[u][i];
                    a[e.to]= min(a[u],e.cap-e.flow);
                    if(!inq[e.to]){ Q.push(e.to); inq[e.to]=true; }
                }
            }
        }
        if(d[t]==INF) return false;
        flow +=a[t];
        cost +=a[t]*d[t];
        int u=t;
        while(u!=s)
        {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -=a[t];
            u = edges[p[u]].from;
        }
        return true;
    }

    int Min_cost()
    {
        int flow=0,cost=0;
        while(BellmanFord(flow,cost));
            //cout<<flow<<" "<<cost<<endl;
        return cost;
    }
}MM;
/****************************************最小割最大流模板****************************************/
void build(){//建边
    tol=n*2+1;//总的可能的点数
    MM.init(tol+1,0,tol);
    //cout<<n<<endl;
    //cout<<tol<<endl;
    for(int i=0;i<n;i++){
        MM.AddEdge(0,i+1,1,0);
        MM.AddEdge(i+1,tol,1,0);
        MM.AddEdge(i+1+n,tol,1,0);
        for(int j=0;j<n;j++){
            if(mapn[i][j]=='1'){//这两个能打起来
                MM.AddEdge(i+1,j+n+1,1,-(val[i]^val[j]));
                //cout<<-(val[i]^val[j])<<endl;
            }
            //cout<<j<<endl;
        }
    }

}
int main(){
    //freopen("in.txt","r",stdin);
    while(scanf("%d",&n)!=EOF&&n){
        for(int i=0;i<n;i++){
            scanf("%d",&val[i]);
        }

        for(int i=0;i<n;i++){
            scanf("%s",mapn[i]);
        }
        //for(int i=0;i<n;i++){
        //    for(int j=0;j<n;j++){
        //        cout<<mapn[i][j]<<" ";
        //    }
        //    cout<<endl;
        //}
        build();
        //cout<<"ok"<<endl;
        printf("%d
",-MM.Min_cost());

    }
    return 0;
}