输出字典序最小的最小割集

/*
ID: gyarena2
PROG: telecow
LANG: C++
*/

char *Task = "telecow";

#include <cstdio>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
#include <cmath>
#include <set>
#include <stack>
#include <list>
#include <iostream>
#include <ctime>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;
typedef pair<int, int> PAIR;

const int MaxN(210);
const int MaxM(10010);
const int MaxE(3010);
const int MaxL(110);
const int MaxD(510);
const int MaxH(16);
const int Inf((INT_MAX - 1) / 3);
const int F(0);
const double Eps(1e-7);
UI Base(1001);
UI Fix0(9);

template<typename T>
inline bool checkmax(T &a, const T &b) {
return b > a ? ((a = b), true) : false;
}

template<typename T>
inline bool checkmin(T &a, const T &b) {
return b < a ? ((a = b), true) : false;
}

template<typename T>
inline T Abs(T a) {
return a < 0 ? -a : a;
}

inline int Dcmp(double t) {
return Abs(t) < Eps ? 0 : (t < 0 ? -1 : 1);
}

void SetIO() {
char inf[64], ouf[64];
sprintf(inf, "%s.in", Task);
sprintf(ouf, "%s.out", Task);
freopen(inf, "r", stdin);
freopen(ouf, "w", stdout);
}

struct E {
int u, v, f;
E *next;
E() {}
E(int u_, int v_, int f_, E *n_) :u(u_), v(v_), f(f_), next(n_) {}
};

int level[MaxN];
int value[MaxN];
queue<int> que;
struct G {
E *h[MaxN], e[MaxE], *re;
void init(int n) {
memset(h, 0, sizeof(h[0])*n);
re = e;
}
void add(int u, int v, int f) {
*re = E(u, v, f, h[u]);
h[u] = re++;
*re = E(v, u, 0, h[v]);
h[v] = re++;
}
bool bfs(int sour, int sink, int n) {
memset(level, -1, sizeof(level[0])*n);
level[sour] = 0;
que.push(sour);
while (!que.empty()) {
int u = que.front();
que.pop();
for (E *i = h[u]; i; i = i->next) {
if (i->f == 0 || level[i->v] != -1) continue;
level[i->v] = level[u] + 1;
que.push(i->v);
}
}
return level[sink] != -1;
}
int dfs(int u, int sink, int lim) {
if (u == sink) return lim;
int ret = 0;
for (E *i = h[u]; i; i = i->next) {
if (i->f == 0 || level[i->v] != level[u] + 1) continue;
int t = dfs(i->v, sink, min(lim, i->f));
i->f -= t;
e[(i - e) ^ 1].f += t;
ret += t;
lim -= t;
if (lim == 0) break;
}
if (ret == 0) level[u] = -1;
return ret;
}
int maxFlow(int sour, int sink, int n) {
int ret = 0;
while (bfs(sour, sink, n)) {
ret += dfs(sour, sink, Inf);
}
return ret;
}
} g;

int main() {
SetIO();
int n, m, sour, sink;
scanf("%d%d%d%d", &n, &m, &sour, &sink);
--sour;
--sink;
g.init(n * 2);
int u, v;
for (int i = 0; i < n; ++i) g.add(i * 2, i * 2 + 1, 1);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
--u;
--v;
g.add(u * 2 + 1, v * 2, 1);
g.add(v * 2 + 1, u * 2, 1);
}
int ans = g.maxFlow(sour * 2 + 1, sink * 2, n * 2);
vector<int> rec;
for (int i = 0; i < n; ++i) {
value[i] = 1;
if (g.e[i * 2].f == 0) rec.push_back(i);
}
sort(rec.begin(), rec.end());
int tans = ans;
vector<int> ans2;
for (vector<int>::iterator it = rec.begin(); it != rec.end(); ++it) {
value[*it] = 0;
for (int i = 0; i < n; ++i) {
g.e[i * 2].f = value[i];
g.e[i * 2 + 1].f = 0;
}
for (int i = 0; i < 2*m; ++i) {
g.e[2 * n + i * 2].f = 1;
g.e[2 * n + i * 2 + 1].f = 0;
}
int temp = g.maxFlow(sour * 2 + 1, sink * 2, 2 * n);
if (temp == tans - 1) {
--tans;
ans2.push_back(*it);
}
else
value[*it] = 1;
}
printf("%d\n", ans);
for (vector<int>::iterator it = ans2.begin(); it != ans2.end(); ++it) {
if (it != ans2.begin()) printf(" ");
printf("%d", *it + 1);
}
printf("\n");
return 0;
}