Codeforces 510 E. Fox And Dinner

题目链接：http://codeforces.com/problemset/problem/510/E

---

乍一看和那啥魔术球问题有点神似啊/XD

其实是不一样的。

解决这道问题的关键在于发现若是相邻的两个数的和是质数，那么他们必定是一奇一偶！

而且一个奇数旁边一定是两个偶数，一个偶数旁边一定是两个奇数(因为是一个大于$3$的环)

秒啊！这就变成了匹配模型。

源点向所有值为奇数的点连容量为$2$边，值为奇数的点向所有与它的和为质数的且值为偶数点连容量为$1$边，所有值为偶数的点向汇点连容量为$2$的边。

跑一边最大流，我们是不是就求出了最大的合法的匹配方案？

如果最大流为$n$才说明了每一个点都匹配上了。

考虑输出方案，$DFS$在$Dinic$之后留下的图，如果流量发生了变化则沿这条路径走下去(当然不能走到源点或者汇点)

---

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 using namespace std;
 #define maxn 1010
 #define inf 0x7fffffff
 #define llg int
 #define yyj(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout);
 llg n,m,ans,c[maxn],cnt1,cnt2,tot[maxn];
 llg d[maxn][maxn];
 inline int getint()
 {
     int w=,q=; char c=getchar();
     while((c<'' || c>'') && c!='-') c=getchar(); if(c=='-') q=,c=getchar();
     while (c>='' && c<='') w=w*+c-'', c=getchar(); return q ? -w : w;
 }

 struct DINIC
 {
     llg N;
     vector<llg>a[maxn],ba[maxn],val[maxn],stval[maxn];
     llg dl[maxn],deep[maxn];
     bool bj[maxn];

     void link(llg x,llg y,llg z)
     {
         a[x].push_back(y),val[x].push_back(z); stval[x].push_back(z);
         a[y].push_back(x),val[y].push_back(); stval[y].push_back();
         ba[x].push_back(a[y].size()-),ba[y].push_back(a[x].size()-);
     }

     llg dfs(llg x,llg low)
     {
         llg va=,inc=;
         if (x==N) return low;
         llg w=a[x].size(),v;
         for (llg i=;i<w;i++)
         {
             v=a[x][i];
             if (deep[x]+==deep[v] && val[x][i]> && (va=dfs(v,min(low,val[x][i]))))
             {
                 val[x][i]-=va; val[v][ba[x][i]]+=va; inc+=va;
                 return va;
             }
         }
         if (!inc) deep[x]=-;
         return ;
     }

     void fencen()
     {
         llg x,w,v; deep[]=;
         memset(bj,,sizeof(bj));
         llg head=,tail=; dl[]=; bj[]=;
         do
         {
             x=dl[++head]; w=a[x].size();
             for (llg i=;i<w;i++)
             {
                 v=a[x][i];
                 if (bj[v] || val[x][i]<=) continue;
                 dl[++tail]=v;
                 deep[v]=deep[x]+; bj[v]=;
             }
         }while (head!=tail);
     }

     llg dinic()
     {
         llg ans=;
         while ()
         {
             fencen();
             if (!bj[N]) break;
             ans+=dfs(,inf);
         }
         return ans;
     }

     void DFS(llg x)
     {
         bj[x]=;
         tot[ans]++;
         d[ans][tot[ans]]=x;
         llg w=a[x].size(),v;
         for (llg i=;i<w;i++)
         {
             v=a[x][i];
             if (v== || v==N || bj[v]) continue;
             if (stval[x][i]==val[x][i]) continue;
             DFS(v);
         }
     }

     bool pd(llg x)
     {
         llg cs=,w=a[x].size(),v;
         for (llg i=;i<w;i++)
         {
             v=a[x][i];
             if (v== || v==N) continue;
             if (bj[v] || val[x][i]==stval[x][i]) continue;
             cs++;
         }
         if (cs>) return ;else return ;
     }

     void make_ans()
     {
         memset(bj,,sizeof(bj));
         while ()
         {
             bool WK=;
             for (llg i=;i<=n;i++)
                 if (!bj[i])
                 {
                     if (!pd(i)) continue;
                     WK=;
                     ans++;
                     DFS(i);
                 }
             if (!WK) break;
         }
     }
 }G;

 bool check(llg v1,llg v2)
 {
     llg x=v1+v2;
     llg up=sqrt(x+);
     for (llg i=;i<=up;i++)
         if (x%i==) return ;
     return ;
 }

 void init()
 {
     cin>>n;
     for (llg i=;i<=n;i++) c[i]=getint();
     for (llg i=;i<=n;i++)
     {
         if (c[i]%) G.link(,i,),cnt1++; else G.link(i,n+,),cnt2++;
            if (c[i]%==) continue;
         for (llg j=;j<=n;j++)
             if (i!=j && check(c[i],c[j]))
                 G.link(i,j,);
     }
     G.N=n+;
 }

 int main()
 {
     yyj("flows");
     init();
     if (cnt1!=cnt2) {cout<<"Impossible"; return ;}
     llg flows=G.dinic();
     if (flows!=n)  {cout<<"Impossible"; return ;}
     G.make_ans();
     cout<<ans<<endl;
     for (llg i=;i<=ans;i++)
     {
         cout<<tot[i]<<" ";
         for (llg j=;j<=tot[i];j++) cout<<d[i][j]<<" ";
         cout<<endl;
     }
     return ;
 }