codeforces #290 div1 C（最大流，输出解）

2015-02-06 00:44:25

思路：神奇的网络流题...

　　之前cf某题也是类似的网络流，不过是相加为奇数的情况。

　　这一题要求相加为素数，其实也是同理的，素数必定为奇数嘛... 那么只要将奇数放在左列，偶数放在右列，然后加一个源点和所有左列点相连，容量为2，加一个汇点和所有右列点相连容量为2... 再考虑对每一个左列点，扫一遍所有右列点，如果相加为素数那么建边，容量为1。

　　这么建图的原因：每个奇数一定相邻2个偶数，每个偶数一定相邻2个奇数，这样才有可能满足题意。每个奇数与两个偶数产生1的流量，与源点和汇点各产生2的流量。

　　最后，要输出解。

　　考虑：跑完最大流后，最大流的边容量都变成0了，反向边存的是最大流...

　　　　　所以我们找到每条容量为0的边，重新建图，对所有未标记的点跑一遍Dfs，Dfs过程中标记点已经遍历即可。

　　注意：由于题目每个数 <= 10^4，但是有数相加的情况，所以如果是用素数表来判断的话，数组范围要开到2*10^4！！

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

#define MEM(a,b) memset(a,b,sizeof(a))
#define REP(i,n) for(int i=0;i<(n);++i)
#define REV(i,n) for(int i=(n-1);i>=0;--i)
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define RFOR(i,a,b) for(int i=(a);i>=(b);--i)
#define MP(a,b) make_pair(a,b)

typedef long long ll;
typedef pair<int,int> pii;
const int INF = (1 << 30) - 1;
const int MAXN = 210;
const int MAXM = 50010;

int pm[200010];

void Pre(){
    FOR(i,2,20000) if(!pm[i]){
        for(int j = i + i; j <= 20000; j += i)
            pm[j] = 1;
    }
}

struct Max_flow{
    int first[MAXN],next[MAXM],ver[MAXM],cp[MAXM],ecnt;
    int lev[MAXN],st,ed;
    void Init(){
        MEM(first,-1);
        ecnt = 0;
    }
    void Add_edge(int u,int v,int c){
        next[ecnt] = first[u];
        ver[ecnt] = v,cp[ecnt] = c;
        first[u] = ecnt++;
        //opposite
        next[ecnt] = first[v];
        ver[ecnt] = u,cp[ecnt] = 0;
        first[v] = ecnt++;
    }
    bool Bfs(){
        queue<int> Q;
        MEM(lev,-1);
        Q.push(st);
        lev[st] = 0;
        while(!Q.empty()){
            int now = Q.front(); Q.pop();
            for(int i = first[now]; ~i; i = next[i]){
                int v = ver[i];
                if(lev[v] < 0 && cp[i] > 0){
                    lev[v] = lev[now] + 1;
                    Q.push(v);
                }
            }
        }
        return lev[ed] != -1;
    }
    int Dfs(int p,int minf){
        if(p == ed) return minf;
        for(int i = first[p]; ~i; i = next[i]){
            int v = ver[i];
            if(lev[v] > lev[p] && cp[i] > 0){
                int d = Dfs(v,min(cp[i],minf));
                if(d > 0){
                    cp[i] -= d;
                    cp[i ^ 1] += d;
                    return d;
                }
            }
         }
        return 0;
    }
    int Dinic(){
        int max_flow = 0,pl;
        while(Bfs()){
            while((pl = Dfs(st,INF)) > 0)
                max_flow += pl;
        }
        return max_flow;
    }
};

int n;
int val[MAXN],cnt[2];
int first[MAXN],ecnt;
vector< vector<int> > ans;
vector<int> res;
int vis[MAXN];

struct edge{
    int v,next;
}e[MAXM];

void Add_edge(int u,int v){
    e[++ecnt].next = first[u];
    e[ecnt].v = v;
    first[u] = ecnt;
}

void Dfs(int p){
    vis[p] = 1;
    res.push_back(p);
    for(int i = first[p]; ~i; i = e[i].next){
        int v = e[i].v;
        if(!vis[v]) Dfs(v);
    }
}

int main(){
    Pre();
    Max_flow MF;  MF.Init();
    scanf("%d",&n);
    FOR(i,1,n){
        scanf("%d",&val[i]);
        int id = val[i] & 1;
        cnt[id]++;
        if(id) MF.Add_edge(0,i,2); //源点和奇数连边
        else MF.Add_edge(i,n + 1,2); //汇点和偶数连边
    }
    if(cnt[0] != cnt[1]){
        printf("Impossible\n");
        return 0;
    }
    FOR(i,1,n) if(val[i] & 1){
        FOR(j,1,n)
            if((val[j] & 1) == 0 && !pm[val[i] + val[j]])
                MF.Add_edge(i,j,1);
    }
    MF.st = 0;
    MF.ed = n + 1;
    if(MF.Dinic() != n){
        printf("Impossible\n");
        return 0;
    }
    //Init
    MEM(first,-1);
    ecnt = 0;
    FOR(i,1,n) if(val[i] & 1){
        for(int j = MF.first[i]; ~j; j = MF.next[j]){
            int v = MF.ver[j];
            if(v && MF.cp[j] == 0){ //防止连回源点
                Add_edge(i,v);
                Add_edge(v,i);
            }
        }
    }
    FOR(i,1,n){
        if(!vis[i]){
            res.clear();
            Dfs(i);
            ans.push_back(res);
        }
    }
    printf("%d\n",(int)ans.size());
    REP(i,ans.size()){
        printf("%d",(int)ans[i].size());
        REP(j,ans[i].size()) printf(" %d",ans[i][j]);
        puts("");
    }
    return 0;
}