text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
const int N = 20;
const int M = 1e5;
int n, m;
long long a[1 << N], b[1 << N];
char s[N][M];
void fwt(long long* f, int n, bool flag) {
for (int p = 2, q = 1; p <= (1 << n); q = (p <<= 1) >> 1)
for (int i = 0; i < (1 << n); i += p)
for (int j = i; j < i + q; j++) {
long long x = f[j], y = f[j + q];
f[j] = x + y, f[j + q] = x - y;
if (flag) f[j] >>= 1, f[j + q] >>= 1;
}
}
signed 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 x = 0;
for (int j = 0; j < n; j++) (x <<= 1) |= (s[j][i] == '1');
++a[x];
}
for (int i = 0; i < (1 << n); i++) b[i] = b[i >> 1] + (i & 1);
for (int i = 0; i < (1 << n); i++) b[i] = std::min(b[i], n - b[i]);
fwt(a, n, 0), fwt(b, n, 0);
for (int i = 0; i < (1 << n); i++) a[i] *= b[i];
fwt(a, n, 1);
printf("%lld\n", *std::min_element(a, a + (1 << n)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 20;
const int maxn = (1 << maxN) + 20;
int t[maxn], r[maxn][maxN + 3];
string s[maxN];
void cal(int n, int k) {
if (!n) return;
cal(n - 1, k);
cal(n - 1, k + (1 << (n - 1)));
for (int j = n; j >= 1; j--)
for (int i = 0; i < (1 << (n - 1)); i++) {
r[k + i][j] += r[k + i + (1 << (n - 1))][j - 1];
r[k + i + (1 << (n - 1))][j] += r[k + i][j - 1];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) t[i] = (t[i] * 2 + (s[j][i] == '1'));
r[t[i]][0]++;
}
cal(n, 0);
int ans = 1e9;
for (int mask = 0; mask < (1 << n); mask++) {
int res = 0;
for (int j = 0; j <= n; j++) res += r[mask][j] * min(j, n - j);
ans = min(ans, res);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 1000;
long long f[maxn], t[maxn], a[maxn];
void FWT(int len, long long *c) {
for (int l = 2; l <= len; l <<= 1) {
for (int i = 0; i + l <= len; i += l) {
for (int j = 0; j < (l >> 1); j++) {
long long tmp1 = c[i + j], tmp2 = c[i + j + (l >> 1)];
c[i + j] = tmp1 + tmp2;
c[i + j + (l >> 1)] = tmp1 - tmp2;
}
}
}
}
void IFWT(int len, long long *c) {
for (int l = 2; l <= len; l <<= 1) {
for (int i = 0; i + l <= len; i += l) {
for (int j = 0; j < (l >> 1); j++) {
long long tmp1 = c[i + j], tmp2 = c[i + j + (l >> 1)];
c[i + j] = (tmp1 + tmp2) / 2;
c[i + j + (l >> 1)] = (tmp1 - tmp2) / 2;
}
}
}
}
char s[maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (1), iend = (n); i <= iend; i++) {
scanf("%s", s + 1);
for (int j = (1), jend = (m); j <= jend; j++) {
if (s[j] == '1') a[j] |= 1 << (n - i);
}
}
int len = (1 << n);
for (int i = (1), iend = (m); i <= iend; i++) t[a[i]]++;
for (int i = (0), iend = (len - 1); i <= iend; i++)
f[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
FWT(len, f);
FWT(len, t);
for (int i = (0), iend = (len - 1); i <= iend; i++) f[i] = f[i] * t[i];
IFWT(len, f);
long long mx = 1e18;
for (int i = (0), iend = (len - 1); i <= iend; i++) mx = min(mx, f[i]);
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long double PI = acos(-1.0);
const int INF = (int)1e9 + 5;
const long long LINF = (long long)1e18 + 5;
template <class T>
long long abs(const T& x) {
return x < 0 ? -x : x;
}
template <class T>
long long round(const T& x) {
return x < 0 ? x - 0.5 : x + 0.5;
}
template <class T>
bool chmin(T& x, const T& y) {
if (y < x) {
x = y;
return true;
}
return false;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (typename vector<T>::const_iterator it = v.begin(); it != v.end(); ++it) {
os << *it;
if ((it + 1) != v.end()) os << ", ";
}
os << "}";
return os;
}
template <class P, class Q>
ostream& operator<<(ostream& os, const pair<P, Q>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
bool chmax(T& x, const T& y) {
if (x < y) {
x = y;
return true;
}
return false;
}
const int N = 20;
int n;
void combineTo(vector<int>& to, const vector<int>& a, const vector<int>& b) {
for (int i = 0; i <= n; i++) {
to[i] += a[i];
if (i) to[i] += b[i - 1];
}
}
vector<vector<int>> rec(int depth, const vector<int>& v) {
if (depth == n) {
vector<vector<int>> res(1, vector<int>(n + 1));
res[0][0] = (int)v.size();
return res;
}
vector<int> leftVec, rightVec;
for (int x : v) {
if (((x >> depth) & 1) == 0) {
leftVec.push_back(x);
} else {
rightVec.push_back(x);
}
}
auto a = rec(depth + 1, leftVec);
auto b = rec(depth + 1, rightVec);
vector<vector<int>> res(a.size() + b.size(), vector<int>(n + 1));
for (int mask = 0; mask < (int)a.size(); mask++) {
combineTo(res[mask], a[mask], b[mask]);
}
int offset = (int)a.size();
for (int mask = 0; mask < (int)a.size(); mask++) {
combineTo(res[mask + offset], b[mask], a[mask]);
}
return res;
}
int main() {
srand(time(0));
int m;
scanf("%d%d", &n, &m);
vector<string> s(n);
for (int i = 0; i < n; i++) {
static char buf[100500];
scanf("%s", buf);
s[i] = buf;
}
vector<int> v(m);
for (int i = 0; i < m; i++) {
int cur = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '1') {
cur |= (1 << j);
}
}
v[i] = cur;
}
auto z = rec(0, v);
int bestRes = INF;
for (const auto& x : z) {
int curRes = 0;
for (int i = 0; i <= n; i++) {
curRes += min(i, n - i) * x[i];
}
chmin(bestRes, curRes);
}
cout << bestRes << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1050000, P = 998244353, inv2 = (P + 1) / 2;
int n, m, U, cnt[N], f[N], g[N], ans;
char s[21][100005];
inline void read(int &i) {
i = 0;
char c = getchar();
bool j = 0;
for (; !isdigit(c); c = getchar())
if (c == '-') j = 1;
for (; isdigit(c); c = getchar()) i = (i << 1) + (i << 3) + c - '0';
i = j ? -i : i;
}
void FWT(int *a, int l, int p) {
for (int i = 1; i < l; i <<= 1) {
for (int j = 0; j < l; j += i << 1) {
for (int k = 0; k < i; ++k) {
int x = a[j + k], y = a[i + j + k];
a[j + k] = (x + y) % P;
a[i + j + k] = (x - y + P) % P;
if (p == -1)
a[j + k] = 1ll * a[j + k] * inv2 % P,
a[i + j + k] = 1ll * a[i + j + k] * inv2 % P;
}
}
}
}
int main() {
read(n);
read(m);
ans = n * m;
U = (1 << n) - 1;
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 << (n - i);
f[x]++;
}
for (int i = 1; i <= U; ++i) cnt[i] = cnt[i >> 1] + (i & 1);
for (int i = 0; i <= U; ++i) g[i] = min(cnt[i], n - cnt[i]);
FWT(f, U, 1);
FWT(g, U, 1);
for (int i = 0; i <= U; ++i) f[i] = 1ll * f[i] * g[i] % P;
FWT(f, U, -1);
for (int i = 0; i <= U; ++i) ans = min(ans, f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 1 << 20;
long long a[N], b[N], c[N];
int t[N];
void fwt(long long *a, int l, int r) {
if (l == r) return;
int m = (l + r) >> 1;
for (int i = (l); i <= (m); ++i) c[i] = a[i], a[i] += a[m + i - l + 1];
for (int i = (m + 1); i <= (r); ++i) a[i] = c[i - m + l - 1] - a[i];
fwt(a, l, m);
fwt(a, m + 1, r);
}
int n, m;
int main() {
cin >> n >> m;
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (m); ++j) {
char c;
while (isspace(c = getchar()))
;
if (c == '1') t[j] |= (1 << (i - 1));
}
}
for (int i = (0); i <= ((1 << n) - 1); ++i) {
int x = __builtin_popcount(i);
a[i] = min(x, n - x);
}
for (int i = (1); i <= (m); ++i) b[t[i]]++;
fwt(a, 0, (1 << n) - 1);
fwt(b, 0, (1 << n) - 1);
for (int i = (0); i <= ((1 << n) - 1); ++i) a[i] *= b[i];
fwt(a, 0, (1 << n) - 1);
for (int i = (0); i <= ((1 << n) - 1); ++i) a[i] >>= n;
int ans = n * m;
for (int i = (0); i <= ((1 << n) - 1); ++i) getmin(&ans, (int)a[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int MX = 100005;
int c[MX];
int dp[1 << 20][22];
int main() {
int n, m, x;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%1d", &x);
if (x) c[j] |= (1 << i);
}
}
int mx = (1 << n) - 1;
for (int i = 0; i < m; i++) dp[c[i]][0]++;
for (int k = 1; k <= n; k++) {
for (int m = 0; m <= mx; m++) {
for (int p = 0; p < n; p++) {
int s = m ^ (1 << p);
for (int i = 1; i <= k; i++) {
if (i & 1)
dp[m][k] += dp[s][k - i];
else
dp[m][k] -= dp[m][k - i];
}
}
dp[m][k] /= k;
}
}
int k = n >> 1, ans = n * m;
for (int m = 0; m < mx; m++) {
int s = 0;
for (int i = 0; i <= n; i++) {
s += min(i, n - i) * dp[m][i];
}
ans = min(ans, s);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1 << 20;
int n, m, len;
long long a[N], b[N], s(1e9);
char Mp[20][N];
void fwt(long long* f, int o) {
for (int l = 1; l < len; l <<= 1)
for (int i = 0; i < len; i += l << 1)
for (int j = i; j < i + l; j++) {
long long x = f[j], y = f[j + l];
f[j] = x + y;
f[j + l] = x - y;
if (o) {
f[j] >>= 1;
f[j + l] >>= 1;
}
}
}
int main() {
scanf("%d%d", &n, &m);
len = 1 << n;
for (int i = 0; i < n; i++) scanf("%s", Mp[i]);
for (int i = 0; i < m; i++) {
int fl = 0;
for (int j = 0; j < n; j++) fl += (Mp[j][i] ^ '0') << j;
++a[fl];
}
for (int i = 0; i < len; i++) {
int x, y;
x = y = 0;
for (int j = 0; j < n; j++) (i >> j) & 1 ? ++x : ++y;
b[i] = (x < y ? x : y);
}
fwt(a, 0);
fwt(b, 0);
for (int i = 0; i < len; i++) a[i] *= b[i];
fwt(a, 1);
for (int i = 0; i < len; i++) s = (s > a[i] ? a[i] : s);
printf("%I64d", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool cmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
inline bool cmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
char bf[1 << 21], *p1, *p2;
template <class T>
inline void read(T &x) {
x = 0;
char t(
(p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)),
flg(0);
while (t > 57 || t < 48)
flg = t == '-',
t = (p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (t < 58 && t > 47)
x = x * 10 + (t & 15),
t = (p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
flg ? x = -x : x;
}
const int _ = 1 << 20;
int N, M, n;
int a[_];
long long A[_], B[_];
void FWT(long long *a, bool opt) {
long long X, Y;
for (int i = 1; i < n; i <<= 1)
for (int j = 0, sj(i << 1); j < n; j += sj)
for (int k(j), I(j + i - 1); k <= I; ++k)
X = a[k], Y = a[k + i], a[k] = X + Y, a[k + i] = X - Y,
opt ? a[k] >>= 1, a[k + i] >>= 1 : 0;
}
int main() {
read(N), read(M), n = 1 << N;
for (int i(0), I(N - 1); i <= I; ++i)
for (int j(1), I(M); j <= I; ++j) {
int t;
while ((t = (p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++)) != '0' &&
t != '1')
;
a[j] |= (t & 1) << i;
}
for (int i(1), I(M); i <= I; ++i) ++A[a[i]];
for (int i(0), I(n - 1); i <= I; ++i) B[i] = B[i >> 1] + (i & 1);
for (int i(0), I(n - 1); i <= I; ++i) cmin(B[i], N - B[i]);
FWT(A, 0), FWT(B, 0);
for (int i(0), I(n - 1); i <= I; ++i) A[i] *= B[i];
FWT(A, 1);
long long ans = 1e18;
for (int i(0), I(n - 1); i <= I; ++i) cmin(ans, A[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 3;
int n, m, lim = 1;
long long f[N], g[N];
char s[21][100010];
inline void fwt(long long *t, int op) {
for (int mid = 1; mid < lim; mid <<= 1)
for (int r = mid << 1, j = 0; j < lim; j += r)
for (int k = 0; k < mid; k++) {
long long x = t[j + k], y = t[j + k + mid];
if (op == 1)
t[j + k] = x + y, t[j + k + mid] = x - y;
else
t[j + k] = (x + y) / 2, t[j + k + mid] = (x - y) / 2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, lit = 1 << n; i < lit; i++)
g[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int res = 0;
for (int j = 1; j <= n; j++)
if (s[j][i] == '1') res |= 1 << (j - 1);
f[res]++;
}
lim = 1 << n;
fwt(f, 1), fwt(g, 1);
for (int i = 0; i < lim; i++) f[i] = f[i] * g[i];
fwt(f, -1);
long long ans = 1ll << 60;
for (int i = 0, lit = 1 << n; i < lit; i++) ans = min(ans, f[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readint() {
int x = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return f ? -x : x;
}
const int maxn = 20, maxm = 1e5 + 5;
int n, m;
char s[maxn + 5][maxm];
int cnt[(1 << maxn) + 5];
long long f[(1 << maxn) + 5], g[(1 << maxn) + 5];
void FWT(long long* f, int n, bool flag) {
for (int i = 1; i < n; i *= 2)
for (int j = 0; j < n; j += i * 2)
for (int k = j; k < j + i; k++) {
long long t = f[k + i];
if (flag) {
f[k + i] = f[k] - t;
f[k] = f[k] + t;
} else {
f[k + i] = (f[k] - t) / 2;
f[k] = (f[k] + t) / 2;
}
}
}
int main() {
n = readint();
m = readint();
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 1; i < (1 << n); i++) cnt[i] = cnt[i ^ (i & -i)] + 1;
for (int i = 0; i < (1 << n); i++) f[i] = min(cnt[i], n - cnt[i]);
for (int i = 0; i < m; i++) {
int res = 0;
for (int j = 0; j < n; j++) res = res << 1 | (s[j][i] - '0');
g[res]++;
}
FWT(f, 1 << n, 1);
FWT(g, 1 << n, 1);
for (int i = 0; i < (1 << n); i++) f[i] *= g[i];
FWT(f, 1 << n, 0);
int ans = n * m;
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 namespace std;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int lowbit(int x) { return x & (-x); }
int quickmod(int x, int y, int mod) {
x = x % mod;
int ans = 1;
while (y) {
if (y & 1) ans = 1LL * ans * x % mod;
y >>= 1;
x = 1LL * x * x % mod;
}
return ans;
}
const int INF = 0x3f3f3f3f;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int MOD = 1e9 + 7;
int N, M;
char str[25][100005];
long long cnt[1100005];
long long dp[1100005];
void FWT(long long a[], int len) {
for (int d = 1; d < len; d <<= 1)
for (int m = d << 1, i = 0; i < len; 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;
}
}
void UFWT(long long a[], int len) {
for (int d = 1; d < len; d <<= 1)
for (int m = d << 1, i = 0; i < len; 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) / 2, a[i + j + d] = (x - y) / 2;
}
}
void solve(long long a[], long long b[], int len) {
FWT(a, len);
FWT(b, len);
for (int i = 0; i < len; i++) a[i] = a[i] * b[i];
UFWT(a, len);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", str[i]);
for (int j = 0; j < M; j++) {
long long temp = 0;
for (int i = 0; i < N; i++) {
temp <<= 1;
temp = temp + str[i][j] - '0';
}
cnt[temp]++;
}
for (int i = 0; i < (1 << N); i++) {
long long what = 0;
int temp = i;
while (temp) {
if (temp & 1) what++;
temp >>= 1;
}
dp[i] = min(N - what, what);
}
solve(dp, cnt, 1 << N);
long long ans = 10000000000;
for (int i = 0; i < (1 << N); i++) ans = min(ans, dp[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 17);
const int OO = (1 << 21);
vector<int> on[30], off[30], inlevel[30];
int tree[OO][21];
int rows, n, st[MX];
map<string, int> freq;
string str[25];
void calc(int x) {
for (int j = 0; j <= rows; j++)
tree[x][j] = tree[x * 2][j] + tree[x * 2 + 1][j];
}
void build(int x, int level, vector<int> vv) {
if (level == rows) {
for (auto pp : vv) tree[x][st[pp]]++;
return;
}
inlevel[level].push_back(x);
on[level + 1].push_back(x * 2);
off[level + 1].push_back(x * 2 + 1);
vector<int> tol, tor;
for (auto pp : vv)
if (str[level + 1][pp] == '1')
tol.push_back(pp);
else
tor.push_back(pp);
build(x * 2, level + 1, tol);
build(x * 2 + 1, level + 1, tor);
calc(x);
}
void inc(int node) {
for (int j = rows; j > 0; j--) tree[node][j] = tree[node][j - 1];
tree[node][0] = 0;
}
void dec(int node) {
for (int j = 0; j < rows; j++) tree[node][j] = tree[node][j + 1];
tree[node][rows] = 0;
}
int ans = (1 << 30);
void solve(int level) {
if (level == 0) {
calc(1);
int cur = 0;
for (int j = 0; j <= rows; j++) {
cur += tree[1][j] * min(j, rows - j);
}
ans = min(ans, cur);
return;
}
for (auto pp : inlevel[level]) calc(pp);
solve(level - 1);
for (auto node : on[level]) dec(node);
for (auto node : off[level]) inc(node);
solve(level - 1);
for (auto node : on[level]) inc(node);
for (auto node : off[level]) dec(node);
}
int main() {
cin >> rows >> n;
for (int j = 1; j <= rows; j++) {
cin >> str[j];
str[j] = "#" + str[j];
for (int i = 1; i <= n; i++) st[i] += str[j][i] - '0';
}
vector<int> amrmahmoud;
for (int j = 1; j <= n; j++) amrmahmoud.push_back(j);
build(1, 0, amrmahmoud);
solve(rows);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res % mod;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const std::vector<std::pair<int, int>> moves{{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
inline int bitCount(long long x) { return __builtin_popcountll(x); }
inline long long highestOneBit(long long x) {
return 1LL << (63 - __builtin_clzll(x | 1LL));
}
inline int binaryDigits(long long x) { return 64 - __builtin_clzll(x | 1LL); }
template <typename A>
string to_string(A* ptr) {
stringstream ss;
ss << "0x" << std::setw(16) << std::setfill('0') << std::hex
<< (uint64_t)(uintptr_t)ptr;
return ss.str();
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
namespace fwht {
template <typename T>
void hadamard(vector<T>& a) {
int n = a.size();
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
T x = a[i + j];
T y = a[i + j + k];
a[i + j] = x + y;
a[i + j + k] = x - y;
}
}
}
}
template <typename T>
vector<T> multiply(vector<T> a, vector<T> b) {
int eq = (a == b);
int n = 1;
while (n < (int)max(a.size(), b.size())) {
n <<= 1;
}
a.resize(n);
b.resize(n);
hadamard(a);
if (eq)
b = a;
else
hadamard(b);
for (int i = 0; i < n; i++) {
a[i] *= b[i];
}
hadamard(a);
T q = static_cast<T>(n);
for (int i = 0; i < n; i++) {
a[i] /= q;
}
return a;
}
} // namespace fwht
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
vector<long long> cost(1 << n, 0);
for (int mask = 0; mask < 1 << n; mask++) {
int count = bitCount(mask);
cost[mask] = min(count, n - count);
}
vector<long long> freq(1 << n, 0);
for (int col = 0; col < m; col++) {
int mask = 0;
for (int i = 0; i < n; i++) mask |= (s[i][col] - '0') << i;
freq[mask]++;
}
auto ans = fwht::multiply(freq, cost);
cout << *min_element(ans.begin(), ans.end()) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
long long die = 0;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long N = 2e6 + 5;
long long n, m;
char str[100005];
long long A[N];
long long B[N];
long long f[N];
void fwt(long long *a, long long up, long long opt) {
for (long long cen = 1; cen < up; cen <<= 1) {
for (long long len = cen << 1, i = 0; i < up; i += len) {
for (long long k = (0); k <= (cen - 1); k++) {
long long x = a[i + k], y = a[i + k + cen];
a[i + k] = x + y, a[i + k + cen] = x - y;
if (opt == -1) a[i + k] >>= 1, a[i + k + cen] >>= 1;
}
}
}
}
void sol1() {
B[0] = 0;
for (long long i = (1); i <= ((1 << n) - 1); i++) B[i] = B[i & (i - 1)] + 1;
for (long long i = (1); i <= ((1 << n) - 1); i++) B[i] = min(B[i], n - B[i]);
fwt(A, (1 << n), 1), fwt(B, 1 << n, 1);
for (long long i = (0); i <= ((1 << n) - 1); i++) A[i] *= B[i];
fwt(A, 1 << n, -1);
long long ans = inf;
for (long long i = (0); i <= ((1 << n) - 1); i++) ans = min(ans, A[i]);
cout << ans;
}
void rd() {
n = read(), m = read();
for (long long i = (1); i <= (n); i++) {
scanf("%s", str + 1);
for (long long j = (1); j <= (m); j++) f[j] = (f[j] << 1) + str[j] - '0';
}
for (long long i = (1); i <= (m); i++) A[f[i]]++;
}
signed main() {
rd();
sol1();
}
|
#include <bits/stdc++.h>
const int N = 1 << 20;
const int moder = 1e9 + 7;
const int inv2 = 5e8 + 4;
int f[N], g[N], a[20][100010];
int n, m;
void trans(int *a, int length) {
for (int i = 1, j = 0; i < length - 1; ++i) {
for (int s = length; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
std::swap(a[i], a[j]);
}
}
}
void FWT_XOR(int *a, int length, int type) {
int len = -1;
for (int x = length; x; ++len, x >>= 1)
;
trans(a, length);
for (int i = 1; i <= len; ++i) {
for (int j = 0; j < length; j += 1 << i) {
for (int k = j, sizk = 1 << i - 1; k < j + sizk; ++k) {
int s = a[k], t = a[k + (1 << i - 1)];
int x = type == 1 ? 1 : inv2;
a[k] = 1ll * (s + t) * x % moder;
a[k + (1 << i - 1)] = 1ll * (s - t + moder) * x % moder;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%1d", &a[i][j]);
}
}
for (int i = 0; i < m; ++i) {
int x = 0;
for (int j = 0; j < n; ++j) {
x = x << 1 | a[j][i];
}
++f[x];
}
for (int i = 0; i < 1 << n; ++i) {
int cnt = 0;
for (int j = 0; j < n; ++j) {
if (i >> j & 1) {
++cnt;
}
}
g[i] = std::min(cnt, n - cnt);
}
FWT_XOR(f, 1 << n, 1);
FWT_XOR(g, 1 << n, 1);
for (int i = 0; i < 1 << n; ++i) {
f[i] = 1ll * f[i] * g[i] % moder;
}
FWT_XOR(f, 1 << n, -1);
int min = INT_MAX;
for (int i = 0; i < 1 << n; ++i) {
min = std::min(min, f[i]);
}
return printf("%d\n", min), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, m;
int c[N];
int dp[1 << 20][20];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int x;
scanf("%1d", &x);
c[j] |= x << i;
}
for (int i = 0; i < m; ++i) dp[c[i]][0] += 1;
for (int k = 1; k <= n; ++k)
for (int mask = 0; mask < (1 << n); ++mask) {
int& res = dp[mask][k];
if (k > 1) res += (k - 2 - n) * dp[mask][k - 2];
for (int i = 0; i < n; ++i) res += dp[mask ^ (1 << i)][k - 1];
res /= k;
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); ++mask) {
int lans = 0;
for (int k = 0; k <= n; ++k) lans += min(k, n - k) * dp[mask][k];
ans = min(ans, lans);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int n, m, len;
int f[(1 << 21)], g[(1 << 21)], mat[(30)][(100010)];
void FWT_XOR(int *a, int length, int type) {
int len = -1;
for (int x = length; x; ++len, x >>= 1)
;
for (int i = 1; i <= len; ++i) {
for (int j = 0; j < length; j += 1 << i) {
for (int k = j, sz = 1 << i - 1; k < j + sz; ++k) {
int s = a[k], t = a[k + sz];
int x = type == 1 ? 1 : (500000004);
a[k] = 1ll * (s + t) * x % (1000000007);
a[k + sz] = 1ll * (s - t + (1000000007)) * x % (1000000007);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
len = 1 << n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%1d", &mat[i][j]);
}
}
for (int j = 0; j < m; ++j) {
int mask = 0;
for (int i = 0; i < n; ++i) {
mask |= mat[i][j] << i;
}
++f[mask];
}
for (int i = 0; i < len; ++i) {
int k = __builtin_popcount(i);
g[i] = std::min(k, n - k);
}
FWT_XOR(f, len, 1);
FWT_XOR(g, len, 1);
for (int i = 0; i < len; ++i) {
f[i] = 1ll * f[i] * g[i] % (1000000007);
}
FWT_XOR(f, len, -1);
int ans = INT_MAX;
for (int i = 0; i < len; ++i) {
ans = std::min(ans, f[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int64_t g[1100005], cnt[1100005], sz[1100005], pop[1100005];
void FWT(int64_t *a, int64_t nn, bool idwt = false) {
for (int64_t h = 1; h <= nn; h <<= 1) {
for (int64_t i = 0; i < nn; i += h) {
for (int64_t j = i; j < i + h / 2; j++) {
int64_t x = a[j], y = a[j + h / 2];
a[j] = x + y;
a[j + h / 2] = x - y;
if (idwt) a[j] >>= 1, a[j + h / 2] >>= 1;
}
}
}
}
int32_t main() {
{
cin.tie(0);
ios_base::sync_with_stdio(false);
};
int64_t n, m, nn;
cin >> n >> m;
nn = (1 << n);
for (int64_t i = 0; i < n; i++) {
cin >> s;
for (int64_t j = 0; j < m; j++) {
g[j] |= (s[j] - '0') << i;
}
}
for (int64_t i = 0; i < m; i++) cnt[g[i]]++;
for (int64_t i = 1; i < nn; i++) sz[i] = sz[i >> 1] + (i & 1);
for (int64_t i = 0; i < nn; i++) pop[i] = min(sz[i], n - sz[i]);
FWT(cnt, nn);
FWT(pop, nn);
for (int64_t i = 0; i < nn; i++) cnt[i] *= pop[i];
FWT(cnt, nn, true);
cout << *min_element(cnt, cnt + nn) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int num[100005];
long long f[1 << 21], a[1 << 21];
void FWT_xor(long long *a, int n, int opt) {
for (int l = 2; l <= n; l <<= 1) {
int m = l >> 1;
for (long long *p = a; p != a + n; p += l) {
for (int i = 0; i < m; i++) {
long long x = p[i], y = p[i + m];
p[i] = x + y;
p[i + m] = x - y;
if (opt == -1) p[i] /= 2, p[i + m] /= 2;
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++)
if (s[j] == '1') num[j] += 1 << i;
}
for (int i = 0; i < m; i++) ++a[num[i]];
for (int i = 0; i < (1 << n); i++) {
int j = i, cnt = 0;
while (j) {
j &= j - 1;
++cnt;
}
f[i] = min(cnt, n - cnt);
}
FWT_xor(a, 1 << n, 1);
FWT_xor(f, 1 << n, 1);
for (int i = 0; i < (1 << n); i++) a[i] *= f[i];
FWT_xor(a, 1 << n, -1);
long long ans = 1 << 30;
for (int i = 0; i < (1 << n); i++) ans = min(ans, a[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
char s[22][maxn];
int n, m;
long long d[22][1 << 20];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i <= (n - 1); ++i) scanf("%s", s[i]);
for (int j = (0); j <= (m - 1); ++j) {
int num = 0;
for (int i = (0); i <= (n - 1); ++i) num = (num << 1) + s[i][j] - '0';
d[0][num]++;
}
for (int k = (1); k <= (n); ++k) {
for (int s = (0); s <= ((1 << n) - 1); ++s) {
if (k >= 2) d[k][s] = (k - 2 - n) * d[k - 2][s];
for (int j = (0); j <= (n - 1); ++j) d[k][s] += d[k - 1][s ^ (1 << j)];
d[k][s] /= k;
}
}
long long ans = n * m;
for (int s = (0); s <= ((1 << n) - 1); ++s) {
long long res = 0;
for (int k = (0); k <= (n); ++k) res += min(k, n - k) * d[k][s];
ans = min(ans, res);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
while (ch < '0') {
ch = getchar();
};
while (ch >= '0') {
x = (x << 1) + (x << 3) + ch - 48;
ch = getchar();
};
return x;
}
long long n, m, g[21][100201], Q[1400021], F[1400022], S[1400201];
inline void FWTxor(long long *a, int id, int lim) {
for (int len = 1; len < lim; len <<= 1) {
for (int i = 0; i < lim; i += len << 1) {
long long *a1 = a + i, *a2 = a1 + len;
for (int j = 0; j < len; j++) {
long long x = a1[j], y = a2[j];
a1[j] = (x + y) / (id == 1 ? 1 : 2);
a2[j] = (x - y) / (id == 1 ? 1 : 2);
}
}
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; j++) {
g[i][j] = getchar() - '0';
}
getchar();
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; j++) {
S[i] |= (1 << j - 1) * g[j][i];
}
}
for (int i = 0; i <= (1 << n); ++i) {
Q[i] = __builtin_popcount(i);
}
for (int i = 0; i <= (1 << n); ++i) {
Q[i] = min(Q[i], n - Q[i]);
}
for (int i = 1; i <= m; ++i) ++F[S[i]];
FWTxor(F, 1, 1 << n);
FWTxor(Q, 1, 1 << n);
for (int i = 0; i < (1 << n); ++i) F[i] *= Q[i];
FWTxor(F, -1, 1 << n);
long long x = 1e18;
for (int i = 0; i < (1 << n); ++i) x = min(F[i], x);
cout << x << endl;
}
|
#include <bits/stdc++.h>
const long long N = 21;
const long long M = 1e5 + 100;
long long n, m;
long long value[M];
void init() {
std::cin >> n >> m;
std::memset(value, 0, sizeof(value));
for (long long i = 0; i < n; i++) {
std::string str;
std::cin >> str;
for (long long j = 0; j < (long long)str.length(); j++) {
if (str[j] == '1') {
value[j] += 1 << i;
}
}
}
}
void fwt(long long a[], long long length, long long dir) {
if (length == 1) {
return;
}
long long half = length >> 1;
fwt(a, half, dir);
fwt(a + half, half, dir);
for (long long i = 0; i < half; i++) {
long long t0 = a[i], t1 = a[i + half];
if (dir == 1) {
a[i] = t0 + t1;
a[i + half] = t0 - t1;
} else {
a[i] = (t0 + t1) / 2;
a[i + half] = (t0 - t1) / 2;
}
}
}
void work() {
static long long a[1 << N], b[1 << N];
std::memset(a, 0, sizeof(a));
std::memset(b, 0, sizeof(b));
for (long long i = 0; i < m; i++) {
a[value[i]]++;
}
for (long long state = 0; state < (1 << n); state++) {
long long t = __builtin_popcount(state);
b[state] = std::min(t, n - t);
}
static long long answer[1 << N];
fwt(a, 1 << n, 1);
fwt(b, 1 << n, 1);
for (long long state = 0; state < (1 << n); state++) {
answer[state] = a[state] * b[state];
}
fwt(answer, 1 << n, -1);
std::cout << *std::min_element(answer, answer + (1 << n)) << std::endl;
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int K = 21;
const int T = (1 << 20);
long long dp[K][T];
string v[K];
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> v[i];
for (int j = 0; j < m; j++) {
int mask = 0;
for (int i = 0; i < n; i++)
if ((v[i][j] == '1')) mask |= (1 << i);
dp[0][mask]++;
}
int gol = (1 << n);
for (long long k = 1; k <= n; k++) {
for (int mask = 0; mask < gol; mask++) {
if (k - 2 >= 0) dp[k][mask] = (long long)(k - 2 - n) * dp[k - 2][mask];
for (int p = 0; p < n; p++) dp[k][mask] += dp[k - 1][mask ^ (1 << p)];
dp[k][mask] /= k;
}
}
long long ans = INF;
for (int mask = 0; mask < gol; mask++) {
long long tmp = 0;
for (long long k = 0; k <= n; k++) tmp += min(n - k, k) * dp[k][mask];
ans = min(ans, tmp);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1000 * 100 + 1000;
int dp[(1 << N) + 20][N + 10][2];
int col[M];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
bool f = false;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++)
if (s[j] == '1') col[j] += (1 << i);
}
for (int i = 0; i < m; i++) dp[col[i]][0][f]++;
for (int i = n - 1; i >= 0; i--) {
f = !f;
for (int j = 0; j < n - i + 1; j++) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[mask][j][f] = dp[mask][j][!f];
if (j != 0) dp[mask][j][f] += dp[mask ^ (1 << i)][j - 1][!f];
}
}
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int curr = 0;
for (int i = 0; i < n; i++) curr += min(i, n - i) * dp[mask][i][f];
ans = min(ans, curr);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T>
inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-') iosig = true;
if (c == -1) return;
}
for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig) x = -x;
}
const int N = 22, M = 100005, K = 1 << 20;
int n, m, a[M];
long long f[K], g[K];
inline void FWT(long long *f, int g, int len = 1 << n) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += i << 1)
for (int k = j; k < j + i; ++k) {
long long x = f[k], y = f[k + i];
f[k] = x + y, f[k + i] = x - y;
}
if (g == -1)
for (int i = 0; i < len; ++i) f[i] >>= n;
}
int main() {
read(n), read(m);
for (int i = 0; i < n; ++i) {
char ch;
while (isspace(ch = read()))
;
for (int j = 0; j < m; ++j, ch = read()) a[j] = a[j] << 1 | (ch ^ '0');
}
for (int i = 0; i < m; ++i) ++f[a[i]];
for (int i = 1; i < 1 << n; ++i) g[i] = g[i ^ (i & -i)] + 1;
for (int i = 0; i < 1 << n; ++i) g[i] = min(g[i], n - g[i]);
FWT(f, 1), FWT(g, 1);
for (int i = 0; i < 1 << n; ++i) f[i] *= g[i];
FWT(f, -1);
int ans = 1e9;
for (int i = 0; i < 1 << n; ++i) ans = min(ans, (int)f[i]);
return printf("%d", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
char G[22][100010];
int C[100010], cnt[1 << 20], dp[2][22][1 << 20];
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
scanf("\n");
for (int j = 0; j < M; j++) {
scanf("%c", &G[i][j]);
}
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
if (G[j][i] == '1') {
C[i] += (1 << j);
}
}
cnt[C[i]]++;
}
for (int i = 0; i < (1 << N); i++) {
dp[N & 1][0][i] += cnt[i];
}
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j <= N; j++) {
for (int mask = 0; mask < (1 << N); mask++) {
dp[i & 1][j][mask] = 0;
if (j) {
dp[i & 1][j][mask] += dp[(i + 1) & 1][j - 1][mask ^ (1 << i)];
}
dp[i & 1][j][mask] += dp[(i + 1) & 1][j][mask];
}
}
}
int ans = 1e9;
for (int mask = 0; mask < (1 << N); mask++) {
int tmp = 0;
for (int i = 1; i <= N; i++) {
tmp += dp[0][i][mask] * min(i, N - i);
}
ans = min(ans, tmp);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace _ {
bool rEOF = 1;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && rEOF &&
(p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? (rEOF = 0, EOF)
: *p1++;
}
template <class _T>
inline bool read(_T &num) {
char c = nc(), f = 1;
num = 0;
while (c < '0' || c > '9') c == '-' && (f = -1), c = nc();
while (c >= '0' && c <= '9') num = num * 10 + c - '0', c = nc();
return (bool)(num *= f);
}
inline bool need(char &c) {
return c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c >= 'A' && c <= 'Z';
}
inline bool read_str(char *a) {
while ((*a = nc()) && need(*a) && rEOF) ++a;
*a = '\0';
return rEOF;
}
} // namespace _
using namespace _;
const int mod = 1e9 + 7;
const int maxm = (1 << 10) + 5;
vector<int> v[maxm];
int dp[maxm][maxm];
int ans[maxm];
int a[maxm];
int tmp[maxm];
int n, m;
int inv2 = 500000004;
void fwt(int *a, int N, int opt) {
for (int i = 1; i < N; i <<= 1)
for (int p = i << 1, j = 0; j < N; j += p)
for (int k = 0; k < i; ++k) {
int X = a[j + k], Y = a[i + j + k];
a[j + k] = (X + Y) % mod;
a[i + j + k] = (X + mod - Y) % mod;
if (opt == -1)
a[j + k] = 1ll * a[j + k] * inv2 % mod,
a[i + j + k] = 1ll * a[i + j + k] * inv2 % mod;
}
}
char aa[22][100005];
int b[100005];
int x[(1 << 20) + 5];
int y[(1 << 20) + 5];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", aa[i]);
for (int i = 0; i < m; i++) {
b[i] = 0;
for (int j = 0; j < n; j++) b[i] |= ((aa[j][i] - '0') << j);
}
for (int i = 0; i < m; i++) x[b[i]]++;
int len = 1 << n;
for (int i = 0; i < len; i++) {
int tt = __builtin_popcount(i);
y[i] = min(tt, n - tt);
}
fwt(x, len, 1);
fwt(y, len, 1);
for (int i = 0; i < len; i++) x[i] = 1ll * y[i] * x[i] % mod;
fwt(x, len, -1);
int ans = n * m;
for (int i = 0; i < len; i++) ans = min(ans, x[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1 << 20;
void setmin(int &a, int b) {
if (a > b) {
a = b;
}
}
int N, M;
int A[MAXM];
int ppcnt[MAXM], mone[MAXM];
inline int getmn(int x) { return min(x, N - x); }
int cpair[1 << 8][13];
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++) {
getchar();
for (int j = 0; j < M; j++) {
A[j] |= ((getchar() == '1') << i);
}
}
for (int i = 1; i < (1 << N); i++) {
ppcnt[i] = ppcnt[i >> 1] + (i & 1);
}
for (int i = 0; i < (1 << N); i++) {
mone[i] = getmn(ppcnt[i]);
}
int ans = 2e9;
if (N <= 12) {
for (int i = 0; i < (1 << N); i++) {
int n1 = 0;
for (int j = 0; j < M; j++) {
n1 += mone[A[j] ^ i];
}
setmin(ans, n1);
}
printf("%d\n", ans);
return 0;
}
int cmp = N - 12;
for (int i = 0; i < (1 << 12); i++) {
memset((cpair), (0), sizeof(cpair));
for (int j = 0; j < M; j++) {
cpair[A[j] >> 12][ppcnt[(i ^ A[j]) & 4095]]++;
}
for (int j = 0; j < (1 << cmp); j++) {
int sum = 0;
for (int k = 0; k < (1 << cmp); k++) {
int pc = ppcnt[j ^ k];
for (int m = 0; m <= 12; m++) {
sum += getmn(pc + m) * cpair[k][m];
}
}
setmin(ans, sum);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T>
inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-') iosig = true;
if (c == -1) return;
}
for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig) x = -x;
}
inline char readchar() {
static char c;
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1) return 0;
return c;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0) print('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
while (cnt) print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
int n, m, num[(100010)], Lim, pc[(1 << 21)];
long long a[(1 << 21)], b[(1 << 21)], ans = 1e18;
void FWT(long long *a, int tp) {
for (int i = 1; i < Lim; i <<= 1)
for (int R = i << 1, j = 0; j < Lim; j += R)
for (int k = j; k < j + i; k++) {
long long x = a[k], y = a[k + i];
a[k] = x + y, a[k + i] = x - y;
if (tp == -1) a[k] /= 2, a[k + i] /= 2;
}
}
int main() {
read(n), read(m), Lim = (1 << n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) (num[j] = (num[j] << 1) + readchar() - '0');
for (int i = 1; i <= m; i++) a[num[i]]++;
for (int i = 1; i < Lim; i++)
pc[i] = pc[i >> 1] + (i & 1), b[i] = min(pc[i], n - pc[i]);
FWT(a, 1), FWT(b, 1);
for (int i = 0; i < Lim; i++) a[i] = (a[i] * b[i]);
FWT(a, -1);
for (int i = 0; i < Lim; i++) ans = min(ans, a[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
void fwht(long long *aa, int n) {
int h, i, j, b, l, r;
long long u, v;
for (h = 0; (b = 1 << h) < n; h++)
for (i = 0; i < n; i += b * 2)
for (j = 0; j < b; j++) {
l = i + j, r = l + b;
u = aa[l], v = aa[r];
aa[l] = u + v;
aa[r] = u - v;
}
}
int main() {
static char cc[20][100000 + 1];
static long long aa[1 << 20], bb[1 << 20];
int n, n_, m, h, i, j, x;
long long ans;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", cc[i]);
for (j = 0; j < m; j++) {
x = 0;
for (i = 0; i < n; i++) x = x * 2 + cc[i][j] - '0';
aa[x]++;
}
n_ = 1 << n;
for (h = 1; h < n_; h++) bb[h] = bb[h & h - 1] + 1;
for (h = 0; h < n_; h++) bb[h] = bb[n_ - 1 ^ h] = min(bb[h], bb[n_ - 1 ^ h]);
fwht(aa, n_);
fwht(bb, n_);
for (h = 0; h < n_; h++) aa[h] *= bb[h];
fwht(aa, n_);
for (h = 0; h < n_; h++) aa[h] /= n_;
ans = n * m;
for (h = 0; h < n_; h++) ans = min(ans, aa[h]);
printf("%lld\n", ans);
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) {
for (int i = 2; i <= n; i <<= 1)
for (int j = 0; j < n; j += i) {
ll *l = a + j, *r = a + j + (i >> 1);
for (int k = 0; k < (i >> 1); k++)
*l += *r, *r = *l - (*r << 1), ++l, ++r;
}
}
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);
for (int i = 0; i < n; i++) c[i] = c[i] / n;
}
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;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
const int N = 2000000;
long long B[N], C[N];
int n, m;
char ch[21][100001];
void fwt(long long *a, int n) {
for (int m = 2; m <= n; m <<= 1)
for (int i = 0; i < n; i += m)
for (int j = i; j < i + (m >> 1); j++) {
long long u = a[j], v = a[j + (m >> 1)];
a[j] = u + v;
a[j + (m >> 1)] = u - v;
}
}
void ifwt(long long *a, int n) {
for (int m = 2; m <= n; m <<= 1)
for (int i = 0; i < n; i += m)
for (int j = i; j < i + (m >> 1); j++) {
long long u = a[j], v = a[j + (m >> 1)];
a[j] = (u + v) / 2;
a[j + (m >> 1)] = (u - v) / 2;
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
for (int i = 1; i <= m; i++) {
int s = 0;
for (int j = 1; j <= n; j++)
if (ch[j][i] == '1') s += (1 << (j - 1));
B[s]++;
}
for (int i = 0; i < (1 << n); i++) {
int s = 0;
for (int j = 1; j <= n; j++)
if (i >> (j - 1) & 1) s++;
s = min(s, n - s);
C[i] = s;
}
fwt(B, (1 << n));
fwt(C, (1 << n));
for (int i = 0; i < (1 << n); i++) B[i] = B[i] * C[i];
ifwt(B, (1 << n));
long long ans = 1e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, B[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
namespace bitwise_convolution {
template <typename T, bool INV>
void transform(vector<T>& v, int N, array<int, 4> t) {
assert(__builtin_popcount(N) == 1);
for (int c : t) assert(abs(c) <= 1);
int w = t[0], x = t[1], y = t[2], z = t[3];
if (INV) swap(w, z), x *= -1, y *= -1;
auto prod = [](int c, T v) { return c > 0 ? v : c < 0 ? -v : 0; };
for (int l = 1; l < N; l <<= 1) {
for (int i = 0; i < N; i += l << 1) {
for (int j = 0; j < l; j++) {
T a = v[i + j];
T b = v[i + j + l];
v[i + j] = prod(w, a) + prod(x, b);
v[i + j + l] = prod(y, a) + prod(z, b);
}
}
}
if (INV) {
T div = 1;
for (int i = 0; i < (__builtin_ctz(N)); i++) div *= T{w * z - x * y};
for (int i = 0; i < N; i++) v[i] /= div;
}
}
constexpr array<int, 4> OR() { return {1, 0, 1, 1}; }
constexpr array<int, 4> AND() { return {0, 1, 1, 1}; }
constexpr array<int, 4> XOR() { return {1, 1, 1, -1}; }
template <typename T>
vector<T> conv(const vector<T>& a, const vector<T>& b, array<int, 4> t) {
if (a.empty() || b.empty()) return {};
int N = 1 << (32 - __builtin_clz(max(int((a).size()), int((b).size())) - 1));
static vector<T> fa, fb;
if (N > int((fa).size())) fa.resize(N), fb.resize(N);
copy((a).begin(), (a).end(), fa.begin());
fill(fa.begin() + int((a).size()), fa.begin() + N, 0);
copy((b).begin(), (b).end(), fb.begin());
fill(fb.begin() + int((b).size()), fb.begin() + N, 0);
transform<T, false>(fa, N, t);
transform<T, false>(fb, N, t);
for (int i = 0; i < N; i++) fa[i] = fa[i] * fb[i];
transform<T, true>(fa, N, t);
return {fa.begin(), fa.begin() + N};
}
} // namespace bitwise_convolution
using namespace bitwise_convolution;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vll a(1 << N), b = a;
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
a[col]++;
}
for (int i = 0; i < (1 << N); i++)
b[i] = min(__builtin_popcount(i), N - __builtin_popcount(i));
vll c = conv(a, b, XOR());
ps(*min_element((c).begin(), (c).end()));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vvi diff(N + 1, vi(1 << N)), DIFF = diff;
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
diff[0][col]++;
}
for (int i = 0; i < (N); i++) {
for (int m = 0; m < (1 << N); m++) {
for (int j = 0; j < (N + 1); j++) DIFF[j][m] += diff[j][m];
for (int j = 0; j < (N); j++) DIFF[j + 1][m ^ (1 << i)] += diff[j][m];
}
swap(diff, DIFF);
for (auto& e : DIFF) fill((e).begin(), (e).end(), 0);
}
int ans = INT_MAX;
for (int m = 0; m < (1 << N); m++) {
int cand = 0;
for (int d = 0; d < (N + 1); d++) cand += min(d, N - d) * diff[d][m];
ckmin(ans, cand);
}
ps(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char s[21][100001];
int f[21][(1 << 20) + 1];
int main() {
scanf("%d%d", &n, &m), ans = 1 << 30;
int i, j, k;
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < m; i++) {
int tmp = 0;
for (j = 0; j < n; j++)
if (s[j][i] == '1') tmp |= 1 << j;
f[0][tmp]++;
}
for (i = 0; i < n; i++)
for (j = n; j; j--)
for (k = 0; k < (1 << n); k++) f[j][k] += f[j - 1][k ^ (1 << i)];
for (k = 0; k < (1 << n); k++) {
int tmp = 0;
for (i = 0; i <= n; i++) tmp += min(i, n - i) * f[i][k];
ans = min(ans, tmp);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vi diff((N + 1) << N), DIFF = diff;
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
diff[col]++;
}
for (int i = 0; i < (N); i++) {
DIFF = diff;
for (int m = 0; m < (1 << N); m++)
for (int j = 0; j < (N); j++)
DIFF[((j + 1) << N) + m ^ (1 << i)] += diff[(j << N) + m];
swap(diff, DIFF);
}
int ans = INT_MAX;
for (int m = 0; m < (1 << N); m++) {
int cand = 0;
for (int d = 0; d < (N + 1); d++)
cand += min(d, N - d) * diff[(d << N) + m];
ckmin(ans, cand);
}
ps(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool board[25][100005];
void fwht(vector<long long>& P) {
int n = int((P).size());
for (int L = 1; 2 * L <= n; L <<= 1)
for (int i = 0; i < n; i += 2 * L)
for (int j = 0; j < L; j++) {
long long u = P[i + j];
long long v = P[i + j + L];
P[i + j] = u + v;
P[i + j + L] = u - v;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int lim = 1 << n;
vector<long long> P(lim), M(lim);
for (int i = int(0); i < int(n); ++i)
for (int j = int(0); j < int(m); ++j) {
char c;
scanf(" %c", &c);
if (c == '1') board[i][j] = 1;
}
for (int j = int(0); j < int(m); ++j) {
int mask = 0;
for (int i = int(0); i < int(n); ++i)
if (board[i][j]) mask |= 1 << i;
P[mask]++;
}
for (int i = int(0); i < int(lim); ++i) {
int num = __builtin_popcount(i);
M[i] = min(num, n - num);
}
fwht(P);
fwht(M);
for (int i = int(0); i < int(lim); ++i) P[i] *= M[i];
fwht(P);
for (int i = int(0); i < int(lim); ++i) P[i] /= lim;
long long ans = 1LL << 60;
for (int i = int(0); i < int(lim); ++i) ans = min(ans, P[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long AA[1048576];
int A[100001];
AA s, a, b, c;
int n, m, i, j, k, l, Len;
char ch;
long long ans;
void tf(long long *a) {
int i, j, k, l;
int S = 1, s1 = 1, s2 = Len + 1;
for (i = 1; i <= n; i++) {
S <<= 1;
s2 >>= 1;
for (j = 0; j <= s2 - 1; j++) {
for (k = 0; k <= s1 - 1; k++) {
l = j * S + k;
s[l] = a[l] + a[l + s1];
s[l + s1] = a[l] - a[l + s1];
}
}
memcpy(a, s, sizeof(long long) * (Len + 1));
s1 <<= 1;
}
}
void utf(long long *a) {
int i, j, k, l;
int S = 1, s1 = 1, s2 = Len + 1;
for (i = 1; i <= n; i++) {
S <<= 1;
s2 >>= 1;
for (j = 0; j <= s2 - 1; j++) {
for (k = 0; k <= s1 - 1; k++) {
l = j * S + k;
s[l] = (a[l] + a[l + s1]) >> 1;
s[l + s1] = (a[l] - a[l + s1]) >> 1;
}
}
memcpy(a, s, sizeof(long long) * (Len + 1));
s1 <<= 1;
}
}
int main() {
scanf("%d%d", &n, &m);
Len = pow(2, n) - 1;
for (i = 1; i <= n; i++) {
scanf("\n");
for (j = 1; j <= m; j++) {
scanf("%c", &ch);
A[j] = (A[j] << 1) + (ch - '0');
}
}
for (i = 1; i <= m; i++) b[A[i]]++;
for (i = 0; i <= Len; i++) {
j = i;
k = 0;
while (j) {
k += j & 1;
j >>= 1;
}
a[i] = (k < n - k ? k : n - k);
}
tf(a);
tf(b);
for (i = 0; i <= Len; i++) c[i] = a[i] * b[i];
utf(c);
ans = 233333333;
for (i = 0; i <= Len; i++) ans = (ans < c[i] ? ans : c[i]);
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x7fffffff;
const long long linf = ~(1LL << 63);
template <typename T>
inline T gcd(T a, T b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename C>
inline void sort(C& v) {
sort(v.begin(), v.end());
}
inline void println(int u) { printf("%d\n", u); }
inline void printsp(int u) { printf("%d ", u); }
const int maxn = 100100;
int dp[22][1 << 20];
int n, m;
int data[maxn];
string s;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
{
int j = 0;
for (auto c : s) {
data[j] = (data[j] << 1) | (c - '0');
j++;
}
}
}
for (int i = 0; i < m; i++) dp[0][data[i]]++;
for (int k = 1; k < n + 1; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[k][mask] += k - 2 >= 0 ? (k - 2 - n) * dp[k - 2][mask] : 0;
for (int p = 0; p < n; p++) {
dp[k][mask] += dp[k - 1][mask ^ (1 << p)];
}
dp[k][mask] /= k;
}
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int cnt = 0;
for (int k = 0; k < n + 1; k++) {
cnt += min(k, n - k) * dp[k][mask];
}
ans = min(cnt, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long num[1 << 20], a[1 << 20];
char s[20][100001];
void FWT(long long x1[], int n) {
int i, j, d, m;
long long x, y;
for (d = 1; n > d; d <<= 1) {
for (m = d << 1, i = 0; n > i; i += m) {
for (j = 0; d > j; j++) {
x = x1[i + j];
y = x1[i + j + d];
x1[i + j] = x + y;
x1[i + j + d] = x - y;
}
}
}
}
void UFWT(long long x1[], int n) {
int d, m, i, j;
long long x, y;
for (d = 1; n > d; d <<= 1) {
for (m = d << 1, i = 0; n > i; i += m) {
for (j = 0; d > j; j++) {
x = x1[i + j];
y = x1[i + j + d];
x1[i + j] = (x + y) / 2;
x1[i + j + d] = (x - y) / 2;
}
}
}
}
void Convolution(long long x1[], long long x2[], int len) {
int i;
FWT(x1, len);
FWT(x2, len);
for (i = 0; len > i; i++) {
x1[i] = x1[i] * x2[i];
}
UFWT(x1, len);
}
int main() {
int n, m, i, i1, temp, k;
long long ans = 0x3f3f3f3f;
scanf("%d %d", &n, &m);
memset(num, 0, sizeof(num));
for (i = 0; n > i; i++) {
scanf("%s", s[i]);
}
for (i = 0; m > i; i++) {
temp = 0;
for (i1 = 0; n > i1; i1++) {
temp = temp | ((s[i1][i] - '0') << (n - i1 - 1));
}
num[temp]++;
}
for (i = 0; (1 << n) > i; i++) {
temp = i;
k = 0;
while (temp != 0) {
k = k + temp % 2;
temp = temp / 2;
}
a[i] = min(k, n - k);
}
Convolution(a, num, 1 << n);
for (i = 0; (1 << n) > i; i++) {
ans = min(ans, a[i]);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FWT(long long *A, int l) {
for (int len = 1; len < l; len <<= 1)
for (int i = 0; i < l; i += len << 1)
for (int j = 0; j < len; ++j) {
long long x = A[i + j], y = A[i + j + len];
A[i + j] = (x + y);
A[i + j + len] = (x - y);
}
}
void IFWT(long long *A, int l) {
for (int len = 1; len < l; len <<= 1)
for (int i = 0; i < l; i += len << 1)
for (int j = 0; j < len; ++j) {
long long x = A[i + j], y = A[i + j + len];
A[i + j] = (x + y) / 2;
A[i + j + len] = (x - y) / 2;
}
}
int n, m;
char str[25][100050];
long long A[1050000], B[1050000];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", str[i] + 1);
int limit = (1 << n);
for (int i = 1; i <= m; ++i) {
int num = 0;
for (int j = 1; j <= n; ++j) num = (num << 1) | (str[j][i] - '0');
A[num]++;
}
for (int i = 0; i < limit; ++i)
B[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
FWT(A, limit);
FWT(B, limit);
for (int i = 0; i < limit; ++i) A[i] = A[i] * B[i];
IFWT(A, limit);
int ans = n * m;
for (int i = 0; i < limit; ++i) ans = min(ans * 1ll, A[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ty() {
register int a = 0, b = 1, c = getchar();
while (!isdigit(c)) b ^= c == '-', c = getchar();
while (isdigit(c)) a = a * 10 + c - 48, c = getchar();
return b ? a : -a;
}
inline int tc() {
register int c = getchar();
while (c <= 32) c = getchar();
return c;
}
const int _ = 23, __ = 100007, _n = 1048577;
void fwtxor(long long a[], int n, int dir) {
register int i, j, k, nn = 1;
register long long x, y;
while (nn < n) nn <<= 1;
for (i = 1; i < nn; i <<= 1)
for (j = 0; j < nn; j += i + i)
for (k = 0; k < i; k++) {
x = a[j + k], y = a[j + k + i];
if (dir > 0)
a[j + k] = x + y, a[j + k + i] = x - y;
else
a[j + k] = (x + y) / 2, a[j + k + i] = (x - y) / 2;
}
}
int n, m, val[__] = {0}, cnt[_n] = {0}, bcnt[_n] = {0};
long long A[_n], B[_n];
int main() {
register int i, j, a, nn = 1;
register long long ans = 2e9;
n = ty(), m = ty();
while (nn < (1 << n)) nn <<= 1;
for (i = 0; i < n; i++)
for (j = 1; j <= m; j++) a = tc() - 48, val[j] |= (a << i);
for (i = 1; i <= m; i++) cnt[val[i]]++;
for (i = 1, bcnt[0] = 0; i < _n; i++) bcnt[i] = bcnt[i >> 1] + (i & 1);
for (i = 0; i < nn; i++) A[i] = min(bcnt[i], n - bcnt[i]);
for (i = 0; i < nn; i++) B[i] = cnt[i];
fwtxor(A, nn, 1), fwtxor(B, nn, 1);
for (i = 0; i < nn; i++) A[i] = A[i] * B[i];
fwtxor(A, nn, -1);
for (i = 0; i < nn; i++) ans = min(ans, A[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 10;
const int mod = 1e9 + 7;
void fwt(int a[], int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; 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) % mod;
a[i + j + d] = (x - y + mod) % mod;
}
}
}
}
void ifwt(int a[], int n) {
int inv2 = (mod + 1) / 2;
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = 1ll * (x + y) * inv2 % mod;
a[i + j + d] = 1ll * (x - y + mod) * inv2 % mod;
}
}
}
}
char a[22][100010];
int cnt[N], num[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 0; i < 1 << n; i++)
for (int j = 0; j < n; j++) cnt[i] += i >> j & 1;
for (int i = 0; i < 1 << n; i++) cnt[i] = min(cnt[i], n - cnt[i]);
for (int i = 1; i <= m; i++) {
int t = 0;
for (int j = 1; j <= n; j++) t = t << 1 | (a[j][i] == '1');
num[t]++;
}
fwt(cnt, 1 << n), fwt(num, 1 << n);
for (int i = 0; i < 1 << n; i++) cnt[i] = 1ll * cnt[i] * num[i] % mod;
ifwt(cnt, 1 << n);
int ans = N;
for (int i = 0; i < 1 << n; i++) ans = min(ans, cnt[i]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 20;
const int maxn = (1 << maxN) + 20;
int t[maxn], r[maxn][maxN + 3], x[maxn][maxN + 3];
string s[maxN];
void cal(int n, int k) {
if (!n) return;
cal(n - 1, k);
cal(n - 1, k + (1 << (n - 1)));
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j <= n; j++) x[k + i][j] = r[k + i][j];
for (int i = 0; i < (1 << (n - 1)); i++)
for (int j = 1; j <= n; j++) {
r[k + i][j] += x[k + i + (1 << (n - 1))][j - 1];
r[k + i + (1 << (n - 1))][j] += x[k + i][j - 1];
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) t[i] = (t[i] * 2 + (s[j][i] == '1'));
r[t[i]][0]++;
}
cal(n, 0);
int ans = 1e9;
for (int mask = 0; mask < (1 << n); mask++) {
int res = 0;
for (int j = 0; j <= n; j++) res += r[mask][j] * min(j, n - j);
ans = min(ans, res);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, dp[21][1 << 20], mn[maxn], ans = 1e7;
string s;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) mn[j] += (s[j] - '0') << i;
}
for (int i = 0; i < m; i++) dp[0][mn[i]]++;
for (int i = 1; i <= n; i++)
for (int j = 0; j < (1 << n); j++) {
if (i > 1) dp[i][j] = dp[i - 2][j] * (i - 2 - n);
for (int k = 0; k < n; k++) dp[i][j] += dp[i - 1][j ^ (1 << k)];
dp[i][j] /= i;
}
for (int i = 0; i < (1 << n); i++) {
int ansi = 0;
for (int j = 0; j <= n; j++) ansi += min(j, n - j) * dp[j][i];
ans = min(ansi, ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAX = 1e5 + 5;
const long long MAX2 = 2505;
const long long MOD = 1000000007;
const long long MOD2 = 1000005329;
const long long INF = 2e15;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 555;
int n, m, x[MAX], y, id, a, b, cnt[MAX * 20][22], ans, res, pre[25];
bool st[MAX * 20];
vector<int> lvl[25], v[MAX * 20];
char c;
void f(int z, int le, int ri, int par) {
if (!z) {
cnt[par][st[par]] = ri - le + 1;
return;
}
int mid, res = ri + 1;
a = le, b = ri, y = 1 << z;
while (a <= b) {
mid = a + b >> 1;
if (x[mid] & y)
res = mid, b = mid - 1;
else
a = mid + 1;
}
if (res != le)
lvl[z].push_back(++id), v[par].push_back(id), f(z - 1, le, res - 1, id);
if (res <= ri)
st[++id] = 1, lvl[z].push_back(id), v[par].push_back(id),
f(z - 1, res, ri, id);
return;
}
void bf(int z, bool q) {
if (z > n) {
if (q) return;
res = 0;
for (int i : v[0]) {
for (int j = 0; j <= n; ++j) {
res += cnt[i][j] * pre[j];
}
}
ans = min(ans, res);
return;
}
if (z == 1) {
if (q)
for (int i : lvl[z]) cnt[i][0] ^= cnt[i][1] ^= cnt[i][0] ^= cnt[i][1];
} else {
for (int i : lvl[z]) {
for (int j = 0; j <= z; ++j) cnt[i][j] = 0;
if (q ^ st[i]) {
for (int k : v[i]) {
for (int j = 0; j < z; ++j) cnt[i][j + 1] += cnt[k][j];
}
} else {
for (int k : v[i]) {
for (int j = 0; j < z; ++j) cnt[i][j] += cnt[k][j];
}
}
}
}
bf(z + 1, 0);
bf(z + 1, 1);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i <= n; ++i) pre[i] = min(i, n - i);
for (int i = 1; i <= n; ++i) {
y = 1 << i;
for (int j = 1; j <= m; ++j) {
cin >> c;
if (c == '1') x[j] |= y;
}
}
sort(x + 1, x + 1 + m);
f(n, 1, m, 0);
ans = MOD;
bf(0, 0);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char s[21][100005];
int F1[2000005], F2[2000005];
long long poww(long long a, long long b) {
long long t = 1;
while (b > 1) {
if (b % 2 == 1) t = t * a % mod;
a = a * a % mod;
b >>= 1;
}
return a * t % mod;
}
void FWT(int *F, int n, int opt) {
const int inv2 = poww(2, mod - 2);
for (int i = 1; i < n; i <<= 1) {
for (int p = i << 1, j = 0; j < n; j += p) {
for (int k = 0; k < i; k++) {
int x = F[j + k], y = F[i + j + k];
F[j + k] = (x + y) % mod;
F[i + j + k] = ((x - y) % mod + mod) % mod;
if (opt == -1)
F[j + k] = 1LL * F[j + k] * inv2 % mod,
F[i + j + k] = 1LL * F[i + j + k] * inv2 % mod;
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (1 << n); i++) {
int temp = i, cnt1 = 0;
while (temp) {
if (temp % 2 == 1) cnt1++;
temp >>= 1;
}
F2[i] = min(cnt1, n - cnt1);
}
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int temp = 0;
for (int j = 1; j <= n; j++) {
temp *= 2;
if (s[j][i] == '1') temp++;
}
F1[temp]++;
}
FWT(F1, 1 << n, 1);
FWT(F2, 1 << n, 1);
for (int i = 0; i < (1 << n); i++) {
F1[i] = 1LL * F1[i] * F2[i] % mod;
}
FWT(F1, 1 << n, -1);
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, F1[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const signed long long INF = 1000000100;
const long double EPS = 1e-9;
int dp[2][21][1 << 20];
int res[1 << 20];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> c(m, 0);
for (int(i) = (0); (i) < (n); (i)++) {
string s;
cin >> s;
for (int(j) = (0); (j) < (m); (j)++) {
if (s[j] == '1') c[j] += (1 << i);
}
}
for (int(i) = (0); (i) < (m); (i)++) {
dp[0][0][c[i]]++;
}
for (int(b) = (1); (b) <= (n); (b)++) {
for (int(mask) = (0); (mask) < ((1 << n)); (mask)++) {
dp[0][b][mask] = dp[0][0][mask];
}
}
for (int(k) = (1); (k) <= (n); (k)++) {
for (int(b) = (0); (b) <= (n); (b)++) {
for (int(mask) = (0); (mask) < ((1 << n)); (mask)++) {
dp[k & 1][b][mask] = 0;
}
}
for (int(b) = (1); (b) <= (n); (b)++) {
for (int(mask) = (0); (mask) < ((1 << n)); (mask)++) {
dp[k & 1][b][mask] = dp[k & 1][b - 1][mask] +
dp[(k - 1) & 1][b - 1][mask ^ (1 << (b - 1))];
}
}
for (int(mask) = (0); (mask) < ((1 << n)); (mask)++)
res[mask] += min(k, n - k) * dp[k & 1][n][mask];
}
int ans = INF;
for (int(mask) = (0); (mask) < ((1 << n)); (mask)++) {
ans = min(ans, res[mask]);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2000001], b[2000001], Ans;
int i, j, k, n, m, p[30], x;
char s[100010];
bool f[21][100010];
inline void FWT(long long* a, int n, int d) {
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += (i << 1))
for (int k = 0; k < i; k++) {
long long x = a[j + k], y = a[j + k + i];
a[j + k] = x + y;
a[j + k + i] = x - y;
if (d == -1) {
a[j + k] /= 2;
a[j + k + i] /= 2;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", s);
for (j = 0; j < m; j++) f[i][j + 1] = s[j] - '0';
}
for (p[0] = i = 1; i <= 20; i++) p[i] = p[i - 1] << 1;
for (i = 1; i <= m; i++) {
x = 0;
for (j = 1; j <= n; j++) x += p[j - 1] * f[j][i];
a[x]++;
}
for (i = 0; i < p[n]; i++) {
for (j = 0; j < n; j++)
if ((i & p[j]) > 0) b[i]++;
b[i] = min(b[i], n - b[i]);
}
FWT(a, p[n], 1);
FWT(b, p[n], 1);
for (i = 0; i < p[n]; i++) a[i] *= b[i];
FWT(a, p[n], -1);
Ans = 1ll * n * m;
for (i = 0; i < p[n]; i++) Ans = min(Ans, a[i]);
cout << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2000010;
const double eps = 1e-10;
inline long long read() {
long long p = 0;
long long f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + (ch - '0');
ch = getchar();
}
return p * f;
}
long long col[N], cnt[N], val[N], f[N];
void FWT(long long *a, long long L, long long R) {
if (L == R) return;
long long mid = (L + R) >> 1;
long long n = (R - L + 1) / 2;
FWT(a, L, mid);
FWT(a, mid + 1, R);
for (long long i = L; i <= mid; i++) {
long long x = a[i];
long long y = a[i + n];
a[i] = x + y;
a[i + n] = x - y;
}
}
int main() {
long long n = read();
long long m = read();
for (long long i = 0; i < n; i++) {
for (long long j = 1; j <= m; j++) {
char ch;
scanf("\n%c", &ch);
if (ch == '1') col[j] += (1 << (i));
}
}
for (long long i = 1; i <= m; i++) cnt[col[i]]++;
for (long long i = 0; i < (1 << (n)); i++)
val[i] = min((long long)__builtin_popcount(i),
(long long)n - __builtin_popcount(i));
long long nn = 1, l = 0;
for (nn = 1; nn < (1 << (n)); nn <<= 1) l++;
FWT(cnt, 0, nn - 1);
FWT(val, 0, nn - 1);
for (long long i = 0; i < (1 << (n)); i++) f[i] = cnt[i] * val[i];
FWT(f, 0, nn - 1);
long long minx = LLONG_MAX;
for (long long i = 0; i < (1 << (n)); i++)
minx = min(minx, f[i] / (1 << (n)));
return printf("%lld\n", minx), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int maxn = 100005;
const int mod = 1e9 + 7;
int ma[25][maxn];
int qpow(int base, int num) {
int ret = 1;
while (num) {
if (num & 1) ret = 1ll * ret * base % mod;
base = 1ll * base * base % mod;
num >>= 1;
}
return ret;
}
int INV = qpow(2, mod - 2);
void FWT_XOR(vector<long long> &vec, int len, int flag) {
for (int i = 2; i <= len; i <<= 1) {
int m = i >> 1;
for (int j = 0; j < len; j += i) {
for (int k = 0; k < m; k++) {
int x = vec[j + k] % mod, y = vec[j + k + m] % mod;
vec[j + k] = (x + y) % mod;
vec[j + k + m] = (x - y + mod) % mod;
if (flag == -1) {
vec[j + k] = 1ll * vec[j + k] * INV % mod;
vec[j + k + m] = 1ll * vec[j + k + m] * INV % mod;
}
}
}
}
}
struct Poly {
vector<long long> vec;
int len;
Poly() { len = -1; }
Poly(int _len) : len(_len) { vec.resize(_len + 1); }
Poly(Poly x, int _len) : len(_len) {
vec.resize(_len + 1);
for (int i = 0; i <= _len; i++) {
vec[i] = i <= x.len ? x.vec[i] : 0;
}
}
long long &operator[](int x) {
assert(x >= 0 && x <= len);
return vec[x];
}
Poly operator^(const Poly B) const {
int n = max(len, B.len), lenret = 1;
for (; lenret <= n; lenret <<= 1)
;
Poly ret(*this, lenret - 1);
Poly tmp(B, lenret - 1);
FWT_XOR(ret.vec, lenret, 1);
FWT_XOR(tmp.vec, lenret, 1);
for (int i = 0; i < lenret; i++) ret[i] *= tmp[i];
FWT_XOR(ret.vec, lenret, -1);
return ret;
}
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
static char tmp[maxn];
scanf("%s", tmp + 1);
for (int j = 1; j <= m; j++) ma[i][j] = tmp[j] - '0';
}
Poly A((1 << n) - 1);
Poly B((1 << n) - 1);
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) {
tmp = tmp << 1 | ma[j][i];
}
A[tmp]++;
}
for (int i = 0; i < 1 << n; i++) {
int res = __builtin_popcount(i);
B[i] = min(res, n - res);
}
A = A ^ B;
long long ans = inf;
for (int i = 0; i < 1 << n; i++) {
ans = min(ans, A[i]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
double Xor[2][2] = {{1, 1}, {1, -1}}, IXor[2][2] = {{0.5, 0.5}, {0.5, -0.5}};
int n, m, a[100001];
long long f[1 << 20], g[1 << 20], cnt[1 << 20];
void fwt(long long *f, int n, double c[2][2]) {
for (int len = 2; len <= n; len <<= 1)
for (int i = 0; i < n; i += len)
for (int j = i; j < i + (len >> 1); ++j) {
long long t1 = f[j], t2 = f[j + (len >> 1)];
f[j] = c[0][0] * t1 + c[0][1] * t2;
f[j + (len >> 1)] = c[1][0] * t1 + c[1][1] * t2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
int x;
scanf("%1d", &x);
a[j] |= x << i - 1;
}
for (int i = 0; i < 1 << n; ++i) cnt[i] = cnt[i >> 1] + (i & 1);
for (int i = 1; i <= m; ++i) ++f[a[i]];
for (int i = 0; i < 1 << n; ++i)
g[i] = std::min(cnt[(1 << n) - 1 - i], cnt[i]);
fwt(f, 1 << n, Xor);
fwt(g, 1 << n, Xor);
for (int i = 0; i < 1 << n; ++i) f[i] = 1ll * f[i] * g[i];
fwt(f, 1 << n, IXor);
long long ans = 1e18;
for (int i = 0; i < 1 << n; ++i) ans = std::min(ans, f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][100010];
int cnt[1048576], cost[1048576];
void FWT(int *a, int n) {
int N = 1 << n;
int i, j, k;
int tmp0, tmp1;
for (i = 1; i < N; i <<= 1) {
for (j = 0; j < N; j += i << 1) {
for (k = 0; k < i; ++k) {
tmp0 = a[j + k], tmp1 = a[i + j + k];
a[j + k] = tmp0 - tmp1;
a[i + j + k] = tmp0 + tmp1;
}
}
}
}
void IFWT(long long *a, int n) {
int N = 1 << n;
int i, j, k;
long long tmp0, tmp1;
for (i = 1; i < N; i <<= 1) {
for (j = 0; j < N; j += i << 1) {
for (k = 0; k < i; ++k) {
tmp0 = a[j + k];
tmp1 = a[i + j + k];
a[j + k] = tmp0 + tmp1 >> 1;
a[i + j + k] = tmp1 - tmp0 >> 1;
}
}
}
}
long long ans[1048576];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int i;
for (i = 0; i < n; ++i) cin >> s[i];
int j;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) s[i][j] ^= 48;
char flag = s[i][0];
for (j = 0; j < m; ++j) s[i][j] ^= flag;
}
for (i = 0; i < m; ++i) {
int sum = 0;
for (j = 0; j < n; ++j) sum |= s[j][i] << j;
++cnt[sum];
}
for (i = 0; i < 1 << n; ++i) {
cost[i] = min(__builtin_popcount(i), __builtin_popcount(i ^ (1 << n) - 1));
}
FWT(cnt, n);
FWT(cost, n);
for (i = 0; i < 1 << n; ++i) ans[i] = (long long)cnt[i] * cost[i];
IFWT(ans, n);
long long min_ = 1e18;
for (i = 0; i < 1 << n; ++i) min_ = min(min_, ans[i]);
cout << min_ << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline long long getbit(long long x, int b) { return (x >> b) & 1; }
inline unsigned long long getbit(unsigned long long x, int b) {
return (x >> b) & 1;
}
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
int p1 = (x >> 32) & ((1ll << 32) - 1);
int p2 = x & ((1ll << 32) - 1);
return countbit(p1) + countbit(p2);
}
template <typename T>
void printbit(T x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st = v;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
0 ? break_point() : 0;
}
} while (0);
return 0;
}
int col[100005];
int cnt[20][1 << 8];
int u[20][1 << 8];
int dp[1 << 13];
void run() {
dp[0] = 0;
for (int i = 1; i < (1 << 13); i++) dp[i] = dp[i >> 1] + (i & 1);
int n, m;
scanf("%d%d", &n, &m);
const int B = max(1, n - 12);
const int A = n - B;
int t;
for (int i = 0; i < n; i++) {
getchar();
for (int j = 0; j < m; j++) {
t = getchar() - '0';
col[j] ^= t * (1 << i);
}
}
int res = std::numeric_limits<int>::max();
int to = 1 << A;
int to_b = 1 << B;
for (int mask = 0; mask < to; mask++) {
for (int i = 0; i <= A; i++)
for (int j = 0; j < to_b; j++) cnt[i][j] = 0;
for (int i = 0; i < m; i++) {
int x = dp[mask ^ (col[i] >> B)];
int y = col[i] & ((1 << B) - 1);
cnt[x][y]++;
}
for (int mask_b = 0; mask_b < to_b; mask_b++) {
int cur = 0;
for (int i = 0; i <= A; i++) {
for (int k = 0; k < to_b; k++) {
cur +=
min(n - (i + dp[k ^ mask_b]), (i + dp[k ^ mask_b])) * cnt[i][k];
}
}
res = min((res), (cur));
}
}
printf("%d", res);
putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
void fwt(long long a[], int n, bool on) {
for (int d = 1; d < n; d <<= 1) {
for (int k = d << 1, i = 0; i < n; i += k) {
for (int j = 0; j < d; ++j) {
long long x = a[i + j], y = a[i + j + d];
if (on) {
a[i + j] = (x + y);
a[i + j + d] = (x - y);
} else {
a[i + j] = (x + y) / 2;
a[i + j + d] = (x - y) / 2;
}
}
}
}
}
char inp[22][maxn];
int arr[maxn];
long long A[1 << 22], B[1 << 22];
int getone(int x, int n) {
int ret = 0;
while (x) {
ret += x & 1;
x >>= 1;
}
return min(ret, n - ret);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", inp[i]);
for (int i = 0; i < m; i++) {
arr[i] = 0;
for (int j = 0; j < n; j++) {
arr[i] |= (inp[j][i] - '0') << j;
}
}
memset(A, 0, sizeof(A));
for (int i = 0; i < m; i++) A[arr[i]]++;
for (int i = 0; i < (1 << n); i++) {
B[i] = getone(i, n);
}
fwt(A, 1 << n, true);
fwt(B, 1 << n, true);
for (int i = 0; i < (1 << n); i++) A[i] *= B[i];
fwt(A, 1 << n, false);
long long ans = INFF;
for (int i = 0; i < (1 << n); i++) ans = min(ans, A[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, f[1050000], a[1050000], b[1050000], mp[21][100005], ans;
void fwt(long long a[], long long n, long long f) {
for (long long i = 1; i < 1 << n; i <<= 1) {
for (long long t = 0; t < 1 << n; t++) {
if (i & t) {
long long x = a[t - i], y = a[t];
a[t - i] = x + y;
a[t] = x - y;
}
}
}
if (f == -1) {
for (long long i = 0; i < 1 << n; i++) a[i] = a[i] / (1 << n);
}
}
long long get(long long x) {
long long num = 0;
while (x) {
if (x % 2 == 1) num++;
x /= 2;
}
return num;
}
int main() {
scanf("%lld%lld", &n, &m);
ans = n * m;
f[1] = 1;
for (long long i = 2; i <= n; i++) {
f[i] = f[i - 1] * 2;
}
for (long long i = 1; i <= n; i++) {
for (long long t = 1; t <= m; t++) {
char s;
cin >> s;
if (s == '1')
mp[i][t] = 1;
else
mp[i][t] = 0;
}
}
for (long long i = 1; i <= m; i++) {
long long x = 0;
for (long long t = 1; t <= n; t++) {
if (mp[t][i] == 1) x += f[t];
}
a[x]++;
}
for (long long i = 0; i < 1 << n; i++) {
long long x = get(i);
b[i] = min(x, n - x);
}
fwt(a, n, 1);
fwt(b, n, 1);
for (long long i = 0; i < 1 << n; i++) {
a[i] = a[i] * b[i];
}
fwt(a, n, -1);
for (long long i = 0; i < 1 << n; i++) {
ans = min(ans, a[i]);
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
int n, m, all;
int val[maxn];
int cnt[maxn];
long long F[maxn], G[maxn];
void FWT(long long *a, int type) {
for (int d = 1; d <= all; d <<= 1)
for (int m = d << 1, i = 0; i <= all; 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 (type == -1)
a[i + j] = a[i + j] / 2, a[i + j + d] = a[i + j + d] / 2;
}
}
char now[maxn];
int main() {
scanf("%d%d", &n, &m);
all = (1 << n) - 1;
for (int s = 0; s <= all; s++) cnt[s] = cnt[s >> 1] + (s & 1);
for (int t = 1; t <= n; t++) {
scanf("%s", now + 1);
for (int i = 1; i <= m; i++) val[i] = (val[i] << 1) + (now[i] == '1');
}
for (int s = 0; s <= all; s++) {
if (cnt[s] > cnt[s ^ all])
G[s] = cnt[s ^ all];
else
G[s] = cnt[s];
}
for (int i = 1; i <= m; i++) F[val[i]]++;
FWT(F, 1);
FWT(G, 1);
for (int s = 0; s <= all; s++) F[s] = F[s] * G[s];
FWT(F, -1);
long long ans = 1LL << 60;
for (int s = 0; s <= all; s++) ans = min(ans, F[s]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[100111];
int dp[1 << 21][21];
int val[100111];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) {
if (s[j] == '1') val[j] |= 1 << i;
}
}
for (int i = 0; i < m; i++) dp[val[i]][0]++;
for (int j = 1; j <= n; j++) {
for (int i = 0; i < 1 << n; i++) {
if (j >= 2) dp[i][j] = (j - 2 - n) * dp[i][j - 2];
for (int k = 0; k < n; k++) dp[i][j] += dp[i ^ 1 << k][j - 1];
dp[i][j] /= j;
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 1 << n; i++) {
int res = 0;
for (int j = 0; j <= n; j++) res += min(j, n - j) * dp[i][j];
smin(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 10, N = 20;
int n, m, ans = 1e9, sum, ar[M], dp[2][N][(1LL << N)];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
ar[j] *= 2;
if (s[j] == '1') ar[j]++;
}
}
for (int i = 0; i < m; i++) dp[0][0][ar[i]]++;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int mask = 0; mask < (1LL << n); mask++) {
if (!j)
dp[i & 1LL][j][mask] = dp[(i - 1LL) & 1LL][j][mask];
else
dp[i & 1][j][mask] = dp[(i - 1) & 1][j][mask] +
dp[(i - 1) & 1][j - 1][mask ^ (1LL << (n - i))];
}
}
}
for (int mask = 0; mask < (1LL << n); mask++) {
int tmp = 0;
for (int i = 0; i <= n; i++) tmp += dp[n & 1][i][mask] * min(i, n - i);
ans = min(ans, tmp);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vi diff((N + 1) << N);
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
diff[col]++;
}
for (int i = 0; i < (N); i++) {
for (int jm = (int((diff).size()) - (1 << N)) - 1; jm >= 0; jm--) {
diff[(jm ^ (1 << i)) + (1 << N)] += diff[jm];
}
}
int ans = INT_MAX;
for (int m = 0; m < (1 << N); m++) {
int cand = 0;
for (int d = 0; d < (N + 1); d++)
cand += min(d, N - d) * diff[(d << N) + m];
ckmin(ans, cand);
}
ps(ans);
return 0;
}
|
#include <bits/stdc++.h>
char popcount[1 << 20], str[21][100010];
int n, m, r, p, lim, ar[100010], counter[14][1 << 7];
int main() {
int i, j, k, l, c, d, x, y, z, lol, res, mask;
for (i = 0; i < (1 << 20); i++) popcount[i] = __builtin_popcount(i);
while (scanf("%d %d", &n, &m) != EOF) {
for (i = 0; i < n; i++) scanf("%s", str[i]);
memset(ar, 0, sizeof(ar));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (str[i][j] == 49) ar[j] |= (1 << i);
}
}
r = 13;
if (n < r) r = n;
lim = (1 << r) - 1, res = 1 << 25;
for (mask = 0; mask <= lim; mask++) {
memset(counter, 0, sizeof(counter));
for (i = 0, z = 0; i < m; i++) {
x = (ar[i] & lim) ^ mask;
counter[popcount[x]][ar[i] >> r]++;
}
p = n - r, l = (1 << p) - 1;
for (k = 0; k <= l; k++) {
for (i = 0, z = 0; i <= r; i++) {
for (j = 0; j <= l; j++) {
if (counter[i][j]) {
x = j ^ k, c = popcount[x] + i;
if ((n - c) < c) c = n - c;
z += (c * counter[i][j]);
}
}
}
if (z < res) res = z;
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') t = -1;
c = getchar();
}
while (isdigit(c)) s = s * 10 + c - 48, c = getchar();
return s * t;
}
const int maxn = 1048576, inf = 2e9 + 7;
inline void Min(long long &x, long long v) {
if (x > v) x = v;
}
int n, m, N;
long long f[maxn], g[maxn];
char c[25][maxn];
inline void fwt(int l, int r, long long *f) {
if (l == r) return;
int mid = (l + r) >> 1, bit = (r - l + 1) >> 1;
long long x, y;
for (register int i = l; i <= mid; i++)
x = f[i], y = f[i + bit], f[i] = x + y, f[i + bit] = x - y;
fwt(l, mid, f), fwt(mid + 1, r, f);
}
inline void nfwt(int l, int r, long long *f) {
if (l == r) return;
int mid = (l + r) >> 1, bit = (r - l + 1) >> 1;
long long x, y;
nfwt(l, mid, f), nfwt(mid + 1, r, f);
for (register int i = l; i <= mid; i++)
x = f[i], y = f[i + bit], f[i] = (x + y) >> 1, f[i + bit] = (x - y) >> 1;
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= n; i++) scanf("%s", c[i] + 1);
int x;
N = 1 << n;
for (register int i = 1; i <= m; i++) {
x = 0;
for (register int j = 1; j <= n; j++) x = (x << 1) | (c[j][i] == '1');
f[x]++;
}
for (register int i = 0; i <= N - 1; i++) g[i] = g[i >> 1] + (i & 1);
for (register int i = 0; i <= N - 1; i++) g[i] = min(g[i], n - g[i]);
fwt(0, N - 1, f), fwt(0, N - 1, g);
for (register int i = 0; i <= N - 1; i++) f[i] = f[i] * g[i];
nfwt(0, N - 1, f);
long long ans = inf;
for (register int i = 0; i <= N - 1; i++) Min(ans, f[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
class Input {
private:
char buf[1000000], *p1, *p2;
public:
inline char getc() {
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
return p1 == p2 ? EOF : *(p1++);
}
template <typename tp>
inline Input &operator>>(tp &n) {
n = 0;
char c = getc();
while (!isdigit(c)) c = getc();
while (isdigit(c)) n = n * 10 + c - 48, c = getc();
return (*this);
}
inline Input &operator>>(char *s) {
char c = getc();
int tot = 0;
while (c != '0' and c != '1') c = getc();
while (c == '0' or c == '1') s[tot++] = c, c = getc();
s[tot] = 0;
return *this;
}
} fin;
const int N = 25, M = (1 << 20);
using namespace std;
inline void Min(int &a, int b) {
if (a > b) a = b;
}
int n, m, sz[M], sta[M];
long long F[M], G[M];
char s[N][M];
void FWT(long long *f, int tp) {
int d = (1 << n);
for (int i = 1; i < d; i <<= 1)
for (int j = 0; j < d; j += (i << 1))
for (int k = 0; k < i; ++k) {
long long x = f[j + k], y = f[i + j + k];
if (tp == 1)
f[j + k] = (x + y), f[i + j + k] = (x - y);
else
f[j + k] = (x + y) / 2, f[i + j + k] = (x - y) / 2;
}
}
int main() {
fin >> n >> m;
for (int i = 1; i <= n; ++i) {
fin >> s[i] + 1;
for (int j = 1; j <= m; ++j)
if (s[i][j] == '1') sta[j] |= (1 << i - 1);
}
for (int i = 1; i <= m; ++i) ++F[sta[i]];
for (int i = 1; i < (1 << n); ++i)
sz[i] = sz[i >> 1] + (i & 1), G[i] = min(sz[i], n - sz[i]);
FWT(F, 1), FWT(G, 1);
for (int i = 0; i < (1 << n); ++i) F[i] = F[i] * G[i];
FWT(F, 0);
int ans = 1e9;
for (int i = 0; i < (1 << n); ++i) Min(ans, F[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxk = 4e6 + 10;
long long n, m, len, a[mxk], b[mxk], c[mxk], col[mxk];
void FWT_xor(long long a[], int opt = 1) {
for (int i = 1; i < len; i <<= 1)
for (int p = i; p < len; p += (i << 1))
for (int k = p; k < p + i; ++k)
if (opt)
a[k - i] = (a[k - i] + a[k]), a[k] = a[k - i] - (a[k] << 1);
else
a[k - i] = (a[k - i] + a[k]) >> 1, a[k] = a[k - i] - a[k];
}
string s[30];
int main() {
cin >> n >> m;
len = (1 << n);
for (int i = 1; i <= n; ++i) cin >> s[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++) col[j + 1] |= (s[i][j] - '0') << (i - 1);
for (int i = 1; i <= m; i++) a[col[i]]++;
for (int i = 0; i < len; i++) {
for (int u = i; u; u ^= u & (-u)) ++b[i];
b[i] = min(b[i], n - b[i]);
}
FWT_xor(a), FWT_xor(b);
for (int i = 0; i < len; ++i) c[i] = a[i] * b[i];
FWT_xor(c, 0);
long long ans = 1e9;
for (int i = 0; i < len; ++i) ans = min(ans, c[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1 << 20;
const long long lg = 23;
long long ans;
long long n, m;
long long num[maxn];
long long dp[lg][maxn];
void in();
void solve();
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
char c;
cin >> c;
num[j] = num[j] * 2 + (c - '0');
}
}
}
void solve() {
for (long long i = 0; i < m; i++) dp[0][num[i]]++;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < (1 << n); j++) {
for (long long k = 1; k <= min(i, 2ll); k++)
for (long long l = 0; l < n; l++)
dp[i][j] += ((k % 2) * 2 - 1) * dp[i - k][j ^ ((1 << l) * (k % 2))];
if (i > 2) dp[i][j] = dp[i][j] + (i - 2) * dp[i - 2][j];
dp[i][j] /= i;
}
}
ans = m * n;
for (long long i = 0; i < (1 << n); i++) {
long long oof = 0;
for (long long j = 0; j <= n; j++) oof += dp[j][i] * min(j, n - j);
ans = min(ans, oof);
}
}
void out() { cout << ans; }
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int inv = 499122177;
char mp[20][100005];
int bit = 0, len = 0;
void FWT(int *A, int flag) {
for (int i = 0; i < bit; i++)
for (int j = 0; j < len; j++)
if ((j) & (1 << i)) {
(A[(j)] += A[(j ^ (1 << i))]) %= mod;
(A[(j ^ (1 << i))] = A[(j)] - 2 * A[(j ^ (1 << i))]) % mod;
A[(j)] = 1ll * A[(j)] * flag % mod;
A[(j ^ (1 << i))] = 1ll * A[(j ^ (1 << i))] * flag % mod;
}
}
void FCP(int *A) {
for (int i = 0; i < (len >> 1); i++) swap(A[i], A[i ^ (len - 1)]);
}
void FMD(int *A) {
for (int i = 0; i < len; i++) A[i] = (A[i] % mod + mod) % mod;
}
void FML(int *A, int *B) {
for (int i = 0; i < len; i++) A[i] = 1ll * A[i] * B[i] % mod;
}
int A[1 << 20];
int B[1 << 20];
int main() {
int n, m;
cin >> n >> m;
bit = n;
len = 1 << bit;
for (int i = 0; i < n; i++) cin >> mp[i];
for (int i = 0; i < m; i++) {
int all = 0;
for (int j = 0; j < n; j++) (all <<= 1) |= (mp[j][i] - '0');
A[all]++;
}
for (int i = 0; i < len; i++) {
B[i] = __builtin_popcount(i);
B[i] = min(B[i], bit - B[i]);
}
FWT(A, 1);
FWT(B, 1);
FML(A, B);
FWT(A, inv);
FCP(A);
FMD(A);
int ans = mod;
for (int i = 0; i < len; i++) ans = min(ans, A[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = (1 << 20) + 9, M = 1e5 + 9;
long long n, m, f[N], g[N], a[M], num[N];
char s[M];
inline void FWT(long long *f, long long flag) {
for (long long mid = 2, k = 1; mid <= n; mid <<= 1, k <<= 1)
for (long long i = 0; i < n; i += mid)
for (long long j = 0; j < k; j++)
f[i + j] += f[i + j + k],
f[i + j + k] = f[i + j] - f[i + j + k] - f[i + j + k],
f[i + j] /= flag, f[i + j + k] /= flag;
}
signed main() {
scanf("%lld%lld", &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') 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++) num[i] = num[i >> 1] + (i & 1);
for (long long i = 0; i < (1 << n); i++) g[i] = min(num[i], n - num[i]);
n = (1 << n);
FWT(f, 1), FWT(g, 1);
for (long long i = 0; i < n; i++) f[i] *= g[i];
FWT(f, 2);
long long ans = 1e15;
for (long long i = 0; i < n; i++) ans = min(ans, f[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int MX = 100005;
int c[MX], dp[1 << 20][22];
int bit[1 << 20][2][12];
void upd(int m, int k, int i, int v) {
while (i <= 10) {
bit[m][k][i] += v;
i += i & -i;
}
}
int qry(int m, int k, int i) {
int s = 0;
while (i > 0) {
s += bit[m][k][i];
i -= i & -i;
}
return s;
}
int main() {
int n, m, x, s;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%1d", &x);
if (x) c[j] |= (1 << i);
}
}
int mx = (1 << n) - 1;
for (int i = 0; i < m; i++) {
dp[c[i]][0]++;
upd(c[i], 0, 1, 1);
}
for (int k = 1; k <= n; k++) {
for (int m = 0; m <= mx; m++) {
for (int p = 0; p < n; p++) {
s = m ^ (1 << p);
dp[m][k] += qry(s, (k - 1) & 1, ((k - 1) >> 1) + 1);
if (k > 1) dp[m][k] -= qry(m, (k - 2) & 1, ((k - 2) >> 1) + 1);
}
dp[m][k] /= k;
upd(m, k & 1, (k >> 1) + 1, dp[m][k]);
}
}
int k = n >> 1, ans = n * m;
for (int m = 0; m < mx; m++) {
s = 0;
for (int i = 0; i <= n; i++) s += min(i, n - i) * dp[m][i];
ans = min(ans, s);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100000];
int col[100000], dp[21][1 << 20];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf(" %s", s);
for (int j = 0; j < m; j++) col[j] |= (s[j] - '0') << i;
}
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++) {
int sum = k > 1 ? (k - 2 - n) * dp[k - 2][mask] : 0;
for (int p = 0; p < n; p++) sum += dp[k - 1][mask ^ (1 << p)];
dp[k][mask] = sum / k;
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int cnt = 0;
for (int k = 0; k <= n; k++) cnt += min(k, n - k) * dp[k][mask];
ans = min(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int n, m;
long long x1[N], x2[N];
char s[21][100005];
void fwt(long long f[], int n, int on) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if (~j & i) {
long long x1 = f[j], x2 = f[j | i];
f[j] = x1 + x2;
f[j | i] = x1 - x2;
}
}
}
if (on == -1) {
for (int i = 0; i < n; i++) {
f[i] /= n;
}
}
}
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 num = 0;
for (int j = 0; j < n; j++) {
num |= (s[j][i] - '0') << j;
}
x1[num]++;
}
for (int i = 0; i < 1 << n; i++) {
int t = __builtin_popcount(i);
x2[i] = min(t, n - t);
}
fwt(x1, 1 << n, 1);
fwt(x2, 1 << n, 1);
for (int i = 0; i < 1 << n; i++) {
x1[i] *= x2[i];
}
fwt(x1, 1 << n, -1);
long long ans = n * m;
for (int i = 0; i < 1 << n; i++) {
ans = min(ans, x1[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9;
int n, m, va[maxn], dp[22][(1 << 20) + 10], sum[22][(1 << 20) + 1];
char a[22][maxn];
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s1;
cin >> s1;
for (int j = 0; j < m; j++) a[i][j] = s1[j];
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
if (a[i][j] == '1') va[j] += (1 << i);
}
}
for (int j = 0; j < m; j++) dp[0][va[j]]++;
for (int mask = 0; mask < (1 << n); mask++) sum[0][mask] = dp[0][mask];
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1 << n); mask++) {
for (int bit = 0; bit < n; bit++) {
dp[i][mask] += sum[i - 1][mask ^ (1 << bit)];
if (i > 1) dp[i][mask] -= sum[i - 2][mask];
}
dp[i][mask] /= i;
sum[i][mask] = dp[i][mask];
if (i > 1) sum[i][mask] += sum[i - 2][mask];
}
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int anss = 0;
for (int i = 0; i <= n; i++) anss += (min(i, n - i) * dp[i][mask]);
ans = min(ans, anss);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = ~0U >> 1;
char s[20][100000 + 10];
int dp[21][1 << 20];
int n, m;
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][x]++;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j >= 1; j--)
for (int k = 0; k < (1 << n); k++) dp[j][k] += dp[j - 1][k ^ (1 << i)];
int ans = INF;
for (int i = 0; i < (1 << n); i++) {
int cur = 0;
for (int j = 0; j <= n; j++) cur += dp[j][i] * min(j, n - j);
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned int n, m;
unsigned int dp[21][1 << 20];
char t[20][100009];
int main() {
scanf("%u %u", &n, &m);
for (unsigned int i = 0; i < n; i++) scanf(" %s", t[i]);
for (unsigned int i = 0; i < m; i++) {
unsigned int mask = 0;
for (unsigned int j = 0; j < n; j++)
if (t[j][i] == '1') mask |= (1 << j);
dp[0][mask]++;
}
unsigned int MAX_N = (1 << n);
for (unsigned int k = 1; k <= n; k++) {
for (unsigned int mask = 0; mask < MAX_N; mask++) {
for (unsigned int p = 0; p < n; p++)
dp[k][mask] += dp[k - 1][mask ^ (1 << p)];
if (k > 1) dp[k][mask] += (k - 2 - n) * dp[k - 2][mask];
dp[k][mask] /= k;
}
}
unsigned int answ = m * n;
for (unsigned int mask = 0; mask < MAX_N; mask++) {
unsigned int tmpansw = 0;
for (unsigned int k = 0; k <= n; k++) {
tmpansw += min(k, n - k) * dp[k][mask];
}
answ = min(tmpansw, answ);
}
cout << answ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
const long long mod = 1e9 + 7;
const int getint() {
char c;
int f = 0;
while (c = getchar(), c > '9' || c < '0')
;
while (f = (f << 1) + (f << 3) + c - '0', c = getchar(), c >= '0' && c <= '9')
;
return f;
}
int n, m, sx;
int S[N], F[N], Q[N];
char T[N];
int a[N];
inline int min(int a, int b) { return a > b ? b : a; }
inline int pop_count(int x) {
int cnt = 0;
while (x) x -= x & -x, ++cnt;
return cnt;
}
inline void XOR(int *t, int rev) {
for (register int k = 2; k <= n + 1; ++k) {
int L = 1 << (k - 1), h_len = 1 << (k - 2);
for (register int i = 0; i < sx; i += L) {
for (register int j = 0; j < h_len; ++j) {
int t1 = t[i + j], t2 = t[i + j + h_len];
switch (rev) {
case 1: {
t[i + j] = (t1 + t2) % mod;
t[i + j + h_len] = (t1 - t2 + mod) % mod;
break;
}
case -1: {
t[i + j] = 1ll * (t1 + t2) * (mod - mod / 2ll) % mod;
t[i + j + h_len] =
1ll * (t1 - t2 + mod) % mod * (mod - mod / 2ll) % mod;
break;
}
}
}
}
}
}
signed main() {
n = getint(), m = getint();
for (register int i = 0; i < n; ++i) {
scanf("%s", T);
for (register int j = 0; j < m; ++j) {
a[j] |= (T[j] - '0') << i;
}
}
sx = 1 << n;
for (register int i = 0; i < sx; ++i)
F[i] = min(pop_count(i), pop_count(sx - 1 - i));
for (register int i = 0; i < m; ++i) ++Q[a[i]];
XOR(F, 1);
XOR(Q, 1);
for (register int i = 0; i < sx; ++i) F[i] = 1ll * F[i] * Q[i] % mod;
XOR(F, -1);
int ans = 0x3f3f3f3f;
for (register int i = 0; i < sx; ++i) ans = min(ans, F[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int mm[N + 1], n, m;
int dp[N + 1][20][2];
int dpp[N + 1][20];
inline int solve() {
for (int i = int(0); i < int(m); i++) dpp[mm[i]][0]++;
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(0); j < int(1 << n); j++) {
for (int e = int(0); e < int(n); e++) {
dp[j][e][i % 2] =
dpp[j ^ (1 << e)][i - 1] - dp[j ^ (1 << e)][e][(i + 1) % 2];
dpp[j][i] += dp[j][e][i % 2];
}
dpp[j][i] /= i;
}
}
int ans = INT_MAX;
for (int i = int(1); i < int(1 << n); i++) {
int sum = 0;
for (int j = int(1); j < int(n + 1); j++) sum += min(j, n - j) * dpp[i][j];
ans = min(ans, sum);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int ag = 0;
for (int i = int(0); i < int(n); i++) {
int cc = 0;
for (int j = int(0); j < int(m); j++) {
char c;
cin >> c;
if (c == '1') mm[j] += (1 << i), cc++;
}
ag += min(cc, m - cc);
}
int ans = min(solve(), ag);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
inline void getint(int &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
inline void print(int first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[101010], f[21][1 << 20];
char s[101010];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) a[j] |= (s[j] - '0') << i;
}
for (int i = 0; i < m; i++) f[0][a[i]]++;
for (int i = 0; i < n; i++) {
for (int j = n; j; j--) {
for (int k = 0; k < 1 << n; k++) f[j][k] += f[j - 1][k ^ (1 << i)];
}
}
int ans = n * m;
for (int i = 0; i < 1 << n; i++) {
int mid = 0;
for (int j = 0; j <= n; j++) mid += min(j, n - j) * f[j][i];
smin(ans, mid);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[25][1100000], ans = 1e9;
char num[25][100005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%s", num[i] + 1);
for (int i = 1; i <= m; ++i) {
int t = 0;
for (int j = 1; j <= n; ++j) t = t * 2 + num[j][i] - '0';
++dp[0][t];
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 1 << n; ++j) {
for (int k = 1; k < 1 << n; k <<= 1)
dp[i][j] = dp[i][j] + dp[i - 1][j ^ k];
if (i >= 2) dp[i][j] = dp[i][j] + (i - 2 - n) * dp[i - 2][j];
dp[i][j] /= i;
}
for (int i = 1; i < 1 << n; ++i) {
int t = 0;
for (int j = 0; j <= n; ++j) t += min(j, n - j) * dp[j][i];
ans = min(ans, t);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int n, m, S[N], cnt[N];
long long a[N], b[N];
char s[N];
void FWT(long long *a, int n) {
for (int d = 1; d < 1 << n; d <<= 1)
for (int i = 0; i < 1 << n; i += d << 1)
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;
}
}
void IFWT(long long *a, int n) {
for (int d = 1; d < 1 << n; d <<= 1)
for (int i = 0; i < 1 << n; i += d << 1)
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) / 2;
a[i + j + d] = (x - y) / 2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(0); i <= (int)(n - 1); i++) {
scanf("%s", s + 1);
for (int j = (int)(1); j <= (int)(m); j++)
if (s[j] == '1') S[j] |= 1 << i;
}
for (int i = (int)(1); i <= (int)(m); i++) a[S[i]]++;
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
cnt[i] = cnt[i / 2] + (i & 1);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
b[i] = min(cnt[i], n - cnt[i]);
FWT(a, n);
FWT(b, n);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++) a[i] *= b[i];
IFWT(a, n);
int ans = 1 << 30;
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
ans = min(1ll * ans, a[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
class FWT {
public:
void fwt(long long *a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; 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;
}
}
}
}
void ufwt(long long *a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; 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) / 2;
a[i + j + d] = (x - y) / 2;
}
}
}
}
void work(long long *a, long long *b, int n) {
fwt(a, n);
fwt(b, n);
for (int i = 0; i < n; i++) a[i] *= b[i];
ufwt(a, n);
}
} myfwt;
const int maxn = 100086;
char str[maxn];
long long dp[(1 << 20) + 5], num[(1 << 20) + 5], a[maxn];
int n, m;
int calc(int x) {
int ans = 0;
for (; x; x >>= 1) ans += (x & 1);
return ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < m; j++) a[j] |= ((str[j] - '0') << i);
}
for (int i = 0; i < m; i++) num[a[i]]++;
for (int i = 0; i < (1 << n); i++) {
int ans = calc(i);
dp[i] = min(ans, n - ans);
}
myfwt.work(dp, num, 1 << n);
long long ans = 1e18;
for (int i = 0; i < (1 << n); i++) ans = min(ans, dp[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 20 + 1, MAX_M = 100 * 1000 + 10, MAX_MASK = (1 << MAX_N) + 10;
int dp[MAX_MASK][MAX_N], a[MAX_M];
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[j] = 2 * a[j] + c - '0';
}
for (int i = 0; i < m; i++) dp[a[i]][0]++;
for (int i = 1; i <= n; i++)
for (int mask = 0; mask < (1 << n); mask++) {
for (int j = 0; j < n; j++) dp[mask][i] += dp[mask ^ (1 << j)][i - 1];
if (i > 1) (dp[mask][i] -= dp[mask][i - 2] * (n - i + 2)) /= i;
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int res = 0;
for (int i = 0; i <= n; i++) res += dp[mask][i] * min(i, n - i);
ans = min(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int col[100000 + 10], f[20 + 1][1 << 20], ans;
char s[100000 + 10];
using namespace std;
void Read(int &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
int n, m;
void read() {
Read(n), Read(m);
int i, j;
for (i = 0; i < n; i++) {
scanf("%s", s);
for (j = 0; j < m; j++) col[j] |= (s[j] - '0') << i;
}
}
void solve() {
ans = n * m;
int i, s, k, t = 1 << n, sum, p, cnt;
for (i = 0; i < m; i++) f[0][col[i]]++;
for (k = 1; k <= n; k++)
for (s = 0; s < t; s++) {
sum = k > 1 ? (k - 2 - n) * f[k - 2][s] : 0;
for (p = 0; p < n; p++) sum += f[k - 1][s ^ (1 << p)];
f[k][s] = sum / k;
}
for (s = 0; s < t; s++) {
cnt = 0;
for (k = 0; k <= n; k++) cnt += min(k, n - k) * f[k][s];
ans = min(ans, cnt);
}
}
int main() {
read();
solve();
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
char st[1048576 + 5];
long long a[1048576 + 5], b[1048576 + 5], c[1048576 + 5];
int n, m, s[1048576 + 5], num[1048576 + 5], f[21][1048576 + 5],
res[1048576 + 5], ans = 1e9;
void FWT(long long* a, int l, int r, int v) {
if (l == r) return;
int mid = l + r >> 1;
FWT(a, l, mid, v);
FWT(a, mid + 1, r, v);
for (int i = 0; i <= mid - l; ++i) {
long long x = a[l + i], y = a[mid + 1 + i];
a[l + i] = (x + y) >> v;
a[mid + 1 + i] = (x - y) >> v;
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", st + 1);
for (int j = 1; j <= m; ++j)
if (st[j] == '1') s[j] |= 1 << i - 1;
}
for (int i = 1; i <= m; ++i) ++a[s[i]];
for (int i = 1; i < 1 << n; ++i) num[i] = num[i >> 1] + (i & 1);
FWT(a, 0, (1 << n) - 1, 0);
for (int j = 0; j < 1 << n; ++j) b[j] = min(num[j], n - num[j]);
FWT(b, 0, (1 << n) - 1, 0);
for (int j = 0; j < 1 << n; ++j) c[j] = b[j] * a[j];
FWT(c, 0, (1 << n) - 1, 1);
for (int j = 0; j < 1 << n; ++j) res[j] += c[j];
for (int j = 0; j < 1 << n; ++j) ans = min(ans, res[j]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[22][1 << 20];
const int maxn = 1 << 20;
char c[20][maxn];
int main() {
int i, j, n, m;
cin >> n >> m;
for (i = 0; i < n; i++) {
scanf("%s", c[i]);
}
for (int i = 0; i < m; i++) {
int s = 0;
for (j = 0; j < n; j++) {
s = s * 2 + c[j][i] - '0';
}
dp[0][s]++;
}
int q = 1 << n;
for (int f = 0; f < n; f++) {
for (int j = f + 1; j >= 1; j--) {
for (int i = 0; i < q; i++) {
dp[j][i] = dp[j][i] + dp[j - 1][i ^ (1 << f)];
}
}
}
int ans = 1000000000;
for (int i = 0; i < q; i++) {
int s = 0;
for (int j = 0; j <= n; j++) {
s += min(j, n - j) * dp[j][i];
}
ans = min(ans, s);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[21][100005];
int d[1 << 20];
long long a[1 << 20], b[1 << 20], c[1 << 20], ap[1 << 20], bp[1 << 20],
cp[1 << 20];
void FWT_xor(int l, long long *c, long long *d) {
if (l == 1) {
*d = *c;
return;
}
int m = l >> 1;
FWT_xor(m, c, d);
FWT_xor(m, c + m, d + m);
for (int i = 0; i < m; i++) {
long long a1 = *(d + i), a2 = *(d + i + m);
*(d + i) = a1 + a2, *(d + i + m) = a1 - a2;
}
}
void IFWT_xor(int l, long long *d, long long *c) {
if (l == 1) {
*c = *d;
return;
}
int m = l >> 1;
IFWT_xor(m, d, c);
IFWT_xor(m, d + m, c + m);
for (int i = 0; i < m; i++) {
long long a1 = *(c + i), a2 = *(c + i + m);
*(c + i) = (a1 + a2) >> 1, *(c + i + m) = (a1 - a2) >> 1;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
int r = 0;
for (int i = 1; i <= n; i++) r = 2 * r + (s[i][j] - '0');
a[r]++;
}
for (int i = 1; i < (1 << n); i++) d[i] = d[i >> 1] + (i & 1);
for (int i = 0; i < (1 << n); i++) b[i] = min(d[i], n - d[i]);
FWT_xor(1 << n, a, ap);
FWT_xor(1 << n, b, bp);
for (int i = 0; i < (1 << n); i++) cp[i] = ap[i] * bp[i];
IFWT_xor(1 << n, cp, c);
long long ans = LLONG_MAX;
for (int i = 0; i < (1 << n); i++) ans = min(ans, c[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 233, mxzt = (1 << 20) + 23;
int f[21][mxzt], tmp[2][mxzt][20];
int stv[maxn];
int i, j, k, n, m;
char s[maxn];
int ra, fh;
char rx;
inline int read() {
rx = getchar(), ra = 0, fh = 1;
while (rx < 48) rx == '-' && (fh = -1), rx = getchar();
while (rx > 47) ra = ra * 10 + rx - 48, rx = getchar();
return ra * fh;
}
inline int getnum1(int x) {
int n = 0;
while (x) n += x & 1, x >>= 1;
return n;
}
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
n = read(), m = read();
int mx = 1 << n;
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (j = 1; j <= m; j++) stv[j] = stv[j] << 1 | (s[j] - 48);
}
for (i = 1; i <= m; i++) f[0][stv[i]]++;
int zt, p, nf;
bool now = 1, pre = 0;
int *nt;
for (i = 1; i <= n; i++, swap(now, pre)) {
for (zt = 0; zt < mx; zt++) {
for (nf = p = 0, nt = tmp[now][zt]; p < n; p++, nt++)
nf += (*nt = f[i - 1][zt ^ (1 << p)] - tmp[pre][zt ^ (1 << p)][p]);
f[i][zt] = nf / i;
}
}
int ans = 1e9;
for (zt = 0; zt < mx; zt++) {
k = 0;
for (j = 0; j <= n && k < ans; j++) k += min(j, n - j) * f[j][zt];
if (j > n) ans = k;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, s[21][100005], a[1 << 21], b[1 << 21], ans;
long long read() {
char c = getchar();
long long ans = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans;
}
long long get_char() {
char c = getchar();
while (c != '0' && c != '1') c = getchar();
return c ^ 48;
}
void fwt_xor(long long *A, long long flag) {
for (register long long l = 1; l < (1 << n); l <<= 1)
for (register long long i = 0; i < (1 << n); i += (l << 1))
for (register long long j = 0; j < l; j++) {
long long u = A[i + j], v = A[i + j + l];
if (flag == 1)
A[i + j] = u + v, A[i + j + l] = u - v;
else
A[i + j] = (u + v) >> 1, A[i + j + l] = (u - v) >> 1;
}
return;
}
void FWT_xor() {
fwt_xor(a, 1);
fwt_xor(b, 1);
for (register long long i = 0; i < (1 << n); i++) a[i] *= b[i];
fwt_xor(a, -1);
return;
}
int main() {
n = read(), m = read();
for (register long long i = 1; i <= n; i++)
for (register long long j = 1; j <= m; j++) s[i][j] = get_char();
for (register long long i = 1, cnt = 0; i <= m; i++, a[cnt]++, cnt = 0)
for (register long long j = 1; j <= n; j++) cnt |= (s[j][i] << j - 1);
for (register long long i = 1; i < (1 << n); i++) b[i] = b[i & (i - 1)] + 1;
for (register long long i = 1; i < (1 << n); i++) b[i] = min(b[i], n - b[i]);
FWT_xor();
ans = a[0];
for (register long long i = 1; i < (1 << n); i++) ans = min(ans, a[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
long long val[(1 << 20) + 5], cnt[(1 << 20) + 5], ans[(1 << 20) + 5];
int a[200010];
char s[25][200010];
int n, m;
void fwt(long long* a, int n) {
for (int k = 1; k < n; k <<= 1)
for (int j = 0; j < n; j += (k << 1))
for (int i = j; i < j + k; i++) {
long long p = a[i], q = a[i + k];
a[i] = p + q;
a[i + k] = p - q;
}
}
void ifwt(long long* a, int n) {
fwt(a, n);
for (int i = 0; i < n; i++) a[i] = a[i] / n;
}
int main() {
n = read();
m = read();
for (int i = 0; i < n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
a[i] = 0;
for (int j = 0; j < n; j++)
if (s[j][i] == '1') a[i] |= (1 << j);
++cnt[a[i]];
}
val[0] = 0;
for (int i = 1; i < 1 << n; i++) val[i] = val[i >> 1] + (i & 1);
for (int i = 0; i < 1 << n; i++) val[i] = std::min(val[i], n - val[i]);
fwt(val, 1 << n);
fwt(cnt, 1 << n);
for (int i = 0; i < 1 << n; i++) ans[i] = val[i] * cnt[i];
ifwt(ans, 1 << n);
long long mn = 1ll << 60;
for (int i = 0; i < 1 << n; i++) mn = std::min(mn, ans[i]);
writeln(mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline void debug(int x) { fprintf(stderr, "ycx has aked ioi %d times\n", x); }
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
if (!x) return;
recursive_print(x / 10);
putc(x % 10 ^ 48);
}
template <typename T>
void print(T x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = ~x + 1;
recursive_print(x);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 20;
const int MAXM = 1e5;
const int MAXP = 1 << 20;
const int INF = 0x3f3f3f3f;
int n, m, a[MAXN + 5][MAXM + 5];
long long cnt[MAXP + 5], mn[MAXP + 5], ans[MAXP + 5];
void FWTxor(long long *a, int len, int type) {
for (int i = 2; i <= len; i <<= 1)
for (int j = 0; j < len; j += i)
for (int k = 0; k < (i >> 1); k++) {
long long X = a[j + k], Y = a[(i >> 1) + j + k];
if (type == 1)
a[j + k] = X + Y, a[(i >> 1) + j + k] = X - Y;
else
a[j + k] = (X + Y) / 2, a[(i >> 1) + j + k] = (X - Y) / 2;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%1d", &a[i][j]);
for (int j = 1; j <= m; j++) {
int msk = 0;
for (int i = 1; i <= n; i++) msk |= (a[i][j] << i - 1);
cnt[msk]++;
}
for (int i = 0; i < (1 << n); i++)
mn[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
FWTxor(cnt, 1 << n, 1);
FWTxor(mn, 1 << n, 1);
for (int i = 0; i < (1 << n); i++) ans[i] = 1ll * cnt[i] * mn[i];
FWTxor(ans, 1 << n, -1);
int ret = INF;
for (int i = 0; i < (1 << n); i++) chkmin(ret, (int)ans[i]);
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
int n, m, mini, rev;
int ans[1 << 20], cnt[1 << 20], val[1 << 20], num[1 << 20];
char ch[21][100010];
inline int get_val(int x) {
int sum = 0;
for (int j = 1; j <= n; j++)
if (x & (1 << (j - 1))) sum++;
return min(sum, n - sum);
}
inline void prework() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (ch[j][i] == '1') x |= (1 << (j - 1));
num[x]++;
}
int len = 1 << 20;
for (int i = 1; i < len; i++) {
cnt[i] = cnt[i >> 1] + (i & 1);
val[i] = min(cnt[i], n - cnt[i]);
}
}
void fwt(int a[], int n) {
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
}
}
void ufwt(int a[], int n) {
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = (1LL * (x + y) * rev) % mod,
a[i + j + d] = (1LL * ((x - y + mod) % mod) * rev) % mod;
}
}
void solve(int a[], int b[], int len) {
fwt(a, len);
fwt(b, len);
for (int i = 0; i < len; i++) a[i] = 1LL * a[i] * b[i] % mod;
ufwt(a, len);
}
inline void mainwork() {
int len = 1 << n;
solve(num, val, len);
mini = n * m;
for (int i = 0; i < len; i++) mini = min(mini, num[i]);
}
inline void print() { printf("%d", mini); }
inline int qp(long long a, long long b) {
long long ans = 1, cnt = a;
while (b) {
if (b & 1) ans = (ans * cnt) % mod;
cnt = (cnt * cnt) % mod;
b >>= 1;
}
return ans;
}
int main() {
rev = qp(2, mod - 2);
prework();
mainwork();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2000010;
long long A[22][100010], a[maxn], n, m, f[maxn], g[maxn], len;
void FWTxor(long long *A, long long ty) {
for (long long mid = 1; mid < len; mid <<= 1)
for (long long j = 0, R = mid << 1; j < len; j += R)
for (long long k = 0; k < mid; ++k) {
long long x = A[j + k], y = A[j + k + mid];
A[j + k] = x + y;
A[j + k + mid] = x - y;
if (ty == -1) A[j + k] >>= 1, A[j + k + mid] >>= 1;
}
}
char s[maxn];
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) A[i][j] = s[j] - '0';
}
for (long long i = (1); i <= (m); ++i) {
long long now = 0;
for (long long j = (1); j <= (n); ++j)
if (A[j][i]) now += (1 << (j - 1));
a[i] = now;
}
for (long long i = (0); i <= ((1 << n) - 1); ++i) {
long long x = __builtin_popcount(i), y = n - x;
f[i] = min(x, y);
}
for (long long i = (1); i <= (m); ++i) ++g[a[i]];
len = (1 << n);
FWTxor(f, 1);
FWTxor(g, 1);
for (long long i = (0); i <= (len - 1); ++i) f[i] = f[i] * g[i];
FWTxor(f, -1);
long long ans = 0x3f3f3f3f3f3f3f3f;
for (long long i = (0); i <= (len - 1); ++i) ans = min(ans, f[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, num[100005], a[2000010], b[2000010];
char s[25][100005];
void FWT(long long *x, long long y) {
for (long long i = 1; i < y; i <<= 1)
for (long long j = 0; j < y; j += (i << 1))
for (long long k = 0; k < i; k++) {
long long pro = x[j + k], prov = x[j + k + i];
x[j + k] = pro + prov, x[j + k + i] = pro - prov;
}
}
void UFWT(long long *x, long long y) {
for (long long i = 1; i < y; i <<= 1)
for (long long j = 0; j < y; j += (i << 1))
for (long long k = 0; k < i; k++) {
long long pro = x[j + k], prov = x[j + k + i];
x[j + k] = (pro + prov) / 2, x[j + k + i] = (pro - prov) / 2;
}
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= n; j++) num[i] = (num[i] << 1) | (s[j][i] - '0');
for (long long i = 1; i <= m; i++) a[num[i]]++;
for (long long i = 0; i < (1 << n); i++) {
long long pro = i, prov = 0;
while (pro) {
if (pro & 1) prov++;
pro >>= 1;
}
prov = min(prov, n - prov), b[i] = prov;
}
FWT(a, 1 << n), FWT(b, 1 << n);
for (long long i = 0; i < (1 << n); i++) a[i] *= b[i];
UFWT(a, 1 << n), ans = n * m;
for (long long i = 0; i < (1 << n); i++) ans = min(ans, a[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1e5 + 5, MAXN = 21, MAXL = 1 << MAXN;
namespace FWT {
void Xor(long long* f, int Lim, int type) {
for (int k = 1, Mid = 2; Mid <= Lim; Mid <<= 1, k <<= 1)
for (int i = 0; i < Lim; i += Mid)
for (int j = 0; j < k; ++j) {
long long f0 = f[i + j], f1 = f[i + j + k];
f[i + j] = f0 + f1, f[i + j + k] = f0 - f1;
if (type < 0) f[i + j] /= 2, f[i + j + k] /= 2;
}
}
} // namespace FWT
int n, m;
long long f[MAXL], g[MAXL];
int A[MAXN][MAXM], B[MAXM];
inline int lowbit(int x) { return x & -x; }
inline int count1(int x) {
int ret = 0;
while (x > 0) ++ret, x -= lowbit(x);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%1d", A[i] + j);
for (int j = 0; j < m; ++j)
for (int i = 0; i < n; ++i) B[j] = (B[j] << 1) + A[i][j];
int Lim = 1 << n;
for (int s = 0; s < Lim; ++s) {
int res = count1(s);
f[s] = min(n - res, res);
}
for (int j = 0; j < m; ++j) ++g[B[j]];
FWT::Xor(f, Lim, 1), FWT::Xor(g, Lim, 1);
for (int i = 0; i < Lim; ++i) f[i] = f[i] * g[i];
FWT::Xor(f, Lim, -1);
long long ans = f[0];
for (int s = 1; s < Lim; ++s) ans = min(ans, f[s]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fwt(long long* a, long long L) {
for (long long i = 2; i <= L; i <<= 1)
for (long long j = 0; j < L; j += i)
for (long long k = j; k < j + (i >> 1); ++k) {
long long x = a[k] + a[k + (i >> 1)];
long long y = a[k] - a[k + (i >> 1)];
a[k] = x;
a[k + (i >> 1)] = y;
}
}
void ifwt(long long* a, long long L) {
for (long long i = L; i >= 2; i >>= 1)
for (long long j = 0; j < L; j += i)
for (long long k = j; k < j + (i >> 1); ++k) {
long long x = a[k] + a[k + (i >> 1)];
long long y = a[k] - a[k + (i >> 1)];
a[k] = x / 2;
a[k + (i >> 1)] = y / 2;
}
}
long long n, m, s[100010], ct[1 << 20];
long long L, a[1 << 20], b[1 << 20], c[1 << 20];
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
for (long long j = 1; j <= m; ++j)
s[j] = s[j] << 1 | (c == '1'), c = getchar();
}
L = (1 << n);
for (long long i = 0; i <= L - 1; ++i)
for (long long j = 1; j <= n; ++j) ct[i] += (i >> j - 1 & 1);
for (long long i = 1; i <= m; ++i) b[s[i]]++;
fwt(b, L);
for (long long i = 0; i <= n; ++i) {
memset(a, 0, sizeof a);
for (long long j = 0; j <= L - 1; ++j)
if (ct[j] == i) a[j] = min(i, n - i);
fwt(a, L);
for (long long j = 0; j <= L - 1; ++j) a[j] = a[j] * b[j];
ifwt(a, L);
for (long long j = 0; j <= L - 1; ++j) c[j] += a[j];
}
long long ans = n * m;
for (long long i = 0; i <= L - 1; ++i) ans = min(ans, c[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, m;
int a[111111];
int a1[111111];
int a2[111111];
int nb[1 << 20];
const int N1 = 13;
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 i = (0); i < (m); i++) a1[i] = a[i] & fn1, a2[i] = a[i] >> n1;
for (int m1 = (0); m1 < (1 << n1); m1++) {
memset(c, 0, sizeof c);
for (int j = (0); j < (m); j++) c[nb[a1[j] ^ m1]][a2[j]]++;
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 long long N = 20, M = 998244353, Inv = M / 2 + 1;
long long n, m, cnt[1 << N], g[1 << N];
char s[N][1 << N];
inline void fwt(long long y[], long long m, long long opt) {
for (long long i = 1; i < 1 << m; i <<= 1)
for (long long j = 0, p = i << 1; j < 1 << m; j += p)
for (long long k = j; k < j + i; k++) {
long long u = y[k], v = y[k + i];
y[k] = u + v;
if (y[k] >= M) y[k] -= M;
y[k + i] = u - v;
if (y[k + i] < 0) y[k + i] += M;
if (opt == -1) y[k] = (y[k] * Inv) % M, y[k + i] = (y[k + i] * Inv) % M;
}
}
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 0; i < n; i++) scanf("%s", s[i]);
for (long long i = 0; i < m; i++) {
long long val = 0;
for (long long j = 0; j < n; j++)
if (s[j][i] == '1') val += 1 << j;
cnt[val]++;
}
for (long long i = 0; i < 1 << n; i++) {
long long cnt = 0;
for (long long j = 0; j < n; j++)
if ((1 << j) & i) cnt++;
g[i] = min(cnt, n - cnt);
}
fwt(cnt, n, 1);
fwt(g, n, 1);
for (long long i = 0; i < 1 << n; i++) (cnt[i] *= g[i]) %= M;
fwt(cnt, n, -1);
long long ans = 1e9;
for (long long i = 0; i < 1 << n; i++) ans = min(ans, cnt[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 20 + 1;
int n, m, a[N], dp[(1 << 20)][M];
long long ans;
void input() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char ch;
cin >> ch;
bool x = ch - '0';
a[j] += (1 << i) * x;
}
}
}
void solve() {
for (int i = 0; i < m; i++) dp[a[i]][0]++;
for (int i = 0; i < n; i++)
for (int j = n; j; j--)
for (int mask = 0; mask < (1 << n); mask++)
dp[mask][j] += dp[mask ^ (1 << i)][j - 1];
ans = 1e18;
for (int mask = 0; mask < (1 << n); mask++) {
long long res = 0;
for (long long i = 0; i <= n; i++) res += min(i, n - i) * dp[mask][i];
ans = min(ans, res);
}
}
void output() { cout << ans << "\n"; }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input();
solve();
output();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 21, N = 2e6 + 7;
int n, m;
int t[N];
int dp[1048576 + 7][2][21];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
t[j] *= 2;
if (c == '1') t[j] += 1;
}
for (int j = 0; j < m; j++) dp[t[j]][0][0]++;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int msk = 0; msk < (1 << n); msk++) {
dp[msk][i % 2][j] = dp[msk][(i - 1) % 2][j];
if (j > 0)
dp[msk][i % 2][j] += dp[(msk ^ (1 << (i - 1)))][(i - 1) % 2][j - 1];
}
int mn = m * n, res;
for (int msk = 0; msk < (1 << n); msk++) {
int tmp = 0;
for (int j = 0; j <= n; j++) {
tmp += dp[msk][n % 2][j] * min(j, n - j);
}
if (tmp < mn) {
mn = tmp;
res = msk;
}
}
cout << mn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 21, maxmask = 1 << MX, MN = 1e5 + 10;
int dp[MX][maxmask];
int msk[MN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '1') msk[j] += (1 << i);
}
}
for (int i = 0; i < m; i++) {
dp[0][msk[i]]++;
}
for (int i = 1; i <= n; i++) {
for (int k = i; k > 0; k--) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[k][mask] += dp[k - 1][mask ^ (1 << (i - 1))];
}
}
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int k = 0;
for (int i = 0; i <= n; i++) {
k += min(i, n - i) * dp[i][mask];
}
ans = min(ans, k);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N, M;
re(N, M);
vs grid(N);
re(grid);
vvi diff(N + 1, vi(1 << N));
for (int j = 0; j < (M); j++) {
int col = 0;
for (int i = 0; i < (N); i++)
if (grid[i][j] - '0') col ^= 1 << i;
diff[0][col]++;
}
for (int d = (1); d < (int((diff).size())); d++)
for (int m = 0; m < (1 << N); m++) {
for (int i = 0; i < (N); i++) diff[d][m] += diff[d - 1][m ^ (1 << i)];
if (d >= 2) diff[d][m] -= (N - (d - 2)) * diff[d - 2][m];
diff[d][m] /= d;
}
int ans = INT_MAX;
for (int m = 0; m < (1 << N); m++) {
int cand = 0;
for (int d = 0; d < (N + 1); d++) cand += min(d, N - d) * diff[d][m];
ckmin(ans, cand);
}
ps(ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.