text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1 << 20 | 1;
int n, m;
char s0[MX];
int a[MX][21];
long long F[MX], G[MX];
void FWT(long long a[], int n) {
long long x, y;
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += (i << 1))
for (int k = j; k < j + i; k++)
x = a[k + i], y = a[k], a[k] = y + x, a[k + i] = y - x;
}
void NFWT(long long a[], int n) {
long long x, y;
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += (i << 1))
for (int k = j; k < j + i; k++)
x = a[k + i], y = a[k], a[k] = (y + x) >> 1, a[k + i] = (y - x) >> 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s0);
for (int j = 0; j < m; j++) a[j][i] = s0[j] - '0';
}
for (int i = 0; i < m; i++) {
int tmp = 0;
for (int j = 0; j < n; j++) tmp |= (a[i][j] << j);
F[tmp]++;
}
for (int i = 0; i < (1 << n); i++) {
int tmp = i, res = 0;
while (tmp) {
res += tmp & 1;
tmp >>= 1;
}
G[i] = min(res, n - res);
}
FWT(F, 1 << n);
FWT(G, 1 << n);
for (int i = 0; i < (1 << n); i++) F[i] *= G[i];
NFWT(F, 1 << n);
long long ans = 0x3f3f3f3f3f3f3f3fLL;
for (int i = 0; i < (1 << n); i++) ans = min(ans, F[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 20 + 2, M = 1e5 + 10, MASK = (1 << 20) + 20;
int n, m, a[M], dp[N][MASK], sum[2][MASK], ans = 1e17;
string s[N];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
a[i] += (1 << j) * (s[j][i] == '1');
}
}
for (int i = 0; i < m; i++) {
dp[0][a[i]]++;
sum[0][a[i]]++;
}
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1 << n); mask++) {
for (int p = 0; p < n; p++) {
dp[i][mask] += sum[(i - 1) & 1][mask ^ (1 << p)] - sum[i & 1][mask];
}
dp[i][mask] /= i;
sum[i & 1][mask] += dp[i][mask];
}
}
for (int mask = 0; mask < (1 << n); mask++) {
int res = 0;
for (int i = 0; i <= n; i++) {
res += min(i, n - i) * dp[i][mask];
}
ans = min(ans, res);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void judge() {
freopen("array.in", "r", stdin);
freopen("array.out", "w", stdout);
}
const int N = 21, inf = 1e9;
int ans = inf, f[N][1 << N], n, m, a[N][110000];
char s[110000];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (register int i = 1; i <= n; i++) {
cin >> s + 1;
for (register int j = 1; j <= m; j++) a[i][j] = s[j] - '0';
}
int Num = (1 << n) - 1;
for (register int i = 1; i <= m; i++) {
int s = 0;
for (register int j = 1; j <= n; j++)
if (a[j][i] == 1) s += (1 << (j - 1));
f[0][s]++;
}
for (register int i = 1; i <= n; i++) {
for (register int j = n; j; j--) {
for (register int s = 0; s <= Num; s++)
f[j][s] += f[j - 1][s ^ (1 << (i - 1))];
}
}
for (register int s = 0; s <= Num; s++) {
int t = 0;
for (register int i = 1; i <= n; i++) t += min(i, n - i) * f[i][s];
ans = min(t, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 10;
using namespace std;
int n, m;
class Fwt {
public:
void fwt(long long *a, int n, int on) {
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;
if (on < 0) {
a[i + j] >>= 1;
a[i + j + d] >>= 1;
}
}
}
}
}
void work(long long *a, long long *b, int n) {
fwt(a, n, 1);
fwt(b, n, 1);
for (int i = 0; i < n; i++) a[i] *= b[i];
fwt(a, n, -1);
}
} huchifwt;
char s[maxn];
long long dp[(1 << 20) + 5], num[(1 << 20) + 5], a[maxn];
int cal(int x) {
int ans = 0;
for (; x; x >>= 1) ans += (x & 1);
return ans;
}
int main() {
scanf("%d%d", &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++) num[a[i]]++;
for (int i = 0; i < (1 << n); i++) {
int ans = cal(i);
dp[i] = min(ans, n - ans);
}
huchifwt.work(dp, num, 1 << n);
long long ans = 1e18;
for (int i = 0; i < (1 << n); i++) {
ans = min(ans, dp[i]);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 100;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
long long qpow(long long base, int t) {
long long ret = 1;
while (t) {
if (t & 1) ret = ret * base % mod;
base = base * base % mod;
t >>= 1;
}
return ret;
}
void FWT(long long* a, int n, int op) {
for (int len = 1; len < n; len <<= 1) {
for (int i = 0; i < n; i += len * 2) {
for (int j = i; j < i + len; j++) {
long long x = a[j], y = a[j + len];
a[j] = (x + y);
a[j + len] = (x - y);
if (op == -1) a[j] /= 2, a[j + len] /= 2;
}
}
}
}
long long b[maxn], a[maxn];
long long d[maxn];
char s[maxn];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
int tot = 1 << n;
for (int i = 0; i < tot; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if ((i & (1 << j)) == 0) cnt++;
d[i] = min(cnt, n - cnt);
}
memset(a, 0, sizeof a);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int i = 0; s[i]; i++) a[i] = a[i] * 2 + s[i] - '0';
}
for (int i = 0; i < m; i++) b[a[i]]++;
FWT(d, tot, 1);
FWT(b, tot, 1);
for (int i = 0; i < tot; i++) d[i] *= b[i];
FWT(d, tot, -1);
long long ans = n * m;
for (int i = 0; i < tot; i++) ans = min(ans, d[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
char S[25][100005];
int Nb[100005];
int DP[25][(1 << 20) + 5];
void Read() {
cin >> N >> M;
cin.get();
for (int i = 1; i <= N; i++) {
cin.getline(S[i] + 1, 100005);
}
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= N; j++) Nb[i] = Nb[i] * 2 + S[j][i] - '0';
DP[0][Nb[i]]++;
}
}
void precalcDP() {
for (int k = 1; k <= N; k++) {
for (int conf = 0; conf < (1 << N); conf++) {
if (k >= 2) DP[k][conf] = (k - 2 - N) * DP[k - 2][conf];
for (int i = 0; i < N; i++) {
DP[k][conf] += DP[k - 1][conf ^ (1 << i)];
}
DP[k][conf] /= k;
}
}
}
void getAns() {
int ans = N * M;
for (int i = 0; i < (1 << N); i++) {
int val = 0;
for (int j = 0; j <= N; j++) val += min(j, N - j) * DP[j][i];
ans = min(ans, val);
}
cout << ans << "\n";
}
int main() {
Read();
precalcDP();
getAns();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000005;
int D, N, M, a[MAXN];
char S[MAXN];
long long f[MAXN], g[MAXN], ans = 2147483647;
void FWT(long long* f, int X) {
for (int l = 2; l <= N; l <<= 1)
for (int i = 0; i < N; i += l)
for (int j = 0; j < (l >> 1); ++j) {
long long x = f[i + j], y = f[i + j + (l >> 1)];
f[i + j] = x + y, f[i + j + (l >> 1)] = x - y;
if (X == -1) f[i + j] /= 2, f[i + j + (l >> 1)] /= 2;
}
}
int main() {
scanf("%d%d", &D, &M), N = 1 << D;
int cnt;
for (int i = 0; i < D; ++i) {
scanf("%s", S);
for (int j = 0; j < M; ++j)
if (S[j] == '1') a[j] |= 1 << i;
}
for (int i = 0; i < M; ++i) ++f[a[i]];
for (int i = 0; i < N; ++i)
cnt = __builtin_popcount(i), g[i] = min(cnt, D - cnt);
FWT(f, 1), FWT(g, 1);
for (int i = 0; i < N; ++i) f[i] = f[i] * g[i];
FWT(f, -1);
for (int i = 0; i < N; ++i) ans = min(ans, f[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 21;
const int maxm = 100010;
const int inf = 1e9;
int n, m, ans = inf;
int a[maxm], size[1 << maxn];
long long f[1 << maxn], g[1 << maxn];
char s[maxm];
inline int read() {
char c = getchar();
int res = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') res = res * 10 + c - '0', c = getchar();
return res * f;
}
inline void FWT(long long *a, int n, int op) {
for (int l = 1; l < (1 << n); l <<= 1)
for (int i = 0; i < (1 << n); i += l << 1)
for (int j = 0; j < l; j++) {
long long x = a[i + j], y = a[i + l + j];
if (~op)
a[i + j] = x + y, a[i + l + j] = x - y;
else
a[i + j] = (x + y) >> 1, a[i + l + j] = (x - y) >> 1;
}
}
signed main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++)
if (s[j] == '1') a[j] |= 1 << i - 1;
}
for (int i = 1; i <= m; i++) f[a[i]]++;
for (int i = 0; i < (1 << n); i++) size[i] = size[i >> 1] + (i & 1);
for (int i = 0; i < (1 << n); i++) g[i] = min(size[i], n - size[i]);
FWT(f, n, 1);
FWT(g, n, 1);
for (int i = 0; i < (1 << n); i++) f[i] *= g[i];
FWT(f, n, -1);
for (int i = 0; i < (1 << n); i++) ans = min(ans, (int)f[i]);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[2000005], g[2000005], res[2000005];
char str[25][100005];
namespace FWT {
void fwt(long long *arr, int n, bool inv = false) {
for (int len = 1; len < n; len <<= 1) {
for (int i = 0; i < n; i += len << 1) {
for (int j = i; j < i + len; j++) {
long long x = arr[j], y = arr[j + len];
arr[j] = (x + y) / (inv + 1);
arr[j + len] = (x - y) / (inv + 1);
}
}
}
}
void mul(long long *a, long long *b, long long *res, int n) {
fwt(a, n);
fwt(b, n);
for (int i = 0; i < n; i++) res[i] = a[i] * b[i];
fwt(res, n, true);
}
} // namespace FWT
inline int cnt(int x) {
int res = 0;
while (x) {
x &= x - 1;
res++;
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
for (int i = 0; i < m; i++) {
int num = 0;
for (int j = 0; j < n; j++) num = num << 1 | str[j][i] - '0';
f[num]++;
}
for (int i = 0; i < 1 << n; i++) g[i] = min(cnt(i), n - cnt(i));
FWT::mul(f, g, res, 1 << n);
long long ans = 1e18;
for (int i = 0; i < 1 << n; i++) ans = min(ans, res[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
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 solve(long long a[], long long b[], int n) {
FWT(a, n);
FWT(b, n);
for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i];
UFWT(a, n);
}
long long a[N], b[N], c[N];
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int mx = (1 << n);
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
c[j] = (c[j] << 1) + s[j] - '0';
}
}
for (int i = 0; i < m; i++) {
a[c[i]]++;
}
for (int i = 0; i < mx; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) cnt++;
b[i] = min(n - cnt, cnt);
}
solve(a, b, mx);
long long ans = 1e18;
for (int i = 0; i < mx; i++) ans = min(ans, a[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[20][100005];
int cnt[1 << 20];
int dp[2][1 << 20][21];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int j = 0; j < m; j++) {
int mask = 0;
for (int i = 0; i < n; i++)
if ((s[i][j] - '0')) mask |= (1 << i);
cnt[mask]++;
}
for (int mask = 0; mask < (1 << n); mask++) dp[0][mask][0] = cnt[mask];
for (int i = 1; i <= n; i++) {
int cur = i & 1;
int prev = (1 - cur);
for (int mask = 0; mask < (1 << n); mask++) {
for (int j = 0; j <= i; j++) {
dp[cur][mask][j] = 0;
if (j > 0) dp[cur][mask][j] += dp[prev][mask ^ (1 << (i - 1))][j - 1];
dp[cur][mask][j] += dp[prev][mask][j];
}
}
}
int ans = 10000000;
for (int mask = 0; mask < (1 << n); mask++) {
int res = 0;
for (int diff = 0; diff <= n; diff++)
res += dp[n & 1][mask][diff] * min(diff, (n - diff));
ans = min(ans, res);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 100;
const int NN = 20 + 3;
int dp[2][NN][N];
string s[NN];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int h = 0;
for (int i = 0, x; i < m; i++) {
x = 0;
for (int j = 0; j < n; j++) {
x = x * 2 + s[j][i] - '0';
}
dp[h][0][x]++;
}
for (int i = 0; i < n; i++) {
h = 1 - h;
for (int k = 0; k <= i + 1; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[h][k][mask] = dp[1 - h][k][mask];
if (k != 0) {
dp[h][k][mask] += dp[1 - h][k - 1][mask ^ (1 << i)];
}
}
}
}
long long ans = 1LL * n * m;
for (int mask = 0; mask < (1 << n); mask++) {
long long tmp = 0;
for (int j = 0; j <= n; j++) {
tmp += 1LL * dp[h][j][mask] * min(j, n - j);
}
ans = min(ans, tmp);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 2e5 + 5;
int dp[21][1 << 20], n, m, a[N], x, y, z, t, p;
char c;
char get() {
c = getchar();
while (c > '1' || c < '0') c = getchar();
return c;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c = get();
if (c == '1') a[j] |= (1 << i - 1);
}
}
int res = inf;
for (int i = 1; i <= m; i++) dp[0][a[i]]++;
int all = (1 << n);
for (int i = 0; i < n; i++)
for (int diff = n; diff >= 1; diff--)
for (int j = 0; j < all; j++) {
dp[diff][j] += dp[diff - 1][(1 << i) ^ j];
}
for (int i = 0; i <= (1 << n) - 1; i++) {
int ans = 0;
for (int j = 0; j <= n; j++) ans += dp[j][i] * min(j, n - j);
res = min(res, ans);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
char buf[N];
vector<long long> conv(const vector<long long>& v1,
const vector<long long>& v2) {
if (v1.size() == 1 && v2.size() == 1) return {v1[0] * v2[0]};
vector<long long> a1(v1.begin(), v1.begin() + v1.size() / 2);
vector<long long> b1(v1.begin() + v1.size() / 2, v1.end());
vector<long long> a2(v2.begin(), v2.begin() + v2.size() / 2);
vector<long long> b2(v2.begin() + v2.size() / 2, v2.end());
vector<long long> sum1(a1.size()), dif1(a1.size());
for (int i = 0; i < a1.size(); i++)
sum1[i] = a1[i] + b1[i], dif1[i] = a1[i] - b1[i];
vector<long long> sum2(a2.size()), dif2(a2.size());
for (int i = 0; i < a2.size(); i++)
sum2[i] = a2[i] + b2[i], dif2[i] = a2[i] - b2[i];
vector<long long> sum = conv(sum1, sum2);
vector<long long> dif = conv(dif1, dif2);
vector<long long> res(v1.size());
for (int i = 0; i < sum.size(); i++) {
res[i] = (sum[i] + dif[i]);
res[i + res.size() / 2] = (sum[i] - dif[i]);
}
return res;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<long long> G(1 << n);
vector<long long> P(1 << n);
for (int i = 1; i < (1 << n); i++) P[i] = 1 + P[i & (i - 1)];
for (int i = 0; i < (1 << n); i++) G[i] = min(P[i], n - P[i]);
vector<long long> A(m);
vector<long long> F(1 << n);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
for (int j = 0; j < m; j++) {
if (buf[j] == '1') A[j] |= (1 << i);
}
}
for (int x : A) F[x]++;
vector<long long> res = conv(F, G);
long long ans = *min_element(res.begin(), res.end());
printf("%lld\n", ans >> n);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char a[22][100002];
int f[21][(1 << 20) + 1];
int main() {
scanf("%d%d", &n, &m);
ans = 1e9;
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) tmp = tmp * 2 + a[j][i] - '0';
f[0][tmp]++;
}
for (int i = 0; i <= n - 1; i++)
for (int j = n; j; j--)
for (int k = 0; k <= (1 << n) - 1; k++) f[j][k] += f[j - 1][k ^ (1 << i)];
for (int k = 0; k <= (1 << n) - 1; k++) {
int tmp = 0;
for (int i = 0; i <= n; i++) tmp += min(i, n - i) * f[i][k];
ans = min(ans, tmp);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100001];
int N, n, m;
long long a[1 << 20], b[1 << 20];
int g[21][100001];
void FWT(long long p[], int flag) {
int temp = N;
for (int i = 2; i <= temp; i *= 2) {
int t = i / 2;
for (int j = 0; j < temp; j += i) {
for (int k = j; k < j + t; k++) {
long long x = p[k];
long long y = p[k + t];
p[k] = x + y;
p[k + t] = x - y;
if (flag == -1) {
p[k] /= 2;
p[k + t] /= 2;
}
}
}
}
}
int main() {
cin >> n >> m;
N = 1 << n;
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; j++) {
g[i][j] = ch[j] - '0';
}
}
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++) {
x = (x * 2) | g[j][i];
}
a[x]++;
}
for (int i = 0; i < N; ++i) b[i] = b[i >> 1] + (i & 1);
for (int i = 0; i < N; ++i) b[i] = min(b[i], n - b[i]);
FWT(a, 1);
FWT(b, 1);
for (int i = 0; i < N; ++i) a[i] *= b[i];
FWT(a, -1);
long long ans = n * m;
for (int i = 0; i < N; ++i) ans = min(ans, a[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 20;
const int MAXM = 100010;
int n, m;
long long A[1 << MAXN], B[1 << MAXN];
char buf[MAXN][MAXM];
void FWT(long long* A) {
const int lim = 1 << n;
for (int mid = 1; mid != lim; mid <<= 1)
for (int k = 0; k != lim; k += mid << 1)
for (int l = 0; l != mid; ++l) {
const long long X = A[l + k], Y = A[l + k + mid];
A[l + k] = X + Y;
A[l + k + mid] = X - Y;
}
}
int main() {
scanf("%d%d", &n, &m);
const int lim = 1 << n;
for (int i = 0; i != n; ++i) scanf("%s", buf[i]);
for (int i = 0; i != m; ++i) {
int vec = 0;
for (int j = 0; j != n; ++j) vec |= buf[j][i] - '0' << j;
++A[vec];
}
for (int i = 0; i != lim; ++i) {
const int ppc = __builtin_popcount(i);
B[i] = std::min(ppc, n - ppc);
}
FWT(A);
FWT(B);
for (int i = 0; i != lim; ++i) A[i] *= B[i];
FWT(A);
long long ans = 0x3f3f3f3f3f3f3f3fLL;
for (int i = 0; i != lim; ++i) ans = std::min(ans, A[i] >> n);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[21][1 << 20];
char grid[21][100005];
int colMask[100005];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", grid + i);
for (int j = 0; j < m; j++) {
colMask[j] |= (grid[i][j] - '0') << i;
}
}
for (int i = 0; i < m; i++) dp[0][colMask[i]]++;
for (int bitCnt = 1; bitCnt <= n; bitCnt++)
for (int mask = 0; mask < (1 << n); mask++) {
int sum = bitCnt == 1 ? 0 : (bitCnt - 2 - n) * dp[bitCnt - 2][mask];
for (int x = 0; x < n; x++) sum += dp[bitCnt - 1][mask ^ (1 << x)];
dp[bitCnt][mask] = sum / bitCnt;
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int cnt = 0;
for (int bitCnt = 0; bitCnt <= n; bitCnt++)
cnt += min(bitCnt, (n - bitCnt)) * dp[bitCnt][mask];
ans = min(ans, cnt);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || '9' < ch) f |= ch == '-', ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int n, m, k[100009], g[1 << 20];
long long f[21][1 << 20];
char s[100009];
inline void fwt(long long *f) {
long long x, y;
for (int i = 0; i <= n - 1; i++)
for (int S = 0; S <= (1 << n) - 1; S++)
if (S & (1 << i))
x = f[S - (1 << i)], y = f[S], f[S - (1 << i)] = x + y, f[S] = x - y;
}
int main() {
n = read(), m = read();
for (int i = 0; i <= n - 1; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) k[j] += (s[j] - '0') << i;
}
for (int j = 1; j <= m; j++) f[0][k[j]]++;
for (int S = 1; S <= (1 << n) - 1; S++)
g[S] = g[S - (S & -S)] + 1, f[g[S]][S] = 1;
for (int i = 0; i <= n; i++) fwt(f[i]);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= (1 << n) - 1; j++) f[i][j] *= f[0][j];
for (int i = 0; i <= n; i++) fwt(f[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= (1 << n) - 1; j++) f[i][j] /= (1 << n);
int A = 0x3fffffff;
for (int S = 0; S <= (1 << n) - 1; S++) {
int a = 0;
for (int i = 0; i <= n; i++) a += min(i, n - i) * f[i][S];
A = min(A, a);
}
printf("%d\n", A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 1e5 + 5;
int n, m;
int col[M], bit[1 << 12], cnt[13][1 << 8];
char s[N][M];
int main() {
for (int i = 1; i < (1 << 12); i++) bit[i] = bit[i - (i & -i)] + 1;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++)
if (s[i][j] == '1') col[j] |= 1 << i;
}
int l = min(n, 12);
int r = n - l;
int ans = 1e9;
for (int i = 0; i < (1 << l); i++) {
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < m; j++) {
int v1 = col[j] & ((1 << l) - 1);
int v2 = col[j] >> l;
cnt[bit[i ^ v1]][v2]++;
}
for (int j = 0; j < (1 << r); j++) {
int res = 0;
for (int mask = 0; mask < (1 << r); mask++) {
for (int c = 0; c <= l; c++) {
int val = bit[mask ^ j] + c;
res += min(val, n - val) * cnt[c][mask];
}
}
ans = min(ans, res);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 20;
long long a[MAXN], b[MAXN], c[MAXN];
char s[20][100010];
void FWT_XOR(long long a[], int n, bool f) {
for (int h = 2, l = 1; h <= n; h <<= 1, l <<= 1) {
for (int i = 0; i < n; i += h) {
for (int j = 0; j < l; ++j) {
long long x = a[i + j], y = a[i + j + l];
a[i + j] = x + y;
a[i + j + l] = x - y;
if (f) a[i + j] >>= 1, c[i + j + l] >>= 1;
}
}
}
}
void Convolution_XOR(long long a[], long long b[], long long c[], int n) {
FWT_XOR(a, n, 0);
FWT_XOR(b, n, 0);
for (int i = 0; i < n; ++i) c[i] = a[i] * b[i];
FWT_XOR(c, n, 1);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int j = 0; j < m; ++j) {
int mask = 0;
for (int i = 0; i < n; ++i)
if (s[i][j] == '1') mask |= 1 << i;
b[mask]++;
}
for (int i = 0; i < (1 << n); ++i)
a[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
Convolution_XOR(a, b, c, 1 << n);
long long ans = 1e9;
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 N = 20, M = (1 << 20);
int n, m, a[M];
int dp[N][M];
void init() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
a[j] += ((s[j] - '0') * ((1 << i)));
}
}
return;
}
void calc() {
for (int i = 0; i < m; i++) {
dp[0][a[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = n; j; j--) {
for (int msk = 0; msk < (1 << n); msk++) {
dp[j][msk] += dp[j - 1][msk ^ (1 << i)];
}
}
}
return;
}
void ans() {
int ret = 1e9;
for (int msk = 0; msk < (1 << n); msk++) {
int now = 0;
for (int i = 0; i <= n; i++) now += min(i, n - i) * dp[i][msk];
ret = min(ret, now);
}
cout << ret;
return;
}
int main() {
init();
calc();
ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21, MASK = 1 << N;
int dp[N][MASK], n, m, ans;
string s[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int j = 0; j < m; j++) {
int tmp = 0;
for (int i = 0; i < n; i++) tmp += (1 << i) * (s[i][j] - '0');
dp[0][tmp]++;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j; j--)
for (int mask = 0; mask < 1 << n; mask++)
dp[j][mask] += dp[j - 1][mask ^ (1 << i - 1)];
}
ans = n * m;
for (int mask = 0; mask < 1 << n; mask++) {
int tmp = 0;
for (int i = 0; i <= n; i++) tmp += min(i, n - i) * dp[i][mask];
ans = min(ans, tmp);
}
return cout << ans << "\n", 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAXN = 1000006;
char S[20][MAXN];
int W[MAXN * 2];
int dp[11][1 << 20];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%s", S[i]);
int qs = 0;
int BIG = 1 << n;
for (int i = 0; i < (m); ++i) {
int e = 0;
for (int j = 0; j < (n); ++j)
if (S[j][i] == '1') e |= 1 << j;
W[qs++] = e;
W[qs++] = e ^ (BIG - 1);
}
for (int i = 0; i < (2 * m); ++i) dp[0][W[i]]++;
for (int bit = 0; bit < (n); ++bit)
for (int k = 9; k >= 0; --k)
for (int mask = 0; mask < (BIG); ++mask)
dp[k + 1][mask] += dp[k][mask ^ (1 << bit)];
int ret = m * n;
for (int mask = 0; mask < (BIG); ++mask) {
int t = 0;
for (int i = 0; i < (n / 2); ++i) t += dp[i][mask] * i;
t += dp[n / 2][mask] * (n / 2) / (n % 2 == 0 ? 2 : 1);
ret = min(ret, t);
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100001];
int N, n, m;
long long a[1 << 20], b[1 << 20];
int g[21][100001];
void FWT(long long p[], int flag) {
int temp = N;
for (int i = 2; i <= temp; i *= 2) {
int t = i / 2;
for (int j = 0; j < temp; j += i) {
for (int k = j; k < j + t; k++) {
long long x = p[k];
long long y = p[k + t];
p[k] = x + y;
p[k + t] = x - y;
if (flag == -1) {
p[k] /= 2;
p[k + t] /= 2;
}
}
}
}
}
int main() {
cin >> n >> m;
N = 1 << n;
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; j++) {
g[i][j] = ch[j] - '0';
}
}
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++) {
x = (x * 2) | g[j][i];
}
a[x]++;
}
for (int i = 0; i < N; ++i) b[i] = b[i >> 1] + (i % 2);
for (int i = 0; i < N; ++i) b[i] = min(b[i], n - b[i]);
FWT(a, 1);
FWT(b, 1);
for (int i = 0; i < N; ++i) a[i] *= b[i];
FWT(a, -1);
long long ans = n * m;
for (int i = 0; i < N; ++i) ans = min(ans, a[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 20 + 5, MaxM = 100000 + 5;
const int MaxV = 2000000 + 5;
const int Mod = 998244353, inv2 = 499122177;
const int INF = 0x7F7F7F7F;
int N, M;
int A[MaxN][MaxM];
int X[MaxV], Y[MaxV], Z[MaxV];
inline int add(int x, int y) { return (x += y) >= Mod ? x - Mod : x; }
inline int sub(int x, int y) { return (x -= y) < 0 ? x + Mod : x; }
inline int mul(int x, int y) { return 1LL * x * y % Mod; }
inline int getDigit() {
char c;
do c = getchar();
while (c < '0' || c > '9');
return c - '0';
}
void init() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) A[i][j] = getDigit();
}
inline int Count(int S) {
int cnt = 0;
while (S) {
cnt++;
S -= (S & -S);
}
return cnt;
}
inline void FWT(int a[], int n) {
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += (i << 1))
for (int k = 0; k < i; ++k) {
int lson = a[j + k], rson = a[i + j + k];
a[j + k] = add(lson, rson);
a[i + j + k] = sub(lson, rson);
}
}
inline void IFWT(int a[], int n) {
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += (i << 1))
for (int k = 0; k < i; ++k) {
int lson = a[j + k], rson = a[i + j + k];
a[j + k] = mul(add(lson, rson), inv2);
a[i + j + k] = mul(sub(lson, rson), inv2);
}
}
void solve() {
for (int i = 1; i <= M; ++i) {
int S = 0;
for (int j = 1; j <= N; ++j) S |= (A[j][i] << (j - 1));
X[S]++;
}
for (int S = 0; S < (1 << N); ++S) Y[S] = min(Count(S), N - Count(S));
FWT(X, 1 << N);
FWT(Y, 1 << N);
for (int i = 0; i < (1 << N); ++i) Z[i] = mul(X[i], Y[i]);
IFWT(Z, 1 << N);
int ans = INF;
for (int i = 0; i < (1 << N); ++i) ans = min(ans, Z[i]);
cout << ans << endl;
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "Possible" : "Impossible");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
}
void et() {
puts("-1");
exit(0);
}
inline void FWT_xor(long long *A, const int fla, int length) {
for (int i = 1; i < length; i <<= 1)
for (int j = 0; j < length; 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 (fla == -1) {
A[j + k] /= 2;
A[j + k + i] /= 2;
}
}
}
const int MN = 1 << 20;
char s[20][100055];
long long cnt[MN], A[MN], B[MN], pc[MN], dp[21][MN];
void fmain() {
scanf("%d%d", &n, &m);
int N = 1 << n;
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%s", s[i]);
}
for (int(j) = 0; (j) < (int)(m); (j)++) {
int x = 0;
for (int(i) = 0; (i) < (int)(n); (i)++)
if (s[i][j] == '1') x += 1 << i;
cnt[x]++;
}
for (int(i) = 0; (i) < (int)(N); (i)++) {
A[i] = cnt[i];
pc[i] = __builtin_popcount(i);
}
FWT_xor(A, 1, N);
for (int(i) = 0; (i) < (int)(n + 1); (i)++) {
for (int(j) = 0; (j) < (int)(N); (j)++) B[j] = (pc[j] == i) ? 1 : 0;
FWT_xor(B, 1, N);
for (int(j) = 0; (j) < (int)(N); (j)++) B[j] = A[j] * B[j];
FWT_xor(B, -1, N);
for (int(j) = 0; (j) < (int)(N); (j)++) dp[i][j] = B[j];
}
int ans = (1 << 30);
for (int(j) = 0; (j) < (int)(N); (j)++) {
int tt = 0;
for (int(i) = 0; (i) < (int)(n + 1); (i)++) {
tt += dp[i][j] * min(i, n - i);
}
ans = min(ans, tt);
}
printf("%d\n", ans);
}
int main() {
fmain();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 1e5 + 10, MAXlg = 22, MAXx = (1 << 20) + 10, lg = 20,
x = (1 << 21);
int dp[MAXx][MAXlg], n, m, cnt, ar2[MAXlg];
char ar[MAXlg][MAXn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> ar[i][j];
}
for (int i = 0; i < m; i++) {
int hp = 0, hp2 = 0;
for (int j = 0; j < n; j++) {
hp *= 2;
if (ar[j][i] - '0' != 0) {
hp++;
cnt++;
}
}
dp[hp][0]++;
}
for (int i = 0; i < n; i++)
for (int j = n; j >= 1; j--)
for (int y = 0; y < (1 << n); y++) dp[y][j] += dp[y ^ (1 << i)][j - 1];
for (int j = 0; j < (1 << n); j++) {
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += min(i, n - i) * dp[j][i];
}
cnt = min(cnt, ans);
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 10, N = 20 + 1;
char s[M];
int clm[M], dp[N][1 << N];
int n, m, cnt;
int toInt(char c) { return (int)(c - '0'); }
int main() {
ios_base::sync_with_stdio(false);
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++) clm[j] |= toInt(s[j]) << i;
}
for (int i = 0; i < m; i++) dp[0][clm[i]]++;
for (int k = 1; k <= n; k++)
for (int mask = 0; mask < (1 << n); mask++) {
int sum = 0;
if (k > 1) sum = (k - 2 - n) * dp[k - 2][mask];
for (int j = 0; j < n; j++) sum += dp[k - 1][mask ^ (1 << j)];
dp[k][mask] = sum / k;
}
cnt = m * n;
for (int mask = 0; mask < (1 << n); mask++) {
int tmp = 0;
for (int k = 0; k <= n; k++) tmp += min(k, n - k) * dp[k][mask];
cnt = min(cnt, tmp);
}
return cout << cnt, 0;
}
|
#include <bits/stdc++.h>
constexpr int N = 20;
int a[2][1 << N][N + 1];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n >> m;
std::vector<std::string> s(n);
for (int i = 0; i < n; ++i) std::cin >> s[i];
for (int i = 0; i < m; ++i) {
int x = 0;
for (int j = 0; j < n; ++j) x = 2 * x + s[j][i] - '0';
for (int j = 0; j <= n; ++j) a[0][x][j] += std::min(j, n - j);
}
int cur = 0;
int c = n;
for (int i = 1; i < (1 << n); i *= 2) {
cur ^= 1;
std::memset(a[cur], 0, sizeof(a[cur]));
for (int j = 0; j < (1 << n); j += 2 * i) {
for (int k = 0; k < i; ++k) {
for (int l = 0; l <= c; ++l) {
if (l < c) a[cur][j + k][l] += a[!cur][j + k][l];
if (l > 0) a[cur][i + j + k][l - 1] += a[!cur][j + k][l];
if (l > 0) a[cur][j + k][l - 1] += a[!cur][i + j + k][l];
if (l < c) a[cur][i + j + k][l] += a[!cur][i + j + k][l];
}
}
}
--c;
}
int ans = n * m;
for (int i = 0; i < (1 << n); ++i) ans = std::min(ans, a[cur][i][0]);
std::cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 20;
const int MAX_MASK = (1 << MAX_N);
int dp[2][MAX_MASK][MAX_N + 1];
void Clear(int id) {
for (int mask = 0; mask < MAX_MASK; ++mask) {
for (int i = 0; i <= MAX_N; ++i) {
dp[id][mask][i] = 0;
}
}
}
void Relax(int id) {
for (int mask = 0; mask < MAX_MASK; ++mask) {
for (int i = MAX_N - 1; i >= 0; --i) {
dp[id][mask][i] += dp[id][mask][i + 1];
}
}
}
int cost[MAX_MASK];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> a(n);
vector<int> masks(m);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int j = 0; j < m; ++j) {
masks[j] = 0;
for (int i = 0; i < n; ++i) {
if (a[i][j] == '1') {
masks[j] += (1 << i);
}
}
}
int curPtr = 0;
Clear(curPtr);
for (int j = 0; j < m; ++j) {
++dp[curPtr][masks[j]][n];
}
Relax(curPtr);
for (int k = 1; k <= n; ++k) {
int nxtPtr = 1 - curPtr;
Clear(nxtPtr);
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = n - 1; i >= 0; --i) {
int newMask = mask ^ (1 << i);
dp[nxtPtr][mask][i] += dp[curPtr][newMask][i + 1];
}
}
swap(curPtr, nxtPtr);
Relax(curPtr);
for (int mask = 0; mask < (1 << n); ++mask) {
cost[mask] += min(k, n - k) * dp[curPtr][mask][0];
}
}
int result = n * m;
for (int mask = 0; mask < (1 << n); ++mask) {
result = min(result, cost[mask]);
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num * flag;
}
int n, m;
long long ans = 0;
char s[22][100005];
long long A[1 << 22], B[1 << 22];
inline void FWT_xor(long long *a, int inv) {
for (int mid = 1; mid < n; mid <<= 1)
for (int j = 0, tmp = mid << 1; j < n; j += tmp)
for (int k = 0; k < mid; ++k) {
long long x = a[j + k], y = a[mid + j + k];
a[j + k] = x + y, a[mid + j + k] = x - y;
if (inv == -1) a[j + k] /= 2, a[mid + j + k] /= 2;
}
}
int main() {
n = getint(), m = getint();
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < m; i++) {
int tmp = 0;
for (int j = 0; j < n; j++) tmp |= (s[j][i] - 48) << j;
A[tmp]++;
}
for (int i = 0; i < (1 << n); i++) {
int tmp = i, num = 0;
while (tmp) num += tmp & 1, tmp >>= 1;
B[i] = min(num, n - num);
}
n = 1 << n;
FWT_xor(A, 1), FWT_xor(B, 1);
for (int i = 0; i < n; i++) A[i] *= B[i];
FWT_xor(A, -1);
ans = 0x3f3f3f3f3f3f3f3fll;
for (int i = 0; i < n; i++) ans = min(ans, A[i]);
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
const int MAXM = 100100;
char s[MAXN][MAXM];
int a[MAXM];
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); ++i) scanf("%s", s[i]);
for (int j = (0); j < (m); ++j) {
for (int i = (0); i < (n); ++i)
if (s[i][j] == '1') a[j] |= 1 << i;
}
static int f[MAXN + 1][1 << MAXN];
for (int i = (0); i < (m); ++i) f[0][a[i]]++;
for (int i = (0); i < (n); ++i)
for (int j = n - 1; j >= 0; --j)
for (int s = (0); s < (1 << n); ++s) f[j + 1][s ^ (1 << i)] += f[j][s];
static int ans[1 << MAXN];
for (int s = (0); s < (1 << n); ++s)
for (int j = (0); j < (n + 1); ++j) ans[s] += min(j, n - j) * f[j][s];
printf("%d\n", *min_element(ans, ans + (1 << n)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bit[100005], cnt[(1 << 21)];
int dp[(1 << 9)][25];
int rt[(1 << 9)][25];
char str[100005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", &str);
for (int j = 0; j < m; j++)
if (str[j] == '1') bit[j] |= 1 << i;
}
cnt[0] = 0;
for (int S = 1; S < (1 << 21); S++) {
int T = S & (S - 1);
cnt[S] = cnt[T] + 1;
}
int st = min(n, 13);
int zan = n - st;
int lim = n / 2;
int ret = n * m;
for (int S = 0; S < 1 << st; S++) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < m; i++) {
int s = bit[i] >> st;
int t = bit[i] - (s << st);
t ^= S;
dp[s][cnt[t]]++;
}
for (int i = 0; i < 1 << zan; i++) {
for (int j = 1; j <= st; j++) {
rt[i][j] = dp[i][j] * j;
dp[i][j] += dp[i][j - 1];
rt[i][j] += rt[i][j - 1];
}
}
for (int T = 0; T < 1 << zan; T++) {
int sum = 0;
for (int i = 0; i < 1 << zan; i++) {
int ft = i ^ T;
ft = cnt[ft];
sum += (n - ft) * dp[i][st] - rt[i][st];
if (ft <= lim)
sum += (2 * ft - n) * dp[i][lim - ft] + 2 * rt[i][lim - ft];
}
ret = min(ret, sum);
}
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100000];
int c[100000], dp[21][1100000];
int n, m, ans;
int main() {
int i, j, k, l, tmp, cnt, sum;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", s);
for (j = 0; j < m; j++) c[j] |= (s[j] - 48) << i;
}
for (i = 0; i < m; i++) dp[0][c[i]]++;
for (k = 1; k <= n; k++)
for (tmp = 0; tmp < (1 << n); tmp++) {
if (k > 1)
sum = (k - 2 - n) * dp[k - 2][tmp];
else
sum = 0;
for (l = 0; l < n; l++) sum += dp[k - 1][tmp ^ (1 << l)];
dp[k][tmp] = sum / k;
}
ans = n * m;
for (tmp = 0; tmp < (1 << n); tmp++) {
for (cnt = 0, k = 0; k <= n; k++) cnt += min(k, n - k) * dp[k][tmp];
ans = min(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 100;
int n, m;
int ans;
int cnt[30][maxn];
int col[maxn];
int f[30][1 << 20];
int getnum() {
char ch;
while ((ch = getchar()) != '0' && ch != '1')
;
return (ch - '0');
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cnt[i][j] = getnum();
for (int j = 1; j <= m; ++j)
for (int i = 1; i <= n; ++i) col[j] |= cnt[i][j] << (i - 1);
}
void solve() {
for (int i = 1; i <= m; ++i) f[0][col[i]]++;
for (int i = 0; i < 1 << n; ++i)
for (int j = 0; j < n; ++j) f[1][i] += f[0][i ^ (1 << j)];
for (int i = 2; i <= n; ++i)
for (int j = 0; j < 1 << n; ++j) {
for (int k = 0; k < n; ++k) f[i][j] += f[i - 1][j ^ (1 << k)];
f[i][j] = (f[i][j] + (i - 2 - n) * f[i - 2][j]) / i;
}
ans = n * m;
for (int i = 0; i < 1 << n; ++i) {
int s = 0;
for (int j = 0; j <= n; ++j) s += f[j][i] * min(j, n - j);
ans = min(ans, s);
}
}
int main() {
init();
solve();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 110005;
long long read() {
long long num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9')
num = (num << 3) + (num << 1) + (c ^ 48), c = getchar();
return num * flag;
}
long long n, m, lim, a[25][M], s[M], f[M * 10], g[M * 10];
void fwt(long long *a, long long n, long long op) {
for (long long i = 1; i < n; i <<= 1)
for (long long p = i << 1, j = 0; j < n; j += p)
for (long long k = 0; k < i; k++) {
long long x = a[j + k], y = a[i + j + k];
a[j + k] = x + y;
a[i + j + k] = x - y;
if (op == -1) {
a[j + k] = a[j + k] / 2;
a[i + j + k] = a[i + j + k] / 2;
}
}
}
signed main() {
n = read();
m = read();
lim = 1 << n;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) scanf("%1lld", &a[i][j]);
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= n; j++) s[i] |= (a[j][i] << j - 1);
for (long long i = 1; i <= m; i++) f[s[i]]++;
for (long long i = 0; i < lim; i++) g[i] = g[i >> 1] + (i & 1);
for (long long i = 0; i < lim; i++) g[i] = min(g[i], n - g[i]);
fwt(f, lim, 1);
fwt(g, lim, 1);
for (long long i = 0; i < lim; i++) f[i] = f[i] * g[i];
fwt(f, lim, -1);
long long ans = 1e9;
for (long long i = 0; i < lim; i++) ans = min(ans, f[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MAX_N = 1e5 + 5, MAX_V = 1 << 20 | 1;
int N, M, a[MAX_N], cnt[MAX_V];
char ch[MAX_N];
int Limit;
LL f[MAX_V], g[MAX_V];
void FWT(LL p[], int op) {
for (int i = 1; i < Limit; i <<= 1)
for (int j = 0; j < Limit; j += i << 1)
for (int k = 0; k < i; k++) {
LL x = p[j + k], y = p[i + j + k];
if (op)
p[j + k] = x + y, p[i + j + k] = x - y;
else
p[j + k] = (x + y) / 2, p[i + j + k] = (x - y) / 2;
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= M; j++) a[j] = a[j] << 1 | (ch[j] - '0');
}
Limit = 1 << N;
for (int i = 1; i <= M; i++) f[a[i]]++;
for (int i = 1; i < Limit; i++) cnt[i] = cnt[i ^ (i & -i)] + 1;
for (int i = 0; i < Limit; i++) g[i] = min(N - cnt[i], cnt[i]);
FWT(f, 1), FWT(g, 1);
for (int i = 0; i < Limit; i++) f[i] *= g[i];
FWT(f, 0);
cout << *min_element(&f[0], &f[Limit]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[20][100005];
int dp[21][1 << 20];
int main() {
int n, m;
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", str[i]);
for (int j = 0; j < m; j++) {
int val = 0;
for (int i = 0; i < n; i++) {
if (str[i][j] == '1') {
val |= 1 << i;
}
}
dp[0][val]++;
}
}
for (int k = 1; k <= n; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
dp[k][mask] = 0;
for (int i = 0; i < n; i++) {
dp[k][mask] += dp[k - 1][mask ^ (1 << i)];
}
if (k >= 2) {
dp[k][mask] -= n * dp[k - 2][mask];
}
if (k >= 3) {
dp[k][mask] += (k - 2) * dp[k - 2][mask];
}
dp[k][mask] /= k;
}
}
int ans = int(1e9);
for (int mask = 0; mask < (1 << n); mask++) {
int cand = 0;
for (int i = 0; i <= n; i++) {
cand += min(i, n - i) * dp[i][mask];
}
ans = min(ans, cand);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int MAXM = 100005;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, m, N;
int val[MAXN][MAXM];
long long a[1 << 20], b[1 << 20], ans = INF;
int Read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
void Put1(long long x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
void Put(long long x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
int ron() {
char c = getchar();
while (c > '9' || c < '0') c = getchar();
return (c ^ 48);
}
void fwtxor(long long *a, int opt) {
for (int i = 1; i < N; i <<= 1)
for (int j = 0, p = i << 1; j < N; j += p)
for (int k = 0; k < i; ++k) {
long long X = a[j + k], Y = a[i + j + k];
a[j + k] = X + Y;
a[i + j + k] = X - Y;
if (opt == -1) a[j + k] >>= 1, a[i + j + k] >>= 1;
}
}
int main() {
n = Read();
m = Read();
N = 1 << n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) val[i][j] = ron();
for (int i = 1; i <= m; ++i) {
int S = 0;
for (int j = 1; j <= n; ++j) S = S << 1 | val[j][i];
a[S]++;
}
for (int i = 1; i < N; ++i) b[i] = b[i - (i & -i)] + 1;
for (int i = 1; i < N; ++i) b[i] = Min(b[i], n - b[i]);
fwtxor(a, 1);
fwtxor(b, 1);
for (int i = 0; i < N; ++i) a[i] *= b[i];
fwtxor(a, -1);
for (int i = 0; i < N; ++i) ans = Min(ans, a[i]);
Put(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 n, m, x, c[MX];
int dp[1 << 20][22];
int sum[1 << 20][22];
int main() {
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 s, mx = (1 << n) - 1;
for (int i = 0; i < m; i++) {
dp[c[i]][0]++;
sum[c[i]][0]++;
}
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] += sum[s][k - 1] - ((k > 1) ? sum[m][k - 2] : 0);
}
dp[m][k] /= k;
sum[m][k] = dp[m][k] + ((k > 1) ? sum[m][k - 2] : 0);
}
}
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;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T &a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T &a, Others &...b) {
a = read(a);
read(b...);
}
int n, m, val[100010], bits[1100000];
long long ans = 0x7fffffff, F[1100000], Q[1100000];
void FWT(long long *A, int len, int op = 1) {
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 = A[k], y = A[k + i];
A[k] = (x + y) / (op == -1 ? 2 : 1);
A[k + i] = (x - y) / (op == -1 ? 2 : 1);
}
}
int main() {
read(n, m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x;
scanf("%1d", &x);
val[j] |= x << (i - 1);
}
for (int i = 1; i <= m; i++) Q[val[i]] += 1;
for (int i = 1; i < (1 << n); i++) bits[i] = bits[i >> 1] + (i & 1);
for (int i = 0; i < (1 << n); i++)
F[i] = min(bits[i], bits[((1 << n) - 1) ^ i]);
FWT(F, 1 << n);
FWT(Q, 1 << n);
for (int i = 0; i < (1 << n); i++) F[i] *= Q[i];
FWT(F, 1 << n, -1);
for (int i = 0; i < (1 << n); i++) ans = min(ans, F[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[21][1050000];
int ti[100010];
char s[100010];
int main() {
int i, j, m, n, x, y, t, k, mask, ans, sum;
scanf("%d%d", &n, &m);
memset(ti, 0, sizeof(ti));
for (i = 1; i <= n; i++) {
scanf("%s", s);
for (j = 0; j < m; j++) ti[j] = ti[j] + (s[j] - '0') * (1 << (i - 1));
}
memset(dp, 0, sizeof(dp));
for (i = 0; i < m; i++) dp[0][ti[i]]++;
for (i = 1; i <= n; i++)
for (mask = 0; mask < (1 << n); mask++) {
sum = 0;
if (i >= 2) sum = (i - 2 - n) * dp[i - 2][mask];
for (j = 0; j < n; j++) sum += dp[i - 1][mask ^ (1 << j)];
dp[i][mask] = sum / i;
}
ans = 2147483647;
for (mask = 0; mask < (1 << n); mask++) {
sum = 0;
for (i = 0; i <= n; i++) sum += dp[i][mask] * min(i, n - i);
if (sum < ans) ans = sum;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long N = 1e5 + 10;
const long long INF = 1e18;
const long long LOG = 25;
long long dp[25][(1 << 20) + 10];
long long n, m, NUM[N], a[22][N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '1') {
NUM[j + 1] += (1 << i);
}
}
}
for (int i = 1; i <= m; i++) {
dp[0][NUM[i]]++;
}
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1 << n); mask++) {
if (i > 1) dp[i][mask] = (i - 2) * dp[i - 2][mask];
for (int BIT = 0; BIT < n; BIT++) {
dp[i][mask] += dp[i - 1][mask ^ (1 << BIT)];
if (i > 1) dp[i][mask] -= dp[i - 2][mask];
}
dp[i][mask] /= i;
}
}
long long ans = INF;
for (int mask = 0; mask < (1 << n); mask++) {
long long Cnt = 0;
for (long long i = 0; i <= n; i++) {
Cnt += dp[i][mask] * min(n - i, i);
}
ans = min(ans, Cnt);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t start;
void Time(bool timeIt) {
if (!timeIt) return;
clock_t end = clock();
double elapsed_time = ((double)end - (double)start) / (double)CLOCKS_PER_SEC;
printf("Time elapsed = %0.4lf\n", elapsed_time);
}
void FWHT(vector<long long>& P, bool inverse = false) {
int degree = P.size();
for (int len = 1; (len << 1) <= degree; len <<= 1) {
for (int i = 0; i < degree; i += (len << 1)) {
for (int j = 0; j < len; j++) {
long long u = P[i + j], v = P[i + len + j];
P[i + j] = u + v;
P[i + len + j] = u - v;
}
}
}
if (inverse) {
for (int i = 0; i < degree; i++) {
P[i] = P[i] / (1ll * degree);
}
}
}
int a[(1 << 20)] = {0}, pres[(1 << 20)] = {0};
char s[21][100010];
int main() {
start = clock();
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) a[j] += (s[i][j] - '0') << i;
}
for (int i = 0; i < m; ++i) pres[a[i]]++;
int lim = (1 << n);
vector<long long> P, Q, R;
for (int i = 0; i < lim; ++i) P.push_back(pres[i]);
for (int i = 0; i < lim; ++i) {
int k = __builtin_popcount(i);
Q.push_back(min(k, n - k));
}
FWHT(P);
FWHT(Q);
for (int i = 0; i < lim; ++i) R.push_back(P[i] * Q[i]);
FWHT(R, true);
long long ans = m * n;
for (int i = 0; i < lim; ++i) ans = min(ans, R[i]);
printf("%lld\n", ans);
Time(false);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[20][100005];
int dp[1 << 20][21];
int main() {
int n, m;
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", str[i]);
for (int j = 0; j < m; j++) {
int val = 0;
for (int i = 0; i < n; i++) {
if (str[i][j] == '1') {
val |= 1 << i;
}
}
dp[val][0]++;
}
}
for (int k = 1; k <= n; k++) {
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
dp[mask][k] += dp[mask ^ (1 << i)][k - 1];
}
if (k >= 2) {
dp[mask][k] -= n * dp[mask][k - 2];
}
if (k >= 3) {
dp[mask][k] += (k - 2) * dp[mask][k - 2];
}
dp[mask][k] /= k;
}
}
int ans = int(1e9);
for (int mask = 0; mask < (1 << n); mask++) {
int cand = 0;
for (int i = 0; i <= n; i++) {
cand += min(i, n - i) * dp[mask][i];
}
ans = min(ans, cand);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tmp[100010];
long long ans, num[1100000], cnt[1100000];
void FWT(long long sz[], int siz) {
static int x, y;
for (int i = 1; i < siz; i <<= 1)
for (int j = 0; j < siz; j += (i << 1))
for (int k = 0; k < i; ++k) {
x = sz[j + k], y = sz[j + i + k];
sz[j + k] = x + y, sz[j + i + k] = x - y;
}
}
void UFWT(long long sz[], int siz) {
for (int i = 1; i < siz; i <<= 1)
for (int j = 0; j < siz; j += (i << 1))
for (int k = 0; k < i; ++k) {
sz[j + k] = (sz[j + k] + sz[j + i + k]) >> 1;
sz[j + i + k] = sz[j + k] - sz[j + i + k];
}
}
int main() {
scanf("%d%d", &n, &m);
getchar();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) tmp[j] = (tmp[j] << 1) + getchar() - '0';
getchar();
}
for (int i = 1; i <= m; ++i) ++num[tmp[i]];
for (int i = 1; i < (1 << n); ++i) cnt[i] = cnt[i - (i & -i)] + 1;
for (int i = 1; i < (1 << n); ++i) cnt[i] = min(cnt[i], n - cnt[i]);
FWT(num, 1 << n);
FWT(cnt, 1 << n);
for (int i = 0; i < (1 << n); ++i) cnt[i] *= num[i];
UFWT(cnt, 1 << n);
ans = 1 << 21;
for (int i = 0; i < (1 << n); ++i) ans = min(cnt[i], ans);
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool is_digit(char c) { return c <= '9' && c >= '0'; }
inline int read() {
int tmp = 0, f = 1;
char c = getchar();
while (!is_digit(c)) {
if (c == '-') f = -f;
c = getchar();
}
while (is_digit(c)) tmp = (tmp << 1) + (tmp << 3) + (c ^ 48), c = getchar();
return tmp * f;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar((x % 10) ^ 48);
}
const int maxn = 2000010;
const int mod = 998244353;
const int inv2 = 499122177;
int n, a[maxn], b[maxn], f[maxn], g[maxn];
inline void fwt_or() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
f[i + j + len] += f[i + j], g[i + j + len] += g[i + j];
f[i + j + len] %= mod, g[i + j + len] %= mod;
}
}
}
}
inline void fwt_and() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
f[i + j] += f[i + j + len], g[i + j] += g[i + j + len];
f[i + j] %= mod, g[i + j] %= mod;
}
}
}
}
inline void fwt_xor() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
int ra = f[i + j], rb = f[i + j + len];
f[i + j] += rb;
f[i + j] %= mod;
f[i + j + len] = ra - rb;
f[i + j + len] %= mod;
f[i + j + len] += mod;
f[i + j + len] %= mod;
ra = g[i + j], rb = g[i + j + len];
g[i + j] += rb;
g[i + j] %= mod;
g[i + j + len] = ra - rb;
g[i + j + len] %= mod;
g[i + j + len] += mod;
g[i + j + len] %= mod;
}
}
}
}
inline void ifwt_or() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
f[i + j + len] -= f[i + j];
f[i + j + len] %= mod;
f[i + j + len] += mod;
f[i + j + len] %= mod;
}
}
}
}
inline void ifwt_and() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
f[i + j] -= f[i + j + len];
f[i + j] %= mod;
f[i + j] += mod;
f[i + j] %= mod;
}
}
}
}
inline void ifwt_xor() {
for (int k = 2, len = 1; k <= n; k <<= 1, len <<= 1) {
for (int i = 0; i < n; i += k) {
for (int j = 0; j < len; j++) {
int ra = f[i + j], rb = f[i + j + len];
f[i + j] += rb;
f[i + j] %= mod;
f[i + j + len] = ra - rb;
f[i + j + len] %= mod;
f[i + j + len] += mod;
f[i + j + len] %= mod;
f[i + j] = 1ll * f[i + j] * inv2 % mod;
f[i + j + len] = 1ll * f[i + j + len] * inv2 % mod;
}
}
}
}
int mp[30][100010], c[100010];
int main() {
n = read();
int m = read();
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '1') mp[i][j] = 1;
}
}
for (register int j = 1; j <= m; j++) {
for (register int i = 1; i <= n; i++) {
if (mp[i][j]) c[j] |= 1 << i - 1;
}
}
for (register int i = 1; i <= m; i++) a[c[i]]++;
for (register int i = 0; i <= (1 << n); i++) b[i] = b[i >> 1] + (i & 1);
for (register int i = 0; i <= (1 << n); i++) b[i] = min(b[i], n - b[i]);
n = 1 << n;
for (register int i = 0; i < n; i++) f[i] = a[i];
for (register int i = 0; i < n; i++) g[i] = b[i];
fwt_xor();
for (register int i = 0; i < n; i++) f[i] = 1ll * f[i] * g[i] % mod;
ifwt_xor();
int ans = f[0];
for (register int i = 1; i < n; i++) {
ans = min(ans, f[i]);
}
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;
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) {
for (int i = 0; i < (N); i++) v[i] >>= __builtin_ctz(N);
if (__builtin_ctz(N) & 1)
for (int i = 0; i < (N); i++) v[i] = -v[i];
}
}
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>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, m;
int a[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 m1 = (0); m1 < (1 << n1); m1++) {
memset(c, 0, sizeof c);
for (int j = (0); j < (m); j++) {
t = a[j] ^ m1;
c[nb[t & fn1]][t >> n1]++;
}
for (int m2 = (0); m2 < (1 << n2); m2++) {
int sum = 0;
for (int fnb = (0); fnb < (n1 + 1); fnb++)
for (int fm2 = (0); fm2 < (1 << n2); fm2++)
if (c[fnb][fm2]) {
t = fnb + nb[fm2 ^ m2];
sum += c[fnb][fm2] * min(n - t, t);
}
best = min(best, sum);
}
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int MAXM = 100000;
const int MAXSIZE = 1048576;
int n, m;
int tab[MAXM + 3];
char r[MAXM + 3];
int ans[MAXSIZE + 3], dp[2][23][MAXSIZE];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", r + 1);
for (int j = 1; j <= m; j++) tab[j] = (tab[j] << 1) + (r[j] - '0');
}
for (int i = 1; i <= m; i++) dp[0][0][tab[i]]++;
for (int t = 1; t <= n; t++)
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[0][t][first] = dp[0][t - 1][first];
for (int k = 1; k <= n; k++) {
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[k & 1][0][first] = 0;
for (int t = 1; t <= n; t++)
for (int first = ((1 << n) - 1); first >= 0; first--)
dp[k & 1][t][first] = dp[k & 1][t - 1][first] +
dp[(k + 1) & 1][t - 1][first ^ (1 << (t - 1))];
for (int first = ((1 << n) - 1); first >= 0; first--)
ans[first] += dp[k & 1][n][first] * min(k, n - k);
}
int res = n * m;
for (int first = ((1 << n) - 1); first >= 0; first--)
res = min(res, ans[first]);
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const long long N = 25, M = 1e5 + 5, S = 1 << 21;
long long a[S], b[S], ans = 1e9, n, m, mp[N][M];
void fwtxor(long long *f, long long n, long long op) {
for (long long len = 2, k = 1; k < n; len <<= 1, k <<= 1)
for (long long i = 0; i < n; i += len)
for (long long j = 0; j < k; j++) {
long long x = f[i + j], y = f[i + j + k];
f[i + j] = x + y;
f[i + j + k] = x - y;
if (op == -1) f[i + j] >>= 1, f[i + j + k] >>= 1;
}
}
signed main() {
read(n, m);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) scanf("%1d", &mp[i][j]);
for (long long i = 0; i < m; i++) {
long long s = 0;
for (long long j = 0; j < n; j++) s |= mp[j][i] << j;
a[s]++;
}
for (long long i = 0; i < (1 << n); i++) {
long long cnt = 0;
for (long long j = 0; j < n; j++) cnt += i >> j & 1;
b[i] = min(cnt, n - cnt);
}
fwtxor(a, 1 << n, 1);
fwtxor(b, 1 << n, 1);
for (long long i = 0; i < (1 << n); i++) a[i] = a[i] * b[i];
fwtxor(a, 1 << n, -1);
for (long long i = 0; i < (1 << n); i++) ans = min(ans, a[i]);
write(ans);
}
|
#include <bits/stdc++.h>
const int maxn = 20, maxm = 100000, maxs = 1 << maxn, mod = 1000000007;
int n, m, val[maxm], len, inv_len, x[maxs], sz[maxs];
char str[maxm + 1];
inline void FWT_iterate(int x[], int len, int delta) {
for (int i = 0, j, t, px = 0, py = delta; i < len;
i += delta << 1, px = py, py += delta)
for (j = 0; j < delta; ++j, ++px, ++py) {
t = x[py];
x[py] = x[px] - t < 0 ? x[px] - t + mod : x[px] - t;
x[px] = x[px] + t >= mod ? x[px] + t - mod : x[px] + t;
}
}
inline void FWT(int x[], int len, int flag) {
if (!flag)
for (int i = 1; i < len; i <<= 1) FWT_iterate(x, len, i);
else {
for (int i = len >> 1; i > 0; i >>= 1) FWT_iterate(x, len, i);
for (int i = 0; i < len; ++i) x[i] = (long long)x[i] * inv_len % mod;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", str);
for (int j = 0; j < m; ++j)
if (str[j] == '1') val[j] |= 1 << i;
}
for (int i = 0; i < m; ++i) ++x[val[i]];
len = 1 << n;
inv_len = 1;
for (int i = 0; i < n; ++i)
inv_len = (long long)inv_len * ((mod + 1) >> 1) % mod;
for (int i = 1; i < len; ++i) sz[i] = sz[i >> 1] + (i & 1);
for (int i = 0; i < len; ++i)
if (sz[i] > n - sz[i]) sz[i] = n - sz[i];
FWT(x, len, 0);
FWT(sz, len, 0);
for (int i = 0; i < len; ++i) x[i] = (long long)x[i] * sz[i] % mod;
FWT(x, len, 1);
int ans = n * m;
for (int i = 0; i < len; ++i)
if (ans > x[i]) ans = x[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[20][100005];
int n, m;
int dp[1 << 19][20];
int ndp[1 << 19][20];
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 x = 0;
for (int j = (0); j < (n); j++)
if (s[j][i] == '1') x |= 1 << j;
if (x & (1 << (n - 1))) x = x ^ ((1 << n) - 1);
dp[x][0]++;
}
auto cur = dp, prv = ndp;
for (int i = (1); i < (n); i++) {
swap(cur, prv);
for (int x = (0); x < (1 << (n - 1)); x++) {
for (int d = (0); d < (i + 1); d++) {
cur[x][d] = prv[x][d];
if (d) cur[x][d] += prv[x ^ (1 << (i - 1))][d - 1];
}
}
}
int res = 1e9;
for (int x = (0); x < (1 << (n - 1)); x++) {
int a = 0;
for (int i = (0); i < (n); i++) a += cur[x][i] * min(i, n - i);
res = min(res, a);
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
int f[21][1 << 21], n, m, ans = 1e9;
char s[21][1000010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (s[j][i] == '1') x += 1 << (j - 1);
f[0][x]++;
}
for (int i = 1; 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 - 1))];
for (int i = 0; i < (1 << n); i++) {
int now = 0;
for (int j = 0; j <= n; j++) now += min(j, n - j) * f[j][i];
ans = min(ans, now);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
FILE *fin, *fout;
int N, M;
vector<vector<char> > T;
vector<int> C;
vector<vector<int> > dp;
int main() {
scanf("%d %d", &N, &M);
T = vector<vector<char> >(N, vector<char>(M));
for (int i = 0; i < N; i++) {
scanf("\n");
for (int j = 0; j < M; j++) {
scanf("%c", &T[i][j]);
}
}
C.resize(M);
for (int i = 0; i < M; i++) {
C[i] = 0;
for (int j = 0; j < N; j++) {
if (T[j][i] == '1') C[i] += (1 << j);
}
}
dp = vector<vector<int> >(N + 1, vector<int>((1 << N), 0));
for (int i = 0; i < M; i++) {
dp[0][C[i]]++;
}
for (int i = 0; i < (1 << N); i++) {
dp[1][i] = 0;
for (int j = 0; j < N; j++) {
dp[1][i] += dp[0][i ^ (1 << j)];
}
}
for (int i = 2; i <= N; i++) {
for (int j = 0; j < (1 << N); j++) {
dp[i][j] = 0;
for (int k = 0; k < N; k++) {
dp[i][j] += dp[i - 1][j ^ (1 << k)];
}
dp[i][j] = ((i - 2 - N) * dp[i - 2][j] + dp[i][j]) / i;
}
}
int mini = inf;
for (int i = 0; i < (1 << N); i++) {
int res = 0;
for (int j = 0; j <= N; j++) {
res += min(j, N - j) * dp[j][i];
}
mini = min(mini, res);
}
printf("%d", mini);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1050000;
const int M = 100010;
int n, m, lim;
long long ans;
long long a[N], b[N];
int g[M], cnt[N];
char ch[M];
void fwt(long long *a) {
for (int l = 2, m = 1; l <= lim; m = l, l <<= 1)
for (int i = 0; i < lim; i += l)
for (int j = 0; j < m; j++) {
long long x = a[i + j], y = a[i + j + m];
a[i + j] = (x + y);
a[i + j + m] = (x - y);
}
}
void ifwt(long long *a) {
for (int l = 2, m = 1; l <= lim; m = l, l <<= 1)
for (int i = 0; i < lim; i += l)
for (int j = 0; j < m; j++) {
long long x = a[i + j], y = a[i + j + m];
a[i + j] = (x + y) >> 1;
a[i + j + m] = (x - y) >> 1;
}
}
int main() {
scanf("%d%d", &n, &m);
lim = 1 << n;
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; j++)
if (ch[j] == '1') g[j] |= 1 << (i - 1);
}
for (int i = 1; i <= m; i++) a[g[i]]++;
for (int i = 0; i < lim; i++) cnt[i] = cnt[i >> 1] + (i & 1);
for (int i = 0; i < lim; i++) b[i] = min(cnt[i], n - cnt[i]);
fwt(a);
fwt(b);
for (int i = 0; i < lim; i++) a[i] = a[i] * b[i];
ifwt(a);
ans = n * m;
for (int i = 0; i < lim; i++) ans = min(ans, a[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = (1 << 20) + 1;
int n, m, s[M], cnt[M];
long long f[M], g[M], Ans = 2e7;
char str[M];
void fwt_xor(long long *p, int o) {
long long x, y;
for (int i = 1; i < 1 << n; i <<= 1)
for (int j = 0; j < 1 << n; j += (i << 1))
for (int k = 0; k < i; ++k) {
x = p[j + k], y = p[i + j + k];
p[j + k] = x + y, p[i + j + k] = x - y;
if (o == -1) p[j + k] >>= 1, p[i + j + k] >>= 1;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", str + 1);
for (int j = 1; j <= m; ++j) s[j] |= ((str[j] - '0') << i - 1);
}
for (int i = 1; i <= m; ++i) ++g[s[i]];
for (int i = 1; i < 1 << n; ++i)
cnt[i] = cnt[i - (i & (-i))] + 1, f[i] = min(cnt[i], n - cnt[i]);
fwt_xor(g, 1), fwt_xor(f, 1);
for (int i = 0; i < 1 << n; ++i) f[i] = f[i] * g[i];
fwt_xor(f, -1);
for (int i = 0; i < 1 << n; ++i) Ans = min(Ans, f[i]);
printf("%lld", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1e5 + 5;
int a[M], dp[(1 << N) + 5][N + 1][2], ans = N * M;
;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char x;
cin >> x;
a[j] += (x == '1') * (1 << i);
}
for (int i = 0; i < m; i++) dp[a[i]][0][0]++;
for (int j = 1; j <= n; j++)
for (int mask = 0; mask < (1 << n); mask++)
for (int i = 0; i <= j; i++) {
dp[mask][i][j & 1] = dp[mask][i][(j - 1) & 1];
if (i > 0)
dp[mask][i][j & 1] += dp[mask ^ (1 << (j - 1))][i - 1][(j - 1) & 1];
}
for (int i = 0; i < (1 << n); i++) {
int rtr = 0;
for (int j = 0; j <= n; j++) rtr += dp[i][j][n & 1] * min(j, n - j);
ans = min(ans, rtr);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5, maxm = 1e6 + 1e5, oo = 1e9;
char s[maxn];
int a[30][maxn], dp[30][maxm], c[maxn], d[30];
int n, m, i, j, ans, x, y, z, mask, p, f, q, now, k;
int main() {
scanf("%d%d", &n, &m);
d[0] = 1;
for (i = 1; i <= 25; i++) d[i] = d[i - 1] * 2;
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (j = 1; j <= m; j++) {
a[i][j] = s[j] - '0';
c[j] += a[i][j];
}
}
for (i = 1; i <= m; i++) {
x = 0;
for (j = n; j > 0; j--) x = x * 2 + a[j][i];
dp[0][x]++;
}
for (mask = 0; mask < d[n]; mask++) {
for (p = 0; p < n; p++) dp[1][mask] += dp[0][mask ^ d[p]];
dp[1][mask] /= 1;
}
for (k = 2; k <= n; k++)
for (mask = 0; mask < d[n]; mask++) {
dp[k][mask] = (k - 2 - n) * dp[k - 2][mask];
for (p = 0; p < n; p++) dp[k][mask] += dp[k - 1][mask ^ d[p]];
dp[k][mask] /= k;
}
ans = oo;
for (mask = 0; mask < d[n]; mask++) {
now = 0;
for (k = 0; k <= n; k++) now += min(k, n - k) * dp[k][mask];
ans = min(ans, now);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int dp[21][1 << 21];
int arr[100009], val[22];
void solve(int x) {
while (1) {
int use;
scanf("%d", &use);
for (int i = 0; i < x; i++) {
if ((use & (1 << i)))
printf("1");
else
printf("0");
}
puts("");
}
}
int main() {
int n, m, res;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char ch;
scanf(" %c", &ch);
if (ch == '1') arr[j] |= (1 << (i - 1));
}
}
int MASK = (1 << n), ans = 1000000007;
for (int i = 1; i <= m; i++) dp[0][arr[i]]++;
for (int i = 0; i < n; i++) {
for (int dif = n; dif >= 1; dif--)
for (int mask = 0; mask < MASK; mask++)
dp[dif][mask] += dp[dif - 1][mask ^ (1 << i)];
val[i] = min(i, n - i);
}
for (int i = 0; i < MASK; i++) {
res = 0;
for (int j = 0; j <= n; j++) res += dp[j][i] * val[j];
umin(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int f[N][1 << N], n, m, ans;
char s[N][1000010];
int main() {
scanf("%d%d", &n, &m);
ans = n * m;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int sum = 0;
for (int j = 1; j <= n; j++)
if (s[j][i] == '1') sum += 1 << (j - 1);
f[0][sum]++;
}
for (int i = 1; i <= n; i++) {
for (int j = n; j >= 1; j--) {
for (int k = 0; k < (1 << n); k++) {
f[j][k] += f[j - 1][k ^ (1 << (i - 1))];
}
}
}
for (int i = 0; i < (1 << n); i++) {
int now = 0;
for (int j = 0; j <= n; j++) {
now += min(j, n - j) * f[j][i];
}
ans = min(ans, now);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 20;
const int MM = 1e5 + 5;
int A[MM], n, m;
char S[MM];
long long F[1 << MX], G[1 << MX];
void fwt(long long F[], int n) {
for (int i = 0; i < n; i++) {
for (int s = 0; s < 1 << n; s++) {
if (s >> i & 1) continue;
long long l = F[s], r = F[s | (1 << i)];
F[s] = l + r;
F[s | (1 << i)] = l - r;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", S);
for (int j = 0; j < m; j++) {
A[j] = A[j] << 1 | (S[j] - '0');
}
}
for (int i = 0; i < m; i++) {
F[A[i]] += 1;
}
for (int i = 0; i < 1 << n; i++) {
int t = __builtin_popcount(i);
G[i] = min(t, n - t);
}
fwt(F, n);
fwt(G, n);
for (int i = 0; i < 1 << n; i++) {
F[i] = F[i] * G[i];
}
fwt(F, n);
int ans = n * m, div = 1 << n;
for (int i = 0; i < 1 << n; i++) {
ans = min(ans, (int)(F[i] / div));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, c[1048576];
char s[20][1048576];
long long A[1048576], B[1048576], d;
inline void fwt(long long* s, int o) {
o = 2 - o;
long long x, y;
for (int i = 1; i <= 1048576; i <<= 1)
for (int j = i; j < 1048576; ++j& i ? 0 : j |= i) {
x = s[i ^ j];
y = s[j];
s[i ^ j] = (x + y) / o;
s[j] = (x - y) / o;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; ++i) {
int k = 0;
for (int j = 0; j < n; ++j) k = (k << 1) | (s[j][i] ^ 48);
++A[k];
}
for (int i = 1; i < 1048576; ++i) c[i] = c[i >> 1] + (i & 1);
for (int i = 0; i < 1048576; ++i) B[i] = min(c[i], c[(1 << n) - 1 ^ i]);
fwt(A, 1);
fwt(B, 1);
for (int i = 0; i < 1048576; ++i) A[i] *= B[i];
fwt(A, 0);
for (int i = 1; i < 1048576; ++i) A[0] = min(*A, A[i]);
printf("%d\n", A[0]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
template <class T>
void r(T &x) {
x = 0;
int f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= f;
}
const int N = 25, M = 1e5 + 5;
int n, m, ans = 2e6;
char str[N][M];
int dp[N][(1 << 20)];
int Min(int x, int y) { return x < y ? x : y; }
int main() {
r(n), r(m);
for (int i = 1; i <= n; i++) {
scanf("\n");
for (int j = 1; j <= m; j++) str[i][j] = getchar();
}
for (int i = 1; i <= m; i++) {
int t = 0;
for (int j = 1; j <= n; j++) t = t * 2 + str[j][i] - '0';
dp[0][t]++;
}
for (int i = 0; i < n; i++)
for (int j = n; j >= 1; j--)
for (int k = 0; k < (1 << n); k++) dp[j][k] += dp[j - 1][k ^ (1 << i)];
for (int k = 0; k < (1 << n); k++) {
int temp = 0;
for (int i = 0; i <= n; i++) temp += Min(i, n - i) * dp[i][k];
ans = Min(temp, ans);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int f[3][1100010], g[1100010];
char a[21][100010];
int main() {
int i, j, k, i0, i1, i2, s;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (i = 1; i <= m; i++) {
s = 0;
for (j = 1; j <= n; j++) s = s * 2 + (a[j][i] == '1');
f[0][s]++;
}
for (i = 1; i <= n; i++) {
i0 = i % 3;
i1 = (i + 2) % 3;
i2 = (i + 1) % 3;
for (j = 0; j < (1 << n); j++) {
f[i0][j] = 0;
for (k = 0; k < n; k++) f[i0][j] += f[i1][j ^ (1 << k)];
f[i0][j] += (i - 2 - n) * f[i2][j];
f[i0][j] /= i;
g[j] += f[i0][j] * min(i, n - i);
}
}
ans = n * m + 1;
for (i = 0; i < (1 << n); i++) ans = min(ans, g[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
inline int read() {
register int x = 0, v = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') v = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * v;
}
const int MOD = 1e9 + 7;
const int _2inv = (MOD + 1) / 2;
const int MAXN = 20;
const int MAXM = 1e5;
inline int bitcnt(int x) {
int res = 0;
while (x > 0) res += x & 1, x >>= 1;
return res;
}
namespace FWT {
void XOR(int *f, int len, int op) {
for (int i = 2; i <= len; i <<= 1) {
for (int j = 0; j < len; j += i) {
for (int k = j; k < j + i / 2; ++k) {
int tmp = f[k];
f[k] = 1LL * (f[k] + f[k + i / 2]) * (op == 1 ? 1 : _2inv) % MOD;
f[k + i / 2] =
1LL * (tmp - f[k + i / 2] + MOD) * (op == 1 ? 1 : _2inv) % MOD;
}
}
}
}
} // namespace FWT
using namespace FWT;
int n, m;
int f[1 << MAXN], g[1 << MAXN];
char a[MAXN | 1][MAXM + 5];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
for (int i = 0; i < 1 << n; ++i) f[i] = bitcnt(i), f[i] = min(f[i], n - f[i]);
for (int i = 1; i <= m; ++i) {
int num = 0;
for (int j = 1; j <= n; ++j) num = num << 1 | (a[j][i] - '0');
++g[num];
}
XOR(f, 1 << n, 1);
XOR(g, 1 << n, 1);
for (int i = 0; i < 1 << n; ++i) f[i] = 1LL * f[i] * g[i] % MOD;
XOR(f, 1 << n, -1);
printf("%d\n", *std::min_element(f, f + (1 << n)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char f[22][100002];
int solve(int p, int n, vector<int> v) {
if (n == 0) {
int ret = 0;
for (int i = 0; i <= p; ++i) {
ret += v[i] * min(i, p - i);
}
return ret;
}
int ans = 1e+9;
{
vector<int> nv((p + 2) * (1 << (n - 1)));
for (int i = 0; i <= p; ++i) {
for (int mask = 0; mask < (1 << n); ++mask) {
int ni = i + (mask & 1), nmask = mask >> 1;
nv[ni * (1 << (n - 1)) + nmask] += v[i * (1 << n) + mask];
}
}
ans = min(ans, solve(p + 1, n - 1, nv));
}
{
vector<int> nv((p + 2) * (1 << (n - 1)));
for (int i = 0; i <= p; ++i) {
for (int mask = 0; mask < (1 << n); ++mask) {
int ni = i + ((mask & 1) == 0), nmask = mask >> 1;
nv[ni * (1 << (n - 1)) + nmask] += v[i * (1 << n) + mask];
}
}
ans = min(ans, solve(p + 1, n - 1, nv));
}
return ans;
}
int main() {
int n, m;
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; ++i) gets(f[i]);
int ans = n * m;
int p = min(10, n);
p = 0;
for (int mask = 0; mask < (1 << p); ++mask) {
vector<int> v((p + 1) * (1 << (n - p)));
for (int j = 0; j < m; ++j) {
int bit = 0, nmask = 0;
for (int i = 0; i < n; ++i) {
int val = (f[i][j] == '1') ^ ((mask >> i) & 1);
if (i < p)
bit += val;
else
nmask = nmask << 1 | val;
}
v[bit * (1 << (n - p)) + nmask]++;
}
ans = min(ans, solve(p, n - p, v));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1 << 20;
int n, m, lim;
char s[22][100005];
int64_t a[N], b[N];
void fwt(int64_t* a, int f) {
for (int i = 1; i < lim; i <<= 1)
for (int j = 0; j < lim; j += i << 1)
for (int k = 0; k < i; ++k) {
int64_t x = a[j + k], y = a[j + k + i];
a[j + k] = x + y >> f;
a[j + k + i] = x - y >> f;
}
}
int main() {
scanf("%d%d", &n, &m);
lim = 1 << n;
for (int i = 0; i < lim; ++i)
b[i] = std::min(__builtin_popcount(i), n - __builtin_popcount(i));
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) s[i][j] ^= '0';
}
for (int i = 0; i < m; ++i) {
int p = 0;
for (int j = 0; j < n; ++j) p |= s[j][i] << j;
++a[p];
}
fwt(a, 0), fwt(b, 0);
for (int i = 0; i < lim; ++i) a[i] *= b[i];
fwt(a, 1);
std::cout << *std::min_element(a, a + lim) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -1 : 1, ch = getchar();
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
int n, m;
char a[21][100001];
long long st[100010], mn[1048580], b[1048580], b2[1048580];
void calc(long long a[], int n, bool fl) {
for (int i = 1, t = fl ? 1 : 2; i * 2 <= n; i <<= 1)
for (int j = 0; j < n; j += i * 2)
for (int k = 0; k < i; k++)
a[k + j] += a[i + j + k], a[i + j + k] = a[k + j] - a[i + j + k] * 2,
a[k + j] /= t, a[i + k + j] /= t;
}
void mul(long long a[], long long b[], int n) {
for (int i = 0; i < n; i++) a[i] *= b[i];
}
void sol(long long a2[], long long b[], int op, int n) {
memcpy(b2, b, n << 3);
calc(a2, n, 1), calc(b2, n, 1), mul(a2, b2, n), calc(a2, n, 0);
}
signed main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) st[j] |= (a[i][j] - '0') * (1 << i - 1);
mn[st[j]]++;
}
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] = min(b[i], n - b[i]);
sol(mn, b, 3, 1 << n);
long long ans = 2e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, mn[i]);
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
const int MAXM = 100005;
const long long Mod = 1000000007;
char s[MAXN + 5][MAXM + 5];
long long a[MAXM], f[1 << MAXN], g[1 << MAXN];
void fwt(long long f[], int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < (1 << n); j++) {
if (j & (1 << i)) continue;
int u = f[j], v = f[j | (1 << i)];
f[j] = (u + v) % Mod, f[j | (1 << i)] = (u - v + Mod) % Mod;
}
}
long long fp(long long a, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * a % Mod;
a = a * a % Mod;
k >>= 1;
}
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[j] |= (s[i][j] - '0') << i;
for (int i = 0; i < m; i++) f[a[i]] = f[a[i]] + 1;
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
g[i] = min(cnt, n - cnt);
}
fwt(f, n);
fwt(g, n);
for (int i = 0; i < (1 << n); i++) f[i] = f[i] * g[i] % Mod;
fwt(f, n);
long long res = n * m, buf = fp(1 << n, Mod - 2);
for (int i = 0; i < (1 << n); i++) res = min(res, f[i] * buf % Mod);
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string a[21];
int dp[21][1 << (21 - 1)], F[21][1 << (21 - 1)];
int res;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 1; j <= m; j++) {
int mask = 0;
for (int i = 1; i <= n; i++) {
mask = mask * 2 + (a[i][j - 1] - '0');
}
dp[0][mask]++;
}
for (int mask = 0; mask < (1 << n); mask++) {
F[0][mask] = dp[0][mask];
}
for (int i = 1; i <= n; i++)
for (int mask = 0; mask < (1 << n); mask++) {
for (int j = 1; j <= n; j++) {
int prev = mask ^ (1 << (j - 1));
if (i > 1)
dp[i][mask] += F[i - 1][prev] - F[i - 2][mask];
else
dp[i][mask] += F[0][prev];
}
dp[i][mask] /= i;
if (i != 1)
F[i][mask] = F[i - 2][mask] + dp[i][mask];
else
F[i][mask] = dp[i][mask];
}
res = m * n;
for (int mask = 0; mask < (1 << n); mask++) {
int sum = 0;
for (int i = 0; i <= n; i++) sum += dp[i][mask] * min(i, n - i);
res = min(res, sum);
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pi = pair<int, int>;
using ll = long long int;
template <typename T1, typename T2, typename T3>
T1 modpow(T1 _a, T2 p, T3 mod) {
assert(p >= 0);
ll ret = 1, a = _a;
if (a < 0) {
a %= mod;
a += mod;
}
if (a >= mod) {
a %= mod;
}
for (; p > 0; p /= 2) {
if (p & 1) ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr int mx_n = 21, mx_m = 100005;
constexpr int mx_mask = (1 << mx_n);
string table[mx_n];
int n, m;
int col[mx_m];
int sum[mx_n][mx_mask], cnt[mx_mask];
int main() {
cin >> n >> m;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) cin >> table[i];
for (int j = ((0)), _j = ((m)-1); j <= _j; ++j) {
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i)
col[j] |= ((table[i][j] - '0') << i);
;
}
for (int j = ((0)), _j = ((m)-1); j <= _j; ++j) ++sum[0][col[j]];
for (int k = (1), _k = (n); k <= _k; ++k) {
for (int mask = ((0)), _mask = (((1 << n)) - 1); mask <= _mask; ++mask) {
ll cur = 0;
for (int p = ((0)), _p = ((n)-1); p <= _p; ++p) {
cur += sum[k - 1][(mask ^ (1 << p))];
if (k - 2 >= 0) cur -= sum[k - 2][mask];
}
cur /= k;
sum[k][mask] = cur;
if (k - 2 >= 0) sum[k][mask] += sum[k - 2][mask];
cnt[mask] += min(k, n - k) * cur;
;
}
}
int ans = *min_element(cnt, cnt + (1 << n));
;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, si[1050005];
long long a[1050005], b[1050005];
char s[20][100005];
inline void fwt(long long *a, int l, int r) {
if (l == r) return;
int mid = l + r >> 1;
fwt(a, l, mid), fwt(a, mid + 1, r);
for (int i = l; i <= mid; i++) {
long long x = a[i], y = a[i + mid - l + 1];
a[i] = x + y, a[i + mid - l + 1] = x - y;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int t = 0;
for (int j = 1; j <= n; j++) t = t * 2 + s[j][i] - '0';
a[t]++;
}
k = (1 << n) - 1;
for (int i = 1; i <= k; i++) si[i] = si[i ^ (i & -i)] + 1;
for (int i = 0; i <= k; i++) b[i] = max(si[i], n - si[i]);
fwt(a, 0, k);
fwt(b, 0, k);
for (int i = 0; i <= k; i++) a[i] = a[i] * b[i];
fwt(a, 0, k);
int ans = 0;
for (int i = 0; i <= k; i++) ans = max(ans, (int)(a[i] / (k + 1)));
printf("%d\n", n * m - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1e5 + 5, MOD = 998244353, S = (1 << N) + 5;
int n, m, n2;
long long a[S], b[S], ans = S;
char mp[N + 5][M];
inline void FWTxor(long long *a, int coe) {
for (int len = 1; len < n2; len <<= 1)
for (int st = 0; st < n2; st += len << 1)
for (int d = 0; d < len; ++d) {
long long ml = a[st + d], mr = a[st + d + len];
a[st + d] = (ml + mr) * coe % MOD;
a[st + d + len] = (ml - mr) * coe % MOD;
}
}
inline int calc(int x) {
int res = 0;
while (x) res += (x & 1), x >>= 1;
return res;
}
int main() {
scanf("%d%d", &n, &m);
n2 = 1 << n;
for (int i = 1; i <= n; ++i) scanf("%s", &mp[i][1]);
for (int i = 1, x; i <= m; ++i) {
x = 0;
for (int j = 1; j <= n; ++j) (x <<= 1) |= mp[j][i] - '0';
++a[x];
}
for (int i = 0; i < n2; ++i) b[i] = calc(i), b[i] = min(b[i], n - b[i]);
FWTxor(a, 1);
FWTxor(b, 1);
for (int i = 0; i < n2; ++i) a[i] = a[i] * b[i] % MOD;
FWTxor(a, (MOD + 1) / 2);
for (int i = 0; i < n2; ++i) ans = min((a[i] + MOD) % MOD, ans);
printf("%lld\n", ans);
return 0;
}
|
#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;
}
inline void wrote(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) wrote(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
wrote(x);
puts("");
}
const int N = 20;
int answ, n, m, f[N + 1][(1 << N) | 111], all;
char s[21][100010];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; ++i) {
int sz = 0;
for (int j = 1; j <= n; ++j) sz = sz << 1 | (s[j][i] - '0');
f[0][sz]++;
}
all = (1 << n) - 1;
for (int v = 0; v <= n - 1; ++v)
for (int k = n - 1; k >= 0; --k)
for (int l = 0; l <= all; ++l) f[k + 1][l ^ (1 << v)] += f[k][l];
answ = n * m;
for (int v = 0; v <= all; ++v) {
int ans = 0;
for (int k = 0; k <= n; ++k) ans += min(k, n - k) * f[k][v];
answ = min(answ, ans);
}
writeln(answ);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25, maxm = 1e5 + 111, maxs = (1 << 20) + 7, mo = 998244353;
int N, M, tot;
char mp[maxn][maxm];
int a[maxs], b[maxs];
int work(int l) {
int res = 0;
for (int i = 1; i <= N; ++i) res = res << 1 | (mp[i][l] - '0');
return res;
}
int ksm(int x, int t) {
int res = 1;
while (t) {
if (t & 1) res = 1ll * res * x % mo;
x = 1ll * x * x % mo;
t >>= 1;
}
return res;
}
void XOR(int *f, int x) {
int aa, bb;
for (int k = 2; k <= tot; k <<= 1)
for (int i = 0; i < tot; i += k)
for (int j = i; j < i + k / 2; ++j) {
aa = f[j], bb = f[j + k / 2];
f[j] = (aa + bb) % mo;
f[j + k / 2] = (aa - bb + mo) % mo;
f[j] = 1ll * f[j] * x % mo;
f[j + k / 2] = 1ll * f[j + k / 2] * x % mo;
}
}
void MUL() {
for (int i = 0; i < tot; ++i) a[i] = 1ll * a[i] * b[i] % mo;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%s", mp[i] + 1);
for (int i = 1; i <= M; ++i) a[work(i)]++;
tot = 1 << N;
for (int i = 0; i < tot; ++i)
b[i] = min(__builtin_popcount(i), N - __builtin_popcount(i));
XOR(a, 1);
XOR(b, 1);
MUL();
XOR(a, ksm(2, mo - 2));
int ans = N * M;
for (int i = 0; i < tot; ++i) ans = min(ans, a[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1048576 + 21, LG = 23;
int n, m, k, ans;
string s[LG];
long long dp[MAXN][LG];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
ans = m * n;
for (int i = 0; i < n; i++) cin >> s[i];
int tmp = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) tmp += (1 << j) * (s[j][i] - '0');
dp[tmp][0]++;
tmp = 0;
}
for (int i = 1; i <= n; i++)
for (int j = i; ~j; j--)
for (int msk = 0; msk < (1 << n); msk++) {
dp[msk][j] += dp[msk ^ (1 << (i - 1))][j - 1];
}
for (int msk = 0; msk < (1 << n); msk++) {
k = 0;
for (int j = 0; j <= n; j++) k += dp[msk][j] * min(n - j, j);
ans = min(ans, k);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, col[N], dp[21][1 << 20], cs[1 << 20][2];
char c[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", c);
for (int j = 0; j < m; j++) col[j] |= (c[j] - '0') << i;
}
for (int i = 0; i < m; i++) dp[0][col[i]]++, cs[col[i]][0]++;
for (int i = 1; i <= n; i++) {
int bit = i & 1;
for (int j = 0; j < 1 << n; j++) {
int &ref = dp[i][j];
for (int k = 0; k < n; k++) ref += cs[j ^ (1 << k)][!bit] - cs[j][bit];
cs[j][bit] += ref /= i;
}
}
int ans = 1e9;
for (int i = 0; i < 1 << n; i++) {
int temp = 0;
for (int j = 1; j < n; j++) temp += min(j, n - j) * dp[j][i];
ans = min(ans, temp);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353, inv2 = 499122177;
inline void XOR(int *a, int lim, int type) {
for (register int mid = 1; mid < lim; mid <<= 1) {
for (register int i = mid << 1, j = 0; j < lim; j += i) {
for (register int k = 0; k < mid; k++) {
a[j + k] += a[j + k + mid];
if (a[j + k] >= p) a[j + k] -= p;
a[j + k + mid] = a[j + k] - a[j + k + mid] - a[j + k + mid];
if (a[j + k + mid] >= p)
a[j + k + mid] -= p;
else
while (a[j + k + mid] < 0) a[j + k + mid] += p;
if (type == -1)
a[j + k] = 1ll * a[j + k] * inv2 % p,
a[j + k + mid] = 1ll * a[j + k + mid] * inv2 % p;
}
}
}
}
int n, m, lim;
char s[25][2000086];
int a[2000086], b[2000086];
int ans = 0x3f3f3f3f;
int main() {
scanf("%d%d", &n, &m), lim = 1 << n;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int sum = 0;
for (int j = 1, k = 1; j <= n; j++, k <<= 1)
if (s[j][i] == '1') sum += k;
++a[sum];
}
for (int i = 1; i <= lim; i++) {
for (int j = i; j; j >>= 1)
if (j & 1) ++b[i];
b[i] = min(b[i], n - b[i]);
}
XOR(a, lim, 1), XOR(b, lim, 1);
for (int i = 0; i < lim; i++) a[i] = 1ll * a[i] * b[i] % p;
XOR(a, lim, -1);
for (int i = 0; i < lim; i++) ans = min(ans, a[i]);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long inff = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-9;
const int maxn = 1 << 21;
long long f[maxn], g[maxn];
int a[21][100005], st[100005], lim;
void XOR(long long *f, int opt) {
for (int o = 2, k = 1; o <= lim; o <<= 1, k <<= 1)
for (int i = 0; i < lim; i += o)
for (int 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] = 1LL * f[i + j] / (opt == 1 ? 1 : 2),
f[i + j + k] = 1LL * f[i + j + k] / (opt == 1 ? 1 : 2);
}
char s[100005];
int main() {
int n, m;
scanf("%d%d", &(n), &(m));
lim = 1 << n;
for (int i = (1); i <= (int)(n); ++i) {
scanf("%s", s + 1);
for (int j = (1); j <= (int)(m); ++j) a[i][j] = s[j] - '0';
}
for (int i = (1); i <= (int)(lim - 1); ++i) f[i] = f[i >> 1] + (i & 1);
for (int i = (0); i <= (int)(lim - 1); ++i) f[i] = min(f[i], n - f[i]);
for (int j = (1); j <= (int)(m); ++j) {
st[j] = 0;
for (int i = (1); i <= (int)(n); ++i) {
st[j] = st[j] * 2 + a[i][j];
}
g[st[j]]++;
}
XOR(f, 1), XOR(g, 1);
for (int i = (0); i <= (int)(lim - 1); ++i) f[i] = f[i] * g[i];
XOR(f, -1);
long long ans = inf;
for (int i = (0); i <= (int)(lim - 1); ++i) ans = min(ans, f[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
string ss[22];
int ar[100001], dp[2][21][1 << 20];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = (0); i < (n); ++i) {
cin >> ss[i];
}
for (int i = (0); i < (m); ++i) {
for (int j = (0); j < (n); ++j) {
if (ss[j][i] == '1') ar[i] ^= 1 << j;
}
dp[0][0][ar[i]]++;
}
int fl = 0;
for (int i = n - 1; i >= 0; i--) {
fl ^= 1;
for (int j = 0; j <= n; j++) {
for (int k = (0); k < (1 << n); ++k) {
dp[fl][j][k] = dp[fl ^ 1][j][k];
if (j) dp[fl][j][k] += dp[fl ^ 1][j - 1][k ^ (1 << i)];
}
}
}
int res = INT_MAX / 3;
for (int i = (0); i < (1 << n); ++i) {
int sum = 0;
for (int j = (0); j < (n + 1); ++j) {
sum += min(j, n - j) * dp[fl][j][i];
}
res = min(res, sum);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int cnt[65536];
int count(int x) { return cnt[x >> 16] + cnt[x & 65535]; }
void pre_count() {
int i, j;
for (i = 0; i < (1 << 16); i++)
for (j = 0; j < 16; j++)
if (i & (1 << j)) cnt[i]++;
}
void FWT_XOR(long long *s, int len, int type) {
int i, j, k;
long long tmp;
for (k = 2; k <= len; k <<= 1)
for (i = 0; i < len; i += k)
for (j = 0; j < (k >> 1); j++) {
tmp = s[i + j];
s[i + j] = s[i + j] + s[i + j + (k >> 1)];
s[i + j + (k >> 1)] = tmp - s[i + j + (k >> 1)];
if (type == -1) s[i + j] >>= 1, s[i + j + (k >> 1)] >>= 1;
}
}
int n, m;
long long a[(1 << 20) + 10], b[(1 << 20) + 10];
int c[(1 << 20) + 10];
char str[(1 << 20) + 10];
int main() {
scanf("%d%d", &n, &m);
int i, j;
long long ans = inf;
for (i = 0; i < n; i++) {
scanf("%s", str + 1);
for (j = 1; j <= m; j++) c[j] |= (str[j] - '0') << i;
}
pre_count();
for (j = 1; j <= m; j++) a[c[j]]++;
for (i = 0; i < (1 << n); i++) b[i] = min(count(i), n - count(i));
FWT_XOR(a, (1 << n), 1);
FWT_XOR(b, (1 << n), 1);
for (i = 0; i < (1 << n); i++) a[i] = a[i] * b[i];
FWT_XOR(a, (1 << n), -1);
for (i = 0; i < (1 << n); i++) ans = min(ans, a[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 22, MAXS = 1 << 20;
int N, M;
int A[MAXS];
int dp[2][MAXN][MAXS];
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);
}
}
int cur = 0, prv = 1;
for (int i = 0; i < M; i++) {
dp[cur][0][A[i]]++;
}
for (int i = 0; i < N; i++) {
swap(cur, prv);
for (int j = 0; j <= N; j++) {
for (int k = 0; k < (1 << N); k++) {
dp[cur][j][k] = dp[prv][j][k];
if (j) {
dp[cur][j][k] += dp[prv][j - 1][k ^ (1 << i)];
}
}
}
}
int ans = 2e9;
for (int val = 0; val < (1 << N); val++) {
int res = 0;
for (int i = 0; i <= N; i++) {
res += dp[cur][i][val] * min(i, N - i);
}
ans = min(ans, res);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 22;
const long long M = 100005;
long long a[1 << N];
long long b[1 << N];
long long tmp[1 << N];
char ss[N][M];
long long n, nn, m;
void FWT(long long *a, long long n, long long o) {
for (long long u = 1; u <= n; u <<= 1) {
for (long long i = 0; i <= n; i++) tmp[i] = 0;
for (long long i = 0; i <= n; i++) {
if (u & i)
tmp[i] -= a[i], tmp[i ^ u] += a[i];
else
tmp[i] += a[i], tmp[i ^ u] += a[i];
}
for (long long i = 0; i <= n; i++) {
a[i] = tmp[i];
if (o == -1) a[i] /= 2;
}
}
}
int main() {
scanf("%lld%lld", &n, &m);
nn = (1 << n);
nn--;
for (long long u = 1; u <= n; u++) scanf("%s", ss[u] + 1);
for (long long u = 1; u <= m; u++) {
long long now = 0;
for (long long i = 1; i <= n; i++) now = ((now << 1) + ss[i][u] - '0');
a[now]++;
}
b[0] = 0;
for (long long u = 1; u <= nn; u++) b[u] = b[u >> 1] + (u & 1);
for (long long u = 0; u <= nn; u++) b[u] = min(b[u], n - b[u]);
FWT(a, nn, 1);
FWT(b, nn, 1);
for (long long u = 0; u <= nn; u++) a[u] = a[u] * b[u];
FWT(a, nn, -1);
long long ans = n * m;
for (long long u = 0; u <= nn; u++) ans = min(ans, a[u]);
printf("%lld\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;
void getint(int &v) {
char ch, fu = 0;
for (ch = '*'; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') fu = 1, ch = getchar();
for (v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = v * 10 + ch - '0';
if (fu) v = -v;
}
const int INF = 1e9 + 10;
char s[500010];
int pc[2000010], n, l, m, a[200010];
long long F[2000010], G[2000010], ans, H[2000010];
void fwt(long long *a, int tp) {
for (int j = 0; j <= l - 1; ++j)
for (int i = 0; i <= n - 1; ++i)
if ((i >> j) & 1) {
long long x = a[i ^ (1 << j)], y = a[i];
a[i ^ (1 << j)] = (x + y) / (tp == 1 ? 1 : 2),
a[i] = (x - y) / (tp == 1 ? 1 : 2);
}
}
int main() {
pc[0] = 0;
for (int i = 1; i <= 2000000; ++i) pc[i] = pc[i >> 1] + (i & 1);
cin >> n >> m;
for (int i = 0; i <= n - 1; ++i) {
scanf("%s", s);
for (int j = 0; j <= m - 1; ++j) a[j] |= (s[j] - '0') << i;
}
l = n;
n = 1 << n;
for (int j = 0; j <= m - 1; ++j) ++F[a[j]];
for (int j = 0; j <= n - 1; ++j) G[j] = min(pc[j], l - pc[j]);
fwt(F, 1);
fwt(G, 1);
for (int j = 0; j <= n - 1; ++j) H[j] = F[j] * G[j];
fwt(H, -1);
ans = INF;
for (int j = 0; j <= n - 1; ++j) ans = min(ans, H[j]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
char s[20][maxn];
long long v[1048576], pc[1048576];
void xorfwt(long long v[], int l, int r) {
if (r - l == 1) return;
int m = l + r >> 1;
xorfwt(v, l, m), xorfwt(v, m, r);
for (int i = l, j = m; i < m; ++i, ++j) {
long long x = v[i] + v[j];
v[j] = v[i] - v[j], v[i] = x;
}
}
void xorifwt(long long v[], int l, int r) {
if (r - l == 1) return;
int m = l + r >> 1;
for (int i = l, j = m; i < m; ++i, ++j) {
long long x = (v[i] + v[j]) / 2;
v[j] = (v[i] - v[j]) / 2, v[i] = x;
}
xorifwt(v, l, m), xorifwt(v, m, r);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < m; ++i) {
int t = 0;
for (int j = 0; j < n; ++j) t ^= ((s[j][i] - '0') << j);
++v[t];
}
auto inv = [&](const int &k, int r = 0) {
for (int i = 0; i < n; ++i) r ^= (((k >> i & 1) ^ 1) << i);
return r;
};
for (int i = 0; i < (1 << n); ++i)
pc[i] = min(__builtin_popcount(i), __builtin_popcount(inv(i)));
xorfwt(v, 0, (1 << n)), xorfwt(pc, 0, (1 << n));
for (int i = 0; i < (1 << n); ++i) v[i] *= pc[i];
xorifwt(v, 0, (1 << n));
int ans = maxn * 20;
for (int i = 0; i < (1 << n); ++i) ans = min(ans, (int)v[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 100000000;
vector<long long> fwt(vector<long long> A, int N, bool inv) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < (1 << N); j++) {
if (!(j >> i & 1)) {
long long x = A[j];
long long y = A[j | (1 << i)];
A[j] = x + y;
A[j | (1 << i)] = x - y;
if (inv) {
A[j] /= 2;
A[j | (1 << i)] /= 2;
}
}
}
}
return A;
}
vector<long long> xor_convolution(vector<long long> A, vector<long long> B,
int N) {
A = fwt(A, N, false);
B = fwt(B, N, false);
vector<long long> C(1 << N);
for (int i = 0; i < (1 << N); i++) {
C[i] = A[i] * B[i];
}
C = fwt(C, N, true);
return C;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<char>> A(n, vector<char>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> A[i][j];
}
}
vector<int> num(m, 0);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
num[i] *= 2;
num[i] += A[j][i] - '0';
}
}
vector<long long> cnt(1 << n, 0);
for (int i = 0; i < m; i++) {
cnt[num[i]]++;
}
vector<long long> cost(1 << n);
for (int i = 0; i < (1 << n); i++) {
cost[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
}
vector<long long> tmp = xor_convolution(cnt, cost, n);
long long ans = INF;
for (int i = 0; i < (1 << n); i++) {
ans = min(ans, tmp[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 1e5 + 5;
char G[22][MAXN];
int sta[MAXN];
long long a[1 << 22], b[1 << 22];
void FWT(long long a[], int n) {
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];
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 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];
a[i + j] = (x + y) / 2, a[i + j + d] = (x - y) / 2;
}
}
int flip(int x, int n) {
int res = 0;
while (x) {
res += x & 1;
x >>= 1;
}
return min(res, n - res);
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; ++i) scanf("%s", G[i]);
for (int i = 0; i < m; ++i) {
sta[i] = 0;
for (int j = 0; j < n; ++j) {
sta[i] |= (G[j][i] - '0') << j;
}
}
memset(a, 0, sizeof(a));
for (int i = 0; i < m; ++i) a[sta[i]]++;
for (int i = 0; i < (1 << n); ++i) b[i] = flip(i, n);
FWT(a, 1 << n);
FWT(b, 1 << n);
for (int i = 0; i < (1 << n); ++i) a[i] = a[i] * b[i];
UFWT(a, 1 << n);
long long ans = INF;
for (int i = 0; i < (1 << n); ++i) ans = min(a[i], ans);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 100100;
const int MOD = 998244353;
int add(int a, int b) { return (a + b) % MOD; }
int sub(int a, int b) { return (a - b + MOD) % MOD; }
int mul(int a, int b) { return (long long)a * b % MOD; }
int ksm(int a, int b) {
if (!b) return 1;
int x = ksm(a, b >> 1);
return mul(mul(x, x), b & 1 ? a : 1);
}
int inv(int a) { return ksm(a, MOD - 2); }
const int INV2 = inv(2);
void FWT(int *x, int n) {
if (n == 1) return;
int l = n >> 1;
FWT(x, l);
FWT(x + l, l);
for (int i = 0; i < l; i++) {
int &u = x[i], &v = x[l + i];
int uu = u, vv = v;
u = add(uu, vv);
v = sub(uu, vv);
}
}
void IFWT(int *x, int n) {
if (n == 1) return;
int l = n >> 1;
for (int i = 0; i < l; i++) {
int &u = x[i], &v = x[l + i];
int uu = u, vv = v;
u = mul(add(uu, vv), INV2);
v = mul(sub(uu, vv), INV2);
}
IFWT(x, l);
IFWT(x + l, l);
}
int n, m;
char s[N][M] = {'\0'};
int a[1 << N] = {0}, b[1 << N] = {0};
int pc(int x) { return x ? pc(x & (x - 1)) + 1 : 0; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char &ch = s[i][j];
do {
ch = getchar();
} while (!isdigit(ch));
}
}
for (int i = 0; i < m; i++) {
int c = 0;
for (int j = 0; j < n; j++) {
c = (c << 1) | (s[j][i] ^ '0');
}
a[c]++;
}
int x = 1 << n;
for (int j = 0; j < x; j++) {
b[j] = min(pc(j), pc((x - 1) ^ j));
}
FWT(a, x);
FWT(b, x);
for (int i = 0; i < x; i++) {
a[i] = mul(a[i], b[i]);
}
IFWT(a, x);
int ans = INT_MAX;
for (int i = 0; i < x; i++) {
ans = min(ans, (int)a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXS = 1 << 20;
const int MAXN = 20;
const int MAXM = 100005;
int n, m, a[MAXM], bit[MAXS];
long long f[MAXS], dp[MAXS];
inline void FWT(long long arr[], int len, int flg) {
long long x, y;
for (int i = 2; i <= len; i <<= 1)
for (int j = 0; j < len; j += i)
for (int k = j; k < j + i / 2; ++k) {
x = arr[k], y = arr[k + i / 2];
if (~flg)
arr[k] = x + y, arr[k + i / 2] = x - y;
else
arr[k] = (x + y) >> 1, arr[k + i / 2] = (x - y) >> 1;
}
}
char s[MAXM];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j) a[j] = (a[j] << 1) | (s[j] == '1');
}
for (int i = 1; i <= m; ++i) ++f[a[i]];
for (int s = 0; s < (1 << n); ++s) bit[s] = bit[s >> 1] + (s & 1);
for (int s = 0; s < (1 << n); ++s)
dp[s] = min(bit[s], bit[s ^ ((1 << n) - 1)]);
FWT(f, 1 << n, 1), FWT(dp, 1 << n, 1);
for (int i = 0; i < (1 << n); ++i) f[i] *= dp[i];
FWT(f, 1 << n, -1);
long long ans = n * m;
for (int i = 0; i < (1 << n); ++i) ans = min(ans, f[i]);
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20);
const long long Mod = (long long)1e9 + 7;
const long long Inv2 = (long long)5e8 + 4;
void dwt(long long x[], int l, int r) {
if (l + 1 == r) return;
int mid = (l + r) >> 1;
dwt(x, l, mid);
dwt(x, mid, r);
for (int i = l; i < mid; i++) {
long long x1 = x[i] - x[i - l + mid];
long long x2 = x[i] + x[i - l + mid];
x[i] = (x1 + Mod) % Mod;
x[i - l + mid] = (x2 + Mod) % Mod;
}
}
void rdwt(long long x[], int l, int r) {
if (l + 1 == r) return;
int mid = (l + r) >> 1;
for (int i = l; i < mid; i++) {
long long x1 = x[i];
long long x2 = x[i - l + mid];
x[i] = (x1 + x2) * Inv2 % Mod;
x[i - l + mid] = (x2 - x1) * Inv2 % Mod;
}
rdwt(x, l, mid);
rdwt(x, mid, r);
}
long long a[N], b[N], c[N];
void multi(long long a[], long long b[], long long c[], int n) {
dwt(a, 0, n);
dwt(b, 0, n);
for (int i = 0; i < n; i++) c[i] = a[i] * b[i] % Mod;
rdwt(c, 0, n);
for (int i = 0; i < n; i++) {
c[i] = (c[i] + Mod) % Mod;
}
}
int x[N];
int main() {
ios ::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < (1 << n); i++) {
int t = __builtin_popcount(i);
b[i] = min(t, n - t);
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++)
if (s[j] == '1') x[j] |= (1 << i);
}
for (int i = 0; i < m; i++) a[x[i]]++;
multi(a, b, c, (1 << n));
int ans = ~0U >> 1;
for (int i = 0; i < (1 << n); i++) ans = min((long long)ans, c[i]);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100010], c[21], n, m;
void init() {
char cur[100010];
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", cur);
for (int j = 1; j <= m; j++) a[j] = (a[j] << 1) + cur[j - 1] - '0';
}
c[1] = 1;
for (int i = 2; i <= 20; i++) c[i] = c[i - 1] << 1;
}
int dp[21][1 << 20];
int main() {
init();
for (int i = 1; i <= m; i++) dp[0][a[i]]++;
for (int k = 1; k <= n; k++)
for (int i = 0; i < (1 << n); i++) {
int sum = (k > 1) ? (k - 2 - n) * dp[k - 2][i] : 0;
for (int j = 1; j <= n; j++) sum += dp[k - 1][i ^ c[j]];
dp[k][i] = sum / k;
}
int ans = n * m;
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int k = 0; k <= n; k++) cnt += min(k, n - k) * dp[k][i];
ans = min(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
unsigned short counter[14][1 << 7];
char popcount[1 << 20], str[21][100010];
int n, m, r, p, lim, ar[100010], dp[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]++;
}
memset(dp, 0, sizeof(dp));
p = n - r, l = (1 << p) - 1;
for (i = 0, z = 0; i <= r; i++) {
for (j = 0; j <= l; j++) {
if (counter[i][j]) {
for (k = 0; k <= l; k++) {
x = j ^ k, c = popcount[x] + i;
if ((n - c) < c) c = n - c;
dp[k] += (c * counter[i][j]);
}
}
}
}
for (i = 0; i <= l; i++) res = ((res) < (dp[i]) ? (res) : (dp[i]));
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FWT(long long *f, int n, int tp) {
int len = 1 << n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < len; j++) {
if (j & (1 << i)) {
long long a = f[j ^ (1 << i)], b = f[j];
f[j ^ (1 << i)] = a + b;
f[j] = a - b;
}
}
}
if (tp == -1) {
for (int i = 0; i < len; i++) f[i] = f[i] / len;
}
}
char s[22][100005];
long long num[((1 << 20) + 5)], Min[((1 << 20) + 5)], ans[((1 << 20) + 5)];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int len = 1 << n;
for (int i = 0; i < n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int sum = 0;
for (int j = 0; j < n; j++)
if (s[j][i] == '1') sum |= (1 << j);
num[sum]++;
}
for (int i = 0; i < len; i++) {
int sum = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) sum++;
Min[i] = min(sum, n - sum);
}
FWT(num, n, 1), FWT(Min, n, 1);
for (int i = 0; i < len; i++) ans[i] = num[i] * Min[i];
FWT(ans, n, -1);
long long ret = 1e9;
for (int i = 0; i < len; i++) ret = min(ret, ans[i]);
printf("%lld\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20 | 10;
int n, m;
char s[N / 10];
int a[20][N / 10];
long long g[N], f[N], F[N];
void FWT(long long *a, int lim, int type) {
for (int len = 2; len <= lim; len <<= 1) {
int mid = len >> 1;
for (int i = 0; i < lim; i += len) {
for (int j = 0; j < mid; ++j) {
long long x = a[i + j], y = a[i + j + mid];
a[i + j] = x + y;
a[i + j + mid] = x - y;
}
}
}
if (type == -1) {
for (int i = 0; i < lim; ++i) {
a[i] /= lim;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < (1 << n); ++i) {
g[i] = (g[i >> 1]) + (i & 1);
}
for (int i = 0; i < (1 << n); ++i) {
g[i] = min(g[i], n - g[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%s", s);
for (int j = 0; j < m; ++j) {
a[i][j] = s[j] - '0';
}
}
for (int i = 0; i < m; ++i) {
int x = 0;
for (int j = 0; j < n; ++j) {
x |= a[j][i] * (1 << j);
}
++f[x];
}
int lim = 1 << n;
FWT(f, lim, 1);
FWT(g, lim, 1);
for (int i = 0; i < lim; ++i) {
F[i] = f[i] * g[i];
}
FWT(F, lim, -1);
long long ans = 0x3f3f3f3f;
for (int i = 0; i < lim; ++i) {
ans = min(ans, F[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1100000 + 1], fl[1100000 + 1], poc[1100000 + 1],
ans = 999999999999;
string s[23];
void putin() {
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> s[i];
for (long long j = 0; j < m; j++) {
for (long long i = 0; i < n; i++) {
if (s[i][j] == '1') a[j] += (1 << i);
}
fl[a[j]]++;
}
}
long long lowbit(long long x) { return x & (-x); }
void ycl() {
for (long long i = 1; i < (1 << n); i++) poc[i] = poc[i - lowbit(i)] + 1;
for (long long i = 0; i < (1 << n); i++)
poc[i] = min(poc[i], poc[i ^ ((1 << n) - 1)]);
}
void fwt(long long* x, long long l, long long r, long long nfl) {
if (r != l + 1) fwt(x, l, (l + r) / 2, nfl), fwt(x, (l + r) / 2, r, nfl);
if (nfl == 1) {
for (long long i = l; i < (l + r) / 2; i++) {
long long np = x[i], nq = x[i + (l + r) / 2 - l];
x[i] = np + nq, x[i + (l + r) / 2 - l] = np - nq;
}
} else {
for (long long i = l; i < (l + r) / 2; i++) {
long long np = x[i], nq = x[i + (l + r) / 2 - l];
x[i] = (np + nq) / 2, x[i + (l + r) / 2 - l] = (np - nq) / 2;
}
}
}
signed main() {
putin();
ycl();
fwt(fl, 0, (1 << n), 1), fwt(poc, 0, (1 << n), 1);
for (long long i = 0; i < (1 << n); i++) fl[i] *= poc[i];
fwt(fl, 0, (1 << n), -1);
for (long long i = 0; i < (1 << n); i++) ans = min(ans, fl[i]);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[21][100100];
int dp[21][1 << 20];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> 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 = n; j > 0; j--)
for (int k = 0; k < 1 << n; k++) dp[j][k ^ 1 << i] += dp[j - 1][k];
int ans = 1e9;
for (int i = 0; i < 1 << n; i++) {
int x = 0;
for (int j = 0; j <= n; j++) x += min(j, n - j) * dp[j][i];
ans = min(ans, x);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000000 + 7;
const int M = 26;
const int mod = 999983;
const int inf = 1e9 + 7;
const double pi = acos(-1);
const int maxn = N * 2;
const double PI = acos(-1);
int n, m;
int a[N];
int dp[22][N];
string s;
void solve() {
cin >> n >> m;
for (int i = (0); i < (n); i++) {
cin >> s;
for (int j = (0); j < (m); j++) {
int u = s[j] - '0';
a[j] = (a[j] << 1) | u;
}
}
for (int i = (0); i < (m); i++) {
dp[0][a[i]]++;
}
for (int k = (1); k < (n + 1); k++) {
for (int mask = (0); mask < (1 << n); mask++) {
if (k >= 2) dp[k][mask] = (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;
}
}
int ans = inf;
for (int mask = (0); mask < (1 << n); mask++) {
int cur = 0;
for (int k = (0); k < (n + 1); k++) cur += min(k, n - k) * dp[k][mask];
ans = min(ans, cur);
}
cout << ans;
}
int main() {
int T = 1;
for (int i = (1); i < (T + 1); i++) {
solve();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.