刷题总结——卡牌配对（bzoj4205网络流）

题目：

Description

现在有一种卡牌游戏，每张卡牌上有三个属性值：A,B,C。把卡牌分为X,Y两类，分别有n1,n2张。

两张卡牌能够配对，当且仅当，存在至多一项属性值使得两张卡牌该项属性值互质，且两张卡牌类别不同。

比如一张X类卡牌属性值分别是225,233,101，一张Y类卡牌属性值分别为115,466,99。那么这两张牌是可以配对的，因为只有101和99一组属性互质。

游戏的目的是最大化匹配上的卡牌组数，当然每张卡牌只能用一次。

Input

数据第一行两个数n1，n2，空格分割。

接下来n1行，每行3个数，依次表示每张X类卡牌的3项属性值。

接下来n2行，每行3个数，依次表示每张Y类卡牌的3项属性值。

Output

输出一个整数：最多能够匹配的数目。

Sample Input

2 2
2 2 2
2 5 5
2 2 5
5 5 5

Sample Output

2

【提示】
样例中第一张X类卡牌和第一张Y类卡牌能配对，第二张X类卡牌和两张Y类卡牌都能配对。所以最佳方案是第一张X和第一张Y配对，第二张X和第二张Y配对。
另外，请大胆使用渐进复杂度较高的算法！

HINT

对于100%的数据，n1,n2≤ 30000，属性值为不超过200的正整数

题解：

第一眼看得出是二分图匹配···然而暴力建边果断T

不得不说建边的方法太NB···其实通过属性值不超过200是可以想到分解质因数的···

另外不得不说自己代码能力好弱····打这题调了半天····

引用hzwer的题解，orz····

考虑到按照匹配建图边数过多，我们采用将边分类的方法优化。考虑a项属性值能被x整除且b项能力值能被y整除的所有点，只要是在两侧一定能够匹配，所以我们在匹配的网络流模型中间增加一排这样的点，满足要求的左右点分别与它相连，边权为正无穷。考虑到x和y只需是质数，这样的点共有至多3*46*46个（1～200质数共46个），而200<2*3*5*7，所以两侧每个点至多连出3*3*3条边。于是我们构成了一个70000个点，2000000条边的网络流，依然是分层图，所以dinic有极佳的速度优势，通过100分数据。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<cctype>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=*+**;
const int M=;
vector<int>num[];
struct node
{
  int x,y,z;
}cardA[],cardB[];
int n1,n2,prime[],cnt,ans=;
int first[N],next[M],go[M],rest[M],lev[N],cur[N],tot=,src,des,id[][];
bool notprime[];
int R()
{
  char c;
  int f=;
  for(c=getchar();c<''||c>'';c=getchar());
  for(;c>=''&&c<='';c=getchar())
    f=(f<<)+(f<<)+c-'';
  return f;
}
void pre()
{
  for(int i=;i<=;i++)
  {
    if(!notprime[i])  prime[++cnt]=i;
    for(int j=i*;j<=;j+=i)
      notprime[j]=true;
  }
  for(int i=;i<=;i++)
    for(int j=;j<=cnt;j++)
      if(i%prime[j]==)
        num[i].push_back(j);
}
inline void comb(int a,int b,int c)
{
  next[++tot]=first[a],first[a]=tot,go[tot]=b,rest[tot]=c;
  next[++tot]=first[b],first[b]=tot,go[tot]=a,rest[tot]=;
}
inline void build1(int u)
{
  for(int i=;i<num[cardA[u].x].size();i++)
    for(int j=;j<num[cardA[u].y].size();j++)
      comb(u,n1+n2+id[num[cardA[u].x][i]][num[cardA[u].y][j]],);
  for(int i=;i<num[cardA[u].x].size();i++)
    for(int j=;j<num[cardA[u].z].size();j++)
      comb(u,n1+n2+*+id[num[cardA[u].x][i]][num[cardA[u].z][j]],);
  for(int i=;i<num[cardA[u].y].size();i++)
    for(int j=;j<num[cardA[u].z].size();j++)
      comb(u,n1+n2+**+id[num[cardA[u].y][i]][num[cardA[u].z][j]],);
}
inline void build2(int u)
{
  for(int i=;i<num[cardB[u].x].size();i++)
    for(int j=;j<num[cardB[u].y].size();j++)
      comb(n1+n2+id[num[cardB[u].x][i]][num[cardB[u].y][j]],n1+u,);
  for(int i=;i<num[cardB[u].x].size();i++)
    for(int j=;j<num[cardB[u].z].size();j++)
      comb(n1+n2+*+id[num[cardB[u].x][i]][num[cardB[u].z][j]],n1+u,);
  for(int i=;i<num[cardB[u].y].size();i++)
    for(int j=;j<num[cardB[u].z].size();j++)
      comb(n1+n2+**+id[num[cardB[u].y][i]][num[cardB[u].z][j]],n1+u,);
}
inline bool bfs()
{
  for(int i=src;i<=des;i++)  lev[i]=-,cur[i]=first[i];
  static int que[N*],tail,v;   //md注意static函数在一次初始化后就不会再初始化了···因此在下面一行再设tail=1
  que[tail=1]=src;
  lev[src]=;
  for(int head=;head<=tail;head++)
  {
    int u=que[head];
    for(int e=first[u];e;e=next[e])
    {
      v=go[e];
      if(lev[v]==-&&rest[e])
      {
        lev[v]=lev[u]+;
        que[++tail]=v;
        if(v==des)  return true;
      }
    }
  }
  return false;
}
inline int dinic(int u,int flow)
{
  if(u==des)
    return flow;
  int res=,delta,v;
  for(int &e=cur[u];e;e=next[e])
  {
    if(lev[v=go[e]]>lev[u]&&rest[e])
    {
      delta=dinic(v,min(rest[e],flow-res));
      if(delta)
      {
        rest[e]-=delta;
        rest[e^]+=delta;
        res+=delta;
        if(res==flow)  break;
      }
    }
  }
  if(res!=flow)  lev[u]=-;
  return res;
}
inline void maxflow()
{
  while(bfs())
    ans+=dinic(src,);
}
int main()
{
  //freopen("a.in","r",stdin);
  pre();  //
  n1=R(),n2=R();
  src=,des=n1+n2+**+;  //
  for(int i=;i<=n1;i++)
    cardA[i].x=R(),cardA[i].y=R(),cardA[i].z=R();
  for(int i=;i<=n2;i++)
    cardB[i].x=R(),cardB[i].y=R(),cardB[i].z=R();  //
  int temp=;
  for(int i=;i<=;i++)
    for(int j=;j<=;j++)
      id[i][j]=++temp;
  for(int i=;i<=n1;i++)
    comb(src,i,),build1(i);
  for(int i=;i<=n2;i++)
    comb(n1+i,des,),build2(i);   //
  maxflow();
  cout<<ans<<endl;
  return ;
}