Codeforces Round #290 (Div. 2) E Fox And Dinner

刚看到这道题的时候就有感觉是一个图论题。。因为可以通过和为质数的两个数字之间建边来构图，但是怎么判成环一直在纠结，最后还是没纠结出来，就去看题解了ORZ

然后看到了奇偶建图。。瞬间开窍。。因为感觉质数环肯定是奇偶交替的数形成的，对于两个和为质数的数a，b 。a为偶数，b为奇数，源点为s，汇点为t，只需要建立如下边

s->a   容量为2

a->b   容量为1

b->t    容量为2

只要能够达到满流那么就说明有解，否则无解，因为要达到满流必须要满足每个奇数都和两个偶数相连，每个偶数都和两个奇数相连。

之后怎么把质数环搞出来呢，我用的是一个比较暴力的方法：

在残余网络中：

（1）对于一个偶数节点就搜一条容量为0的边（正边）到达一个奇数节点

（1）对于一个奇数节点就搜一条容量为1的边（反向边）到达一个偶数节点

重复（1），（2）直到搜到一个环

具体看代码吧。。。调试了好久好久。。写得比较挫。

#include<iostream>
#include<sstream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>
#include<math.h>
#include<map>
#include<time.h>
#include<set>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
#define inf 0x7fffffff
#define lc l,m,index<<1
#define rc m+1,r,index<<1|1
#define max_n 200005
#define mod 10000007
#define LL __int64
struct edge
{
int to,cap,rev;
};
vector<edge> G[max_n];
bool used[max_n];
int num[max_n];
int id[max_n];
int n;
void add_edge(int from,int to,int cap)
{
G[from].push_back((edge){to,cap,G[to].size()});
G[to].push_back((edge){from,0,G[from].size()-1});
}
int dfs(int v,int t,int f)
{
// printf("%d ",v);
if(v==t) return f;
used[v] = true;

for(int i=0;i<G[v].size();i++)
{
edge &e=G[v][i];
if(!used[e.to] && e.cap>0)
{
int d=dfs(e.to,t,min(f,e.cap));
if(d>0)
{
e.cap-=d;
G[e.to][e.rev].cap+=d;
return d;
}
}
}
return 0;
}
int max_flow(int s,int t)
{
int flow=0;
while(1)
{
memset(used,0,sizeof(used));
int f=dfs(s,t,inf);
// printf("\n");
// printf("f == %d\n",f);
// system("pause");
if(f==0) return flow;
flow+=f;
}

}
bool judge(int x)
{
for(int i=2;i<=(int)sqrt(x);i++)
{
if(x%i==0) return 0;
}
return 1;
}
bool judge1(bool a[])
{
for(int i=1;i<=n;i++)
{
if(!used[i])return 0;
}
return 1;
}
void Dfs(int v,vector<int> &ans)
{
ans.push_back(v);
used[v]=1;
int l;
if(num[v-1]%2==0)
l=0;
else
l=1;
for(int i=0;i<G[v].size();i++)
{
edge e=G[v][i];
if(!used[e.to] && e.cap==l && e.to!=0 && e.to!=10005)
Dfs(e.to,ans);
}
}
void solve()
{
int res=max_flow(0,10005);
if(res!=n)
{
// printf("%d\n",res);
printf("Impossible\n");
return ;
}

vector<int>ans[10005];
int index=0;

memset(used,0,sizeof(used));

while(!judge1(used))
{
for(int i=0;i<n;i++)
{
if(!used[i+1])
{
Dfs(i+1,ans[index++]);
}
}
}
printf("%d\n",index);
for(int i=0;i<index;i++)
{
printf("%d",ans[i].size());
for(int j=0;j<ans[i].size();j++)
printf(" %d",ans[i][j]);
printf("\n");
}
}
int main()
{
while(~scanf("%d",&n))
{

for(int i=0;i<n;i++)
scanf("%d",&num[i]);

memset(used,0,sizeof(used));

for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(judge(num[i]+num[j]))
{
int s=i+1;
int t=j+1;
if(num[i]%2==0 && num[j]%2!=0)
{

// printf("0-->%d-->%d-->10005\n",num[i],num[j]);
add_edge(s,t,1);
if(!used[s])
{
add_edge(0,s,2);
used[s]=1;
}
// printf("0-->%d\n",num[i]);
if(!used[t])
{
add_edge(t,10005,2);
used[t]=1;
}
}
else if(num[j]%2==0 && num[i]%2!=0)
{
// printf("0-->%d-->%d-->10005\n",num[j],num[i]);
add_edge(t,s,1);
if(!used[t])
{
add_edge(0,t,2);
used[t]=1;
}
if(!used[s])
{
add_edge(s,10005,2);
used[s]=1;
}
}
}
}
}
/*
for(int i=0;i<n;i++)
{
int s=num[i];
for(int j=0;j<G[s].size();j++)
printf("%d-->%d %d\n",s,G[s][j].to,G[s][j].cap);
}*/
solve();
}
return 0;
}