GCJ 2015R2(Bilingual-最小割)

Problem C. Bilingual

Problem

Elliot's parents speak French and English to him at home. He has heard a lot of words, but it isn't always clear to him which word comes from which language! Elliot knows one sentence that he's sure is English and one sentence that he's sure is French, and
some other sentences that could be either English or French. If a word appears in an English sentence, it must be a word in English. If a word appears in a French sentence, it must be a word in French.

Considering all the sentences that Elliot has heard, what is the minimum possible number of words that he's heard that must be words in both English and French?

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each starts with a single line containing an integer N. N lines follow, each of which contains a series
of space-separated "words". Each "word" is made up only of lowercase characters a-z. The first of those N lines is a "sentence" in English, and the second is a "sentence" in French. The rest could be "sentences" in either English or French.
(Note that the "words" and "sentences" are not guaranteed to be valid in any real language.)

Output

For each test case, output one line containing "Case #x: y", where x is the test case number (starting from 1) and y is the minimum number of words that Elliot has heard that must be words in both English and French.

Limits

1 ≤ T ≤ 25.

Each word will contain no more than 10 characters.

The two "known" sentences will contain no more than 1000 words each.

The "unknown" sentences will contain no more than 10 words each.

Small dataset

2 ≤ N ≤ 20.

Large dataset

2 ≤ N ≤ 200.

Sample

Input	Output
4 2 he loves to eat baguettes il aime manger des baguettes 4 a b c d e f g h i j a b c i j f g h d e 4 he drove into a cul de sac elle a conduit sa voiture il a conduit dans un cul de sac il mange pendant que il conduit sa voiture 6 adieu joie de vivre je ne regrette rien adieu joie de vivre je ne regrette rien a b c d e f g h i j a b c i j f g h d e	Case #1: 1 Case #2: 4 Case #3: 3 Case #4: 8

In Case #1, Elliot knows for sure that the first sentence is in English and the second is in French, so there is no ambiguity; the only word that must be in both English and French is "baguettes".



In Case #2, the last two sentences could either be: English English, English French, French English, or French French. The second of those possibilities is the one that minimizes the number of words common to both languages; that set turns out to be d, e, i,
and j.

最小割

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<map>
#include<string>
#include<vector>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])
#define Lson (x<<1)
#define Rson ((x<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define MAXT (25+10)
#define MAXLen (1000*11+10)
#define MAXWord1 (1000+10)
#define MAXWord2 (10)
#define MAXTotword (2000+10*200+10)
#define MAXn (200+10)
#define MAXm (200000+10)
#define MAXN (1000000+2)
#define MAXM ((1000000+2)*2+100)
long long mul(long long a,long long b){return (a*b)%F;}
long long add(long long a,long long b){return (a+b)%F;}
long long sub(long long a,long long b){return (a-b+(a-b)/F*F+F)%F;}
typedef long long ll;
class Max_flow  //dinic+当前弧优化
{
public:
    int n,s,t;
    int q[MAXN];
    int edge[MAXM],next[MAXM],pre[MAXN],weight[MAXM],size;
    void addedge(int u,int v,int w)
    {
        edge[++size]=v;
        weight[size]=w;
        next[size]=pre[u];
        pre[u]=size;
    }
    void addedge2(int u,int v,int w){addedge(u,v,w),addedge(v,u,0);}
    bool b[MAXN];
    int d[MAXN];
    bool SPFA(int s,int t)
    {
        For(i,n) d[i]=INF;
        MEM(b)
        d[q[1]=s]=0;b[s]=1;
        int head=1,tail=1;
        while (head<=tail)
        {
            int now=q[head++];
            Forp(now)
            {
                int &v=edge[p];
                if (weight[p]&&!b[v])
                {
                    d[v]=d[now]+1;
                    b[v]=1,q[++tail]=v;
                }
            }
        }
        return b[t];
    }
    int iter[MAXN];
    int dfs(int x,int f)
    {
        if (x==t) return f;
        Forpiter(x)
        {
            int v=edge[p];
            if (weight[p]&&d[x]<d[v])
            {
                  int nowflow=dfs(v,min(weight[p],f));
                  if (nowflow)
                  {
                    weight[p]-=nowflow;
                    weight[p^1]+=nowflow;
                    return nowflow;
                  }
            }
        }
        return 0;
    }
    int max_flow(int s,int t)
    {
        int flow=0;
        while(SPFA(s,t))
        {
            For(i,n) iter[i]=pre[i];
            int f;
            while (f=dfs(s,INF))
                flow+=f;
        }
        return flow;
    }
    void mem(int n,int s,int t)
    {
        (*this).n=n;
        (*this).t=t;
        (*this).s=s;    

        size=1;
        MEM(pre)
    }
}S;    

int T,n;

vector<string> split(string s,string del = " \n\0") // 以在del出现过的不论什么字符为分隔符
{
	vector<string> ret;
	s+=del[0];

	string p="";
	int sz=s.size();
	Rep(i,sz)
	{
		if (del.find(s[i])==string::npos)
		{
			p+=s[i];
		}
		else
		{
			if (p!="")
			{
				ret.push_back(p);
				p="";
			}
		}
	}
	return ret;
}

vector<string> get_line_words() {
	static string buf;
	getline(cin,buf,'\n');
	return split(buf);
}

map<string,int> h;
int get_id(string s)
{
	map<string,int>::iterator it=h.find(s);
	if (it==h.end()) return h[s]=h.size();
	return it->second;
}

vector<string> a[MAXn];
int a2[MAXn][MAXWord1];
int main()
{
	freopen("gcj2015R2CC-large-practice.in","r",stdin);
	freopen("gcj2015R2CC-large-practice.out","w",stdout);

	cin>>T;
	For(kcase,T)
	{
		h.clear();
		scanf("%d\n",&n);
		For(i,n)
		{
			string s;
			a[i]=get_line_words();
			a2[i][0]=a[i].size();
			Rep(j,a2[i][0])
				a2[i][j+1]=get_id(a[i][j]);

		}
//
//		For(i,n)
//		{
//			For(j,a2[i][0]) cout<<a2[i][j]<<' ';
//			cout<<endl;
//
//		}
//		

		int m = h.size(),s=1,t=2*m+n;
		S.mem(t,s,t);

		For(i,m)
		{
			S.addedge2(i+1,i+1+m,1);
		}

		For(j,a2[1][0]) {
			S.addedge2(s,1+a2[1][j],INF);
		}
		For(j,a2[2][0]) {
			S.addedge2(1+a2[2][j]+m,t,INF);
		}

		Fork(i,3,n)
		{
			For(j,a2[i][0]) {
				S.addedge2(2*m+1+i-2,1+a2[i][j],INF);
				S.addedge2(1+a2[i][j]+m,2*m+1+i-2,INF);
			}
		}

		int ans=S.max_flow(s,t);
		printf("Case #%d: %d\n",kcase,ans);
	}

	return 0;
}