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 = 200 + 10;
const int INF = 1000000000;

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 = 0; i < n; ++i) G[i].clear();
        edges.clear();
    }

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

    int MaxFlow(int s, int t)
    {
        int flow = 0;
        for(;;)
        {
            memset(a, 0, sizeof(a));
            queue<int> Q;
            Q.push(s);
            a[s] = INF;
            while(!Q.empty())
            {
                int x = Q.front(); Q.pop();
                for(int i = 0; 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]^1].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 = 20000;
bool prime[maxp + 10], vis[maxn];

void prime_table()
{
    int m = sqrt(maxp + 0.5);
    for(int i = 2; 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 = 0; 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+2);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d", &a[i]);
        if(a[i] & 1) odd[p1++] = i;
        else even[p2++] = i;
    }
    if(p1 != p2) { puts("Impossible"); return 0; }//奇数和偶数个数不同

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

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

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

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

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

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

    return 0;
}