text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 * 1000 + 19;
const int MASK = 20;
const int inf = 2e9 + 19;
long long n, m, dp[1 << MASK][MASK + 1];
string s[MAX_N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < m; i++) {
long long tmp = 0;
for (int j = 0; j < n; j++) tmp += ((1 << j) * (s[j][i] == '1'));
dp[tmp][0]++;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
for (int mask = 0; mask < (1 << n); mask++)
dp[mask][j] += dp[mask ^ (1 << (i - 1))][j - 1];
}
}
long long ans = inf;
for (int mask = 0; mask < (1 << n); mask++) {
long long sum = 0;
for (long long j = 0; j <= n; j++) sum += dp[mask][j] * min(j, n - j);
ans = min(ans, sum);
}
cout << ans;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int c[21][1 << 20];
char buff[20][100005];
int main() {
scanf("%d%d", &n, &m);
gets(buff[0]);
for (int i = 0; i < n; i++) gets(buff[i]);
for (int j = 0; j < m; j++) {
int x = 0;
for (int i = 0; i < n; i++) x ^= (buff[i][j] == '1') << i;
c[0][x]++;
}
for (int p = n - 1; p >= 0; p--)
for (int k = n - 1; k >= 0; k--)
for (int x = 0; x < 1 << n; x++) c[k + 1][x] += c[k][x ^ (1 << p)];
int solmin = n * m;
for (int x = 0; x < 1 << n; x++) {
int sol = 0;
for (int k = 0; k <= n; k++) sol += min(k, n - k) * c[k][x];
solmin = min(solmin, sol);
}
printf("%d\n", solmin);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, limit, f[1 << 21], num[1 << 21];
char s[25][100005];
inline int gt(int S) {
int tot = 0;
for (int i = 0; i < n; i++)
if (S >> i & 1) tot++;
return tot;
}
inline int ksm(int x, int y) {
int ans1 = 1;
while (y) {
if (y & 1) ans1 = 1ll * ans1 * x % 998244353;
y >>= 1;
x = 1ll * x * x % 998244353;
}
return ans1;
}
inline void fwt(int *a, int flag) {
for (int i = 2; i <= limit; i *= 2) {
for (int j = 0; j < limit; j += i) {
for (int k = 0; k < (i >> 1); k++) {
int tmpx = a[j + k], tmpy = a[j + k + (i >> 1)];
a[j + k] = (tmpx + tmpy) % 998244353;
a[j + k + (i >> 1)] = (tmpx - tmpy + 998244353) % 998244353;
}
}
}
if (flag == -1) {
int inv = ksm(limit, 998244353 - 2);
for (int i = 0; i < limit; i++) a[i] = 1ll * a[i] * inv % 998244353;
}
}
int main() {
scanf("%d%d", &n, &m);
limit = 1 << n;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
int x = 0;
for (int i = 1; i <= n; i++)
if (s[i][j] == '1') x ^= (1 << (i - 1));
num[x]++;
}
for (int i = 1; i < (1 << n); i++) f[i] = gt(i), f[i] = min(f[i], n - f[i]);
fwt(f, 0);
fwt(num, 0);
for (int i = 0; i < limit; i++) f[i] = 1ll * f[i] * num[i] % 998244353;
fwt(f, -1);
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, n, m;
long long a[1 << 20], b[1 << 20];
int g[21][100001];
void FWT(long long *P, int opt) {
for (int i = 2; i <= N; i <<= 1)
for (int p = i >> 1, j = 0; j < N; j += i)
for (int k = j; k < j + p; ++k) {
long long x = P[k], y = P[k + p];
P[k] = x + y;
P[k + p] = x - y;
if (opt == -1) P[k] /= 2, P[k + p] /= 2;
}
}
int main() {
cin >> n >> m;
N = 1 << n;
char ch[100001];
for (int i = 1; i <= n; ++i) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; ++j) g[i][j] = ch[j] - 48;
}
for (int i = 1; i <= m; ++i) {
int x = 0;
for (int j = 1; j <= n; ++j) x = (x << 1) | g[j][i];
a[x]++;
}
for (int i = 0; i < N; ++i) b[i] = b[i >> 1] + (i & 1);
for (int i = 0; i < N; ++i) b[i] = min(b[i], n - b[i]);
FWT(a, 1);
FWT(b, 1);
for (int i = 0; i < N; ++i) a[i] *= b[i];
FWT(a, -1);
long long ans = n * m;
for (int i = 0; i < N; ++i) ans = min(ans, a[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1 << 20 | 1;
int n, m, N, S[MN];
long long F[MN], Q[MN];
char ch[MN];
void FWT_xor(long long *f, int op) {
for (int p = 2, len = 1; len < N; len <<= 1, p <<= 1)
for (int i = 0; i < N; i += p)
for (int k = 0; k < len; ++k) {
f[i + k] = (f[i + k] + f[i + k + len]);
f[i + k + len] = (f[i + k] - f[i + k + len] * 2ll);
if (!op) f[i + k] >>= 1, f[i + k + len] >>= 1;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; ++j) S[j] |= (1 << i) * (ch[j] == '1');
}
N = (1 << n);
for (int i = 1; i <= m; ++i) {
Q[S[i]]++;
}
for (int i = 0; i < N; ++i) {
F[i] = F[i >> 1] + (i & 1);
}
for (int i = 0; i < N; ++i) F[i] = min(F[i], n - F[i]);
FWT_xor(F, 1);
FWT_xor(Q, 1);
long long ans = n * m;
for (int i = 0; i < N; ++i) {
F[i] = F[i] * Q[i];
}
FWT_xor(F, 0);
for (int i = 0; i < N; ++i) ans = min(ans, F[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
namespace Fread {
const int SIZE = 1 << 21;
char buf[SIZE], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T) return '\n';
}
return *S++;
}
} // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 21;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c) {
*S++ = c;
if (S == T) flush();
}
struct NTR {
~NTR() { flush(); }
} ztr;
} // namespace Fwrite
namespace Fastio {
struct Reader {
template <typename T>
Reader& operator>>(T& x) {
char c = Fread ::getchar();
T f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = Fread ::getchar();
}
x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = Fread ::getchar();
}
x *= f;
return *this;
}
Reader& operator>>(char& c) {
c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
return *this;
}
Reader& operator>>(char* str) {
int len = 0;
char c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
while (c != '\n' && c != ' ') {
str[len++] = c;
c = Fread ::getchar();
}
str[len] = '\0';
return *this;
}
Reader() {}
} cin;
const char endl = '\n';
struct Writer {
template <typename T>
Writer& operator<<(T x) {
if (x == 0) {
Fwrite ::putchar('0');
return *this;
}
if (x < 0) {
Fwrite ::putchar('-');
x = -x;
}
static int sta[45];
int top = 0;
while (x) {
sta[++top] = x % 10;
x /= 10;
}
while (top) {
Fwrite ::putchar(sta[top] + '0');
--top;
}
return *this;
}
Writer& operator<<(char c) {
Fwrite ::putchar(c);
return *this;
}
Writer& operator<<(char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer& operator<<(const char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer() {}
} cout;
} // namespace Fastio
const int MAXN = 20, MAXM = 1e5;
const int INF = 1e9;
const int MOD = 1e9 + 7;
inline int mod1(int x) { return x < MOD ? x : x - MOD; }
inline int mod2(int x) { return x < 0 ? x + MOD : x; }
inline void add(int& x, int y) { x = mod1(x + y); }
inline void sub(int& x, int y) { x = mod2(x - y); }
inline int pow_mod(int x, int i) {
int y = 1;
while (i) {
if (i & 1) y = (long long)y * x % MOD;
x = (long long)x * x % MOD;
i >>= 1;
}
return y;
}
int inv_2;
int n, m;
char s[MAXN + 5][MAXM + 5];
int bitcnt[1 << MAXN];
int f[1 << MAXN], g[1 << MAXN];
void fwt_xor(int* a, int n, int flag) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; ++k) {
int x = a[j + k], y = a[i + j + k];
if (flag == 1) {
a[j + k] = mod1(x + y);
a[i + j + k] = mod2(x - y);
} else {
a[j + k] = (long long)mod1(x + y) * inv_2 % MOD;
a[i + j + k] = (long long)mod2(x - y) * inv_2 % MOD;
}
}
}
}
}
int main() {
Fastio ::cin >> n >> m;
for (int i = 1; i <= n; ++i) {
Fastio ::cin >> (s[i] + 1);
}
for (int i = 1; i < (1 << n); ++i) {
bitcnt[i] = bitcnt[i >> 1] + (i & 1);
g[i] = min(bitcnt[i], n - bitcnt[i]);
}
for (int i = 1; i <= m; ++i) {
int mask = 0;
for (int j = 1; j <= n; ++j) {
if (s[j][i] == '1') {
mask |= (1 << (j - 1));
}
}
f[mask]++;
}
inv_2 = pow_mod(2, MOD - 2);
fwt_xor(f, 1 << n, 1);
fwt_xor(g, 1 << n, 1);
for (int i = 0; i < (1 << n); ++i) {
f[i] = (long long)f[i] * g[i] % MOD;
}
fwt_xor(f, 1 << n, -1);
int ans = INF;
for (int i = 0; i < (1 << n); ++i) {
ckmin(ans, f[i]);
}
Fastio ::cout << ans << Fastio ::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxr = 20;
string s[maxr];
int F[maxr + 1][1 << maxr];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> s[i];
for (int col = 0; col < m; col++) {
int perCol = 0;
for (int row = 0; row < n; row++) {
if (s[row][col] == '1') perCol |= (1 << row);
}
F[0][perCol]++;
}
for (int i = 0; i < n; i++) {
for (int dif = i + 1; dif >= 1; dif--) {
for (int mask = 0; mask < (1 << n); mask++) {
F[dif][mask] += F[dif - 1][mask ^ (1 << i)];
}
}
}
int ret = INT_MAX;
for (int mask = 0; mask < (1 << n); mask++) {
int ans = 0;
for (int dif = 0; dif <= n; dif++) ans += min(dif, n - dif) * F[dif][mask];
ret = min(ret, ans);
}
printf("%d", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, MAXS = 1048580;
long long ans, res[MAXS], cnt[MAXS];
int n, m, s, a[MAXN];
int read() {
char ch = getchar();
while (ch < '0' || ch > '1') ch = getchar();
return ch - '0';
}
int lowbit(int x) { return x & (-x); }
int count(int x) {
int tot = 0;
for (; x; x -= lowbit(x)) tot++;
return tot;
}
void FWT(long long *C, int len, int on) {
for (int h = 2; h <= len; h <<= 1)
for (int j = 0; j < len; j += h)
for (int k = j; k < j + h / 2; k++) {
long long x = C[k], y = C[k + h / 2];
C[k] = x + y, C[k + h / 2] = x - y;
if (on == -1) C[k] /= 2, C[k + h / 2] /= 2;
}
}
int main() {
scanf("%d%d", &n, &m);
s = 1 << n;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) a[j] = a[j] * 2 + read();
for (int i = (1); i <= (m); i++) cnt[a[i]]++;
for (int i = (0); i <= (s - 1); i++) {
int x = count(i);
res[i] = min(x, n - x);
}
FWT(res, s, 1);
FWT(cnt, s, 1);
for (int i = (0); i <= (s - 1); i++) res[i] *= cnt[i];
FWT(res, s, -1);
ans = n * m;
for (int i = (0); i <= (s - 1); i++) ans = min(ans, res[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = (1 << 20) + 7;
void Xor(int n, long long *a, long long op) {
long long x, y;
for (int w = 2, l = 1; w <= n; w <<= 1, l <<= 1)
for (int j = 0; j < n; j += w)
for (int k = 0; k < l; k++)
x = (a[j | k] + a[j | k | l]) / op, y = (a[j | k] - a[j | k | l]) / op,
a[j | k] = x, a[j | k | l] = y;
}
int n, m;
long long a[N], f[N], g[N];
inline int min(int x, int y) { return x < y ? x : y; }
inline int lowbit(int x) { return -x & x; }
inline int count(int x) {
int ret = 0;
while (x) x -= lowbit(x), ret++;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
int ans = n * m;
for (int i = 1; i <= n; i++) {
char c;
for (int j = 1; j <= m; j++) {
c = getchar();
while (c != '0' && c != '1') c = getchar();
a[j] = (a[j] << 1) + c - '0';
}
}
for (int i = 1; i <= m; i++) f[a[i]]++;
m = 1 << n;
for (int i = 0; i < m; i++) {
int x = count(i);
g[i] = min(n - x, x);
}
Xor(m, f, 1), Xor(m, g, 1);
for (int i = 0; i < m; i++) f[i] = f[i] * g[i];
Xor(m, f, 2);
for (int i = 0; i < m; i++) ans = min(ans, f[i]);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxs = (1 << 20) + 2333, MOD = 998244353;
int c[maxs], g[maxs], n, m, full, pop[maxs];
char s[22][101010];
inline int mo(int x) {
if (x >= MOD) return x - MOD;
if (x < 0) return x + MOD;
return x;
}
inline int muln(int x, int y) { return (long long)x * y % MOD; }
inline int qpow(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = muln(x, x))
if (y & 1) ret = muln(ret, x);
return ret;
}
int Base, Len;
int* fwt(int* A, int dwt = 1) {
int l, r;
for (int i = 0; i < Base; ++i)
for (int S = 0; S < Len; ++S)
if (~S >> i & 1) {
l = A[S], r = A[S | (1 << i)];
A[S] = mo(l + r);
A[S | (1 << i)] = mo(l - r);
}
if (dwt == -1) {
int inv2 = qpow(Len, MOD - 2);
for (int S = 0; S < Len; ++S) A[S] = muln(A[S], inv2);
}
return A;
}
int main() {
scanf("%d%d", &n, &m);
full = (1 << n) - 1;
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < m; ++i) {
int res = 0;
for (int j = 0; j < n; ++j) res = 2 * res + s[j][i] - '0';
c[res]++;
}
for (int S = 1; S <= full; ++S) {
pop[S] = pop[S >> 1] + (S & 1);
g[S] = min(pop[S], n - pop[S]);
}
Len = 1 << n, Base = n;
fwt(c, 1);
fwt(g, 1);
for (int S = 0; S <= full; ++S) c[S] = muln(c[S], g[S]);
fwt(c, -1);
int ans = 0x3f3f3f3f;
for (int S = 0; S <= full; ++S) ans = min(ans, c[S]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
long long n, m, s, cnt[1400205], f[1400205];
bool g[21][100005];
inline void fwtxor(long long *f, long long n, long long x) {
for (long long l = 2, k = 1; l <= n; l <<= 1, k <<= 1)
for (long long i = 0; i < n; i += l)
for (long long j = 0; j < k; ++j) {
long long a = f[i + j], b = f[i + j + k];
f[i + j] = (a + b) / x, f[i + j + k] = (a - b) / x;
}
}
signed main() {
n = read(), m = read(), s = 1 << n;
for (register long long i = (1); i <= (n); ++i)
for (register long long j = (1); j <= (m); ++j) {
char ch;
cin >> ch;
g[i][j] = (ch - '0');
}
for (register long long i = (1); i <= (m); ++i) {
long long sta = 0;
for (register long long j = (1); j <= (n); ++j)
sta |= (1 << (j - 1)) * g[j][i];
f[sta]++;
}
for (register long long i = (0); i <= (s - 1); ++i)
cnt[i] = cnt[i >> 1] + (i & 1);
for (register long long i = (0); i <= (s - 1); ++i)
cnt[i] = min(cnt[i], n - cnt[i]);
fwtxor(f, s, 1), fwtxor(cnt, s, 1);
for (register long long i = (0); i <= (s - 1); ++i) f[i] *= cnt[i];
fwtxor(f, s, 2);
long long res = INT_MAX;
for (register long long i = (0); i <= (s - 1); ++i) res = min(res, f[i]);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e5 + 5;
int n, m, a[maxm], f[21][1 << 21], ans = 1e9, res;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
char d;
for (int i = 1, j; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> d, a[j] = (a[j] << 1) + d - '0';
}
for (int i = 1; i <= m; i++) f[0][a[i]]++;
for (int i = 0; i < n; i++)
for (int k = n; k >= 1; k--)
for (int S = 0; S < (1 << n); S++) f[k][S] += f[k - 1][S ^ (1 << i)];
for (int S = 0, i; S < (1 << n); S++) {
for (res = 0, i = 0; i <= n; i++) res += f[i][S] * min(i, n - i);
ans = min(ans, res);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 21;
const int MAX_M = 1000100;
void rec(int f[][MAX_N], int n, int l, int r) {
if (l == r) {
return;
}
int x = (l + r) / 2;
rec(f, n, l, x);
rec(f, n, x + 1, r);
int len = r - x;
for (int i = l; i <= x; i++) {
for (int j = n - 1; j >= 0; j--) {
f[i][j + 1] += f[i + len][j];
f[i + len][j + 1] += f[i][j];
}
}
}
void count_xor_ones(int n, int a[], int f[][MAX_N]) {
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j <= n; j++) {
f[i][j] = 0;
}
f[i][0] = a[i];
}
rec(f, n, 0, (1 << n) - 1);
}
int n;
int columns[MAX_M];
int a[1 << MAX_N];
int f[1 << MAX_N][MAX_N];
char buffer[MAX_M];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", buffer);
for (int j = 0; j < m; j++) {
if (buffer[j] == '1') {
columns[j] += 1 << i;
}
}
}
for (int i = 0; i < m; i++) {
a[columns[i]] += 1;
}
count_xor_ones(n, a, f);
int answer = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int penalty = 0;
for (int i = 0; i <= n; i++) {
penalty += f[mask][i] * min(i, n - i);
}
answer = min(answer, penalty);
}
printf("%d\n", answer);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char CRTBUFF[300000];
struct debugger {
static void call(const char* it) {}
template <typename T, typename... aT>
static void call(const char* it, T a, aT... rest) {
string b;
for (; *it && *it != ','; ++it)
if (*it != ' ') b += *it;
cerr << b << "=" << a << " ";
call(++it, rest...);
}
};
int inv2;
long long add(long long a, long long b) {
long long res = a + b;
if (res >= 1000000007) res -= 1000000007;
return res;
}
long long sub(long long a, long long b) { return add(1000000007, add(a, -b)); }
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
void walsh_transform(long long* ar, int n) {
if (n == 0) return;
int i, j, m = n / 2, len;
for (len = 1; 2 * len <= n; len <<= 1) {
for (i = 0; i < n; i += 2 * len) {
for (j = 0; j < len; j++) {
long long x = ar[i + j], y = ar[i + j + len];
ar[i + j] = add(x, y), ar[i + j + len] = sub(x, y);
}
}
}
}
void inverse_walsh_transform(long long* ar, int n) {
if (n == 0) return;
int i, j, m = n / 2, len;
for (len = 1; 2 * len <= n; len <<= 1) {
for (i = 0; i < n; i += 2 * len) {
for (j = 0; j < len; j++) {
long long x = ar[i + j], y = ar[i + j + len];
ar[i + j] = mul(add(x, y), inv2),
ar[i + j + len] = mul(sub(x, y), inv2);
}
}
}
}
long long modpow(long long x, long long e) {
long long res = 1;
while (e) {
if (e & 1) res = mul(res, x);
x = mul(x, x), e >>= 1;
}
return res;
}
const int lim = 1 << 21;
string s[30];
long long ones[lim + 10], freq[lim + 10], res[lim + 10];
void init() { inv2 = modpow(2, 1000000007 - 2); }
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
init();
int n, m;
while (cin >> n >> m) {
memset(freq, 0, sizeof(freq));
memset(ones, 0, sizeof(ones));
for (int i = (0); i < (n); i += (1)) cin >> s[i];
for (int j = (0); j < (m); j += (1)) {
int mask = 0;
for (int i = (0); i < (n); i += (1))
if (s[i][j] == '1') {
mask = ((mask) | (1 << (i)));
}
freq[mask]++;
}
for (int i = (0); i < (lim); i += (1)) {
int p = __builtin_popcount(i);
ones[i] = min(p, n - p);
}
walsh_transform(ones, lim);
walsh_transform(freq, lim);
for (int i = (0); i < (lim); i += (1)) res[i] = mul(freq[i], ones[i]);
inverse_walsh_transform(res, lim);
long long ans = res[0];
for (int i = (0); i < (1 << n); i += (1)) ans = min(ans, res[i]);
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20, maxm = 100005, maxs = (1 << maxn) + 5;
int n, m, a[maxm];
char mp[maxn][maxm];
long long cnt[maxs], num[maxs], ans = 1e9;
void FWT(long long* A, bool typ) {
for (int i = 0; i < n; i++)
for (int j = 0, k = 1 << i; j + k < (1 << n); j++) {
if (j / k & 1) continue;
long long A0 = A[j], A1 = A[j + k];
A[j] = A0 + A1, A[j + k] = A0 - A1;
if (typ) A[j] /= 2, A[j + k] /= 2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mp[i][j] == '1') a[j] |= 1 << i;
for (int i = 0; i < m; i++) num[a[i]]++;
for (int i = 1; i < (1 << n); i++) cnt[i] = cnt[i - (i & -i)] + 1;
for (int i = 0; i < (1 << n); i++) cnt[i] = min(cnt[i], n - cnt[i]);
FWT(cnt, 0), FWT(num, 0);
for (int i = 0; i < (1 << n); i++) num[i] *= cnt[i];
FWT(num, 1);
for (int i = 0; i < (1 << n); i++) ans = min(ans, num[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 21;
const long long maxm = 100010;
const long long inf = 1e18;
long long n, m, ans = inf;
long long a[maxm], size[1 << maxn], f[1 << maxn], g[1 << maxn];
char s[maxm];
inline long long read() {
char c = getchar();
long long res = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') res = res * 10 + c - '0', c = getchar();
return res * f;
}
inline void FWT(long long *a, long long n, long long op) {
for (long long l = 1; l < (1 << n); l <<= 1)
for (long long i = 0; i < (1 << n); i += l << 1)
for (long long j = 0; j < l; j++) {
long long x = a[i + j], y = a[i + l + j];
if (~op)
a[i + j] = x + y, a[i + l + j] = x - y;
else
a[i + j] = (x + y) >> 1, a[i + l + j] = (x - y) >> 1;
}
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (long long j = 1; j <= m; j++)
if (s[j] == '1') a[j] |= 1 << i - 1;
}
for (long long i = 1; i <= m; i++) f[a[i]]++;
for (long long i = 0; i < (1 << n); i++) size[i] = size[i >> 1] + (i & 1);
for (long long i = 0; i < (1 << n); i++) g[i] = min(size[i], n - size[i]);
FWT(f, n, 1);
FWT(g, n, 1);
for (long long i = 0; i < (1 << n); i++) f[i] *= g[i];
FWT(f, n, -1);
for (long long i = 0; i < (1 << n); i++) ans = min(ans, f[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 20;
const long long MAXM = 1e5 + 10;
const long long INF = 1e12 + 10;
int x[1 << MAXN][MAXN];
int z[1 << MAXN][MAXN];
int a[MAXM];
void solve(long long k, long long u) {
if (u == 0) {
return;
}
solve(k, u - 1);
solve(k + (1 << (u - 1)), u - 1);
for (long long i = 0; i < (1 << u); i++) {
for (long long j = 0; j < u; j++) {
x[k + i][j] = z[k + i][j];
}
x[k + i][u] = 0;
}
for (long long i = 0; i < (1 << (u - 1)); i++) {
for (long long j = 0; j < u; j++) {
x[k + i][j + 1] += z[k + i + (1 << (u - 1))][j];
x[k + i + (1 << (u - 1))][j + 1] += z[k + i][j];
}
}
for (long long i = 0; i < (1 << u); i++) {
for (long long j = 0; j <= u; j++) {
z[k + i][j] = x[k + i][j];
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
long long n, m, ans = INF;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
char e;
cin >> e;
a[j] *= 2;
a[j] += (e - '0');
}
}
for (long long i = 0; i < m; i++) {
z[a[i]][0]++;
}
solve(0, n);
for (long long mask = 0; mask < (1 << n); mask++) {
long long res = 0;
for (long long j = 0; j <= n; j++) {
if (j < (n - j)) {
res += z[mask][j] * j;
} else {
res += z[mask][j] * (n - j);
}
}
ans = min(ans, res);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[20][100005];
int dp[21][1 << 20];
int cand[1 << 20];
int main() {
int n, m;
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", str[i]);
for (int j = 0; j < m; j++) {
int val = 0;
for (int i = 0; i < n; i++) {
if (str[i][j] == '1') {
val |= 1 << i;
}
}
dp[0][val]++;
}
}
for (int k = 1; k <= n; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[k][mask] = 0;
for (int i = 0; i < n; i++) {
dp[k][mask] += dp[k - 1][mask ^ (1 << i)];
}
if (k >= 2) {
dp[k][mask] -= n * dp[k - 2][mask];
}
if (k >= 3) {
dp[k][mask] += (k - 2) * dp[k - 2][mask];
}
dp[k][mask] /= k;
cand[mask] += min(k, n - k) * dp[k][mask];
}
}
int ans = int(1e9);
for (int mask = 0; mask < (1 << n); mask++) {
ans = min(ans, cand[mask]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
char s[21][100100];
int n, m, ans = 1e9, all, inv, a[100100], bit[1100000], w[1100000], f[1100000];
int power(int a, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
k >>= 1;
}
return ret;
}
void FWT(int *a, int t) {
int pre, cur = 0;
static int f[2][1100000];
for (int i = 0; i <= all; i++) f[0][i] = a[i];
for (int i = 0; i <= n - 1; i++) {
pre = cur, cur ^= 1;
for (int s = 0; s <= all; s++)
if (!(s >> i & 1)) {
int l = f[pre][s], r = f[pre][s | (1 << i)];
f[cur][s] = (l + r) % mod;
f[cur][s | (1 << i)] = (l + mod - r) % mod;
}
}
if (t)
for (int i = 0; i <= all; i++) f[cur][i] = 1ll * f[cur][i] * inv % mod;
for (int i = 0; i <= all; i++) a[i] = f[cur][i];
}
int main() {
scanf("%d%d", &n, &m);
all = (1 << n) - 1;
inv = power(power(2, mod - 2), n);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) a[i] = (a[i] << 1) + s[j][i] - '0';
for (int i = 1; i <= all; i++) bit[i] = bit[i >> 1] + (i & 1);
for (int i = 1; i <= m; i++) f[a[i]]++;
for (int i = 0; i <= all; i++) w[i] = min(bit[i], n - bit[i]);
FWT(f, 0);
FWT(w, 0);
for (int i = 0; i <= all; i++) f[i] = 1ll * f[i] * w[i] % mod;
FWT(f, 1);
for (int i = 0; i <= all; i++) ans = min(ans, f[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 100;
const long double eps = 1e-12;
const long double pi = acos(-1.0L);
int myrand() { return rand(); }
unsigned rdtsc() {
unsigned ans;
asm("rdtsc" : "=a"(ans));
return ans;
}
int rnd(int x) { return myrand() % x; }
int c[30][30];
void precalc() {
for (int i = 0; i < 30; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
}
const int maxn = 1e6;
const int maxm = 21;
int n, m;
vector<int> a;
char s[maxn];
bool read() {
if (scanf("%d%d", &m, &n) < 2) {
return false;
}
a = vector<int>(n);
for (int i = 0; i < m; i++) {
scanf("%s", s);
for (int j = 0; j < n; j++) {
a[j] *= 2;
a[j] += (s[j] == '1');
}
}
return true;
}
int dp[11][1 << 20];
int ans[1 << 20];
void solve() {
int all = 0;
for (int i = 0; i < m; i++) {
all = all * 2 + 1;
}
memset(ans, 0, sizeof(ans));
for (int big = 0; big <= m / 2; big++) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
int cur = __builtin_popcount(a[i]);
if (cur > m - cur) {
cur = m - cur;
a[i] = a[i] ^ all;
}
if (cur != big) {
continue;
}
for (int mask = a[i];; mask = a[i] & (mask - 1)) {
dp[__builtin_popcount(mask)][mask]++;
if (mask == 0) {
break;
}
}
}
for (int b = 0; b <= big; b++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < (1 << m); k++) {
if (((k >> j) & 1)) {
dp[b][k] += dp[b][k ^ (1 << j)];
}
}
}
}
for (int mask = 0; mask < (1 << m); mask++) {
int cur = 0;
int curcnt = __builtin_popcount(mask);
int i = big;
for (int j = i; j >= 0; j--) {
int &cnt = dp[j][mask];
for (int k = i; k > j; k--) {
cnt -= c[k][j] * dp[k][mask];
}
cur += min((curcnt + i - 2 * j), m - (curcnt + i - 2 * j)) * cnt;
}
ans[mask] += cur;
}
}
int mn = inf;
for (int i = 0; i < (1 << m); i++) {
mn = min(mn, ans[i]);
}
printf("%d\n", mn);
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
long long n, m, ans = 0x3f3f3f3f, c[23][100005], f[23][(1 << 20) + 1];
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (long long j = 1; j <= m; j++) {
if (s[j] == '1') c[i][j] = 1;
}
}
for (long long j = 1; j <= m; j++) {
long long tmp = 0;
for (long long i = 1; i <= n; i++) tmp = (tmp << 1) | c[i][j];
f[0][tmp]++;
}
for (long long i = 0; i < n; i++) {
for (long long j = n; j; j--) {
for (long long k = 0; k < (1 << n); k++) {
f[j][k] += f[j - 1][k ^ (1 << i)];
}
}
}
for (long long i = 0; i < (1 << n); i++) {
long long sum = 0;
for (long long j = 0; j <= n; j++) {
sum += f[j][i] * min(j, n - j);
}
ans = min(ans, sum);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][200001];
int n, m;
long long f[2000001], g[2000001];
void FWT(long long* f) {
for (int i = 2; i <= (1 << n); i <<= 1)
for (int j = 0; j < (1 << n); j += i)
for (int k = j; k < j + i / 2; k++) {
long long fk = f[k];
f[k] = f[k] + f[k + i / 2];
f[k + i / 2] = fk - f[k + i / 2];
}
}
void IFWT(long long* f) {
FWT(f);
for (int i = 0; i < (1 << n); i++) f[i] >>= n;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i]);
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (s[j][i] == '1')
x = (x << 1) + 1;
else
x <<= 1;
f[x]++;
}
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
g[i] = min(cnt, n - cnt);
}
FWT(f);
FWT(g);
for (int i = 0; i < (1 << n); i++) f[i] *= g[i];
IFWT(f);
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, (int)f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
int const nmax = 100000;
int const kmax = 20;
int v[1 + nmax];
int dp[(1 << kmax)][1 + kmax];
int dp2[(1 << kmax)][1 + kmax];
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m;
std::cin >> n >> m;
std::string s[1 + kmax];
for (int i = 0; i < n; i++) std::cin >> s[i];
for (int i = 1; i <= m; i++)
for (int j = 0; j < n; j++) v[i] |= ((s[j][i - 1] - '0') << j);
for (int j = 1; j <= m; j++) dp[v[j]][0]++;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << n); j++)
for (int h = 0; h <= i; h++) {
dp2[j][h] += dp[j][h];
dp2[j ^ (1 << i)][h + 1] += dp[j][h];
}
for (int j = 0; j < (1 << n); j++)
for (int h = 0; h < n; h++) {
dp[j][h] = dp2[j][h];
dp2[j][h] = 0;
}
}
int result = (1 << n) * n;
for (int i = 0; i < (1 << n); i++) {
int aux = 0;
for (int h = 0; h <= n; h++) {
aux += std::min(h, n - h) * dp[i][h];
}
result = std::min(result, aux);
}
std::cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s;
char mp[22][200005];
long long a[2000036], b[2000036];
void FWT(long long *A) {
for (int len = 2; len <= s; len <<= 1) {
int g = len >> 1;
for (int i = 0; i < s; i += len) {
for (int j = 0; j < g; j++) {
long long a = A[i + j], b = A[i + j + g];
A[i + j] = (a + b);
A[i + j + g] = (a - b);
}
}
}
}
void IFWT(long long *A) {
for (int len = s; len >= 2; len >>= 1) {
int g = len >> 1;
for (int i = 0; i < s; i += len) {
for (int j = 0; j < g; j++) {
long long a = A[i + j], b = A[i + j + g];
A[i + j] = (a + b) / 2;
A[i + j + g] = (a - b) / 2;
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
for (int i = 0; i < m; i++) {
int t = 0;
for (int j = 0; j < n; j++)
if (mp[j][i] == '1') t += (1 << j);
a[t]++;
}
for (int i = 0; i < (1 << n); i++) {
int cnt1 = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) cnt1++;
}
b[i] = min(cnt1, n - cnt1);
}
s = (1 << n);
FWT(a);
FWT(b);
for (int i = 0; i < s; i++) a[i] = a[i] * b[i];
IFWT(a);
long long ans = 0x3f3f3f3f;
for (int i = 0; i < s; i++) ans = min(ans, a[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e5 + 5;
long long n, m, G[25][M], S[M], lim, g[1 << 21], f[1 << 21], ans = 0x7f7f7f7f;
long long read() {
long long x = 0, f = 1;
char s;
while ((s = getchar()) > '9' || s < '0')
if (s == '-') f = -1;
while (s >= '0' && s <= '9')
x = (x << 1) + (x << 3) + (s ^ 48), s = getchar();
return x * f;
}
void FWT(long long *f, const long long op = 1) {
for (long long i = 2; i <= lim; i <<= 1)
for (long long j = 0, p = i >> 1; j < lim; j += i)
for (long long k = j; k < j + p; ++k) {
long long x = f[k], y = f[k + p];
f[k] = x + y;
f[k + p] = x - y;
if (op == -1) f[k] >>= 1, f[k + p] >>= 1;
}
}
signed main() {
n = read(), m = read();
lim = 1 << n;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= m; ++j) G[i][j] = getchar() - '0';
getchar();
}
for (long long i = 1; i <= m; ++i)
for (long long j = 1; j <= n; ++j) S[i] |= G[j][i] * (1 << j - 1);
for (long long i = 1; i <= m; ++i) ++f[S[i]];
for (long long i = 0; i < lim; ++i) g[i] = g[i >> 1] + (i & 1);
for (long long i = 0; i < lim; ++i) g[i] = min(g[i], n - g[i]);
FWT(f), FWT(g);
for (long long i = 0; i < lim; ++i) f[i] *= g[i];
FWT(f, -1);
for (long long i = 0; i < lim; ++i) ans = min(ans, f[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[23][100013];
int dp[2][21][1 << 20];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", &s[i]);
for (int j = 0; j < m; j++) {
int x = 0;
for (int i = 0; i < n; i++)
if (s[i][j] == '1') {
x |= (1 << i);
}
dp[0][0][x] += 1;
}
for (int i = 0; i < n; i++) {
int r = i & 1;
for (int j = 0; j <= n; j++) {
for (int k = 0; k < (1 << n); k++) {
dp[r ^ 1][j][k] = dp[r][j][k];
if (j) dp[r ^ 1][j][k] += dp[r][j - 1][k ^ (1 << i)];
}
}
}
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) {
int cur = 0;
for (int j = 0; j <= n; j++) {
cur += dp[n & 1][j][i] * min(j, n - j);
}
ans = min(ans, cur);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
vl mult(vl& a, vl& b) {
assert(a.size() == b.size());
if (a.size() == 1) return {a[0] * b[0]};
vl a0(a.begin(), a.begin() + a.size() / 2),
a1(a.begin() + a.size() / 2, a.begin() + a.size());
vl as(a.size() / 2), ad(a.size() / 2);
for (int i = (0); i < (a.size() / 2); i++)
as[i] = a0[i] + a1[i], ad[i] = a0[i] - a1[i];
vl b0(b.begin(), b.begin() + b.size() / 2),
b1(b.begin() + b.size() / 2, b.begin() + b.size());
vl bs(b.size() / 2), bd(b.size() / 2);
for (int i = (0); i < (b.size() / 2); i++)
bs[i] = b0[i] + b1[i], bd[i] = b0[i] - b1[i];
vl x0 = mult(as, bs), x1 = mult(ad, bd), ans(a.size());
for (int i = (0); i < (a.size() / 2); i++) ans[i] = (x0[i] + x1[i]) / 2;
for (int i = (0); i < (a.size() / 2); i++)
ans[i + a.size() / 2] = (x0[i] - x1[i]) / 2;
return ans;
}
string tp[20];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vl a(1 << n), b(1 << n);
for (int i = (0); i < (n); i++) cin >> tp[i];
for (int i = (0); i < (m); i++) {
string k;
for (int j = (0); j < (n); j++) k += tp[j][i];
a[bitset<20>(k).to_ulong()]++;
}
for (int i = (0); i < (1 << n); i++) {
int ppc = __builtin_popcount(i);
b[i] = min(ppc, n - ppc);
}
vl c = mult(a, b);
ll ans = c[0];
for (ll& t : c) ans = min(ans, t);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100010, inf = 1e9 + 233;
long long n, m, N;
long long f[1 << 20], g[1 << 20];
char s[21][maxn];
template <typename T>
inline void read(T &k) {
long long f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
inline void FWT(long long *a) {
for (long long i = 2; i <= N; i <<= 1) {
for (long long j = 0, m = i >> 1; j < N; j += i) {
for (long long k = 0; k < m; k++) {
long long x = a[j + k], y = a[j + k + m];
a[j + k] = x + y;
a[j + k + m] = x - y;
}
}
}
}
inline void IFWT(long long *a) {
for (long long i = 2; i <= N; i <<= 1) {
for (long long j = 0, m = i >> 1; j < N; j += i) {
for (long long k = 0; k < m; k++) {
long long x = a[j + k], y = a[j + k + m];
a[j + k] = (x + y) >> 1;
a[j + k + m] = (x - y) >> 1;
}
}
}
}
signed main() {
read(n);
read(m);
for (long long i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (long long j = 1; j <= m; j++) {
long long now = 0;
for (long long i = 1; i <= n; i++) now = now << 1 | (s[i][j] - '0');
f[now]++;
}
N = 1 << n;
for (long long i = 0; i < N; i++) {
long long cnt = 0;
for (long long j = 0; j < n; j++) cnt += (i >> j) & 1;
g[i] = min(cnt, n - cnt);
}
FWT(f);
FWT(g);
for (long long i = 0; i < N; i++) f[i] *= g[i];
IFWT(f);
long long ans = inf;
for (long long i = 0; i < N; i++) ans = min(ans, f[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans = INT_MAX;
long long a[1 << 20], b[1 << 20];
char s[20][100000];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = 0; i < m; i++) {
int S = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '1') S |= 1 << j;
}
a[S]++;
}
for (int i = 0; i < 1 << n; i++) {
int j = __builtin_popcount(i);
b[i] = min(j, n - j);
}
auto FWT = [&](long long *a) {
for (int i = 1; i < 1 << n; i <<= 1) {
for (int j = 0; j < 1 << n; j += i << 1) {
for (int k = 0; k < i; k++) {
long long p = a[j + k], q = a[i + j + k];
a[j + k] = p + q, a[i + j + k] = p - q;
}
}
}
};
FWT(a), FWT(b);
for (int i = 0; i < 1 << n; i++) {
a[i] *= b[i];
}
FWT(a);
for (int i = 0; i < 1 << n; i++) {
ans = min(ans, int(a[i] >> n));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, m;
int a[111111];
int nb[1 << 20];
const int N1 = 12;
int c[N1 + 1][1 << (20 - N1)];
int main() {
cin >> n >> m;
string s;
getline(cin, s);
for (int i = (0); i < (n); i++) {
getline(cin, s);
for (int j = (0); j < (m); j++)
if (s[j] == '1') a[j] |= 1 << i;
}
for (int i = (0); i < (1 << 20); i++) nb[i] = nb[i / 2] + i % 2;
int n1 = min(n, N1);
int fn1 = (1 << n1) - 1;
int n2 = n - n1;
int t;
int best = n * m;
for (int m1 = (0); m1 < (1 << n1); m1++) {
memset(c, 0, sizeof c);
for (int j = (0); j < (m); j++) {
t = a[j] ^ m1;
c[nb[t & fn1]][t >> n1]++;
}
for (int m2 = (0); m2 < (1 << n2); m2++) {
int sum = 0;
for (int fnb = (0); fnb < (n1 + 1); fnb++)
for (int fm2 = (0); fm2 < (1 << n2); fm2++)
if (c[fnb][fm2]) {
t = fnb + nb[fm2 ^ m2];
sum += c[fnb][fm2] * min(n - t, t);
}
best = min(best, sum);
}
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nk = 20, N = 1 << Nk;
int k, n, m, c[N];
long long F[N], G[N];
string s[Nk];
void FwtX(long long *A, int n, bool type) {
for (int m = 1; m < n; m <<= 1) {
for (int i = 0; i < n; i += m * 2) {
for (int j = (i); j < (i + m); ++j) {
long long x = A[j], y = A[j + m];
A[j] = x + y, A[j + m] = x - y;
if (type) {
A[j] /= 2, A[j + m] /= 2;
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> k >> m, n = 1 << k;
for (int i = (0); i < (k); ++i) {
cin >> s[i];
}
for (int i = (0); i < (m); ++i) {
int x = 0;
for (int j = (0); j < (k); ++j) {
if (s[j][i] == '1') {
x |= 1 << j;
}
}
G[x] += 1;
}
for (int s = (1); s < (n); ++s) {
c[s] = c[s >> 1] + (s & 1);
F[s] = min(c[s], k - c[s]);
}
FwtX(F, n, false);
FwtX(G, n, false);
for (int s = (0); s < (n); ++s) {
F[s] *= G[s];
}
FwtX(F, n, true);
int res = k * m;
for (int s = (0); s < (n); ++s) {
res = min<int>(res, F[s]);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using intl = long long;
using ll = long long;
const int mxn = 100006;
const int mxl = 1 << 20;
int n, m;
char s[mxn];
int t[mxn];
ll a[mxl];
ll b[mxl];
ll c[mxl];
void fwt(ll *a, int n, int op = 1) {
for (int i = 1; i < n; i *= 2)
for (int j = 0; j < n; j += i * 2)
for (int k = 0; k < i; ++k) {
ll x = a[j + k], y = a[j + k + i];
a[j + k] = x + y;
a[j + k + i] = x - y;
if (op == -1) a[j + k] /= 2, a[j + k + i] /= 2;
}
}
void multi(intl a[], intl b[], intl c[], int n) {
fwt(a, n);
fwt(b, n);
for (int i = 0; i < n; i++) c[i] = a[i] * b[i];
fwt(c, n, -1);
}
void EXEC() {
cin >> m >> n;
for (int i = 0; i < m; ++i) {
scanf("%s", s);
for (int j = 0; j < n; ++j) t[j] |= (s[j] - '0') << i;
}
for (int i = 0; i < n; ++i) ++a[t[i]];
int l = 1 << m;
for (int i = 0; i < l; ++i)
b[i] = min(__builtin_popcount(i), m - __builtin_popcount(i));
multi(a, b, c, l);
printf("%lld\n", *min_element(c, c + l));
}
int main() {
EXEC();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> dp(n + 1, vector<int>(1 << n, 0));
vector<string> s(n);
for (int i = (0); i < (n); i++) cin >> s[i];
for (int i = (0); i < (m); i++) {
int mask = 0;
for (int j = (0); j < (n); j++) {
if (s[j][i] == '1') mask ^= (1 << j);
}
dp[0][mask]++;
}
for (int k = (1); k < (n + 1); k++) {
for (int mask = (0); mask < (1 << n); mask++) {
for (int i = (0); i < (n); i++) {
dp[k][mask] += dp[k - 1][mask ^ (1 << i)] / max(1, k - 1);
}
if (k >= 2) dp[k][mask] -= (n - k + 2) * dp[k - 2][mask] / max(1, k - 2);
}
}
int ans = INT_MAX;
for (int mask = (0); mask < (1 << n); mask++) {
int cnt = 0;
for (int k = (1); k < (n + 1); k++) {
cnt += (dp[k][mask] / k) * min(k, n - k);
}
ans = min(ans, cnt);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, S;
int dp[20][1 << 20];
char buf[100013];
int val[100013];
int main() {
scanf("%d%d", &N, &M);
for (int i = int(0), __board_right = int(N); i < __board_right; i++) {
scanf("%s", buf);
for (int j = int(0), __board_right = int(M); j < __board_right; j++) {
val[j] += (buf[j] - '0') << i;
}
}
for (int i = int(0), __board_right = int(M); i < __board_right; i++) {
dp[0][val[i]]++;
}
S = 1 << N;
for (int i = int(0), __board_right = int(S); i < __board_right; i++) {
for (int j = int(0), __board_right = int(N); j < __board_right; j++) {
dp[1][i] += dp[0][i ^ (1 << j)];
}
}
for (int k = int(2), __board_right = int(N); k < __board_right; k++) {
for (int i = int(0), __board_right = int(S); i < __board_right; i++) {
for (int j = int(0), __board_right = int(N); j < __board_right; j++) {
dp[k][i] += dp[k - 1][i ^ (1 << j)];
}
dp[k][i] += (k - 2 - N) * dp[k - 2][i];
dp[k][i] /= k;
}
}
int res = N * M;
for (int i = int(0), __board_right = int(S); i < __board_right; i++) {
int tmp = 0;
for (int k = int(0), __board_right = int(N); k < __board_right; k++) {
tmp += dp[k][i] * min(k, N - k);
}
res = min(res, tmp);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long n, m;
char s[30][200000];
long long a[200000];
long long d[22][1050000];
int main() {
long long i, j, k, l;
cin >> n >> m;
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) a[i] += (s[j][i] == '1') << j;
}
for (i = 0; i < m; i++) {
d[0][a[i]]++;
for (j = 0; j < n; j++) {
d[1][a[i] ^ (1 << j)]++;
}
}
for (i = 2; i <= n; i++) {
for (j = 0; j < (1 << n); j++) {
long long sum = 0;
for (k = 0; k < n; k++) {
sum += d[i - 1][j ^ (1 << k)] - d[i - 2][j];
}
d[i][j] = (sum + d[i - 2][j] * (i - 2)) / i;
}
}
long long mi = 0x3f3f3f3f3f3f3f3fll;
for (i = 0; i < (1 << n); i++) {
long long sum = 0;
for (j = 0; j <= n; j++) {
sum += min((long long)j, n - j) * d[j][i];
}
mi = min(mi, sum);
}
cout << mi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FWT(long long a[], int l, int on) {
for (int d = 1; d < l; d <<= 1) {
for (int m = d << 1, i = 0; i < l; i += m) {
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = x + y;
a[i + j + d] = x - y;
if (on < 0) {
a[i + j] >>= 1;
a[i + j + d] >>= 1;
}
}
}
}
}
int n, m;
char str[100005];
int A[100005];
long long num[1 << 21];
long long B[1 << 21];
long long C[1 << 21];
int main() {
scanf("%d%d", &n, &m);
long long ans = n * m;
for (int i = 1, x; i <= n; i++) {
scanf("%s", str + 1);
for (int j = 1; j <= m; j++) {
x = str[j] - '0';
A[j] = (A[j] << 1) + x;
}
}
for (int i = 1; i <= m; i++) {
num[A[i]]++;
}
int l = (1 << n);
for (int i = 0; i < l; i++) {
B[i] = B[i >> 1] + (i & 1);
C[i] = min(B[i], n - B[i]);
}
FWT(num, l, 1);
FWT(C, l, 1);
for (int i = 0; i < l; i++) {
C[i] = C[i] * num[i];
}
FWT(C, l, -1);
for (int i = 0; i < l; i++) {
ans = min(ans, C[i]);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1e5 + 5;
int a[M], dp[(1 << N) + 5][N + 1][2], ans = N * M;
;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char x;
cin >> x;
a[j] += (x == '1') * (1 << i);
}
for (int i = 0; i < m; i++) dp[a[i]][0][0]++;
for (int j = 1; j <= n; j++)
for (int mask = 0; mask < (1 << n); mask++)
for (int i = 0; i <= j; i++) {
dp[mask][i][j & 1] = dp[mask][i][(j - 1) & 1];
if (i > 0)
dp[mask][i][j & 1] += dp[mask ^ (1 << (j - 1))][i - 1][(j - 1) & 1];
}
for (int i = 0; i < (1 << n); i++) {
int rtr = 0;
for (int j = 0; j <= n; j++) rtr += dp[i][j][n & 1] * min(j, n - j);
ans = min(ans, rtr);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char input[32][131072];
int cols[1 << 20];
int groups[16][1 << 7];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
scanf("%d %d\n", &n, &m);
char pattern[100];
sprintf(pattern, "%%%dc\n", m);
for (int i = 0; i < n; i++) {
scanf(pattern, input[i]);
}
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 0; j < n; j++) {
x = x * 2 + (int)(input[j][i] - '0');
}
cols[i] = x;
}
if (n == 1) {
printf("0\n");
} else {
int bestAns = n * m;
int split = min(max(1, n - 5), 13);
int mask1Max = (1 << split);
int lol = mask1Max - 1;
int mask2Max = (1 << (n - split));
int popcount[(1 << 13)];
for (int i = 0; i < (1 << 13); i++) popcount[i] = __builtin_popcount(i);
for (int mask1 = 0; mask1 < mask1Max; mask1++) {
for (int i = 0; i <= split; i++) {
memset(groups[i], 0, mask2Max * sizeof(int));
}
for (int i = 0; i < m; i++) {
int x1 = popcount[(cols[i] & lol) ^ mask1];
int x2 = cols[i] >> split;
groups[x1][x2]++;
}
for (int mask2 = 0; mask2 < mask2Max; mask2++) {
int currAns = 0;
for (int i = 0; i <= split; i++) {
for (int j = 0; j < mask2Max; j++) {
int popCount = i + popcount[mask2 ^ j];
currAns += groups[i][j] * min(popCount, n - popCount);
}
}
bestAns = min(bestAns, currAns);
}
}
printf("%d\n", bestAns);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
const long long MOD = 998244353;
using namespace std;
inline void ckmax(long long &a, long long b) { a = max(a, b); }
inline void ckmin(long long &a, long long b) { a = min(a, b); }
inline void addmod(long long &a, long long b) {
long long t = a + b;
a = (t >= MOD ? t - MOD : t);
}
inline long long ksm(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = 1ll * ans * a % MOD;
a = 1ll * a * a % MOD;
}
return ans;
}
inline long long inv(long long a) { return ksm(a, MOD - 2); }
inline long long read() {
long long num = 0, flag = 1;
char c = ' ';
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') flag = -1;
for (; c >= '0' && c <= '9'; num = num * 10 + c - 48, c = getchar())
;
return num * flag;
}
const long long MAXN = (1 << 20) | 1;
inline void FWT(long long *a, long long n, long long op) {
for (long long k = 1; k < n; k <<= 1)
for (long long i = 0; i < n; i += (k << 1))
for (long long j = 0; j < k; j++) {
a[i + j] += a[i + j + k],
a[i + j + k] = a[i + j] - a[i + j + k] - a[i + j + k];
a[i + j] /= op, a[i + j + k] /= op;
}
}
long long n, m, a[MAXN], b[MAXN], mp[21][MAXN];
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (register long long i = (1); i <= (n); i++) {
string s;
cin >> s;
for (register long long j = (1); j <= (m); j++)
mp[i][j] = (s[j - 1] == '1');
}
for (register long long i = (1); i <= (m); i++) {
long long st = 0;
for (register long long j = (1); j <= (n); j++) st = (st << 1) | mp[j][i];
a[st]++;
}
for (register long long st = (0); st <= ((1 << n) - 1); st++) {
b[st] = min(1ll * __builtin_popcount(st), n - __builtin_popcount(st));
}
FWT(a, (1 << n), 1);
FWT(b, (1 << n), 1);
for (register long long i = (0); i <= ((1 << n) - 1); i++) a[i] *= b[i];
FWT(a, (1 << n), 2);
long long ans = n * m;
for (register long long i = (0); i <= ((1 << n) - 1); i++) {
ckmin(ans, a[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][1 << 22];
long long cont[1 << 22];
long long ones[1 << 22];
void Fwt(long long *f, int n, int on) {
for (int i = 2; i <= n; i <<= 1) {
for (int j = 0; j < n; j += i) {
for (int k = j; k < j + (i >> 1); k++) {
long long x1 = f[k], x2 = f[k + (i >> 1)];
f[k] = x1 + x2;
f[k + (i >> 1)] = x1 - x2;
}
}
}
if (on == -1) {
for (int i = 0; i < n; i++) {
f[i] /= n;
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("\n%s", s[i]);
}
for (int i = 0; i < m; i++) {
int mask_col = 0;
for (int j = 0; j < n; j++) {
mask_col |= (s[j][i] - '0') << j;
}
cont[mask_col]++;
}
for (int mask = 0; mask < (1 << n); mask++) {
ones[mask] = __builtin_popcount(mask);
ones[mask] = min(ones[mask], n - ones[mask]);
}
Fwt(cont, 1 << n, 1);
Fwt(ones, 1 << n, 1);
for (int mask_lines = 0; mask_lines < (1 << n); mask_lines++) {
cont[mask_lines] *= ones[mask_lines];
}
Fwt(cont, 1 << n, -1);
long long ans = INT_MAX;
for (int mask_lines = 0; mask_lines < (1 << n); mask_lines++) {
ans = min(ans, cont[mask_lines]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
char in[22][MAXN + 1];
long long A[2097152];
long long B[2097152];
long long res;
int N;
int n;
int m;
inline int cnt(int);
inline void FWT_xor(long long[], int);
int main() {
scanf("%d%d", &n, &m);
N = 1 << n;
for (int i = 1; i <= n; i++) scanf("%s", in[i] + 1);
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++) x |= (in[j][i] & 1) << (j - 1);
A[x]++;
}
for (int i = 0; i < N; i++) B[i] = cnt(i);
FWT_xor(A, 1), FWT_xor(B, 1);
for (int i = 0; i < N; i++) A[i] *= B[i];
FWT_xor(A, -1);
res = A[0];
for (int i = 1; i < N; i++) res = res < A[i] ? res : A[i];
printf("%lld\n", res);
}
inline int cnt(int x) {
int r = 0;
while (x) ++r, x ^= x & -x;
return min(r, n - r);
}
inline void FWT_xor(long long a[], int k) {
for (int l = 2; l <= N; l <<= 1) {
int len = l >> 1;
for (int i = 0; i < N; i += l)
for (int j = i; j < i + len; j++) {
long long t1 = a[j], t2 = a[j + len];
a[j] = t1 + t2;
a[j + len] = t1 - t2;
if (k == -1) a[j] >>= 1, a[j + len] >>= 1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 4;
using namespace std;
void FWT(long long a[], int l, int on) {
for (int d = 1; d < l; d <<= 1) {
for (int m = d << 1, i = 0; i < l; i += m) {
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = x + y;
a[i + j + d] = x - y;
if (on < 0) {
a[i + j] >>= 1;
a[i + j + d] >>= 1;
}
}
}
}
}
int n, m;
char str[100005];
int A[100005];
long long num[1 << 21];
long long B[1 << 21];
long long C[1 << 21];
int main() {
scanf("%d%d", &n, &m);
long long ans = n * m;
for (int i = 1, x; i <= n; i++) {
scanf("%s", str + 1);
for (int j = 1; j <= m; j++) {
x = str[j] - '0';
A[j] = (A[j] << 1) + x;
}
}
for (int i = 1; i <= m; i++) {
num[A[i]]++;
}
int l = (1 << n);
for (int i = 0; i < l; i++) {
B[i] = B[i >> 1] + (i & 1);
C[i] = min(B[i], n - B[i]);
}
FWT(num, l, 1);
FWT(C, l, 1);
for (int i = 0; i < l; i++) {
C[i] = C[i] * num[i];
}
FWT(C, l, -1);
for (int i = 0; i < l; i++) {
ans = min(ans, C[i]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[21][1 << 21];
int fact[100010];
int n, m, res;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) fact[j] |= ((s[j] - '0') << i);
}
res = 1e9 + 10;
for (int j = 0; j < m; j++) dp[0][fact[j]]++;
for (int x = 0; x < n; x++)
for (int i = n; i >= 1; i--)
for (int mask = 0; mask < (1 << n); mask++)
dp[i][mask] += dp[i - 1][mask ^ (1 << x)];
for (int mask = 0; mask < (1 << n); mask++) {
int sum = 0;
for (int i = 0; i <= n; i++) sum += dp[i][mask] * min(i, n - i);
res = min(res, sum);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fwt(long long *P, int len, int opt) {
for (int i = 1; i < len; i <<= 1)
for (int p = i << 1, j = 0; j < len; j += p)
for (int k = 0; k < i; ++k) {
long long x = P[j + k], y = P[j + k + i];
P[j + k] = (x + y) / opt;
P[j + k + i] = (x - y) / opt;
}
}
char s[100005];
int mp[22][100005];
long long a[1 << 21];
long long b[1 << 21];
int two[22];
int main() {
int n, m;
two[0] = 1;
for (int i = 1; i <= 21; i++) {
two[i] = two[i - 1] << 1;
}
scanf("%d%d", &n, &m);
int len = 1 << n;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 1; j <= m; j++) {
mp[i][j] = s[j - 1] - '0';
}
}
for (int j = 1; j <= m; j++) {
int res = 0;
for (int i = 0; i < n; i++) {
if (mp[i][j]) res += two[i];
}
a[res]++;
}
for (int i = 0; i <= len - 1; i++) {
int res = 0;
for (int j = 0; j <= n - 1; j++) {
if ((i >> j) & 1) res++;
}
b[i] = min(res, n - res);
}
fwt(a, len, 1);
fwt(b, len, 1);
for (int i = 0; i < len; i++) a[i] *= b[i];
fwt(a, len, 2);
long long ans = a[0];
for (int i = 1; i < len; i++) {
ans = min(ans, a[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, cnt[(1 << 20) + 10], c[100010];
long long ans[(1 << 20) + 10], f[(1 << 20) + 10], tot[(1 << 20) + 10],
mn = 1e10;
void get01(int& x) {
x = getchar();
while (x != '0' && x != '1') x = getchar();
x -= '0';
}
void FWT(long long* F, const int& len, const int& op) {
long long t1, t2;
for (int i = 2, tl = 1; i <= (1 << len); i <<= 1, tl <<= 1)
for (int j = 0; j < (1 << len); j += i)
for (int k = j; k < j + tl; ++k)
t1 = F[k], t2 = F[k + tl], F[k] = (t1 + t2) / op,
F[k + tl] = (t1 - t2) / op;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (1 << n); ++i)
cnt[i] = cnt[i >> 1] + (i & 1), f[i] = min(cnt[i], n - cnt[i]);
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) get01(t), c[j] += t << i;
for (int i = 1; i <= m; ++i) ++tot[c[i]];
FWT(f, n, 1), FWT(tot, n, 1);
for (int i = 0; i < (1 << n); ++i) ans[i] = f[i] * tot[i];
FWT(ans, n, 2);
for (int i = 0; i < (1 << n); ++i) mn = min(mn, ans[i]);
printf("%I64d", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[21][100100];
int n, m, ans = 1e9, all, inv, a[100100], bit[1100000], is[21][1100000],
f[21][1100000], tf[2][1100000];
int power(int a, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = 1LL * ret * a % 1000000007;
a = 1LL * a * a % 1000000007;
k >>= 1;
}
return ret;
}
void make(int &f, int v) {
f = v;
if (f > 1000000007) f -= 1000000007;
if (f < 1000000007) f += 1000000007;
}
void FWT(int *a, int t) {
int pre, cur = 0;
for (int i = 0; i <= all; i++) tf[0][i] = a[i];
for (int i = 0; i <= n - 1; i++) {
pre = cur, cur ^= 1;
for (int s = 0; s <= all; s++)
if (!(s >> i & 1)) {
int l = tf[pre][s], r = tf[pre][s | (1 << i)];
tf[cur][s] = (l + r) % 1000000007;
tf[cur][s | (1 << i)] = (l + 1000000007 - r) % 1000000007;
}
}
if (t)
for (int i = 0; i <= all; i++)
tf[cur][i] = 1LL * tf[cur][i] * inv % 1000000007;
for (int i = 0; i <= all; i++) a[i] = tf[cur][i];
}
int main() {
scanf("%d%d", &n, &m);
all = (1 << n) - 1;
inv = power(power(2, 1000000007 - 2), n);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) a[i] = (a[i] << 1) + s[j][i] - '0';
for (int i = 1; i <= all; i++) bit[i] = bit[i >> 1] + (i & 1);
for (int i = 1; i <= m; i++) f[0][a[i]]++;
for (int i = 0; i <= all; i++) is[bit[i]][i] = 1;
FWT(f[0], 0);
for (int i = 1; i <= n; i++) {
FWT(is[i], 0);
for (int j = 0; j <= all; j++)
f[i][j] = 1LL * f[0][j] * is[i][j] % 1000000007;
FWT(f[i], 1);
}
for (int i = 0; i <= all; i++) {
int tmp = 0;
for (int j = 0; j <= n; j++) tmp += min(j, n - j) * f[j][i];
ans = min(ans, tmp);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 1;
const int N = 20;
int z, n, k, m;
string s;
vector<int> col;
int dp[N][1 << N];
int mem[2][1 << N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
col.resize(m);
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
col[j] <<= 1;
col[j] |= (s[j] == '1');
}
}
for (int i = 0; i < m; i++) {
dp[0][col[i]]++;
}
for (int k = 1; k < n; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
for (int p = 0; p < n; p++) {
mem[k % 2][mask][p] =
dp[k - 1][mask ^ (1 << p)] - mem[1 - k % 2][mask ^ (1 << p)][p];
dp[k][mask] += mem[k % 2][mask][p];
}
dp[k][mask] /= k;
}
}
int ans = inf;
for (int mask = 0; mask < (1 << n); mask++) {
int cur = 0;
for (int k = 0; k < n; k++) {
cur += dp[k][mask] * min(k, n - k);
}
ans = ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > p;
vector<int> color;
int count_0, count_1;
int n, m;
bool dfs(int x) {
int now;
vector<int> q;
color[x] = 0;
count_0++;
q.push_back(x);
while (q.size() > 0) {
now = q.back();
q.pop_back();
for (int i = 0; i < p[now].size(); i++) {
if (color[p[now][i]] > -1) {
if (color[p[now][i]] != 1 - color[now]) {
return 1;
}
} else {
color[p[now][i]] = 1 - color[now];
if (color[p[now][i]])
count_1++;
else
count_0++;
q.push_back(p[now][i]);
}
}
}
return 0;
}
int main() {
int a, b;
cin >> n >> m;
p.resize(n);
color.resize(n, -1);
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
p[a].push_back(b);
p[b].push_back(a);
}
count_0 = 0;
count_1 = 0;
for (int i = 0; i < n; i++) {
if (color[i] == -1 && p[i].size() > 0) {
if (dfs(i)) {
cout << -1 << endl;
return 0;
}
}
}
int k = 0;
cout << count_0 << endl;
for (int j = 0; j < n; j++) {
if (color[j] == 0) {
cout << j + 1;
k++;
if (k < count_0)
cout << " ";
else
break;
}
}
cout << endl;
k = 0;
cout << count_1 << endl;
for (int j = 0; j < n; j++) {
if (color[j] == 1) {
cout << j + 1;
k++;
if (k < count_1)
cout << " ";
else
break;
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int> > G;
vector<int> V;
vector<long long int> S;
int A[100001];
int B[100001];
int dfs(long long int x, long long int d) {
V[x] = 1;
for (unsigned long long int j = 0; j < G[x].size(); j++) {
if (d % 2) {
if (A[G[x][j]])
return 1;
else
B[G[x][j]] = 1;
} else {
if (B[G[x][j]])
return 1;
else
A[G[x][j]] = 1;
}
if (V[G[x][j]] == 0) {
if (dfs(G[x][j], d + 1)) {
return 1;
}
}
}
return 0;
}
int main() {
long long int m, n, u, v, a;
int f = 0;
cin >> n >> m;
G.clear();
V.clear();
for (long long int i = 0; i <= n; i++) {
A[i] = B[i] = 0;
V.push_back(0);
G.push_back(vector<long long int>(0));
}
for (long long int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (long long int i = 1; i <= n; i++) {
if (!V[i]) {
if (G[i].size() > 0) {
A[i] = 1;
if (dfs(i, 1)) {
f = 1;
break;
}
}
}
}
if (f)
cout << "-1" << endl;
else {
S.clear();
a = 0;
for (long long int i = 0; i <= n; i++) {
if (A[i]) {
S.push_back(i);
a++;
}
}
cout << a << endl;
for (unsigned long long int i = 0; i < S.size(); i++) {
cout << S[i] << " ";
}
cout << endl;
S.clear();
a = 0;
for (long long int i = 0; i <= n; i++) {
if (B[i]) {
S.push_back(i);
a++;
}
}
cout << a << endl;
for (unsigned long long int i = 0; i < S.size(); i++) {
cout << S[i] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> gp[100005];
bool visited[100005] = {false};
long long int arr[100005];
long long int n, k;
long long int ct = 0;
double depth[100005] = {-1};
bool flag = false;
void bfs(long long int root) {
queue<long long int> q;
q.push(root);
visited[root] = true;
ct++;
while (!q.empty()) {
long long int curr = q.front();
q.pop();
for (long long int x : gp[curr]) {
if (!visited[x]) {
q.push(x);
visited[x] = true;
ct++;
depth[x] = 1 - depth[curr];
} else {
if (depth[x] == depth[curr]) {
flag = true;
break;
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0, u, v; i < k; ++i) {
cin >> u >> v;
gp[u].push_back(v);
gp[v].push_back(u);
}
for (long long int i = 1; i < n + 1; i++) {
if ((!visited[i]) && (gp[i].size() != 0)) {
bfs(i);
}
}
if (flag == true) {
cout << -1 << "\n";
return 0;
}
vector<long long> one, zero;
for (long long i = 1; i < n + 1; ++i) {
if (visited[i]) {
(depth[i] == 1) ? one.push_back(i) : zero.push_back(i);
}
}
cout << zero.size() << "\n";
for (long long int x : zero) {
cout << x << " ";
}
cout << "\n";
cout << one.size() << "\n";
for (long long int x : one) {
cout << x << " ";
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
int col[100005];
bool posi = true;
void bfs(int s) {
queue<int> q;
col[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
int c = col[u];
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (col[v] == -1) {
col[v] = c ^ 1;
q.push(v);
} else {
if (col[v] == c) {
posi = false;
}
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
adj.resize(n + 5);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) col[i] = -1;
for (int i = 1; i <= n; i++)
if (col[i] == -1) bfs(i);
if (!posi) {
cout << -1 << endl;
return 0;
}
int c0 = 0, c1 = 0;
for (int i = 1; i <= n; i++) {
if (col[i] == 0)
c0++;
else
c1++;
}
printf("%d\n", c0);
for (int i = 1; i <= n; i++)
if (col[i] == 0) printf("%d ", i);
printf("\n");
printf("%d\n", c1);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void pass() { return; }
mt19937 rnd(rand() << 15 + rand());
const int MOD = 1e9 + 7;
const long long BIG_MOD = 1e18 + 7;
const int MAXN = 1e5 + 7;
vector<int> g[MAXN];
int color[MAXN];
bool used[MAXN];
void dfs(int u, int c) {
color[u] = c;
used[u] = true;
for (int v : g[u]) {
if (!used[v]) {
dfs(v, color[u] ^ 1);
} else if (color[v] == color[u]) {
cout << "-1\n";
exit(0);
}
}
}
signed main() {
cout.tie(NULL);
cout.precision(20);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
vector<int> ans1, ans2;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i, 0);
}
if (!color[i]) {
ans1.push_back(i);
} else {
ans2.push_back(i);
}
}
cout << ans1.size() << '\n';
for (int elem : ans1) {
cout << elem + 1 << ' ';
}
cout << '\n';
cout << ans2.size() << '\n';
for (int elem : ans2) {
cout << elem + 1 << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long pow(long long B, long long P) {
long long S = 1;
for (long long i = 1; i <= P; i++) S = S * B;
return S;
}
int fx4[] = {1, -1, 0, 0};
int fy4[] = {0, 0, 1, -1};
vector<int> graph[200000];
vector<int> first, second;
int color[200000];
bool BFS(int source) {
color[source] = 2;
queue<int> Q;
Q.push(source);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (color[v] == 0 && color[u] == 2) {
color[v] = 1;
Q.push(v);
} else if (color[v] == 0 && color[u] == 1) {
color[v] = 2;
Q.push(v);
} else if (color[v] != 0 && color[u] == color[v]) {
return false;
}
}
}
return true;
}
int main() {
FastIO();
int N, M;
cin >> N >> M;
int u, v;
int source;
for (int i = 0; i < M; i++) {
cin >> u >> v;
source = u;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= N; i++) {
bool check;
if (color[i] == 0 && graph[i].size() > 0) check = BFS(i);
if (check == false) {
cout << "-1" << endl;
return 0;
}
}
for (int i = 1; i <= N; i++) {
if (color[i] == 1)
first.push_back(i);
else if (color[i] == 2)
second.push_back(i);
}
cout << first.size() << endl;
for (int i = 0; i < first.size(); i++) cout << first[i] << " ";
cout << endl;
cout << second.size() << endl;
for (int i = 0; i < second.size(); i++) cout << second[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Solution {
int N, M;
vector<vector<int> > Out;
vector<int> A[2], Visited;
bool DFS(int no, int part) {
stack<int> stack0;
Visited[no] = part;
stack0.push(no);
while (!stack0.empty()) {
no = stack0.top();
part = Visited[no];
A[part - 1].push_back(no);
stack0.pop();
for (int i = 0; i < Out[no].size(); ++i) {
int target = Out[no][i];
if (Visited[target] == 0) {
Visited[target] = 3 - part;
stack0.push(target);
} else if (Visited[target] != 3 - part) {
return false;
}
}
}
return true;
}
bool Bipartite() {
Visited.resize(N);
for (int i = 0; i < N; ++i) {
if (!Visited[i] && !DFS(i, 1)) return false;
}
return true;
}
void Print(const vector<int>& a) {
printf("%d\n", a.size());
bool head = true;
for (int i = 0; i < a.size(); ++i) {
if (!head) putchar(' ');
head = false;
printf("%d", a[i] + 1);
}
printf("\n");
}
void Solve() {
scanf("%d%d", &N, &M);
Out.resize(N);
for (int i = 0; i < M; ++i) {
int u, v;
scanf("%d%d", &u, &v);
Out[u - 1].push_back(v - 1);
Out[v - 1].push_back(u - 1);
}
if (Bipartite()) {
Print(A[0]);
Print(A[1]);
} else {
printf("-1\n");
}
}
};
int main() {
Solution().Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
int n, m;
const int N = 100005;
vector<int> v[N];
int c[N];
int _runtimeTerror_() {
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
v[x].push_back(y), v[y].push_back(x);
}
vector<bool> vis(n + 1, 0);
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
queue<int> q;
c[i] = 0;
q.push(i);
vis[i] = true;
while (!q.empty()) {
int t = q.front();
q.pop();
for (auto k : v[t]) {
if (!vis[k]) {
vis[k] = true, q.push(k), c[k] = c[t] ^ 1;
} else if (vis[k] && c[k] == c[t]) {
cout << "-1\n";
return 0;
}
}
}
}
vector<int> cc, ccc;
for (int i = 1; i <= n; ++i) c[i] ? cc.push_back(i) : ccc.push_back(i);
auto disp = [&](vector<int> a) {
cout << (long long)a.size() << '\n';
for (auto j : a) cout << j << " ";
cout << '\n';
};
disp(cc);
disp(ccc);
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<vector<int> >;
using VS = vector<string>;
using SS = stringstream;
using PII = pair<int, int>;
using VPII = vector<pair<int, int> >;
template <typename T = int>
using VT = vector<T>;
template <typename T = int>
using VVT = vector<vector<T> >;
template <typename T = int>
using LIM = numeric_limits<T>;
template <typename T>
inline istream &operator>>(istream &s, vector<T> &v) {
for (T &t : v) {
s >> t;
}
return s;
}
template <typename T>
inline ostream &operator<<(ostream &s, const vector<T> &v) {
for (int i = 0; i < int(v.size()); ++i) {
s << (" " + !i) << v[i];
}
return s;
}
template <typename T>
inline T fromString(const string &s) {
T res;
istringstream iss(s);
iss >> res;
return res;
}
template <typename T>
inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
template <typename T>
inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class IsBipartite {
private:
const int N;
vector<vector<int> > G;
vector<int> colors;
public:
IsBipartite(const int n) : N(n), G(n), colors(N){};
void connect(const int u, const int v) {
G[u].push_back(v);
G[v].push_back(u);
}
bool solve() {
fill(colors.begin(), colors.end(), -1);
for (int u = 0; u < N; ++u) {
if (colors[u] == -1 && !paint(u, 1)) {
return false;
}
}
return true;
}
bool color(const int v) const { return colors[v]; }
private:
bool paint(const int u, const int c) {
if (colors[u] != -1) {
return colors[u] == c;
}
colors[u] = c;
for (const int v : G[u]) {
if (!paint(v, 1 - c)) {
return false;
}
}
return true;
}
};
void print_res(const VI &res) {
const int L = ((int)(res).size());
printf("%d\n", L);
for (int i = (int)(0); i < (int)(L); ++i) {
printf("%d%c", res[i], i + 1 == L ? '\n' : ' ');
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int N, M;
scanf("%d%d", &N, &M);
IsBipartite is_bipartite(N);
for (int _ = (int)(0); _ < (int)(M); ++_) {
int u, v;
scanf("%d%d", &u, &v);
is_bipartite.connect(u - 1, v - 1);
}
if (!is_bipartite.solve()) {
puts("-1");
return 0;
}
VI res1, res2;
for (int v = (int)(0); v < (int)(N); ++v) {
(is_bipartite.color(v) ? res1 : res2).push_back(v + 1);
}
print_res(res1);
print_res(res2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
vector<long long> v[N];
bool vis[N], col[N];
void no() {
cout << "-1";
exit(0);
}
void dfs(long long node, bool white) {
col[node] = white;
vis[node] = true;
for (auto it : v[node]) {
if (!vis[it]) {
dfs(it, white ^ 1);
} else if (col[it] == col[node]) {
no();
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
long long n1 = 0;
for (long long i = 1; i <= n; i++) {
if (col[i]) {
n1++;
}
}
cout << n1 << '\n';
for (long long i = 1; i <= n; i++) {
if (col[i]) {
cout << i << ' ';
}
}
cout << '\n' << n - n1 << '\n';
for (long long i = 1; i <= n; i++) {
if (!col[i]) {
cout << i << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int xn = 1e5 + 20;
int n, m, a[xn], r, b;
vector<int> adj[xn];
bool f;
void dfs(int v, int par) {
if (v == par) {
a[v] = 1;
} else {
a[v] = 3 - a[par];
}
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (a[u] == a[v]) {
f = 1;
} else if (a[u] == 0)
dfs(u, v);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0, d, c; i < m; i++) {
cin >> c >> d;
c--;
d--;
adj[c].push_back(d);
adj[d].push_back(c);
}
for (int i = 0; i < n; i++) {
if (a[i] == 0) dfs(i, i);
if (f) return cout << -1, 0;
}
for (int i = 0; i < n; i++) {
if (a[i] == 1) r++;
if (a[i] == 2) b++;
}
cout << r << "\n";
for (int i = 0; i < n; i++)
if (a[i] == 1) cout << i + 1 << ' ';
cout << "\n" << b << "\n";
for (int i = 0; i < n; i++)
if (a[i] == 2) cout << i + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5;
long long int md = 1e9 + 7;
long long int __gcd(long long int a, long long int b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
long long int poww(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= md;
}
a *= a;
a %= md;
b >>= 1;
}
return res;
}
void ainp(long long int arr[], long long int n) {
for (long long int i = 1; i <= n; i++) cin >> arr[i];
}
void vinp(vector<long long int> v, long long int n) {
for (long long int i = 0; i < n; i++) {
long long int a;
cin >> a;
v.push_back(a);
}
}
map<long long int, long long int> mapp;
set<long long int> s;
vector<long long int> g[N], ans[2];
bool vis[N];
long long int color[N];
void fun() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void dfs(long long int k, long long int col) {
if (vis[k]) {
if (color[k] != col) {
cout << "-1\n";
exit(0);
}
return;
}
vis[k] = 1;
color[k] = col;
ans[col].push_back(k);
for (long long int i = 0; i < g[k].size(); i++) {
long long int child = g[k][i];
dfs(child, col ^ 1);
}
}
signed main() {
fun();
long long int n, m, x, y;
cin >> n >> m;
memset(vis, 0, n + 1);
memset(color, 0, n + 1);
for (long long int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (long long int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
for (long long int i = 0; i < 2; i++) {
cout << ans[i].size() << "\n";
for (auto &it : ans[i]) {
cout << it << " ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, flag = 0, x, y, f = 0, s = 0;
cin >> n >> m;
vector<list<int> > v(n + 1);
int visit[n + 1];
for (int i = 0; i <= n; i++) visit[i] = 0;
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
list<int> q;
for (int i = 1; i <= n; i++) {
if (visit[i] == 0) {
q.push_back(i);
visit[i] = 1;
while (!q.empty()) {
s = q.front();
q.pop_front();
for (auto it = v[s].begin(); it != v[s].end(); it++) {
if (!visit[*it]) {
visit[*it] = visit[s] == 1 ? 2 : 1;
q.push_back(*it);
} else if (visit[*it] == visit[s]) {
flag = 1;
break;
}
}
}
}
}
s = 0;
if (flag)
cout << -1;
else {
for (int i = 1; i <= n; i++) {
if (visit[i] == 1)
f++;
else if (visit[i] == 2)
s++;
}
cout << f << endl;
for (int i = 1; i <= n; i++)
if (visit[i] == 1) cout << i << " ";
cout << endl;
cout << s << endl;
for (int i = 1; i <= n; i++)
if (visit[i] == 2) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000;
vector<int> f, s;
vector<int> adj[MAXN + 10];
bool vis[MAXN + 10], bip[MAXN + 10];
bool dcd = true;
void dfs(int v, int len) {
vis[v] = 1;
if (len % 2 == 0) bip[v] = 1;
for (int u : adj[v]) {
if (!vis[u])
dfs(u, len + 1);
else {
if (bip[v] == bip[u]) {
dcd = 0;
}
}
}
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> a >> b, adj[a].push_back(b), adj[b].push_back(a);
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
if (!dcd)
cout << -1 << endl;
else {
for (int i = 1; i <= n; i++) {
if (bip[i])
f.push_back(i);
else
s.push_back(i);
}
cout << f.size() << endl;
for (int i : f) cout << i << " ";
cout << endl;
cout << s.size() << endl;
for (int i : s) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, color[100005] = {0};
vector<vector<int> > adjlist;
void dfs(int u, int prv) {
color[u] = (prv == 1) ? -1 : 1;
for (int i = 0; i < (int)adjlist[u].size(); i++) {
int v = adjlist[u][i];
if (color[v] == 0) dfs(v, color[u]);
}
}
int main() {
scanf("%d %d", &N, &M);
adjlist.assign(N, vector<int>());
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adjlist[u].push_back(v);
adjlist[v].push_back(u);
}
for (int i = 0; i < N; i++)
if (color[i] == 0) dfs(i, 0);
bool cycle = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < (int)adjlist[i].size(); j++)
if (color[i] == color[adjlist[i][j]]) cycle = 1;
if (cycle) {
puts("-1");
return 0;
}
vector<int> black, white;
for (int i = 0; i < N; i++)
if (color[i] == 1)
black.push_back(i);
else
white.push_back(i);
printf("%d\n", (int)black.size());
for (int i = 0; i < (int)black.size(); i++) printf("%d ", black[i] + 1);
printf("\n%d\n", (int)white.size());
for (int i = 0; i < (int)white.size(); i++) printf("%d ", white[i] + 1);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, col[100005], clb = 1, a[100005], la;
vector<int> G[100005];
void dfs(int t) {
int i;
for (i = 0; i < G[t].size(); i++)
if (!col[G[t][i]])
col[G[t][i]] = col[t] ^ 1, dfs(G[t][i]);
else if (col[G[t][i]] == col[t])
clb = 0;
}
int main() {
int i, x, y;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (!col[i]) col[i] = 2, dfs(i);
if (clb == 0) {
printf("-1");
return 0;
}
la = 0;
for (i = 1; i <= n; i++)
if (col[i] == 2) a[++la] = i;
printf("%d\n", la);
for (i = 1; i <= la; i++) printf("%d ", a[i]);
cout << endl;
la = 0;
for (i = 1; i <= n; i++)
if (col[i] == 3) a[++la] = i;
printf("%d\n", la);
for (i = 1; i <= la; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> g[100005];
long long int lvl[100005];
long long int flag = 0;
void dfs(long long int u, long long int f) {
for (long long int v : g[u]) {
if (lvl[v] == 0) {
if (f == 1) {
lvl[v] = 2;
dfs(v, 2);
} else {
lvl[v] = 1;
dfs(v, 1);
}
} else {
if (lvl[v] == f) {
flag = 1;
return;
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int i;
long long int u, v;
for (i = 1; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (i = 1; i <= n; i++) {
if (lvl[i] == 0) {
lvl[i] = 1;
dfs(i, 1);
}
}
if (flag == 1)
cout << "-1";
else {
vector<long long int> v1, v2;
for (i = 1; i <= n; i++) {
if (lvl[i] == 1)
v1.push_back(i);
else if (lvl[i] == 2)
v2.push_back(i);
}
cout << (long long int)v1.size() << '\n';
for (long long int x : v1) {
cout << x << " ";
}
cout << '\n';
cout << (long long int)v2.size() << '\n';
for (long long int x : v2) {
cout << x << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
list<int> *adj;
int flag;
void DFS(int src, int vis[], int n, int bit) {
vis[src] = bit;
bit = (bit == 1 ? -1 : 1);
for (list<int>::iterator it = adj[src].begin(); it != adj[src].end(); it++)
if (vis[(*it)] == 0)
DFS((*it), vis, n, bit);
else if (vis[(*it)] == (bit == 1 ? -1 : 1)) {
flag = 0;
return;
}
}
void get_output(int v) {
int vis[v];
for (int i = 0; i < v; i++) vis[i] = 0;
flag = 1;
for (int i = 0; i < v; i++)
if (vis[i] == 0) DFS(i, vis, v, 1);
if (flag) {
int c1 = 0, c2 = 0;
for (int i = 0; i < v; i++)
if (vis[i] == 1)
c1++;
else if (vis[i] == -1)
c2++;
cout << c1 << endl;
for (int i = 0; i < v; i++)
if (vis[i] == 1) cout << i + 1 << " ";
cout << endl;
cout << c2 << endl;
for (int i = 0; i < v; i++)
if (vis[i] == -1) cout << i + 1 << " ";
cout << endl;
} else
cout << -1;
return;
}
int main() {
int n, m;
cin >> n >> m;
adj = new list<int>[n];
int temp1, temp2;
for (int i = 0; i < m; i++) {
cin >> temp1 >> temp2;
adj[temp1 - 1].push_back(temp2 - 1);
adj[temp2 - 1].push_back(temp1 - 1);
}
get_output(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int maxn = 1e5 + 7;
int m, n, u, v, minn = oo, p[maxn];
vector<int> a[maxn], A, B;
bool flag = true;
void nhap() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
minn = min(min(minn, u), v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; ++i) p[i] = -1;
}
void dfs(int u, int c) {
if (!flag) return;
if (p[u] != -1) {
if (p[u] != c) {
flag = false;
return;
} else
return;
}
p[u] = c;
if (c == 1)
A.push_back(u);
else
B.push_back(u);
if (a[u].size()) {
for (int i = 0; i <= a[u].size() - 1; ++i) {
if (c == 1)
dfs(a[u][i], 2);
else
dfs(a[u][i], 1);
}
}
}
void solve() {
for (int i = 1; i <= n; ++i)
if (a[i].size() && p[i] == -1) dfs(i, 1);
if (!flag) {
cout << -1;
return;
}
cout << A.size() << endl;
for (int i = 0; i <= A.size() - 1; ++i) cout << A[i] << ' ';
cout << endl;
cout << B.size() << endl;
for (int i = 0; i <= B.size() - 1; ++i) cout << B[i] << ' ';
}
void print() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
nhap();
solve();
print();
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int n;
int value;
vector<int> next;
} p[100010];
queue<struct point> q;
int main() {
int n, m, x, y, flag = 1, t;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
p[x].next.push_back(y);
p[x].n++;
p[y].next.push_back(x);
p[y].n++;
}
for (int i = 1; i <= n; i++) {
if (!flag) break;
if (p[i].n && !p[i].value) {
p[i].value = 1;
q.push(p[i]);
while (!q.empty()) {
for (int j = 0; j < q.front().n; j++) {
if (!p[q.front().next[j]].value) {
p[q.front().next[j]].value = q.front().value % 2 + 1;
q.push(p[q.front().next[j]]);
} else {
if (p[q.front().next[j]].value != q.front().value % 2 + 1) {
flag = 0;
break;
}
}
}
q.pop();
}
}
}
if (flag) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (p[i].value == 1) ans++;
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (p[i].value == 1) {
printf("%d ", i);
}
}
printf("\n");
ans = 0;
for (int i = 1; i <= n; i++) {
if (p[i].value == 2) ans++;
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (p[i].value == 2) {
printf("%d ", i);
}
}
} else {
printf("-1");
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100005];
int ans[1000005] = {0};
int main() {
int n, m, i, idx1 = 0, j;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
queue<int> q;
for (i = 1; i <= n; i++) {
if (ans[i] == 0) {
q.push(i);
ans[i] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
if (ans[u] == 1) idx1++;
int si = G[u].size();
for (j = 0; j < si; j++) {
int v = G[u][j];
if (ans[v] == 0) {
if (ans[u] == 1) {
ans[v] = 2;
q.push(v);
} else {
ans[v] = 1;
q.push(v);
}
} else if (ans[v] == ans[u]) {
printf("-1\n");
return 0;
}
}
}
}
}
printf("%d\n", idx1);
for (i = 1; i <= n; i++) {
if (ans[i] == 1) printf("%d ", i);
}
printf("\n");
printf("%d\n", n - idx1);
for (i = 1; i <= n; i++) {
if (ans[i] == 2) printf("%d ", i);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
cin >> n >> m;
list<int> graph[n + 1];
int i;
for (i = 0; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
list<int> q;
int visited[n + 1];
int set1[n + 1], set2[n + 1];
for (i = 0; i <= n; i++) {
visited[i] = 0;
set1[i] = 0;
set2[i] = 0;
}
list<int>::iterator it;
int count = 1, sum;
int level = 0;
int f = 0;
int len1 = 0, len2 = 0;
for (i = 1; i <= n; i++) {
if (visited[i]) continue;
visited[i] = 1;
q.push_back(i);
level = 0;
count = 1;
while (!q.empty()) {
sum = 0;
while (count) {
count--;
a = q.front();
q.pop_front();
if (level == 0) {
set1[a] = 1;
len1++;
} else {
set2[a] = 1;
len2++;
}
for (it = graph[a].begin(); it != graph[a].end(); ++it) {
if (!visited[*it]) {
visited[*it] = 1;
sum++;
q.push_back(*it);
} else {
if (level == 0 && set1[*it] == 1)
f = 1;
else if (level == 1 && set2[*it] == 1)
f = 1;
}
}
}
level++;
count = sum;
level = level % 2;
}
}
if (f == 1) {
cout << -1 << endl;
return 0;
}
cout << len1 << endl;
for (i = 1; i <= n; i++) {
if (set1[i]) cout << i << " ";
}
cout << endl;
cout << len2 << endl;
for (i = 1; i <= n; i++) {
if (set2[i]) cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> G[N];
int color[N];
bool dfs(int v) {
bool ret = true;
for (auto x : G[v]) {
if (color[x] && color[x] == color[v]) return false;
if (color[x] == 0) {
color[x] = (color[v] == 1) ? 2 : 1;
ret = ret & dfs(x);
}
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
int u, v;
int st;
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
st = v;
}
color[st] = 1;
bool chk = dfs(st);
for (int i = 1; i <= n; i++) {
chk &= dfs(i);
}
if (not chk)
cout << -1 << endl;
else {
vector<int> a[3];
for (int i = 1; i <= n; i++) {
if (color[i]) a[color[i]].push_back(i);
}
cout << a[1].size() << endl;
for (auto x : a[1]) cout << x << " ";
cout << endl;
cout << a[2].size() << endl;
for (auto x : a[2]) cout << x << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, m;
long long vis[N], color[N];
vector<long long> g[N], ans[2];
void dfs(long long k, long long col) {
if (vis[k]) {
if (color[k] != col) {
cout << "-1";
exit(0);
}
return;
}
vis[k] = 1;
color[k] = col;
ans[col].push_back(k);
for (auto it : g[k]) dfs(it, col ^ 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
for (long long i = 0; i <= 1; i++) {
cout << ans[i].size() << "\n";
for (auto it : ans[i]) cout << it << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
int n, m;
vector<int> g[N], U, V;
int col[N];
bool vis[N];
bool dfs(int i, int c) {
if (col[i] == c) return 0;
if (c == 1) col[i] = 2, U.push_back(i);
if (c == 2) col[i] = 1, V.push_back(i);
vis[i] = 1;
bool ans = 1;
for (int j = 0; j < g[i].size(); ++j) {
if (vis[g[i][j]])
if (col[g[i][j]] == col[i])
return 0;
else
continue;
ans = dfs(g[i][j], col[i]);
if (!ans) break;
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
memset(col, 0, sizeof(col));
memset(vis, false, sizeof(vis));
bool ok = 1;
for (int i = 0; i < n; ++i) {
if (vis[i + 1]) continue;
if (!dfs(i + 1, 1)) {
ok = 0;
break;
}
}
if (ok) {
cout << V.size() << "\n";
for (auto v : V) cout << v << " ";
cout << "\n";
cout << U.size() << "\n";
for (auto u : U) cout << u << " ";
cout << "\n";
} else
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000;
int n, m;
bool chek[maxn], a[maxn];
vector<int> v[maxn], v1, v2;
void dfs(int x) {
chek[x] = true;
for (int i = 0; i < v[x].size(); i++)
if (chek[v[x][i]] == false) {
a[v[x][i]] = 1 - a[x];
dfs(v[x][i]);
}
}
int main() {
int x, y;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (chek[i] == false) {
a[i] = 0;
dfs(i);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < v[i].size(); j++)
if (a[i] == a[v[i][j]]) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] == 0)
v1.push_back(i);
else
v2.push_back(i);
}
cout << v1.size() << endl;
for (int i = 0; i < v1.size(); i++) cout << v1[i] + 1 << " ";
cout << endl << v2.size() << endl;
for (int i = 0; i < v2.size(); i++) cout << v2[i] + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto a : v) out << a << " ";
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& a : v) in >> a;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, multiset<T>& S) {
for (auto a : S) out << a << " ";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, set<T>& S) {
for (auto a : S) out << a << " ";
return out;
}
template <typename T>
set<T> operator+(set<T> A, set<T> B) {
for (auto b : B) A.insert(b);
return A;
}
vector<int> V;
vector<vector<int> > E;
vector<int> D;
vector<int> O;
void dfs(int s) {
if (V[s]) return;
V[s] = 1;
for (auto t : E[s]) {
if (!V[t]) {
D[t] = D[s] + 1;
dfs(t);
} else {
if (D[s] > D[t] && (D[s] - D[t]) % 2 == 0) {
O[s] = 1;
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
V = vector<int>(n, 0);
D = vector<int>(n, 0);
O = vector<int>(n, 0);
E = vector<vector<int> >(n, vector<int>());
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
E[a].push_back(b);
E[b].push_back(a);
}
for (int i = 0; i < n; i++) {
dfs(i);
}
int oddSum = accumulate(O.begin(), O.end(), 0);
set<int> A;
set<int> B;
if (oddSum > 0) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
if (D[i] % 2 == 0)
A.insert(i + 1);
else
B.insert(i + 1);
}
cout << A.size() << endl;
cout << A << endl;
cout << B.size() << endl;
cout << B << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100005], ve[100005];
int vertex[100005], edge[100005];
bool dfs(int n, int par) {
vertex[n] = 1 - par;
bool ans = true;
for (int i = 0; i < v[n].size(); i++) {
if (edge[ve[n][i]] == -1) {
edge[ve[n][i]] = 1;
if (vertex[v[n][i]] == -1)
ans = ans & (dfs(v[n][i], vertex[n]));
else if (vertex[v[n][i]] != (1 - vertex[n])) {
ans = false;
break;
}
}
}
return ans;
}
int main() {
int n, m, i, j, a, b, flag = 0, cnt0 = 0, cnt1 = 0;
bool res = true;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a >> b;
v[a].push_back(b);
ve[a].push_back(i);
v[b].push_back(a);
ve[b].push_back(i);
}
for (i = 0; i <= n; i++) vertex[i] = -1;
for (i = 0; i <= m; i++) edge[i] = -1;
for (i = 1; i <= n; i++)
if (vertex[i] == -1) {
res = dfs(i, 0);
if (res == false) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("-1\n");
} else {
for (i = 1; i <= n; i++) {
if (vertex[i] == 0)
cnt0++;
else
cnt1++;
}
printf("%d\n", cnt0);
for (i = 1; i <= n; i++)
if (vertex[i] == 0) printf("%d ", i);
printf("\n");
printf("%d\n", cnt1);
for (i = 1; i <= n; i++)
if (vertex[i] == 1) printf("%d ", i);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 120021;
vector<int> vc[2];
vector<int> g[N];
int mark[N];
bool dfs(int v, int color = 2) {
mark[v] = color;
vc[color - 1].push_back(v);
for (int u : g[v]) {
if (!mark[u] && dfs(u, 3 - color)) return 1;
if (mark[u] != 3 - color) return 1;
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u = in() - 1;
int v = in() - 1;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (!mark[i]) {
if (g[i].empty()) continue;
if (dfs(i)) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < 2; i++) {
cout << vc[i].size() << endl;
for (int v : vc[i]) cout << v + 1 << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
class GRAPH {
public:
int to[410000], next[410000];
int head[201000];
int cnt;
GRAPH() { cnt = 1; }
void add(int x, int y) {
next[cnt] = head[x];
to[cnt] = y;
head[x] = cnt++;
}
};
int col[201000];
GRAPH g;
int n, m;
int cnt[4];
bool dfs(int pos, int c) {
cnt[c]++;
col[pos] = c;
for (register int i = g.head[pos]; i; i = g.next[i])
if (col[g.to[i]] == col[pos])
return false;
else if (col[g.to[i]] == 0) {
if (!dfs(g.to[i], 3 - c)) return false;
}
return true;
}
int main() {
int x, y;
cin >> n >> m;
for (register int i = (0); i < (m); i++) {
scanf("%d%d", &x, &y);
g.add(x, y);
g.add(y, x);
}
for (register int i = (1); i < (n + 1); i++)
if (col[i] == 0)
if (!dfs(i, 2)) {
cout << -1;
return 0;
}
cout << cnt[1] << endl;
for (register int i = (1); i < (n + 1); i++)
if (col[i] == 1) cout << i << ' ';
cout << endl;
cout << cnt[2] << endl;
for (register int i = (1); i < (n + 1); i++)
if (col[i] == 2) cout << i << ' ';
cout << endl;
return ~~(0 ^ 0 ^ 0);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <class S, class T>
struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T>
struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v) h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v) os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v) os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, m, v[100000];
vector<vector<int>> e;
bool rec(int c, int p, int col) {
v[c] = col;
for (int i : e[c]) {
if (v[i] && v[i] != -col) return 0;
if (!v[i])
if (!rec(i, c, -col)) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
e.resize(n);
for (int i = 0; i < (int)m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
}
bool ok = 1;
for (int i = 0; i < (int)n; i++)
if (!v[i]) ok &= rec(i, i, 1);
if (!ok) {
cout << -1 << endl;
} else {
vector<int> u, w;
for (int i = 0; i < (int)n; i++) (v[i] == 1 ? u : w).push_back(i + 1);
printf("%d\n", u.size());
for (int i = 0; i < (int)u.size(); i++)
printf("%d%c", u[i], i + 1 == u.size() ? '\n' : ' ');
printf("%d\n", w.size());
for (int i = 0; i < (int)w.size(); i++)
printf("%d%c", w[i], i + 1 == w.size() ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[100002];
int ran[100002];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
ran[i] = 0;
}
}
int fin(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = fin(par[x]);
}
}
void unite(int x, int y) {
x = fin(x);
y = fin(y);
if (x == y) return;
if (ran[x] < ran[y]) {
par[x] = y;
} else {
par[y] = x;
if (ran[x] == ran[y]) ran[x]++;
}
}
bool same(int x, int y) { return fin(x) == fin(y); }
vector<int> vec[100008];
int used[100008] = {0};
int judge = 0;
void dfs(int now) {
used[now] = 1;
for (int i = 0; i < vec[now].size(); i++) {
if (same(now, vec[now][i])) judge = 1;
if (used[vec[now][i]] == 0) dfs(vec[now][i]);
for (int j = 0; j < vec[vec[now][i]].size(); j++) {
unite(now, vec[vec[now][i]][j]);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int a, b;
init(n);
pair<int, int> road[100008];
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
vec[a - 1].push_back(b - 1);
vec[b - 1].push_back(a - 1);
road[i].first = a - 1;
road[i].second = b - 1;
}
for (int i = 0; i < n; i++) {
dfs(i);
if (judge == 1) break;
}
if (judge == 1)
cout << -1;
else {
set<int> aa;
set<int> bb;
for (int i = 0; i < m; i++) {
if (aa.count(fin(road[i].first))) {
bb.insert(fin(road[i].second));
} else {
if (bb.count(fin(road[i].first))) {
aa.insert(fin(road[i].second));
} else {
if (aa.count(fin(road[i].second))) {
bb.insert(fin(road[i].first));
} else {
if (bb.count(fin(road[i].second))) {
aa.insert(fin(road[i].first));
} else {
aa.insert(fin(road[i].first));
bb.insert(fin(road[i].second));
}
}
}
}
}
vector<int> aaa;
vector<int> bbb;
for (int i = 0; i < n; i++) {
if (aa.count(fin(i))) aaa.push_back(i + 1);
}
cout << aaa.size() << endl;
for (int i = 0; i < aaa.size(); i++) printf("%d ", aaa[i]);
cout << endl;
for (int i = 0; i < n; i++) {
if (bb.count(fin(i))) bbb.push_back(i + 1);
}
cout << bbb.size() << endl;
for (int i = 0; i < bbb.size(); i++) printf("%d ", bbb[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int prime[1000000];
void seive() {
int n_prime = 1000000;
fill_n(prime, n_prime, 1);
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= n_prime; i++) {
if (prime[i]) {
for (int j = i * i; j <= n_prime; j += i) {
prime[j] = 0;
}
}
}
}
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long long t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.ff);
cerr << ",";
_print(p.ss);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
vector<vector<int> > adj;
vector<int> vis;
vector<int> col;
vector<vector<int> > comp;
int ind = 0;
void init(int n) {
vector<int> temp;
for (int i = 0; i < n; i++) {
vis.push_back(0);
col.push_back(0);
adj.push_back(temp);
}
comp.push_back(temp);
comp.push_back(temp);
}
void dfs(int s) {
vis[s] = 1;
for (auto u : adj[s]) {
if (vis[u] == 0) {
vis[u] = 1;
col[u] = 1 - col[s];
dfs(u);
}
if (col[u] == col[s]) {
ind = 1;
}
}
comp[col[s]].push_back(s);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
std::cin >> n >> m;
init(n + 1);
int x, y;
for (int i = 0; i < m; i++) {
std::cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i < n + 1; i++) {
if (vis[i] == 0) {
dfs(i);
}
}
if (ind == 0) {
std::cout << (int)comp[0].size() << '\n';
for (int i = 0; i < (int)comp[0].size(); i++) {
cout << comp[0][i] << " ";
}
std::cout << '\n';
std::cout << (int)comp[1].size() << '\n';
for (int i = 0; i < (int)comp[1].size(); i++) {
cout << comp[1][i] << " ";
}
std::cout << '\n';
} else {
std::cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mk[101000];
vector<int> edge[101000];
vector<int> ans[3];
bool dfs(int u, int color) {
mk[u] = color;
ans[color].push_back(u);
bool ok = 1;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (mk[v]) {
if (mk[v] == 3 - color)
continue;
else
return 0;
} else {
ok &= dfs(v, 3 - color);
}
}
return ok;
}
int main() {
int n, m, u, v;
cin >> n >> m;
while (m--) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!mk[i]) {
bool f = dfs(i, 1);
if (!f) {
puts("-1");
return 0;
}
}
}
for (int i = 1; i <= 2; i++) {
int len = ans[i].size();
cout << len << endl;
for (int j = 0; j < len; j++) {
printf("%d ", ans[i][j]);
}
puts("");
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n, m;
vector<int> G[100005], ans[2];
int col[100005];
bool dfs(int x, int y) {
col[x] = y;
ans[y].push_back(x);
for (int v : G[x]) {
if (col[v] == -1) {
if (!dfs(v, !y)) return false;
} else {
if (col[v] == y) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
memset(col, -1, sizeof(col));
bool flag = true;
for (int i = 1; i <= n; i++)
if (col[i] == -1) {
if (!dfs(i, 1)) {
flag = false;
break;
}
}
if (!flag) {
puts("-1");
return 0;
}
for (int i = 0; i < 2; i++) {
printf("%d\n", ans[i].size());
for (int v : ans[i]) printf("%d ", v);
putchar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
int maxn = 100001;
vector<int> adj[100001];
bool visited[100001];
int rec[100001];
vector<int> one, zero;
void dfs(int node, bool &detected, int prev, int cnt) {
cnt++;
visited[node] = true;
rec[node] = cnt;
if (cnt % 2 == 1) {
zero.push_back(node);
} else {
one.push_back(node);
}
for (int next : adj[node]) {
if (next != prev) {
if (rec[next] == 0) {
if (!visited[next]) dfs(next, detected, node, cnt);
} else {
if (abs(rec[node] - rec[next]) % 2 == 0) {
detected = true;
}
}
}
}
rec[node] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool detected = false;
for (int i = 0; i < n; i++) {
if (!visited[i + 1]) {
dfs(i + 1, detected, -1, 0);
}
if (detected) {
cout << "-1\n";
return 0;
}
}
cout << one.size() << "\n";
for (int a : one) {
cout << a << " ";
}
cout << "\n" << zero.size() << "\n";
for (int a : zero) {
cout << a << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v;
int dis[100010];
void bfs(int u) {
dis[u] = 1;
queue<int> q;
q.push(u);
while (!q.empty()) {
int f = q.front();
q.pop();
for (int i = 0; i < v[f].size(); i++) {
int d = v[f][i];
if (!dis[d]) {
dis[d] = dis[f] + 1;
q.push(d);
}
}
}
}
vector<int> res1, res2;
bool vis[100010];
bool test(int u) {
queue<int> q;
q.push(u);
vis[u] = 1;
while (!q.empty()) {
int f = q.front();
q.pop();
if (dis[f] % 2 == 0)
res2.push_back(f);
else
res1.push_back(f);
for (int i = 0; i < v[f].size(); i++) {
int d = v[f][i];
if (dis[f] % 2 == dis[d] % 2) return false;
if (!vis[d]) {
q.push(d);
vis[d] = 1;
}
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
v.resize(n + 10);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!dis[i]) bfs(i);
}
bool ok = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ok = test(i);
if (!ok) {
break;
}
}
}
if (!ok) {
cout << -1;
} else {
cout << res1.size() << endl;
for (int i = 0; i < res1.size(); i++) cout << res1[i] << " ";
cout << endl;
cout << res2.size() << endl;
for (int i = 0; i < res2.size(); i++) cout << res2[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int vis[100005], a[100005], b[100005];
vector<int> g[100005];
bool bfs(int x, int color) {
q.push(x);
vis[x] = color;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < g[now].size(); i++) {
int t = g[now][i];
if (vis[t] != -1) {
if (vis[t] != (vis[now] + 1) % 2) return false;
} else {
vis[t] = (vis[now] + 1) % 2;
q.push(t);
}
}
}
return true;
}
int main() {
int n, m, u, v;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) vis[i] = -1;
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == -1) {
if (!bfs(i, 0)) {
printf("-1\n");
return 0;
}
}
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 1)
a[cnt1++] = i;
else if (vis[i] == 0)
b[cnt2++] = i;
}
printf("%d\n", cnt1);
for (int i = 0; i < cnt1; i++) printf("%d ", a[i]);
printf("\n");
printf("%d\n", cnt2);
for (int i = 0; i < cnt2; i++) printf("%d ", b[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max3(long long a, long long b, long long c) {
return max(a, max(c, b));
}
long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
int32_t main() {
long long n, m;
cin >> n >> m;
map<long long, vector<long long>> map;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
if (map.count(a)) {
map[a].push_back(b);
} else {
std::vector<long long> arr;
arr.push_back(b);
map[a] = arr;
}
if (map.count(b)) {
map[b].push_back(a);
} else {
std::vector<long long> arr;
arr.push_back(a);
map[b] = arr;
}
}
stack<pair<long long, long long>> st;
long long arr[n + 1];
long long flag = 0;
for (long long i = 0; i <= n; i++) {
arr[i] = 0;
}
for (auto k : map) {
long long i = k.first;
if (arr[i] == 0) {
st.push(make_pair(i, 1));
}
while (!st.empty()) {
pair<long long, long long> p = st.top();
st.pop();
if (arr[p.first] == 0) {
arr[p.first] = p.second;
if (p.second == 1) {
for (long long j = 0; j < map[p.first].size(); j++) {
st.push(make_pair(map[p.first][j], 2));
}
} else {
for (long long j = 0; j < map[p.first].size(); j++) {
st.push(make_pair(map[p.first][j], 1));
}
}
} else if (arr[p.first] == 1) {
if (p.second == 2) {
flag = 1;
cout << -1;
break;
}
} else {
if (p.second == 1) {
flag = 1;
cout << -1;
break;
}
}
}
if (flag == 1) {
break;
}
}
if (flag == 0) {
long long one = 0;
long long two = 0;
for (long long i = 1; i <= n; i++) {
if (arr[i] == 1) {
one++;
}
if (arr[i] == 2) {
two++;
}
}
cout << one << "\n";
for (long long i = 1; i <= n; i++) {
if (arr[i] == 1) {
cout << i << " ";
}
}
cout << "\n";
cout << two << "\n";
for (long long i = 1; i <= n; i++) {
if (arr[i] == 2) {
cout << i << " ";
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
bool vis[200005];
int col[200005];
vector<int> ans[3];
void dfs(int x, int p) {
vis[x] = 1;
col[x] = 3 - col[p];
ans[col[x]].push_back(x);
for (auto i : v[x]) {
if (vis[i] && col[i] == col[x]) {
cout << -1;
exit(0);
}
if (!vis[i]) dfs(i, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m;
cin >> n >> m;
for (int i = 1; i < m + 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
col[0] = 1;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
cout << ans[1].size() << '\n';
for (auto i : ans[1]) cout << i << " ";
cout << '\n';
cout << ans[2].size() << '\n';
for (auto i : ans[2]) cout << i << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
}
int fr[100005], to[100005 << 1], ne[100005 << 1], x[100005];
int a[100005], b[100005], l, r;
int n, m;
int flag;
int c, d, e;
inline void dfs(int w) {
for (int u = fr[w]; u; u = ne[u])
if (!x[to[u]]) {
x[to[u]] = 3 - x[w];
dfs(to[u]);
} else if (x[w] == x[to[u]])
flag = 1;
}
int main() {
read(n);
read(m);
for (int i = 1; i <= m; ++i) {
read(c);
read(d);
to[++e] = d;
ne[e] = fr[c];
fr[c] = e;
to[++e] = c;
ne[e] = fr[d];
fr[d] = e;
}
flag = 0;
for (int i = 1; i <= n; ++i)
if (!x[i]) {
x[i] = 1;
dfs(i);
}
if (flag)
printf("-1\n");
else {
for (int i = 1; i <= n; ++i)
if (x[i] == 1)
a[++l] = i;
else
b[++r] = i;
printf("%d\n", l);
for (int i = 1; i <= l; ++i) printf("%d%c", a[i], i < l ? ' ' : '\n');
printf("%d\n", r);
for (int i = 1; i <= r; ++i) printf("%d%c", b[i], i < r ? ' ' : '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int color[100005];
vector<int> adj[100005];
void dfs(int u) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (color[v] == color[u]) {
printf("-1");
exit(0);
}
if (color[v] == 0) {
color[v] = -color[u];
dfs(v);
}
}
}
void Print() {
int cnt = 0;
for (int i = 1; i <= n; i++)
if (color[i] == 1) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (color[i] == 1) printf("%d ", i);
cnt = 0;
printf("\n");
for (int i = 1; i <= n; i++)
if (color[i] == -1) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (color[i] == -1) printf("%d ", i);
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
fill(color + 1, color + n + 1, 0);
for (int i = 1; i <= n; i++)
if (color[i] == 0) {
color[i] = 1;
dfs(i);
}
Print();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
vector<int> G[maxn];
int n, m;
int color[maxn];
bool dfs(int u, int c) {
color[u] = c;
for (int v = 0; v < G[u].size(); v++) {
if (color[G[u][v]] == c) return false;
if (color[G[u][v]] == 0 && !dfs(G[u][v], -c)) return false;
}
return true;
}
bool judge() {
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
if (!dfs(i, 1)) return false;
}
}
return true;
}
void solve() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(color, 0, sizeof(color));
cin >> n >> m;
for (int k = 1; k <= m; k++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
if (!judge())
cout << "-1" << endl;
else {
int num = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == 1) ++num;
}
cout << num << endl;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
++cnt;
cout << i << (cnt == num ? '\n' : ' ');
}
}
cout << (n - num) << endl;
cnt = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
++cnt;
cout << i << (cnt == n - num ? '\n' : ' ');
}
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> edges[100005];
bool vis[100005], col[100005];
void dfs(int pos) {
vis[pos] = 1;
for (auto to : edges[pos]) {
if (!vis[to]) {
col[to] = col[pos] ^ 1;
dfs(to);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
for (int i = 1; i <= n; i++) {
for (auto to : edges[i]) {
if (col[i] == col[to]) {
cout << -1 << endl;
return 0;
}
}
}
vector<int> a;
vector<int> b;
for (int i = 1; i <= n; i++) {
if (col[i])
a.push_back(i);
else
b.push_back(i);
}
cout << a.size() << endl;
for (auto to : a) cout << to << ' ';
cout << endl << b.size() << endl;
for (auto to : b) cout << to << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100000 + 5, M = 100000 + 5, BM = M * 2;
int n, m;
int hd[N], to[BM], nxt[BM];
inline void add_se(int idx, int a, int b) {
nxt[idx] = hd[a];
hd[a] = idx;
to[idx] = b;
}
bool vis[N], color[N];
bool dfs(int u) {
vis[u] = true;
for (int e = hd[u]; e; e = nxt[e]) {
int v = to[e];
if (vis[v]) {
if (color[v] == color[u]) return false;
} else {
color[v] = !color[u];
if (!dfs(v)) return false;
}
}
return true;
}
inline void output(bool type) {
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (color[i] == type) ++cnt;
printf("%d\n", cnt);
for (int i = 1; i <= n; ++i)
if (color[i] == type) printf("%d ", i);
putchar('\n');
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add_se(i << 1, u, v);
add_se(i << 1 | 1, v, u);
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
if (!dfs(i)) {
puts("-1");
return 0;
}
}
output(false);
output(true);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
int head[100005];
int color[100005];
int p1[100005], p2[100005];
struct node {
int v, nxt;
} e[100005];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
memset(color, -1, sizeof(color));
}
void add(int u, int v) {
e[tot].v = v;
e[tot].nxt = head[u];
head[u] = tot++;
}
int dfs(int u, int c) {
color[u] = c;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (color[v] != -1 && color[v] == color[u])
return 0;
else if (color[v] == -1) {
if (dfs(v, c ^ 1) == 0) return 0;
}
}
return 1;
}
int main() {
init();
int maxn = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
maxn = max(maxn, max(u, v));
}
for (int i = 1; i <= maxn; i++) {
if (color[i] == -1) {
if (!dfs(i, 0)) {
printf("-1\n");
return 0;
}
}
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= maxn; i++) {
if (color[i] == 1)
p1[cnt1++] = i;
else if (color[i] == 0)
p2[cnt2++] = i;
}
printf("%d\n", cnt1);
if (cnt1 > 1) {
for (int i = 0; i < cnt1 - 1; i++) {
printf("%d ", p1[i]);
}
printf("%d\n", p1[cnt1 - 1]);
} else
printf("%d\n", p1[0]);
printf("%d\n", cnt2);
if (cnt2 > 1) {
for (int i = 0; i < cnt2 - 1; i++) {
printf("%d ", p2[i]);
}
printf("%d\n", p2[cnt2 - 1]);
} else
printf("%d\n", p2[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > v;
vector<int> as, bs, c;
void colour(int x, int y) {
if (!c[x]) {
c[x] = y;
if (y == 1) {
as.push_back(x);
} else {
bs.push_back(x);
}
} else if (c[x] != y) {
cout << -1 << endl;
exit(0);
} else {
return;
}
for (vector<int>::iterator it = v[x].begin(); it != v[x].end(); it++) {
if (y == 1) {
colour(*it, 2);
} else {
colour(*it, 1);
}
}
}
int main() {
cin >> n >> m;
v.resize(n + 1);
c.resize(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!c[i] && v[i].size()) {
colour(i, 1);
}
}
cout << as.size() << endl;
for (vector<int>::iterator it = as.begin(); it != as.end(); it++) {
if (it != as.begin()) {
cout << " ";
}
cout << *it;
}
cout << endl;
cout << bs.size() << endl;
for (vector<int>::iterator it = bs.begin(); it != bs.end(); it++) {
if (it != bs.begin()) {
cout << " ";
}
cout << *it;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> v[maxn];
int mark[maxn];
inline int dfs(int x, int c) {
mark[x] = c;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (mark[y] == 0)
dfs(y, 3 - c);
else if (mark[y] == mark[x]) {
cout << -1;
exit(0);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int c = 1;
for (int i = 1; i <= n; i++)
if (v[i].size() && mark[i] == 0) dfs(i, c), c = 3 - c;
int cnt1, cnt2;
cnt1 = cnt2 = 0;
for (int i = 1; i <= n; i++)
if (mark[i] == 1)
cnt1++;
else if (mark[i] == 2)
cnt2++;
cout << cnt1 << endl;
for (int i = 1; i <= n; i++)
if (mark[i] == 1) cout << i << " ";
cout << endl << cnt2 << endl;
for (int i = 1; i <= n; i++)
if (mark[i] == 2) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int const oo = INT_MAX;
int const mod = 1000000007;
vector<vector<int> > ve;
vector<int> a, b, vis;
int flag = 0;
void dfs(int u) {
for (int i = 0; i < ve[u].size(); ++i) {
if (flag) return;
int v = ve[u][i];
if (vis[v] == vis[u])
flag = 1;
else if (!vis[v]) {
if (vis[u] == 1)
b.push_back(v);
else
a.push_back(v);
vis[v] = -1 * vis[u];
dfs(v);
}
}
}
int main() {
int n, m, u, v;
cin >> n >> m;
ve.assign(n + 1, vector<int>());
vis.assign(n + 1, 0);
for (int i = 0; i < m; ++i) {
cin >> u >> v;
ve[u].push_back(v);
ve[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
vis[i] = 1;
a.push_back(i);
dfs(i);
}
if (flag) break;
}
if (flag)
cout << -1;
else {
cout << a.size() << endl;
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
cout << endl << b.size() << endl;
for (int i = 0; i < b.size(); ++i) {
cout << b[i] << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9 + 1;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void FileIO() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, m;
vector<vector<int> > adj(100001);
int color[100001];
vector<int> res[2];
void inp() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) color[i] = -1;
}
bool bfs(int u) {
color[u] = 1;
queue<int> q;
q.push(u);
res[color[u]].push_back(u);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int x : adj[t]) {
if (color[x] == -1) {
q.push(x);
color[x] = 1 - color[t];
res[color[x]].push_back(x);
} else if (color[x] == color[t]) {
return false;
}
}
}
return true;
}
int main() {
inp();
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
if (int((adj[i]).size()) == 0) continue;
if (!bfs(i)) {
cout << "-1\n";
return 0;
}
}
}
for (int i = 0; i < 2; i++) {
cout << res[i].size() << endl;
for (int x : res[i]) {
cout << x << " ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long n, m, a, b, p[N];
vector<long long> g[N], s, t;
bool vis[N], x;
void DFS(int v) {
vis[v] = true;
for (int i = 0; i < g[v].size(); i++) {
if (vis[g[v][i]] == true)
if (p[g[v][i]] != (p[v] + 1) % 2) x = 1;
if (vis[g[v][i]] == false) {
p[g[v][i]] = (p[v] + 1) % 2;
DFS(g[v][i]);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
g[a].push_back(b), g[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (vis[i] == false) p[i] == 0, DFS(i);
for (int i = 1; i <= n; i++) {
if (p[i] == 1 && g[i].size() > 0) s.push_back(i);
if (p[i] == 0 && g[i].size() > 0) t.push_back(i);
}
if (x == 0) {
cout << s.size() << endl;
for (int i = 0; i < s.size(); i++) cout << s[i] << " ";
cout << endl << t.size() << endl;
for (int i = 0; i < t.size(); i++) cout << t[i] << " ";
}
if (x == 1) cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
int n, m;
vector<int> path[maxn];
int belong[maxn];
int na, nb;
bool dfs(int p, int to) {
belong[p] = to;
if (to == 1)
na++;
else
nb++;
for (int i = 0; i < path[p].size(); i++) {
if (belong[path[p][i]] + belong[p] == 3)
continue;
else if (belong[path[p][i]] == 0) {
bool f = dfs(path[p][i], 3 - to);
if (!f) return false;
} else
return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
path[u].push_back(v);
path[v].push_back(u);
}
na = nb = 0;
for (int i = 1; i <= n; i++) {
if (belong[i] == 0) {
bool f = dfs(i, 1);
if (!f) {
printf("-1\n");
return 0;
}
}
}
printf("%d\n", na);
for (int i = 1; i <= n; i++)
if (belong[i] == 1) printf("%d ", i);
printf("\n%d\n", nb);
for (int i = 1; i <= n; i++)
if (belong[i] == 2) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> adj[maxn], part[2];
vector<pair<int, int> > edge;
int par[maxn], partv[maxn];
bool mark[maxn];
int n, m;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
edge.push_back(make_pair(u, v));
}
}
void bfs(int root) {
int p = 0;
queue<int> q;
q.push(root);
mark[root] = true;
part[p].push_back(root);
partv[root] = p;
while (!q.empty()) {
int v = q.front();
q.pop();
p = 1 - partv[v];
for (auto u : adj[v])
if (!mark[u])
q.push(u), mark[u] = true, part[p].push_back(u), partv[u] = p;
}
}
bool valid() {
for (auto x : edge) {
int u = x.first, v = x.second;
if (partv[u] == partv[v]) return false;
}
return true;
}
void ans() {
cout << part[0].size() << endl;
for (auto x : part[0]) cout << x + 1 << " ";
cout << endl << part[1].size() << endl;
for (auto x : part[1]) cout << x + 1 << " ";
cout << endl;
}
int main() {
input();
for (int i = 0; i < n; i++)
if (!mark[i]) bfs(i);
if (!valid()) {
cout << -1 << endl;
return 0;
}
ans();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.