CodeForces Round #290 Fox And Dinner

而是Div2的最后一题，当时打比赛的时候还不会最大流。自己能够把它写出来然后1A还是很开心的。

题意：

有n个不小于2的整数，现在要把他们分成若干个圈。在每个圈中，数字的个数不少于3个，而且相邻的两个数之和是质数。

分析：

因为每个数都不小于2，所以相加得到的质数一定是奇数，那么在某个圈中，一定是奇偶相间的。

也就是 奇数相邻的两个数是偶数，偶数相邻的两个数是奇数。

所以一个圈中的数字一定是偶数个，所有的输入中也必须是偶数和奇数的个数相同才可能有解。

这转化为了二分图匹配，其中X是奇数，Y是偶数，如果X和Y中的两个数加起来是质数，则连一条容量为1的边。

因为每个奇数的两边是偶数，所以将X中的点与源点连一条容量为2的边。

同样地，将Y中的点与汇点连一条容量为2的边。

求一次最大流，如果满载也就是流量为n的话，说明有解。

输出解：可以根据求解最大流的时候，找到的路径，再建一个图，然后DFS找环。

 #include <bits/stdc++.h>

 using namespace std;

 const int maxn =  + ;
 const int INF = ;

 struct Edge
 {
     int from, to, cap, flow;
     Edge(int u, int v, int c, int f): from(u), to(v), cap(c), flow(f) {}
 };

 struct EdmondsKarp
 {
     int n, m;
     vector<Edge> edges;
     vector<int> G[maxn];
     int a[maxn];    //可改进量
     int p[maxn];    //上一条弧

     void Init(int n)
     {
         for(int i = ; i < n; ++i) G[i].clear();
         edges.clear();
     }

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

     int MaxFlow(int s, int t)
     {
         int flow = ;
         for(;;)
         {
             memset(a, , sizeof(a));
             queue<int> Q;
             Q.push(s);
             a[s] = INF;
             while(!Q.empty())
             {
                 int x = Q.front(); Q.pop();
                 for(int i = ; i < G[x].size(); ++i)
                 {
                     Edge& e = edges[G[x][i]];
                     if(!a[e.to] && e.cap > e.flow)
                     {
                         a[e.to] = min(a[x], e.cap - e.flow);
                         p[e.to] = G[x][i];
                         Q.push(e.to);
                     }
                 }
                 if(a[t]) break;
             }
             if(!a[t]) break;
             for(int u = t; u != s; u = edges[p[u]].from)
             {
                 edges[p[u]].flow +=  a[t];
                 edges[p[u]^].flow -= a[t];
             }
             flow += a[t];
         }
         return flow;
     }
 }g;

 int a[maxn], odd[maxn], even[maxn], p1, p2;
 vector<int> G[maxn], ans[maxn];
 const int maxp = ;
 bool prime[maxp + ], vis[maxn];

 void prime_table()
 {
     int m = sqrt(maxp + 0.5);
     for(int i = ; i <= m; ++i) if(!prime[i])
         for(int j = i*i; j <= maxp; j += i) prime[j] = true;
 }

 void find_circle(int cnt, int u)
 {
     ans[cnt].push_back(u);
     vis[u] = true;
     for(int i = ; i < G[u].size(); ++i)
     {
         int v = G[u][i];
         if(!vis[v]) find_circle(cnt, v);
     }
 }

 int main()
 {
     //freopen("in.txt", "r", stdin);

     int n;
     scanf("%d", &n);
     g.Init(n+);
     for(int i = ; i <= n; ++i)
     {
         scanf("%d", &a[i]);
         if(a[i] & ) odd[p1++] = i;
         else even[p2++] = i;
     }
     if(p1 != p2) { puts("Impossible"); return ; }//奇数和偶数个数不同

     for(int i = ; i < p1; ++i)
     {
         g.AddEdge(, odd[i], );
         g.AddEdge(even[i], n+, );
     }

     prime_table();
     for(int i = ; i < p1; ++i)
         for(int j = ; j < p1; ++j)
             if(!prime[ a[odd[i]] + a[even[j]] ])
                 g.AddEdge(odd[i], even[j], );

     int flow = g.MaxFlow(, n+);
     if(flow != n) { puts("Impossible"); return ; }

     for(int i = ; i < g.edges.size(); ++i)
     {//为了寻找路径，建一个新图
         Edge& e = g.edges[i];
         if(e.cap ==  && e.flow == )
         {
             G[e.from].push_back(e.to);
             G[e.to].push_back(e.from);
         }
     }

     int cnt = ;
     for(int i = ; i <= n; ++i) if(!vis[i]) find_circle(cnt++, i);

     printf("%d\n", cnt);
     for(int i = ; i < cnt; ++i)
     {
         printf("%d %d", ans[i].size(), ans[i][]);
         for(int j = ; j < ans[i].size(); ++j) printf(" %d", ans[i][j]);
         puts("");
     }

     return ;
 }

代码君