网络流+打印路径 Codeforces510E Fox And Dinner

传送门：点击打开链接

题意：n只狐狸，每个狐狸对应了一个数字，现在要把n只狐狸分成很多个圈坐着，每个圈中至少要有3只，且相邻两只狐狸对应的数字只和必须是质数

思路：由于相加必须是质数。，且有对应的那个数字>=2，说明这个质数必须是奇数，进一步说明两只挨在一起的狐狸必须一奇一偶。看到奇偶，我们就应该要想到网络流

我们让超级源点s连接所有的偶数，边容量为2.让所有的奇数连接超级汇点t，边容量为2，再两两枚举点，看其相加是否为质数，如果是质数，就连接一条从偶数到奇数的边，容量为1。然后跑一遍网络流，验证最后的流量是否等于n就做完了。

还有一个问题就是如何打印。maze[u][v]里面是边的容量。如果之前有容量，但是后来减小了，说明有流量从这里经过。利用这个性质我们就能构造出路径，然后再DFS打印路径，这题就算完成了~

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<cstdio>
#include<cctype>
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<functional>
#define fuck printf("fuck")
#define FIN freopen("input.txt","r",stdin)
#define FOUT freopen("output.txt","w+",stdout)
using namespace std;
typedef long long LL;

const int MX = 300 + 5;
const int INF = 0x3f3f3f3f;

vector<int>G[MX], temp;
vector<vector<int> >ans;
int maze[MX][MX], TO[MX][MX], vis[MX];
int gap[MX], dis[MX], pre[MX], cur[MX];

int sap(int start, int end, int nodenum) {
memset(cur, 0, sizeof(cur));
memset(dis, 0, sizeof(dis));
memset(gap, 0, sizeof(gap));
int u = pre[start] = start, maxflow = 0, aug = -1;
gap[0] = nodenum;
while(dis[start] < nodenum) {
loop:
for(int v = cur[u]; v < nodenum; v++) {
if(maze[u][v] && dis[u] == dis[v] + 1) {
if(aug == -1 || aug > maze[u][v]) aug = maze[u][v];
pre[v] = u; u = cur[u] = v;
if(v == end) {
maxflow += aug;
for(u = pre[u]; v != start; v = u, u = pre[u]) {
maze[u][v] -= aug;
maze[v][u] += aug;
}
aug = -1;
}
goto loop;
}
}
int mindis = nodenum - 1;
for(int v = 0; v < nodenum; v++) {
if(maze[u][v] && mindis > dis[v]) {
cur[u] = v;
mindis = dis[v];
}
}
if((--gap[dis[u]]) == 0) break;
gap[dis[u] = mindis + 1]++;
u = pre[u];
}
return maxflow;
}

bool is_prime(int x) {
for(int i = 2; i * i <= x; i++) {
if(!(x % i)) return false;
}
return true;
}

void DFS(int u) {
vis[u] = 1;
temp.push_back(u);
for(int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if(!vis[v]) DFS(v);
}
}

int A[MX];

int main() {
int n; //FIN;
while(~scanf("%d", &n)) {
ans.clear();
for(int i = 1; i <= n; i++) G[i].clear();
memset(TO, 0, sizeof(TO));
memset(maze, 0, sizeof(maze));
memset(vis, 0, sizeof(vis));

int s = 0, t = n + 1, cnt = 0;
for(int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
if(A[i] % 2 == 0) {
maze[s][i] += 2;
cnt++;
} else maze[i][t] += 2;
}

for(int i = 1; i <= n; i++) {
for(int j = i + 1; j <= n; j++) {
if(is_prime(A[i] + A[j])) {
if(A[i] % 2 == 0) {
maze[i][j]++;
TO[i][j] = 1;
} else {
maze[j][i]++;
TO[j][i] = 1;
}
}
}
}

int ret = sap(s, t, n + 2);
if(ret != 2 * cnt) printf("Impossible\n");
else {
for(int i = 1; i <= n; i++) if(A[i] % 2 == 0) {
for(int j = 1; j <= n; j++) {
if(TO[i][j] && !maze[i][j]) {
G[i].push_back(j);
G[j].push_back(i);
}
}
}

for(int i = 1; i <= n; i++) {
temp.clear();
if(!vis[i]){
DFS(i);
ans.push_back(temp);
}

}

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