【Cf #290 C】Fox And Dinner（最大流）

如果要相邻两个数（a[i] >= 2）相加为质数，显然它们的奇偶性不同，也就是说一个圆桌（环）必须是偶环。

也就是答案的若干个环组成了一张二分图，其中以奇偶分色。

考虑每个点的度数一定为2，用最大流解决：

1. 让源点向所有的奇数点连流量为2的边。
2. 让所有的偶数点向汇点连流量为2的边。
3. 当且仅当一组奇数和偶数相加为质数时，连一条流量为1的边。

可以证明，如果最大流小于n，那就不存在解，否则一定存在若干个边数大于2的偶环，使得所有点只出现在一个环里，最后Dfs找出环即可。

$ igodot $ 技巧&套路：

• 根据奇偶性或网格图黑白染色，想到建立二分图。
• 最大流的模型。

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

const int N = 305, M = 100005;

int n, s, t, tot, a[N], vis[N], lc[N], rc[N], ln, rn;
int ntp[20005];
std::vector<int> an[N];

void Init() {
    ntp[1] = 1;
    for (int i = 2; i <= 20000; ++i) if (!ntp[i]) {
        for (int j = i * i; j <= 20000; j += i) {
            ntp[j] = 1;
        }
    }
}

namespace GR {
    int yun = 1, cur[N], las[N], to[M << 1], pre[M << 1], fl[M << 1];
    int h[N], gap[N];
    inline void Add(int a, int b, int c) {
        to[++yun] = b; fl[yun] = c; pre[yun] = las[a]; las[a] = yun;
        to[++yun] = a; fl[yun] = 0; pre[yun] = las[b]; las[b] = yun;
    }
    int Isap(int x, int flo, int usd = 0) {
        if (x == t) return flo;
        for (int i = cur[x]; i; i = pre[i]) if (fl[i] > 0 && h[to[i]] + 1 == h[x]) {
            int f = Isap(to[i], std::min(flo, fl[i]));
            usd += f; fl[i] -= f; fl[i ^ 1] += f;
            if (fl[i] > 0) cur[x] = i;
            if (usd == flo) return flo;
        }
        if (gap[h[x]] == 1) h[s] = t + 9;
        --gap[h[x]]; ++gap[++h[x]];
        cur[x] = las[x];
        return usd;
    }
    int Max_flow(int re = 0) {
        memset(h, 0, sizeof h);
        memset(gap, 0, sizeof gap);
        for (; h[s] < t + 9; ) re += Isap(s, 1e9);
        return re;
    }
}

void Build() {
    s = n + 1; t = n + 2;
    for (int i = 1; i <= n; ++i) {
        if (a[i] & 1) {
            lc[++ln] = i; GR::Add(s, i, 2);
        } else {
            rc[++rn] = i; GR::Add(i, t, 2);
        }
    }
    for (int i = 1; i <= ln; ++i) {
        for (int j = 1; j <= rn; ++j) {
            if (!ntp[a[lc[i]] + a[rc[j]]]) {
                GR::Add(lc[i], rc[j], 1);
            }
        }
    }
}

void Dfs(int gr, int x) {
    an[gr].push_back(x);
    vis[x] = 1;
    for (int i = GR::las[x]; i; i = GR::pre[i]) {
        int v = GR::to[i];
        if (vis[v] || v == s || v == t) continue;
        if (((~i & 1) && GR::fl[i] == 0) || ((i & 1) && GR::fl[i] == 1)) {
            Dfs(gr, v);
        }
    }
}

int main() {
    Init();
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
    }
    Build();
    
    int ans = GR::Max_flow();
    if (ans != n) {
        puts("Impossible"); return 0;
    }
    for (int i = 1; i <= n; ++i) {
        if (!vis[i]) Dfs(++tot, i);
    }
    printf("%d
", tot);
    for (int i = 1; i <= tot; ++i) {
        printf("%d ", (int)an[i].size());
        for (int j = 0; j < (int)an[i].size(); ++j) {
            printf("%d ", an[i][j]);
        }
        putchar('
');
    }
    
    return 0;
}