text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 300005;
string perm = "ACGT";
int n, m;
string grid[MAXN];
string ans[MAXN];
int absolute_min = INF;
int shift[MAXN];
void solve() {
int cur_cost = 0;
for (int i = 0; i < n; ++i) {
int cost_no_shift = 0;
int cost_shift = 0;
for (int j = 0; j < m; ++j) {
cost_no_shift += (perm[(i % 2) * 2 + (j % 2)] != grid[i][j]);
cost_shift += (perm[(i % 2) * 2 + ((j + 1) % 2)] != grid[i][j]);
}
cur_cost += min(cost_no_shift, cost_shift);
shift[i] = (cost_no_shift > cost_shift);
}
if (cur_cost < absolute_min) {
absolute_min = cur_cost;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
ans[i][j] = perm[(i % 2) * 2 + (j + shift[i]) % 2];
}
}
}
void solve_transposed() {
int cur_cost = 0;
for (int j = 0; j < m; ++j) {
int cost_no_shift = 0;
int cost_shift = 0;
for (int i = 0; i < n; ++i) {
cost_no_shift += (perm[(j % 2) * 2 + (i % 2)] != grid[i][j]);
cost_shift += (perm[(j % 2) * 2 + ((i + 1) % 2)] != grid[i][j]);
}
cur_cost += min(cost_no_shift, cost_shift);
shift[j] = (cost_no_shift > cost_shift);
}
if (cur_cost < absolute_min) {
absolute_min = cur_cost;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
ans[i][j] = perm[(j % 2) * 2 + (i + shift[j]) % 2];
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
cin >> grid[i];
ans[i].resize(m);
}
do {
solve();
solve_transposed();
} while (next_permutation(perm.begin(), perm.end()));
for (int i = 0; i < n; ++i) {
cout << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<int> mp[300135];
char s[300135];
string S = "AGCT";
int r[300135][2][4], col[300135][2][4];
int ans[4], id[4], A;
int gid(char x) {
for (int(i) = 0; (i) < (int)(4); (i)++)
if (S[i] == x) return i;
return -1;
}
int cal(int a, int b, int c, int d, bool fg) {
int t1 = 0, t2 = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (i % 2 == 1)
t1 += max(r[i][0][a] + r[i][1][b], r[i][0][b] + r[i][1][a]);
else
t1 += max(r[i][0][c] + r[i][1][d], r[i][0][d] + r[i][1][c]);
}
if (fg && t1 == A) {
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (i % 2 == 1) {
if (r[i][0][a] + r[i][1][b] < r[i][0][b] + r[i][1][a]) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[a] : S[b]);
} else
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[b] : S[a]);
} else {
if (r[i][0][c] + r[i][1][d] < r[i][0][d] + r[i][1][c]) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[c] : S[d]);
} else
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[d] : S[c]);
}
puts("");
}
exit(0);
}
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (j % 2 == 1) {
t2 += max(col[j][0][a] + col[j][1][c], col[j][0][c] + col[j][1][a]);
} else {
t2 += max(col[j][0][b] + col[j][1][d], col[j][0][d] + col[j][1][b]);
}
}
if (fg) {
assert(t2 == A);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (j % 2 == 1) {
if (col[j][0][a] + col[j][1][c] < col[j][0][c] + col[j][1][a]) {
printf("%c", i & 1 ? S[a] : S[c]);
} else
printf("%c", i & 1 ? S[c] : S[a]);
} else {
if (col[j][0][b] + col[j][1][d] < col[j][0][d] + col[j][1][b]) {
printf("%c", i & 1 ? S[b] : S[d]);
} else
printf("%c", i & 1 ? S[d] : S[b]);
}
}
puts("");
}
}
return max(t1, t2);
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
mp[i].resize(m + 5, -1);
scanf("%s", s + 1);
for (int(j) = 1; (j) <= (int)(m); (j)++) {
mp[i][j] = gid(s[j]);
}
for (int(j) = 1; (j) <= (int)(m); (j)++) {
r[i][j % 2][mp[i][j]]++;
col[j][i % 2][mp[i][j]]++;
}
}
for (int(i) = 0; (i) < (int)(4); (i)++) id[i] = i;
do {
int tt = cal(id[0], id[1], id[2], id[3], 0);
if (tt > A) {
A = tt;
for (int(i) = 0; (i) < (int)(4); (i)++) ans[i] = id[i];
}
} while (next_permutation(id, id + 4));
cal(ans[0], ans[1], ans[2], ans[3], 1);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long m, n, ans, a, b, cnt[2][300100][4], zh[210], dp[300100][4][4];
pair<long long, long long> last[300100][4][4], pp;
char fz[4];
string str[300100], tmp[300100], A, B, C, D;
inline long long get(long long u, long long v) {
long long i, j, p, q, res = 0;
for (p = 0; p < 4; p++)
if (p != u && p != v) break;
for (q = p + 1; q < 4; q++)
if (q != u && q != v) break;
for (i = 0; i < n; i++) {
A[i] = (i & 1) ? fz[p] : fz[q];
B[i] = (i & 1) ? fz[q] : fz[p];
C[i] = (i & 1) ? fz[u] : fz[v];
D[i] = (i & 1) ? fz[v] : fz[u];
}
for (i = 0; i < m; i++) {
long long c1, c2;
c1 = c2 = 0;
if (i & 1) {
for (j = 0; j < n; j++)
c1 += (C[j] == str[i][j]), c2 += (D[j] == str[i][j]);
if (c1 > c2)
tmp[i] = C, res += c1;
else
tmp[i] = D, res += c2;
} else {
for (j = 0; j < n; j++)
c1 += (A[j] == str[i][j]), c2 += (B[j] == str[i][j]);
if (c1 > c2)
tmp[i] = A, res += c1;
else
tmp[i] = B, res += c2;
}
}
return res;
}
inline long long cmp() {
long long i, j, res = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
res += (str[i][j] == tmp[i][j]);
}
}
return res;
}
int main() {
memset(dp, -0x3f, sizeof(dp));
ios::sync_with_stdio(0);
long long i, j, k, p, q, t;
zh['A'] = 0, zh['G'] = 1, zh['T'] = 2, zh['C'] = 3;
fz[0] = 'A', fz[1] = 'G', fz[2] = 'T', fz[3] = 'C';
cin >> m >> n;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++) tmp[i] += '0';
for (i = 0; i < n; i++) A += '0', B += '0', C += '0', D += '0';
for (i = 0; i < m; i++) {
cin >> str[i];
for (j = 0; j < n; j++) {
cnt[i & 1][j][zh[str[i][j]]]++;
}
}
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
if (i != j) dp[0][i][j] = cnt[0][0][i] + cnt[1][0][j];
for (i = 0; i < n - 1; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++) {
if (j == k) continue;
for (p = 0; p < 4; p++) {
if (p == j || p == k) continue;
for (q = 0; q < 4; q++) {
if (q == p || q == j || q == k) continue;
t = dp[i][j][k] + cnt[0][i + 1][p] + cnt[1][i + 1][q];
if (dp[i + 1][p][q] < t) {
dp[i + 1][p][q] = t;
last[i + 1][p][q] = make_pair(j, k);
}
}
}
}
}
}
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (i == j) continue;
if (dp[n - 1][i][j] > ans) {
a = i, b = j;
ans = dp[n - 1][i][j];
}
}
}
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (i == j) continue;
t = get(i, j);
if (t > ans) {
ans = t;
pp = make_pair(i, j);
}
}
}
if (pp.first + pp.second) {
get(pp.first, pp.second);
for (i = 0; i < m; i++) cout << tmp[i] << endl;
return 0;
}
for (p = a, q = b, i = n - 1; i >= 0; i--) {
tmp[0][i] = fz[p];
tmp[1][i] = fz[q];
pp = make_pair(p, q);
p = last[i][pp.first][pp.second].first;
q = last[i][pp.first][pp.second].second;
}
for (i = 0; i < m; i++) {
cout << tmp[i & 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, vector<string> > solve(int n, int m, vector<string> a) {
char l[4] = {'A', 'C', 'G', 'T'};
int opt = n * m + 1;
vector<string> ans;
for (int u = 0; u < 4; ++u) {
for (int v = 0; v < 4; ++v) {
if (u == v) {
continue;
}
int uu = 0;
while (uu == u || uu == v) {
++uu;
}
int vv = 6 - u - v - uu;
int cnt = 0;
vector<string> curr(n);
for (int i = 0; i < n; ++i) {
int x, y;
if (i % 2 == 0) {
x = u, y = v;
} else {
x = uu, y = vv;
}
int cx = 0, cy = 0;
for (int j = 0; j < m; ++j) {
if ((j % 2 == 0) && a[i][j] != l[x]) {
++cx;
}
if ((j % 2 == 0) && a[i][j] != l[y]) {
++cy;
}
if ((j & 1) && a[i][j] != l[y]) {
++cx;
}
if ((j & 1) && a[i][j] != l[x]) {
++cy;
}
}
if (cx < cy) {
cnt += cx;
string s = "";
for (int j = 0; j < m; ++j) {
if (j % 2 == 0) {
s += l[x];
} else {
s += l[y];
}
}
curr[i] = s;
} else {
cnt += cy;
string s = "";
for (int j = 0; j < m; ++j) {
if (j % 2 == 0) {
s += l[y];
} else {
s += l[x];
}
}
curr[i] = s;
}
}
if (cnt < opt) {
opt = cnt;
ans = curr;
}
}
}
return {opt, ans};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
pair<int, vector<string> > ans1 = solve(n, m, a);
vector<string> b(m);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
b[i] += a[j][i];
}
}
pair<int, vector<string> > ans2 = solve(m, n, b);
vector<string> res(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
res[i] += ans2.second[j][i];
}
}
ans2.second = res;
if (ans1.first > ans2.first) {
swap(ans1, ans2);
}
for (int i = 0; i < n; ++i) {
cout << ans1.second[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int grand(int x) { return uniform_int_distribution<int>(0, x - 1)(rng); }
const int maxn = 3e5 + 7;
const int inf = 1e9 + 7;
const long long mod = 1e9 + 7;
long long gcd(long long x, long long y) {
if (x < y) return gcd(y, x);
if (y == 0) return x;
return gcd(y, x % y);
}
string A[maxn];
string B[maxn];
string best[maxn];
char ch[] = {'A', 'T', 'G', 'C'};
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
};
int n, m;
cin >> n >> m;
for (int j = 0; j < n; j++) {
cin >> A[j];
B[j] = A[j];
}
string blk[2];
blk[0] = " ";
blk[1] = " ";
int bsc = inf;
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
for (int z = 0; z < 4; z++) {
for (int w = 0; w < 4; w++) {
if (x == y || x == z || x == w || y == z || y == w || z == w)
continue;
blk[0][0] = ch[x];
blk[0][1] = ch[y];
blk[1][0] = ch[z];
blk[1][1] = ch[w];
int sc = 0;
for (int k = 0; k < m; k++) {
B[0][k] = blk[0][k % 2];
B[1][k] = blk[1][k % 2];
sc += B[0][k] != A[0][k];
sc += B[1][k] != A[1][k];
}
for (int j = 2; j < n; j++) {
int sc0 = 0, sc1 = 0;
for (int k = 0; k < m; k++) {
sc0 += B[j % 2][(k & 1)] != A[j][k];
sc1 += B[j % 2][(k & 1) ^ 1] != A[j][k];
}
if (sc0 < sc1) {
for (int k = 0; k < m; k++) {
B[j][k] = B[j % 2][k & 1];
sc += B[j][k] != A[j][k];
}
} else {
for (int k = 0; k < m; k++) {
B[j][k] = B[j % 2][(k & 1) ^ 1];
sc += B[j][k] != A[j][k];
}
}
}
if (sc < bsc) {
bsc = sc;
for (int j = 0; j < n; j++) {
best[j] = B[j];
}
}
sc = 0;
for (int j = 0; j < n; j++) {
B[j][0] = blk[j % 2][0];
B[j][1] = blk[j % 2][1];
sc += B[j][0] != A[j][0];
sc += B[j][1] != A[j][1];
}
for (int k = 2; k < m; k++) {
int sc0 = 0, sc1 = 0;
for (int j = 0; j < n; j++) {
sc0 += B[j & 1][(k & 1)] != A[j][k];
sc1 += B[(j & 1) ^ 1][(k & 1)] != A[j][k];
}
if (sc0 < sc1) {
for (int j = 0; j < n; j++) {
B[j][k] = B[(j & 1)][k & 1];
sc += B[j][k] != A[j][k];
}
} else {
for (int j = 0; j < n; j++) {
B[j][k] = B[(j & 1) ^ 1][(k & 1)];
sc += B[j][k] != A[j][k];
}
}
}
if (sc < bsc) {
bsc = sc;
for (int j = 0; j < n; j++) {
best[j] = B[j];
}
}
}
}
}
}
for (int j = 0; j < n; j++) {
cout << best[j] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9;
int n, m;
int ans = 1e9 + 7;
vector<int> g[N], invg[N], dans[N], tmp[N], tmp1[N], tmp2[N];
bool flag = 0;
int solve(int n, int m, vector<int> g[N], int tg) {
for (int i = 1; i <= n; i++)
tmp[i].resize(m + 1), tmp1[i].resize(m + 1), tmp2[i].resize(m + 1);
for (int i = 0; i <= 3; i++)
for (int j = i + 1; j <= 3; j++) {
int x1 = i, x2 = j, y1 = -1, y2 = -1, x, y;
for (int k = 0; k <= 3; k++)
if (k != i && k != j) {
if (y1 == -1)
y1 = k;
else
y2 = k;
}
int sum = 0;
for (int ii = 1; ii <= n; ii++) {
if (ii & 1)
x = x1, y = x2;
else
x = y1, y = y2;
int cnt1 = 0, cnt2 = 0;
for (int jj = 1; jj <= m; jj++) {
if (jj & 1) {
tmp1[ii][jj] = x;
if (g[ii][jj] != x) cnt1++;
} else {
tmp1[ii][jj] = y;
if (g[ii][jj] != y) cnt1++;
}
if (jj & 1) {
tmp2[ii][jj] = y;
if (g[ii][jj] != y) cnt2++;
} else {
tmp2[ii][jj] = x;
if (g[ii][jj] != x) cnt2++;
}
}
sum += min(cnt1, cnt2);
if (cnt1 <= cnt2)
tmp[ii] = tmp1[ii];
else
tmp[ii] = tmp2[ii];
}
if (ans > sum) {
flag = (tg == -1);
ans = sum;
for (int ii = 1; ii <= n; ii++) dans[ii] = tmp[ii];
}
}
return ans;
}
char cc[9] = {'A', 'G', 'C', 'T'};
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
char c;
for (int i = 1; i <= n; i++) g[i].resize(m + 1);
for (int i = 1; i <= m; i++) invg[i].resize(n + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> c;
if (c == 'A')
g[i][j] = invg[j][i] = 0;
else if (c == 'G')
g[i][j] = invg[j][i] = 1;
else if (c == 'C')
g[i][j] = invg[j][i] = 2;
else
g[i][j] = invg[j][i] = 3;
}
int ans = min(solve(n, m, g, 1), solve(m, n, invg, -1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (!flag)
cout << cc[dans[i][j]];
else
cout << cc[dans[j][i]];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int lo = pow(10, 16);
vector<string> res;
vector<string> trans(vector<string> &v, long long int n, long long int m) {
vector<string> g(m);
for (long long int j = 0; j < m; j++)
for (long long int i = 0; i < n; i++) g[j].push_back(v[i][j]);
return g;
}
void func(vector<char> per, vector<string> &v, long long int n, long long int m,
long long int f) {
vector<string> temp = v;
temp[0][0] = per[0], temp[0][1] = per[1], temp[1][0] = per[2],
temp[1][1] = per[3];
long long int sum = 0;
for (long long int j = 0; j < m; j++) {
long long int val1 = 0, val2 = 0;
char a, b;
if (j % 2 == 0)
a = per[0], b = per[3];
else
a = per[1], b = per[2];
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0 && v[i][j] != a) val1++;
if (i % 2 == 1 && v[i][j] != b) val1++;
}
for (long long int i = 0; i < n; i++) {
if (i % 2 == 1 && v[i][j] != a) val2++;
if (i % 2 == 0 && v[i][j] != b) val2++;
}
if (val1 <= val2 || j < 2) {
for (long long int i = 0; i < n; i++) temp[i][j] = (i % 2 == 0 ? a : b);
sum += val1;
} else {
for (long long int i = 0; i < n; i++) temp[i][j] = (i % 2 == 0 ? b : a);
sum += val2;
}
}
if (sum < lo) {
lo = sum;
if (f) temp = trans(temp, n, m);
res = temp;
}
}
void solve() {
long long int n, m;
cin >> n >> m;
vector<string> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
vector<string> vr = trans(v, n, m);
vector<char> per(4);
per[0] = 'A', per[1] = 'C', per[2] = 'G', per[3] = 'T';
do {
func(per, v, n, m, 0);
func(per, vr, m, n, 1);
} while (next_permutation(per.begin(), per.end()));
for (long long int i = 0; i < n; i++) cout << res[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int qc = 1;
for (long long int i = 1; i <= qc; i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<char> chars = {'A', 'C', 'G', 'T'};
vector<string> inp;
int n, m;
pair<int, vector<string>> solve(vector<string> s) {
pair<int, vector<string>> ans;
ans.first = (1 << 30);
for (char aa : chars) {
for (char bb : chars) {
char a = aa, b = bb;
if (a >= b) continue;
char c, d;
for (char cc : chars)
if (cc != a && cc != b) c = cc;
for (char cc : chars)
if (cc != a && cc != b && cc != c) d = cc;
int diffs = 0;
vector<string> res(s.size());
for (int i = 0; i < s.size(); i += 2) {
int abcost = 0, bacost = 0;
for (int j = 0; j < s[i].size(); j++) {
if (j % 2 == 0) {
if (s[i][j] != a) abcost++;
if (s[i][j] != b) bacost++;
} else {
if (s[i][j] != a) bacost++;
if (s[i][j] != b) abcost++;
}
}
if (abcost < bacost) {
for (int j = 0; j < s[i].size(); j++) {
res[i] += (j % 2 ? b : a);
}
} else {
for (int j = 0; j < s[i].size(); j++) {
res[i] += (j % 2 ? a : b);
}
}
diffs += min(abcost, bacost);
}
a = c;
b = d;
for (int i = 1; i < s.size(); i += 2) {
int abcost = 0, bacost = 0;
for (int j = 0; j < s[i].size(); j++) {
if (j % 2 == 0) {
if (s[i][j] != a) abcost++;
if (s[i][j] != b) bacost++;
} else {
if (s[i][j] != a) bacost++;
if (s[i][j] != b) abcost++;
}
}
if (abcost < bacost) {
for (int j = 0; j < s[i].size(); j++) {
res[i] += (j % 2 ? b : a);
}
} else {
for (int j = 0; j < s[i].size(); j++) {
res[i] += (j % 2 ? a : b);
}
}
diffs += min(abcost, bacost);
}
ans = min(ans, {diffs, res});
}
}
return ans;
}
vector<string> invert(vector<string> s) {
vector<string> res(s[0].size());
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < s[i].size(); j++) {
res[j].push_back(s[i][j]);
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string in;
cin >> in;
inp.push_back(in);
}
assert(invert(invert(inp)) == inp);
pair<int, vector<string>> res = solve(inp);
inp = invert(inp);
pair<int, vector<string>> res2 = solve(inp);
vector<string> ans = res.second;
if (res2.first < res.first) {
ans = invert(res2.second);
}
assert(n == ans.size());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << "\n";
}
cerr << min(res2.first, res.first) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
const ll INF = 5e15;
int main() {
vector<char> chars = {'A', 'G', 'C', 'T'};
ll N, M;
cin >> N >> M;
vector<string> SV(N);
for (auto &s : SV) cin >> s;
vector<vector<ll>> costN(N, vector<ll>(4 * 4));
vector<vector<ll>> costM(M, vector<ll>(4 * 4));
for (ll F = 0; F < 4; F++) {
for (ll S = 0; S < 4; S++) {
for (ll row = 0; row < N; row++) {
for (ll i = 0; i < M; i++) {
char c = chars[(i % 2 == 0 ? F : S)];
costN[row][4 * F + S] += (SV[row][i] != c);
}
}
for (ll col = 0; col < M; col++) {
for (ll i = 0; i < N; i++) {
char c = chars[(i % 2 == 0 ? F : S)];
costM[col][4 * F + S] += (SV[i][col] != c);
}
}
}
}
ll ans = INF;
vector<ll> print;
bool rowf;
for (ll A = 0; A < 4; A++) {
for (ll G = A + 1; G < 4; G++) {
vector<ll> tmpv;
for (ll i = 0; i < 4; i++)
if (i != A && i != G) tmpv.push_back(i);
ll C = tmpv[0], T = tmpv[1];
ll cn = 0, cc = 0;
vector<ll> cnv(N), ccv(M);
for (ll row = 0; row < N; row++) {
ll idx =
row % 2 == 0
? (costN[row][4 * A + G] < costN[row][4 * G + A] ? 4 * A + G
: 4 * G + A)
: (costN[row][4 * C + T] < costN[row][4 * T + C] ? 4 * C + T
: 4 * T + C);
cn += costN[row][idx];
cnv[row] = idx;
}
for (ll col = 0; col < M; col++) {
ll idx =
col % 2 == 0
? (costM[col][4 * A + G] < costM[col][4 * G + A] ? 4 * A + G
: 4 * G + A)
: (costM[col][4 * C + T] < costM[col][4 * T + C] ? 4 * C + T
: 4 * T + C);
cc += costM[col][idx];
ccv[col] = idx;
}
if (ans > cn) {
ans = cn;
print = cnv;
rowf = 1;
}
if (ans > cc) {
ans = cc;
print = ccv;
rowf = 0;
}
}
}
for (ll i = 0; i < N; i++) {
for (ll j = 0; j < M; j++) {
ll mark = print[rowf ? i : j];
char cf = chars[mark / 4];
char cs = chars[mark % 4];
char cp = rowf ? (j % 2 == 0 ? cf : cs) : (i % 2 == 0 ? cf : cs);
printf("%c", cp);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
const string S = "AGCT";
vector<string> s, s1, s2;
vector<string> flip(vector<string> s) {
vector<string> res;
int n = s.size(), m = s[0].length();
res.resize(m);
for (int i = 0; i < m; i++) {
res[i].resize(n);
for (int j = 0; j < n; j++) res[i][j] = s[j][i];
}
return res;
}
int calc(vector<string> s, vector<string> &ans) {
int n = s.size(), m = s[0].length();
ans = s;
int bestCnt = INT_MAX;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++) {
int k = 0;
while (k == i || k == j) k++;
int l = 6 - (i + j + k);
vector<int> a = {i, j, k, l};
vector<string> cur = s;
int cnt = 0;
for (int x = 0; x < n; x++) {
int c1 = 0, c2 = 0;
for (int y = 0; y < m; y++) {
c1 += S[a[((x & 1) << 1) + (y & 1)]] != s[x][y];
c2 += S[a[((x & 1) << 1) + ((y & 1) ^ 1)]] != s[x][y];
}
int inv = c2 < c1;
for (int y = 0; y < m; y++)
cur[x][y] = S[a[((x & 1) << 1) + ((y & 1) ^ inv)]];
cnt += min(c1, c2);
}
if (cnt < bestCnt) {
ans = cur;
bestCnt = cnt;
}
}
return bestCnt;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
string ss;
cin >> ss;
s.emplace_back(ss);
}
int a1, a2;
a1 = calc(s, s1);
a2 = calc(flip(s), s2);
s2 = flip(s2);
if (a1 > a2) s1 = s2;
for (auto ss : s1) cout << ss << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
FILE* in = stdin;
FILE* out = stdout;
int n, m;
vector<string> board;
int main(void) {
fscanf(in, "%d %d", &n, &m);
for (int row = 0; row < n; row++) {
static char buff[300003];
fscanf(in, "%s", buff);
board.push_back(buff);
}
int best = n * m + 1;
vector<string> ans;
vector<string> cand = board;
string str = "ACGT";
do {
int curH = 0;
for (int row = 0; row < n; row++) {
int diff1 = 0, xr1 = 0;
for (int col = 0; col < m; col++) {
cand[row][col] = str[(row % 2) * 2 + ((col % 2) ^ xr1)];
if (cand[row][col] != board[row][col]) diff1++;
}
int diff2 = 0, xr2 = 1;
for (int col = 0; col < m; col++) {
cand[row][col] = str[(row % 2) * 2 + ((col % 2) ^ xr2)];
if (cand[row][col] != board[row][col]) diff2++;
}
if (diff1 < diff2) {
for (int col = 0; col < m; col++)
cand[row][col] = str[(row % 2) * 2 + ((col % 2) ^ xr1)];
}
curH += min(diff1, diff2);
}
if (best > curH) {
best = curH;
ans = cand;
}
int curV = 0;
for (int col = 0; col < m; col++) {
int diff1 = 0, xr1 = 0;
for (int row = 0; row < n; row++) {
cand[row][col] = str[(col % 2) * 2 + ((row % 2) ^ xr1)];
if (cand[row][col] != board[row][col]) diff1++;
}
int diff2 = 0, xr2 = 1;
for (int row = 0; row < n; row++) {
cand[row][col] = str[(col % 2) * 2 + ((row % 2) ^ xr2)];
if (cand[row][col] != board[row][col]) diff2++;
}
if (diff1 < diff2) {
for (int row = 0; row < n; row++)
cand[row][col] = str[(col % 2) * 2 + ((row % 2) ^ xr1)];
}
curV += min(diff1, diff2);
}
if (best > curV) {
best = curV;
ans = cand;
}
} while (next_permutation(str.begin(), str.end()));
for (int row = 0; row < n; row++) fprintf(out, "%s\n", ans[row].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> arr;
int optimal(int i, bool turn, string a, string b) {
int r1 = 0, r2 = 0;
for (int j = 0; j < m; j += 2) {
if (!turn) {
r1 += (arr[i][j] != a[0]);
if (j + 1 < m) r1 += (arr[i][j + 1] != a[1]);
r2 += (arr[i][j] != a[1]);
if (j + 1 < m) r2 += (arr[i][j + 1] != a[0]);
} else {
r1 += (arr[i][j] != b[0]);
if (j + 1 < m) r1 += (arr[i][j + 1] != b[1]);
r2 += (arr[i][j] != b[1]);
if (j + 1 < m) r2 += (arr[i][j + 1] != b[0]);
}
}
return min(r1, r2);
}
int solve(string a, string b) {
int ret = 0;
for (auto i = 0; i < (long long)(n); i++) {
bool turn = (i & 1);
ret += optimal(i, turn, a, b);
}
return ret;
}
void applyOptimal(int i, bool turn, string a, string b) {
int r1 = 0, r2 = 0;
for (int j = 0; j < m; j += 2) {
if (!turn) {
r1 += (arr[i][j] != a[0]);
if (j + 1 < m) r1 += (arr[i][j + 1] != a[1]);
r2 += (arr[i][j] != a[1]);
if (j + 1 < m) r2 += (arr[i][j + 1] != a[0]);
} else {
r1 += (arr[i][j] != b[0]);
if (j + 1 < m) r1 += (arr[i][j + 1] != b[1]);
r2 += (arr[i][j] != b[1]);
if (j + 1 < m) r2 += (arr[i][j + 1] != b[0]);
}
}
if (r2 <= r1) {
for (int j = 0; j < m; j += 2) {
if (!turn) {
arr[i][j] = a[1];
if (j + 1 < m) arr[i][j + 1] = a[0];
} else {
arr[i][j] = b[1];
if (j + 1 < m) arr[i][j + 1] = b[0];
}
}
} else {
for (int j = 0; j < m; j += 2) {
if (!turn) {
arr[i][j] = a[0];
if (j + 1 < m) arr[i][j + 1] = a[1];
} else {
arr[i][j] = b[0];
if (j + 1 < m) arr[i][j + 1] = b[1];
}
}
}
}
void apply(string a, string b) {
for (auto i = 0; i < (long long)(n); i++) {
bool turn = (i & 1);
applyOptimal(i, turn, a, b);
}
}
void transpose() {
swap(n, m);
vector<string> temp(n);
for (auto i = 0; i < (long long)(n); i++)
for (auto j = 0; j < (long long)(m); j++) temp[i].push_back(arr[j][i]);
arr = temp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
arr.resize(n);
for (auto &x : arr) cin >> x;
string hoba = "ACGT", target = "";
bool flag = false;
int mn = 1e9;
do {
int ans = solve(hoba.substr(0, 2), hoba.substr(2, 2));
if (ans < mn) mn = ans, target = hoba;
} while (next_permutation(((hoba).begin()), ((hoba).end())));
sort(((hoba).begin()), ((hoba).end()));
transpose();
do {
int ans = solve(hoba.substr(0, 2), hoba.substr(2, 2));
if (ans < mn) mn = ans, target = hoba, flag = true;
} while (next_permutation(((hoba).begin()), ((hoba).end())));
if (!flag) transpose();
apply(target.substr(0, 2), target.substr(2, 2));
if (flag) transpose();
for (auto i = 0; i < (long long)(n); i++) cout << arr[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
auto& errStream = cerr;
class CerrDummy {
} cerrDummy;
template <class T>
CerrDummy& operator<<(CerrDummy& cd, const T&) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy& operator<<(CerrDummy& cd,
basic_ostream<charTDummy, traitsDummy>&(
basic_ostream<charTDummy, traitsDummy>&)) {
return cd;
}
using pi = pair<ll, ll>;
using vi = vector<ll>;
using ld = long double;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (ll i = ll(0); i < ll((ll)v.size()); i++) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, ll suc = 1) {
printf("%" PRId64, x);
if (suc == 1) printEoln();
if (suc == 2) printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char* readCharArray() {
static char buf[3341000];
static ll bufUsed = 0;
char* ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U>
void chmax(T& a, U b) {
if (a < b) a = b;
}
template <class T, class U>
void chmin(T& a, U b) {
if (b < a) a = b;
}
template <class T>
T Sq(const T& t) {
return t * t;
}
void Yes(bool ex = true) {
cout << "YES" << endl;
if (ex) exit(0);
}
void No(bool ex = true) {
cout << "NO" << endl;
if (ex) exit(0);
}
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
vector<string> flip(vector<string> x) {
ll n = x.size(), m = x[0].size();
vector<string> res(m, string(n, '.'));
for (ll i = ll(0); i < ll(m); i++)
for (ll j = ll(0); j < ll(n); j++) res[i][j] = x[j][i];
return res;
}
pair<ll, vector<string>> Solve(vector<string> x) {
ll n = x.size(), m = x[0].size();
string waf = "ACGT";
sort(waf.begin(), waf.end());
pair<ll, string> ans(inf, "");
do {
if (waf[0] < waf[1] && waf[2] < waf[3]) {
ll sum = 0;
for (ll i = ll(0); i < ll(n); i++) {
ll k = (i % 2) * 2;
ll mn = inf;
for (ll _ = ll(0); _ < ll(2); _++) {
ll cnt = 0;
for (ll j = ll(0); j < ll(m); j++)
if (x[i][j] != waf[k + j % 2]) cnt++;
chmin(mn, cnt);
swap(waf[k], waf[k + 1]);
}
sum += mn;
}
chmin(ans, make_pair(sum, waf));
}
} while (next_permutation(waf.begin(), waf.end()));
waf = ans.second;
vector<string> res(n, string(m, '.'));
for (ll i = ll(0); i < ll(n); i++) {
ll k = (i % 2) * 2;
pi mn(inf, -1);
for (ll _ = ll(0); _ < ll(2); _++) {
ll cnt = 0;
for (ll j = ll(0); j < ll(m); j++)
if (x[i][j] != waf[k + j % 2]) cnt++;
chmin(mn, pi(cnt, _));
swap(waf[k], waf[k + 1]);
}
if (mn.second) swap(waf[k], waf[k + 1]);
for (ll j = ll(0); j < ll(m); j++) res[i][j] = waf[k + j % 2];
}
return make_pair(ans.first, res);
}
signed main() {
ll n = read(), m = read();
vector<string> x(n);
for (ll i = ll(0); i < ll(n); i++) {
x[i] = readString();
}
auto ans1 = Solve(x);
auto ans2 = Solve(flip(x));
ans2.second = flip(ans2.second);
auto ans = min(ans1, ans2);
{
ll dif = 0;
for (ll i = ll(0); i < ll(n); i++)
for (ll j = ll(0); j < ll(m); j++)
if (x[i][j] != ans.second[i][j]) dif++;
assert(dif == ans.first);
cerrDummy << dif << endl;
}
for (ll i = ll(0); i < ll(n); i++) printf("%s\n", ans.second[i].c_str());
}
|
#include <bits/stdc++.h>
using namespace std;
string S[300009], T[300009], U[300009], V[300009];
int H, W, minx = 1000000;
int compare(string V1, string V2) {
int cnt = 0;
for (int i = 0; i < V1.size(); i++) {
if (V1[i] != V2[i]) cnt++;
}
return cnt;
}
void rotate() {
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) T[j] += S[i][j];
}
for (int i = 0; i < W; i++) S[i] = T[i];
swap(H, W);
}
void solve(int flag, string V1, string V2) {
int sum = 0;
for (int i = 0; i < H; i += 2) {
string P1;
for (int j = 0; j < W; j++) P1 += V1[(j + 0) % 2];
string P2;
for (int j = 0; j < W; j++) P2 += V1[(j + 1) % 2];
int L1 = compare(P1, S[i]);
int L2 = compare(P2, S[i]);
if (L1 < L2) {
V[i] = P1;
sum += L1;
} else {
V[i] = P2;
sum += L2;
}
}
for (int i = 1; i < H; i += 2) {
string P1;
for (int j = 0; j < W; j++) P1 += V2[(j + 0) % 2];
string P2;
for (int j = 0; j < W; j++) P2 += V2[(j + 1) % 2];
int L1 = compare(P1, S[i]);
int L2 = compare(P2, S[i]);
if (L1 < L2) {
V[i] = P1;
sum += L1;
} else {
V[i] = P2;
sum += L2;
}
}
if (sum < minx) {
minx = sum;
if (flag == 0) {
for (int i = 0; i < H; i++) U[i] = V[i];
} else {
for (int i = 0; i < 300000; i++) U[i] = "";
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) U[j] += V[i][j];
}
}
}
}
int main() {
cin >> H >> W;
for (int i = 0; i < H; i++) cin >> S[i];
for (int i = 0; i < 2; i++) {
solve(i, "AC", "GT");
solve(i, "AG", "CT");
solve(i, "AT", "CG");
solve(i, "CG", "AT");
solve(i, "CT", "AG");
solve(i, "GT", "AC");
if (i == 0) rotate();
}
for (int i = 0; i < W; i++) cout << U[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
vector<char> ch = {'A', 'C', 'T', 'G'};
int h(char c) {
if (c == 'A') return 0;
if (c == 'C') return 1;
if (c == 'T') return 2;
if (c == 'G') return 3;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < (int)(n); i++) cin >> s[i];
vector<vector<int>> odR(4, vector<int>(n)), evR(4, vector<int>(n)),
odC(4, vector<int>(m)), evC(4, vector<int>(m));
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) {
if (j & 1)
odR[h(s[i][j])][i]++;
else
evR[h(s[i][j])][i]++;
if (i & 1)
odC[h(s[i][j])][j]++;
else
evC[h(s[i][j])][j]++;
}
int ans = 1e9;
pair<int, vector<char>> bst;
for (int i = 0; i < (int)(4); i++)
for (int j = (int)(i + 1); j < (int)(4); j++) {
pair<char, char> p = {ch[i], ch[j]};
pair<char, char> p1 = {'#', '#'};
for (int d = 0; d < (int)(4); d++)
if (d != i && d != j) {
if (p1.first == '#')
p1.first = ch[d];
else
p1.second = ch[d];
}
int cur = 0;
for (int d = 0; d < (int)(n); d++) {
if (d % 2 == 0) {
cur += m - max(odR[h(p.first)][d] + evR[h(p.second)][d],
odR[h(p.second)][d] + evR[h(p.first)][d]);
} else {
cur += m - max(odR[h(p1.first)][d] + evR[h(p1.second)][d],
odR[h(p1.second)][d] + evR[h(p1.first)][d]);
}
}
if (cur < ans) {
ans = cur;
vector<char> c = {p.first, p.second, p1.first, p1.second};
bst = make_pair(0, c);
}
}
for (int i = 0; i < (int)(4); i++)
for (int j = (int)(i + 1); j < (int)(4); j++) {
pair<char, char> p = {ch[i], ch[j]};
pair<char, char> p1 = {'#', '#'};
for (int d = 0; d < (int)(4); d++)
if (d != i && d != j) {
if (p1.first == '#')
p1.first = ch[d];
else
p1.second = ch[d];
}
int cur = 0;
for (int d = 0; d < (int)(m); d++) {
if (d % 2 == 0) {
cur += n - max(odC[h(p.first)][d] + evC[h(p.second)][d],
odC[h(p.second)][d] + evC[h(p.first)][d]);
} else {
cur += n - max(odC[h(p1.first)][d] + evC[h(p1.second)][d],
odC[h(p1.second)][d] + evC[h(p1.first)][d]);
}
}
if (cur < ans) {
ans = cur;
vector<char> c = {p.first, p.second, p1.first, p1.second};
bst = make_pair(1, c);
}
}
pair<char, char> p = {bst.second[0], bst.second[1]};
pair<char, char> p1 = {bst.second[2], bst.second[3]};
if (!bst.first) {
for (int d = 0; d < (int)(n); d++) {
if (d % 2 == 0) {
if ((odR[h(p.first)][d] + evR[h(p.second)][d]) >
(odR[h(p.second)][d] + evR[h(p.first)][d])) {
for (int i = 0; i < (int)(m); i++) {
if (i % 2 == 0)
cout << p.second;
else
cout << p.first;
}
} else {
for (int i = 0; i < (int)(m); i++) {
if (i % 2 == 0)
cout << p.first;
else
cout << p.second;
}
}
} else {
if ((odR[h(p1.first)][d] + evR[h(p1.second)][d]) >
(odR[h(p1.second)][d] + evR[h(p1.first)][d])) {
for (int i = 0; i < (int)(m); i++) {
if (i % 2 == 0)
cout << p1.second;
else
cout << p1.first;
}
} else {
for (int i = 0; i < (int)(m); i++) {
if (i % 2 == 0)
cout << p1.first;
else
cout << p1.second;
}
}
}
cout << endl;
}
} else {
vector<vector<char>> an(n, vector<char>(m));
for (int d = 0; d < (int)(m); d++) {
if (d % 2 == 0) {
if ((odC[h(p.first)][d] + evC[h(p.second)][d]) >
(odC[h(p.second)][d] + evC[h(p.first)][d])) {
for (int i = 0; i < (int)(n); i++) {
if (i % 2 == 0)
an[i][d] = p.second;
else
an[i][d] = p.first;
}
} else {
for (int i = 0; i < (int)(n); i++) {
if (i % 2 == 0)
an[i][d] = p.first;
else
an[i][d] = p.second;
}
}
} else {
if ((odC[h(p1.first)][d] + evC[h(p1.second)][d]) >
(odC[h(p1.second)][d] + evC[h(p1.first)][d])) {
for (int i = 0; i < (int)(n); i++) {
if (i % 2 == 0)
an[i][d] = p1.second;
else
an[i][d] = p1.first;
}
} else {
for (int i = 0; i < (int)(n); i++) {
if (i % 2 == 0)
an[i][d] = p1.first;
else
an[i][d] = p1.second;
}
}
}
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) cout << an[i][j];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MAXN = 300010;
const int INF = 1000000000;
bool Check(string A, string B) {
set<char> s;
s.insert(A[0]);
s.insert(A[1]);
s.insert(B[0]);
s.insert(B[1]);
if (s.size() != 4) return false;
s.clear();
s.insert(A[1]);
s.insert(A[2]);
s.insert(B[1]);
s.insert(B[2]);
if (s.size() != 4) return false;
s.clear();
s.insert(A[2]);
s.insert(A[3]);
s.insert(B[2]);
s.insert(B[3]);
if (s.size() != 4) return false;
return true;
}
const int C = 36;
vector<string> B;
vector<vector<int>> e;
pair<int, int> Solve(int n, int m, vector<vector<int>>& f,
vector<vector<int>>& fp, const vector<vector<char>>& x) {
for (int i = 0; i < C; ++i) {
f[0][i] = 0;
for (int j = 0; j < m; ++j) {
f[0][i] += x[0][j] != B[i][j % 4];
}
}
for (int i = 0; i + 1 < n; ++i) {
vector<int> cnt(C);
for (int j = 0; j < C; ++j) {
for (int k = 0; k < m; ++k) {
cnt[j] += x[i + 1][k] != B[j][k % 4];
}
}
for (int j = 0; j < C; ++j) {
for (int k : e[j]) {
if (f[i][k] < f[i + 1][j]) {
f[i + 1][j] = f[i][k];
fp[i + 1][j] = k;
}
}
f[i + 1][j] += cnt[j];
}
}
int ansc = INF, p = -1;
for (int i = 0; i < C; ++i) {
if (f[n - 1][i] < ansc) {
ansc = f[n - 1][i];
p = i;
}
}
return {ansc, p};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> x(n);
for (int i = 0; i < n; ++i) cin >> x[i];
B = {"AGAG", "AGCT", "AGTC", "GAGA", "GACT", "GATC", "ACAC", "ACTG", "ACGT",
"CACA", "CATG", "CAGT", "ATAT", "ATCG", "ATGC", "TATA", "TACG", "TAGC",
"CTCT", "CTAG", "CTGA", "TCTC", "TCAG", "TCGA", "CGCG", "CGAT", "CGTA",
"GCGC", "GCTA", "GCAT", "TGTG", "TGAC", "TGCA", "GTGT", "GTAC", "GTCA"};
e = vector<vector<int>>(C);
for (int i = 0; i < C; ++i) {
for (int j = 0; j < C; ++j) {
if (Check(B[i], B[j])) e[i].push_back(j);
}
}
vector<vector<int>> fr(n, vector<int>(C, INF));
vector<vector<int>> frp(n, vector<int>(C, -1));
vector<vector<char>> xr(n, vector<char>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) xr[i][j] = x[i][j];
}
auto [ansr, pr] = Solve(n, m, fr, frp, xr);
vector<vector<int>> fc(m, vector<int>(C, INF));
vector<vector<int>> fcp(m, vector<int>(C, -1));
vector<vector<char>> xc(m, vector<char>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) xc[j][i] = x[i][j];
}
auto [ansc, pc] = Solve(m, n, fc, fcp, xc);
if (ansr <= ansc) {
vector<vector<char>> ans(n, vector<char>(m));
int p = pr;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < m; ++j) ans[i][j] = B[p][j % 4];
p = frp[i][p];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << ans[i][j];
cout << endl;
}
} else {
vector<vector<char>> ans(m, vector<char>(n));
int p = pc;
for (int i = m - 1; i >= 0; --i) {
for (int j = 0; j < n; ++j) ans[i][j] = B[p][j % 4];
p = fcp[i][p];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << ans[j][i];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int read();
const int M = 300016, MOD = 1000000007;
int n, m, ans;
string save[M];
string output[M];
const char tpch[6][2] = {{'A', 'C'}, {'A', 'G'}, {'A', 'T'},
{'C', 'G'}, {'C', 'T'}, {'G', 'T'}};
void modify(int arc, int tp) {
if (arc == 0) {
for (int row = 0; row < n; ++row) {
tp = 5 - tp;
char c1 = tpch[tp][0], c2 = tpch[tp][1];
int res1 = 0, res2 = 0;
for (int c = 0; c < m; ++c) {
char ch = save[row][c];
if (c & 1) {
if (ch != c1) ++res1;
if (ch != c2) ++res2;
} else {
if (ch != c1) ++res2;
if (ch != c2) ++res1;
}
}
if (res1 < res2) {
for (int c = 0; c < m; ++c) {
if (c & 1)
output[row][c] = c1;
else
output[row][c] = c2;
}
} else {
for (int c = 0; c < m; ++c) {
if (c & 1)
output[row][c] = c2;
else
output[row][c] = c1;
}
}
}
} else {
for (int col = 0; col < m; ++col) {
tp = 5 - tp;
char c1 = tpch[tp][0], c2 = tpch[tp][1];
int res1 = 0, res2 = 0;
for (int r = 0; r < n; ++r) {
char ch = save[r][col];
if (r & 1) {
if (ch != c1) ++res1;
if (ch != c2) ++res2;
} else {
if (ch != c1) ++res2;
if (ch != c2) ++res1;
}
}
if (res1 < res2) {
for (int r = 0; r < n; ++r) {
if (r & 1)
output[r][col] = c1;
else
output[r][col] = c2;
}
} else {
for (int r = 0; r < n; ++r) {
if (r & 1)
output[r][col] = c2;
else
output[r][col] = c1;
}
}
}
}
}
int calrow(int row, int tp) {
char c1 = tpch[tp][0], c2 = tpch[tp][1];
int res1 = 0, res2 = 0;
for (int c = 0; c < m; ++c) {
char ch = save[row][c];
if (c & 1) {
if (ch != c1) ++res1;
if (ch != c2) ++res2;
} else {
if (ch != c1) ++res2;
if (ch != c2) ++res1;
}
}
return min(res1, res2);
}
int calcol(int col, int tp) {
char c1 = tpch[tp][0], c2 = tpch[tp][1];
int res1 = 0, res2 = 0;
for (int r = 0; r < n; ++r) {
char ch = save[r][col];
if (r & 1) {
if (ch != c1) ++res1;
if (ch != c2) ++res2;
} else {
if (ch != c1) ++res2;
if (ch != c2) ++res1;
}
}
return min(res1, res2);
}
int save_row[M][6];
int save_col[M][6];
int main(void) {
n = read(), m = read(), ans = INT_MAX;
for (int i = 0; i < n; ++i) cin >> save[i];
for (int i = 0; i < n; ++i) {
for (int tp = 0; tp < 6; ++tp) {
save_row[i][tp] = calrow(i, tp);
}
}
for (int i = 0; i < m; ++i) {
for (int tp = 0; tp < 6; ++tp) {
save_col[i][tp] = calcol(i, tp);
}
}
int atp = -1, arc = -1;
for (int tp = 0; tp < 6; ++tp) {
int tmp = 0;
for (int r = 0; r < n; ++r) {
if (r & 1)
tmp += save_row[r][tp];
else
tmp += save_row[r][5 - tp];
}
if (tmp < ans) {
ans = tmp;
atp = tp;
arc = 0;
}
tmp = 0;
for (int c = 0; c < m; ++c) {
if (c & 1)
tmp += save_col[c][tp];
else
tmp += save_col[c][5 - tp];
}
if (tmp < ans) {
ans = tmp;
atp = tp;
arc = 1;
}
}
for (int i = 0; i < n; ++i) output[i] = save[i];
modify(arc, atp);
for (int i = 0; i < n; ++i) cout << output[i] << endl;
return 0;
}
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;
}
|
#include <bits/stdc++.h>
using namespace std;
string toTry[6][2] = {{"AT", "CG"}, {"AC", "TG"}, {"AG", "CT"},
{"CG", "AT"}, {"CT", "AG"}, {"GT", "AC"}};
pair<int, int> solve(vector<vector<int>>& arr) {
int n = arr.size(), m = arr[0].size();
int best = 0x3f3f3f3f, bestT = 0;
for (int t = 0; t < 6; t++) {
int sum = 0;
for (int i = 0; i < n; i++) {
string test = toTry[t][i % 2];
int T1 = 0, T2 = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] != test[j % 2]) T1++;
if (arr[i][j] != test[(j + 1) % 2]) T2++;
}
sum += min(T1, T2);
}
if (sum < best) {
best = sum;
bestT = t;
}
}
return {best, bestT};
}
void construct(vector<vector<int>>& arr, int t) {
int n = arr.size(), m = arr[0].size();
for (int i = 0; i < n; i++) {
string test = toTry[t][i % 2];
int T1 = 0, T2 = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] != test[j % 2]) T1++;
if (arr[i][j] != test[(j + 1) % 2]) T2++;
}
int bias = T1 < T2 ? 0 : 1;
for (int j = 0; j < m; j++) arr[i][j] = test[(j + bias) % 2];
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> orig(n, vector<int>(m));
vector<vector<int>> trans(m, vector<int>(n));
char g[300100];
for (int i = 0; i < n; i++) {
scanf("%s", g);
for (int j = 0; j < m; j++) {
orig[i][j] = g[j];
trans[j][i] = g[j];
}
}
pair<int, int> O = solve(orig);
pair<int, int> T = solve(trans);
if (O.first < T.first) {
construct(orig, O.second);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", (char)orig[i][j]);
printf("\n");
}
} else {
construct(trans, T.second);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", (char)trans[j][i]);
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int r, c;
string g[200000];
string alpha = "ACGT";
void rowSolve(vector<vector<char>>& ret, string even, string odd, int& cost) {
ret.resize(r);
for (int i = 0; i < r; i++) {
string match = i % 2 == 0 ? even : odd;
int normalCost = 0;
int flipCost = 0;
for (int j = 0; j < c; j++) {
if (g[i][j] != match[j % 2]) normalCost++;
if (g[i][j] != match[1 ^ (j % 2)]) flipCost++;
}
cost += min(normalCost, flipCost);
if (normalCost < flipCost) {
for (int j = 0; j < c; j++) {
ret[i].push_back(match[j % 2]);
}
} else {
for (int j = 0; j < c; j++) {
ret[i].push_back(match[1 ^ (j % 2)]);
}
}
}
}
void colSolve(vector<vector<char>>& ret, string even, string odd, int& cost) {
ret.resize(r);
for (int j = 0; j < c; j++) {
string match = j % 2 == 0 ? even : odd;
int normalCost = 0;
int flipCost = 0;
for (int i = 0; i < r; i++) {
if (g[i][j] != match[i % 2]) normalCost++;
if (g[i][j] != match[1 ^ (i % 2)]) flipCost++;
}
cost += min(normalCost, flipCost);
if (normalCost < flipCost) {
for (int i = 0; i < r; i++) {
ret[i].push_back(match[i % 2]);
}
} else {
for (int i = 0; i < r; i++) {
ret[i].push_back(match[1 ^ (i % 2)]);
}
}
}
}
void solve() {
cin >> r >> c;
for (int i = 0; i < r; i++) {
cin >> g[i];
}
vector<vector<char>> ret;
int cost = 1e9;
for (int aPair = 1; aPair < alpha.size(); aPair++) {
string even = "A";
even += alpha[aPair];
string odd = "";
for (int i = 1; i < 4; i++) {
if (i != aPair) odd += alpha[i];
}
{
int currCost = 0;
vector<vector<char>> cand;
rowSolve(cand, even, odd, currCost);
if (currCost < cost) {
ret = cand;
cost = currCost;
}
}
{
int currCost = 0;
vector<vector<char>> cand;
rowSolve(cand, odd, even, currCost);
if (currCost < cost) {
ret = cand;
cost = currCost;
}
}
{
int currCost = 0;
vector<vector<char>> cand;
colSolve(cand, even, odd, currCost);
if (currCost < cost) {
ret = cand;
cost = currCost;
}
}
{
int currCost = 0;
vector<vector<char>> cand;
colSolve(cand, odd, even, currCost);
if (currCost < cost) {
ret = cand;
cost = currCost;
}
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cout << ret[i][j];
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long add(long long a, long long b) {
a += b;
if (a >= 1000000007) return a - 1000000007;
return a;
}
long long mul(long long a, long long b) {
a *= b;
if (a >= 1000000007) return a % 1000000007;
return a;
}
long long power(long long a, long long b) {
long long p = 1;
while (b) {
if (b & 1) p = mul(p, a);
a = mul(a, a);
b /= 2;
}
return p;
}
int n, m;
vector<vector<char> > a;
char c[4] = {'G', 'C', 'T', 'A'};
long long go1(int idx, char x, char y) {
long long res = 0;
for (int i = 0; i < m; i++) {
if (i & 1)
res += (a[idx][i] != y);
else
res += (a[idx][i] != x);
}
return res;
}
long long get1(char w, char x, char y, char z) {
long long res = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
res += min(go1(i, y, z), go1(i, z, y));
else
res += min(go1(i, w, x), go1(i, x, w));
}
return res;
}
long long go2(int idx, char x, char y) {
long long res = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
res += (a[i][idx] != y);
else
res += (a[i][idx] != x);
}
return res;
}
long long get2(char w, char x, char y, char z) {
long long res = 0;
for (int i = 0; i < m; i++) {
if (i & 1)
res += min(go2(i, y, z), go2(i, z, y));
else
res += min(go2(i, w, x), go2(i, x, w));
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<char> t(m);
a.assign(n, t);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int tp;
long long mn = 1e18;
vector<char> cc(4);
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int ii = 0; ii < 4; ii++) {
if (ii == i || ii == j) continue;
for (int jj = ii + 1; jj < 4; jj++) {
if (jj == i || jj == j) continue;
long long val = get1(c[i], c[j], c[ii], c[jj]);
if (val < mn) {
mn = val;
tp = 1;
cc = {c[i], c[j], c[ii], c[jj]};
}
}
}
}
}
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int ii = 0; ii < 4; ii++) {
if (ii == i || ii == j) continue;
for (int jj = ii + 1; jj < 4; jj++) {
if (jj == i || jj == j) continue;
long long val = get2(c[i], c[j], c[ii], c[jj]);
if (val < mn) {
mn = val;
tp = 2;
cc = {c[i], c[j], c[ii], c[jj]};
}
}
}
}
}
vector<vector<char> > vv = a;
if (tp == 1) {
char w = cc[0], x = cc[1], y = cc[2], z = cc[3];
for (int i = 0; i < n; i++) {
if (i & 1) {
if (go1(i, y, z) < go1(i, z, y)) {
for (int j = 0; j < m; j++) {
if (j & 1)
vv[i][j] = z;
else
vv[i][j] = y;
}
} else {
for (int j = 0; j < m; j++) {
if (j & 1)
vv[i][j] = y;
else
vv[i][j] = z;
}
}
} else {
if (go1(i, x, w) < go1(i, w, x)) {
for (int j = 0; j < m; j++) {
if (j & 1)
vv[i][j] = w;
else
vv[i][j] = x;
}
} else {
for (int j = 0; j < m; j++) {
if (j & 1)
vv[i][j] = x;
else
vv[i][j] = w;
}
}
}
}
} else {
char w = cc[0], x = cc[1], y = cc[2], z = cc[3];
for (int i = 0; i < m; i++) {
if (i & 1) {
if (go2(i, y, z) < go2(i, z, y)) {
for (int j = 0; j < n; j++) {
if (j & 1)
vv[j][i] = z;
else
vv[j][i] = y;
}
} else {
for (int j = 0; j < n; j++) {
if (j & 1)
vv[j][i] = y;
else
vv[j][i] = z;
}
}
} else {
if (go2(i, w, x) < go2(i, x, w)) {
for (int j = 0; j < n; j++) {
if (j & 1)
vv[j][i] = x;
else
vv[j][i] = w;
}
} else {
for (int j = 0; j < n; j++) {
if (j & 1)
vv[j][i] = w;
else
vv[j][i] = x;
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << vv[i][j];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int n, m;
std::string mat[300300], wtf[300300];
std::string wut[300300];
std::string dna = "ACGT";
int count = 0;
int ans = (int)1e9;
void brute(int i, int j, int cost) {
if (cost >= ans) return;
if (n == i) {
ans = cost;
for (int k = 0; k < n; k++) {
wut[k] = wtf[k];
}
return;
}
if (m == j) {
brute(i + 1, 0, cost);
return;
}
for (auto c : dna) {
if (i && wtf[i - 1][j] == c) continue;
if (j && wtf[i][j - 1] == c) continue;
if (i && j + 1 < m && wtf[i - 1][j + 1] == c) continue;
if (i && j && wtf[i - 1][j - 1] == c) continue;
wtf[i][j] = c;
brute(i, j + 1, cost + (c != mat[i][j] ? 1 : 0));
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cin >> n >> m;
if (false) {
for (int i = 0; i < n; i++) {
mat[i] = wtf[i] = std::string(m, '#');
}
brute(0, 0, 0);
std::cout << ans << '\n';
for (int i = 0; i < n; i++) {
std::cout << wut[i] << '\n';
}
} else {
int p[] = {0, 1, 2, 3};
for (int i = 0; i < n; i++) {
mat[i] = wtf[i] = std::string(m, '#');
std::cin >> mat[i];
}
do {
if (p[0] > p[1] || p[2] > p[3]) continue;
{
int cost = n * m;
for (int j = 0; j < m; j++) {
int a1, a2;
if (j % 2 == 0) {
a1 = p[0], a2 = p[1];
} else {
a1 = p[2], a2 = p[3];
}
int cost1 = 0;
int cost2 = 0;
for (int i = 0; i < n; i++) {
if (mat[i][j] == dna[a1]) {
cost1++;
} else if (mat[i][j] == dna[a2]) {
cost2++;
}
std::swap(a1, a2);
}
if (j % 2 == 0) {
a1 = p[0], a2 = p[1];
} else {
a1 = p[2], a2 = p[3];
}
if (cost2 > cost1) {
std::swap(a1, a2);
std::swap(cost2, cost1);
}
cost -= cost1;
for (int i = 0; i < n; i++) {
wtf[i][j] = dna[a1];
std::swap(a1, a2);
}
}
if (cost < ans) {
ans = cost;
for (int i = 0; i < n; i++) {
wut[i] = wtf[i];
}
}
}
{
int cost = n * m;
for (int i = 0; i < n; i++) {
int a1, a2;
if (i % 2 == 0) {
a1 = p[0], a2 = p[1];
} else {
a1 = p[2], a2 = p[3];
}
int cost1 = 0;
int cost2 = 0;
for (int j = 0; j < m; j++) {
if (mat[i][j] == dna[a1]) {
cost1++;
} else if (mat[i][j] == dna[a2]) {
cost2++;
}
std::swap(a1, a2);
}
if (i % 2 == 0) {
a1 = p[0], a2 = p[1];
} else {
a1 = p[2], a2 = p[3];
}
if (cost2 > cost1) {
std::swap(a1, a2);
std::swap(cost2, cost1);
}
cost -= cost1;
for (int j = 0; j < m; j++) {
wtf[i][j] = dna[a1];
std::swap(a1, a2);
}
}
if (cost < ans) {
ans = cost;
for (int i = 0; i < n; i++) {
wut[i] = wtf[i];
}
}
}
} while (std::next_permutation(p, p + 4));
for (int i = 0; i < n; i++) {
std::cout << wut[i] << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
string s[N];
string s1[N];
string t[N];
string t1[N];
string tmp1[N];
string tmp[N];
int n, m;
void C1(char a, char b, char c, char d, int l, int &mmin) {
int sum = 0;
for (int i = 0; i < s[l].length(); i++) {
if (i % 2 == 0) {
tmp[l][i] = a;
if (s[l][i] != a) sum++;
} else {
tmp[l][i] = b;
if (s[l][i] != b) sum++;
}
}
l++;
if (l >= n) {
if (sum < mmin) {
tmp1[l - 1] = tmp[l - 1];
mmin = sum;
}
}
for (int i = 0; i < s[l].length(); i++) {
if (i % 2 == 0) {
tmp[l][i] = c;
if (s[l][i] != c) sum++;
} else {
tmp[l][i] = d;
if (s[l][i] != d) sum++;
}
}
if (sum < mmin) {
tmp1[l - 1] = tmp[l - 1];
tmp1[l] = tmp[l];
mmin = sum;
}
}
int C(char a, char b, char c, char d, int &mmin) {
int sum = 0;
for (int i = 0; i < n; i += 2) {
int mmin = 0x7fffffff;
C1(a, b, c, d, i, mmin);
C1(b, a, c, d, i, mmin);
C1(a, b, d, c, i, mmin);
C1(b, a, d, c, i, mmin);
sum += mmin;
}
if (sum < mmin) {
mmin = sum;
for (int i = 0; i < n; i++) {
t[i] = tmp1[i];
}
}
return sum;
}
int ss() {
for (int i = 0; i < n; i++) tmp1[i] = s[i];
for (int i = 0; i < n; i++) tmp[i] = s[i];
char ch[] = {'A', 'C', 'G', 'T'};
int k = 24;
int ans = 0x7fffffff;
while (k--) {
next_permutation(ch, ch + 4);
C(ch[0], ch[1], ch[2], ch[3], ans);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
int ans1 = ss();
for (int i = 0; i < m; i++) s1[i] = string(n, ' ');
for (int i = 0; i < m; i++) t1[i] = string(n, ' ');
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s1[j][i] = s[i][j];
swap(s1, s);
swap(t1, t);
swap(n, m);
int ans2 = ss();
if (ans1 > ans2)
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) t1[j][i] = t[i][j];
for (int i = 0; i < m; i++) cout << t1[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pci = pair<char, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
const ll infll = 1e18 + 3;
const int maxn = 1e6 + 77;
const int nmax = 1e6 + 577;
const ll basell = 1e18 + 3;
const int mod = 1e9 + 7;
const ld eps = 1e-7;
const int inf = 1009000999;
const int nv = 100505;
const int baseint = 1000200013;
const ld PI = acos(-1.0);
inline bool EQ(ld a, ld b) { return fabs(a - b) < 1e-9; }
inline bool IF(int a, int b, int c) { return (a >= b && a <= c); }
inline bool IFS(int a, int b, int c) { return (a > b && a < c); }
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
string str[3 * nv];
map<pair<char, char>, int> ssd;
int inline solve() {
ios::sync_with_stdio(NULL), cin.tie(NULL), cout.tie(NULL);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> str[i];
}
string h = "AGCT";
int ans = 0, v = 0;
string anss;
for (int g = 0; g < 32; ++g) {
next_permutation(begin(h), end(h));
char a, b, c, d;
a = h[0];
b = h[1];
c = h[2];
d = h[3];
if (ssd[{h[1], h[0]}] == 1) continue;
ssd[{h[0], h[1]}] = 1;
int res = 0;
for (int i = 0; i < n; ++i) {
int u1 = 0, u2 = 0;
for (int j = 0; j < m; ++j) {
if (i % 2 == 0) {
if (j % 2 == 0 && a == str[i][j]) {
u1++;
}
if (j % 2 == 1 && b == str[i][j]) {
u1++;
}
} else {
if (j % 2 == 0 && c == str[i][j]) {
u1++;
}
if (j % 2 == 1 && d == str[i][j]) {
u1++;
}
}
if (i % 2 == 0) {
if (j % 2 == 0 && b == str[i][j]) {
u2++;
}
if (j % 2 == 1 && a == str[i][j]) {
u2++;
}
} else {
if (j % 2 == 0 && d == str[i][j]) {
u2++;
}
if (j % 2 == 1 && c == str[i][j]) {
u2++;
}
}
}
res += max(u1, u2);
}
if (res > ans) {
ans = res;
anss = h;
v = 0;
}
res = 0;
for (int j = 0; j < m; ++j) {
int u1 = 0, u2 = 0;
for (int i = 0; i < n; ++i) {
if (j % 2 == 0) {
if (i % 2 == 0 && a == str[i][j]) {
u1++;
}
if (i % 2 == 1 && b == str[i][j]) {
u1++;
}
} else {
if (i % 2 == 0 && c == str[i][j]) {
u1++;
}
if (i % 2 == 1 && d == str[i][j]) {
u1++;
}
}
if (j % 2 == 0) {
if (i % 2 == 0 && b == str[i][j]) {
u2++;
}
if (i % 2 == 1 && a == str[i][j]) {
u2++;
}
} else {
if (i % 2 == 0 && d == str[i][j]) {
u2++;
}
if (i % 2 == 1 && c == str[i][j]) {
u2++;
}
}
}
res += max(u1, u2);
}
if (res > ans) {
ans = res;
anss = h;
v = 1;
}
}
if (v == 0) {
char a, b, c, d;
a = anss[0];
b = anss[1];
c = anss[2];
d = anss[3];
for (int i = 0; i < n; ++i) {
int u1 = 0, u2 = 0;
for (int j = 0; j < m; ++j) {
if (i % 2 == 0) {
if (j % 2 == 0 && a == str[i][j]) {
u1++;
}
if (j % 2 == 1 && b == str[i][j]) {
u1++;
}
} else {
if (j % 2 == 0 && c == str[i][j]) {
u1++;
}
if (j % 2 == 1 && d == str[i][j]) {
u1++;
}
}
if (i % 2 == 0) {
if (j % 2 == 0 && b == str[i][j]) {
u2++;
}
if (j % 2 == 1 && a == str[i][j]) {
u2++;
}
} else {
if (j % 2 == 0 && d == str[i][j]) {
u2++;
}
if (j % 2 == 1 && c == str[i][j]) {
u2++;
}
}
}
if (u1 > u2) {
for (int j = 0; j < m; ++j) {
if (i % 2 == 0) {
if (j % 2 == 0) {
cout << a;
}
if (j % 2 == 1) {
cout << b;
}
} else {
if (j % 2 == 0) {
cout << c;
}
if (j % 2 == 1) {
cout << d;
}
}
}
} else {
for (int j = 0; j < m; ++j) {
if (i % 2 == 0) {
if (j % 2 == 0) {
cout << b;
} else {
cout << a;
}
} else {
if (j % 2 == 0) {
cout << d;
} else {
cout << c;
}
}
}
}
cout << '\n';
}
} else {
char a, b, c, d;
a = anss[0];
b = anss[1];
c = anss[2];
d = anss[3];
vector<string> sd;
sd.reserve(m);
string ff;
for (int j = 0; j < m; ++j) {
int u1 = 0, u2 = 0;
for (int i = 0; i < n; ++i) {
if (j % 2 == 0) {
if (i % 2 == 0 && a == str[i][j]) {
u1++;
}
if (i % 2 == 1 && b == str[i][j]) {
u1++;
}
} else {
if (i % 2 == 0 && c == str[i][j]) {
u1++;
}
if (i % 2 == 1 && d == str[i][j]) {
u1++;
}
}
if (j % 2 == 0) {
if (i % 2 == 0 && b == str[i][j]) {
u2++;
}
if (i % 2 == 1 && a == str[i][j]) {
u2++;
}
} else {
if (i % 2 == 0 && d == str[i][j]) {
u2++;
}
if (i % 2 == 1 && c == str[i][j]) {
u2++;
}
}
}
if (u1 > u2) {
for (int i = 0; i < n; ++i) {
if (j % 2 == 0) {
if (i % 2 == 0) {
ff += a;
}
if (i % 2 == 1) {
ff += b;
}
} else {
if (i % 2 == 0) {
ff += c;
}
if (i % 2 == 1) {
ff += d;
}
}
}
} else {
for (int i = 0; i < n; ++i) {
if (j % 2 == 0) {
if (i % 2 == 0) {
ff += b;
}
if (i % 2 == 1) {
ff += a;
}
} else {
if (i % 2 == 0) {
ff += d;
}
if (i % 2 == 1) {
ff += c;
}
}
}
}
sd.push_back(ff);
ff = "";
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << sd[j][i];
}
cout << '\n';
}
}
return 0;
}
int32_t main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m;
pair<int, vector<vector<char>>> solve(vector<vector<char>> v) {
vector<char> t = {'A', 'C', 'T', 'G'};
int gans = 1e9;
vector<vector<char>> best = v;
for (char a : t) {
for (char b : t) {
if (a == b) continue;
char c, d;
for (char c1 : t) {
if (c1 != a && c1 != b) {
c = c1;
break;
}
}
for (char d1 : t) {
if (d1 != a && d1 != b && d1 != c) {
d = d1;
break;
}
}
int ans = 0;
vector<bool> z(n);
for (int i = 0; i < n; i++) {
int ans1 = 0, ans2 = 0;
for (int j = 0; j < m; j++) {
if (i % 2 == 0 && j % 2 == 0) {
ans1 += !(v[i][j] == a);
ans2 += !(v[i][j] == b);
}
if (i % 2 == 0 && j % 2 == 1) {
ans1 += !(v[i][j] == b);
ans2 += !(v[i][j] == a);
}
if (i % 2 == 1 && j % 2 == 0) {
ans1 += !(v[i][j] == c);
ans2 += !(v[i][j] == d);
}
if (i % 2 == 1 && j % 2 == 1) {
ans1 += !(v[i][j] == d);
ans2 += !(v[i][j] == c);
}
}
ans += min(ans1, ans2);
z[i] = ans1 > ans2;
}
if (ans < gans) {
gans = ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i % 2 == 0) {
if (z[i])
best[i][j] = (j % 2 == 0 ? b : a);
else
best[i][j] = (j % 2 == 0 ? a : b);
} else {
if (z[i])
best[i][j] = (j % 2 == 0 ? d : c);
else
best[i][j] = (j % 2 == 0 ? c : d);
}
}
}
}
}
}
return {gans, best};
}
int main() {
cin >> n >> m;
vector<vector<char>> v(n, vector<char>(m));
vector<vector<char>> t(m, vector<char>(n));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
v[i][j] = s[j];
t[j][i] = s[j];
}
}
auto p1 = solve(v);
swap(n, m);
auto p2 = solve(t);
swap(n, m);
if (p1.first < p2.first) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << p1.second[i][j];
cout << "\n";
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << p2.second[j][i];
cout << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
string dict = "AGCT";
const int N = 3e5 + 10;
string ans[N];
string a[N], b[N];
int n, m;
string s[N];
void solve() {
for (int i = 0; i < n; i++) b[i].resize(m);
for (int i = 0; i < n; i++) ans[i].resize(m);
int answ = 0;
for (int u1 = 0; u1 < 4; u1++)
for (int u2 = u1 + 1; u2 < 4; u2++) {
int u3 = 0;
while (u3 == u1 || u3 == u2) u3++;
int u4 = 6 - u1 - u2 - u3;
int cans = 0;
for (int i = 0; i < n; i++) {
vector<char> turn;
if (i % 2)
turn = {dict[u1], dict[u2]};
else
turn = {dict[u3], dict[u4]};
int w[2] = {0, 0};
for (int j = 0; j < m; j++) {
for (int sw = 0; sw <= 1; sw++) {
w[sw] += s[i][j] == turn[(j % 2) ^ sw];
}
}
if (w[1] > w[0]) {
swap(turn[0], turn[1]);
swap(w[0], w[1]);
}
cans += w[0];
for (int j = 0; j < m; j++) b[i][j] = turn[j % 2];
}
if (cans > answ) {
answ = cans;
for (int i = 0; i < n; i++) ans[i] = b[i];
}
}
for (int u1 = 0; u1 < 4; u1++)
for (int u2 = u1 + 1; u2 < 4; u2++) {
int u3 = 0;
while (u3 == u1 || u3 == u2) u3++;
int u4 = 6 - u1 - u2 - u3;
int cans = 0;
for (int j = 0; j < m; j++) {
vector<char> turn;
if (j % 2)
turn = {dict[u1], dict[u2]};
else
turn = {dict[u3], dict[u4]};
int w[2] = {0, 0};
for (int i = 0; i < n; i++) {
for (int sw = 0; sw <= 1; sw++) {
w[sw] += s[i][j] == turn[(i % 2) ^ sw];
}
}
if (w[1] > w[0]) {
swap(turn[0], turn[1]);
swap(w[0], w[1]);
}
cans += w[0];
for (int i = 0; i < n; i++) b[i][j] = (turn[i % 2]);
}
if (cans > answ) {
answ = cans;
for (int i = 0; i < n; i++) ans[i] = b[i];
}
}
int p[4];
for (int i = 0; i < 4; i++) p[i] = i;
do {
string pat[2];
for (int i = 0; i < 4; i++) pat[0].push_back(dict[p[i]]);
pat[1] = pat[0].substr(2, 2) + pat[0].substr(0, 2);
int cans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cans += s[i][j] == pat[i % 2][j % 4];
if (cans > answ) {
answ = cans;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = pat[i % 2][j % 4];
}
} while (next_permutation(p, p + 4));
for (int i = 0; i < 4; i++) p[i] = i;
do {
string pat[2];
for (int i = 0; i < 4; i++) pat[0].push_back(dict[p[i]]);
pat[1] = pat[0].substr(2, 2) + pat[0].substr(0, 2);
int cans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cans += s[i][j] == pat[j % 2][i % 4];
if (cans > answ) {
answ = cans;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = pat[j % 2][i % 4];
}
} while (next_permutation(p, p + 4));
for (int i = 0; i < n; i++) cout << ans[i] << '\n';
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000, N = 300010;
const string pat[6] = {"AC", "AG", "AT", "CG", "CT", "GT"};
string st[N];
int rpt[N], cpt[N], ansrpt[N], anscpt[N], currpt[N], curcpt[N];
int n, m, ansr[2], ansc[2];
int rcalc(int pt, int odd, int row) {
int cnt = 0;
for (int j = 0; j < m; j++)
if (st[row][j] != pat[pt][(j & 1) ^ odd]) cnt++;
return cnt;
}
int ccalc(int pt, int odd, int col) {
int cnt = 0;
for (int i = 0; i < n; i++)
if (st[i][col] != pat[pt][(i & 1) ^ odd]) cnt++;
return cnt;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> st[i];
int rmin = INF, cmin = INF;
for (rpt[0] = 0; rpt[0] < 6; rpt[0]++) {
rpt[1] = 5 - rpt[0];
int cnt = 0;
for (int i = 0; i < n; i++) {
int cnt0 = rcalc(rpt[i & 1], 0, i), cnt1 = rcalc(rpt[i & 1], 1, i);
if (cnt0 <= cnt1) {
currpt[i] = 0;
cnt += cnt0;
} else {
currpt[i] = 1;
cnt += cnt1;
}
}
if (cnt < rmin) {
rmin = cnt;
ansr[0] = rpt[0];
ansr[1] = rpt[1];
for (int i = 0; i < n; i++) ansrpt[i] = currpt[i];
}
}
for (cpt[0] = 0; cpt[0] < 6; cpt[0]++) {
cpt[1] = 5 - cpt[0];
int cnt = 0;
for (int j = 0; j < m; j++) {
int cnt0 = ccalc(cpt[j & 1], 0, j), cnt1 = ccalc(cpt[j & 1], 1, j);
if (cnt0 <= cnt1) {
curcpt[j] = 0;
cnt += cnt0;
} else {
curcpt[j] = 1;
cnt += cnt1;
}
}
if (cnt < cmin) {
cmin = cnt;
ansc[0] = cpt[0];
ansc[1] = cpt[1];
for (int j = 0; j < m; j++) anscpt[j] = curcpt[j];
}
}
if (rmin <= cmin) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << pat[ansr[i & 1]][ansrpt[i] ^ (j & 1)];
cout << "\n";
}
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << pat[ansc[j & 1]][anscpt[j] ^ (i & 1)];
cout << "\n";
}
}
}
|
#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 C[55555], ts, tmp[333], c[2][300010][4];
vector<int> a[300010], now[300010], ANS[300010];
pair<int, int> g[300010][4][4];
int n, m, f[300010][4][4], ans;
int main() {
cin >> n >> m;
C['A'] = 0;
C['T'] = 1;
C['C'] = 2;
C['G'] = 3;
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
a[i].push_back(0);
for (int j = 1; j <= m; ++j) a[i].push_back(C[s[j]]);
}
ans = INF;
for (int i = 0; i <= n; ++i) now[i].resize(m + 1), ANS[i].resize(m + 1);
for (int X = 0; X <= 3; ++X)
for (int Y = X + 1; Y <= 3; ++Y) {
int t = 0;
int XX = -1, YY = -1;
for (int t = 0; t <= 3; ++t)
if (t != X && t != Y) {
if (XX == -1)
XX = t;
else
YY = t;
}
for (int j = 1; j <= m; ++j)
if (j & 1) {
int t1 = 0, t2 = 0;
for (int i = 1; i <= n; ++i) {
if ((i & 1) && (a[i][j] != X)) ++t1;
if ((i & 1) && (a[i][j] != Y)) ++t2;
if (!(i & 1) && (a[i][j] != Y)) ++t1;
if (!(i & 1) && (a[i][j] != X)) ++t2;
}
t += min(t1, t2);
if (t1 <= t2) {
for (int i = 1; i <= n; ++i)
if (i & 1)
now[i][j] = X;
else
now[i][j] = Y;
} else {
for (int i = 1; i <= n; ++i)
if (i & 1)
now[i][j] = Y;
else
now[i][j] = X;
}
} else {
int t1 = 0, t2 = 0;
for (int i = 1; i <= n; ++i) {
if ((i & 1) && (a[i][j] != XX)) ++t1;
if ((i & 1) && (a[i][j] != YY)) ++t2;
if (!(i & 1) && (a[i][j] != YY)) ++t1;
if (!(i & 1) && (a[i][j] != XX)) ++t2;
}
t += min(t1, t2);
if (t1 <= t2) {
for (int i = 1; i <= n; ++i)
if (i & 1)
now[i][j] = XX;
else
now[i][j] = YY;
} else {
for (int i = 1; i <= n; ++i)
if (i & 1)
now[i][j] = YY;
else
now[i][j] = XX;
}
}
if (t < ans) {
ans = t;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) ANS[i][j] = now[i][j];
}
}
for (int rp = 0; rp <= 1; ++rp)
for (int i = 1; i <= n; ++i)
for (int h = 0; h <= 3; ++h) {
for (int j = 1; j <= m; ++j)
if (j % 2 == rp) {
if (a[i][j] != h) ++c[rp][i][h];
}
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= 3; ++j)
for (int k = 0; k <= 3; ++k) f[i][j][k] = INF;
for (int i = 0; i <= 3; ++i)
for (int j = 0; j <= 3; ++j)
if (i != j) f[1][i][j] = c[1][1][i] + c[0][1][j];
for (int i = 1; i <= n - 1; ++i)
for (int j = 0; j <= 3; ++j)
for (int k = 0; k <= 3; ++k)
if (j != k && f[i][j][k] < INF) {
ts = 0;
for (int t = 0; t <= 3; ++t)
if (t != j && t != k) tmp[++ts] = t;
if (f[i][j][k] + c[1][i + 1][tmp[1]] + c[0][i + 1][tmp[2]] <
f[i + 1][tmp[1]][tmp[2]]) {
f[i + 1][tmp[1]][tmp[2]] =
f[i][j][k] + c[1][i + 1][tmp[1]] + c[0][i + 1][tmp[2]];
g[i + 1][tmp[1]][tmp[2]] = make_pair(j, k);
}
if (f[i][j][k] + c[1][i + 1][tmp[2]] + c[0][i + 1][tmp[1]] <
f[i + 1][tmp[2]][tmp[1]]) {
f[i + 1][tmp[2]][tmp[1]] =
f[i][j][k] + c[1][i + 1][tmp[2]] + c[0][i + 1][tmp[1]];
g[i + 1][tmp[2]][tmp[1]] = make_pair(j, k);
}
}
for (int j = 0; j <= 3; ++j)
for (int k = 0; k <= 3; ++k)
if (j != k && f[n][j][k] < ans) {
ans = min(ans, f[n][j][k]);
int t = n;
int J = j, K = k;
while (1) {
for (int o = 1; o <= m; ++o)
if (o & 1)
ANS[t][o] = J;
else
ANS[t][o] = K;
if (t == 1) break;
pair<int, int> tmp = g[t][J][K];
J = tmp.first;
K = tmp.second;
--t;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (ANS[i][j] == 0)
putchar('A');
else if (ANS[i][j] == 1)
putchar('T');
else if (ANS[i][j] == 2)
putchar('C');
else
putchar('G');
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
int n, m;
vector<string> A;
vector<string> pem;
vector<string> res;
string second;
int now[4];
bool sudah[4];
char aw[4] = {'A', 'T', 'C', 'G'};
int mins = INF;
void permut(int sek) {
if (sek == 4) {
if (!(now[0] <= now[1] && now[2] <= now[3])) return;
int tot = 0;
for (int i = 0; i < m; i += 2) {
int satu = 0;
for (int j = 0; j < n; j += 2) {
if (A[j][i] != aw[now[0]]) satu++;
if (j + 1 < n && A[j + 1][i] != aw[now[1]]) satu++;
}
int dua = 0;
for (int j = 0; j < n; j += 2) {
if (A[j][i] != aw[now[1]]) dua++;
if (j + 1 < n && A[j + 1][i] != aw[now[0]]) dua++;
}
if (satu <= dua) {
for (int j = 0; j < n; j += 2) {
pem[j][i] = aw[now[0]];
if (j + 1 < n) pem[j + 1][i] = aw[now[1]];
}
tot += satu;
} else {
for (int j = 0; j < n; j += 2) {
pem[j][i] = aw[now[1]];
if (j + 1 < n) pem[j + 1][i] = aw[now[0]];
}
tot += dua;
}
}
for (int i = 1; i < m; i += 2) {
int satu = 0;
for (int j = 0; j < n; j += 2) {
if (A[j][i] != aw[now[2]]) satu++;
if (j + 1 < n && A[j + 1][i] != aw[now[3]]) satu++;
}
int dua = 0;
for (int j = 0; j < n; j += 2) {
if (A[j][i] != aw[now[3]]) dua++;
if (j + 1 < n && A[j + 1][i] != aw[now[2]]) dua++;
}
if (satu <= dua) {
for (int j = 0; j < n; j += 2) {
pem[j][i] = aw[now[2]];
if (j + 1 < n) pem[j + 1][i] = aw[now[3]];
}
tot += satu;
} else {
for (int j = 0; j < n; j += 2) {
pem[j][i] = aw[now[3]];
if (j + 1 < n) pem[j + 1][i] = aw[now[2]];
}
tot += dua;
}
}
if (tot < mins) {
mins = tot;
res = pem;
}
tot = 0;
for (int i = 0; i < n; i += 2) {
int satu = 0;
for (int j = 0; j < m; j += 2) {
if (A[i][j] != aw[now[0]]) satu++;
if (j + 1 < m && A[i][j + 1] != aw[now[1]]) satu++;
}
int dua = 0;
for (int j = 0; j < m; j += 2) {
if (A[i][j] != aw[now[1]]) dua++;
if (j + 1 < m && A[i][j + 1] != aw[now[0]]) dua++;
}
if (satu <= dua) {
for (int j = 0; j < m; j += 2) {
pem[i][j] = aw[now[0]];
if (j + 1 < m) pem[i][j + 1] = aw[now[1]];
}
tot += satu;
} else {
for (int j = 0; j < m; j += 2) {
pem[i][j] = aw[now[1]];
if (j + 1 < m) pem[i][j + 1] = aw[now[0]];
}
tot += dua;
}
}
for (int i = 1; i < n; i += 2) {
int satu = 0;
for (int j = 0; j < m; j += 2) {
if (A[i][j] != aw[now[2]]) satu++;
if (j + 1 < m && A[i][j + 1] != aw[now[3]]) satu++;
}
int dua = 0;
for (int j = 0; j < m; j += 2) {
if (A[i][j] != aw[now[3]]) dua++;
if (j + 1 < m && A[i][j + 1] != aw[now[2]]) dua++;
}
if (satu <= dua) {
for (int j = 0; j < m; j += 2) {
pem[i][j] = aw[now[2]];
if (j + 1 < m) pem[i][j + 1] = aw[now[3]];
}
tot += satu;
} else {
for (int j = 0; j < m; j += 2) {
pem[i][j] = aw[now[3]];
if (j + 1 < m) pem[i][j + 1] = aw[now[2]];
}
tot += dua;
}
}
if (tot < mins) {
mins = tot;
res = pem;
}
return;
}
for (int i = 0; i < 4; i++) {
if (sudah[i] == 0) {
sudah[i] = 1;
now[sek] = i;
permut(sek + 1);
sudah[i] = 0;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> second;
A.push_back(second);
pem.push_back(second);
}
permut(0);
for (int i = 0; i < res.size(); i++) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long long INF = 2e9 + 10;
const long long MAX = 1e14 + 10;
const long double EPS = 1e-9;
const int N = 3e5 + 10;
char ch[N];
string CH = "AGCT";
int NUM(char c) { return CH.find(c); }
vector<vector<int> > ans;
int d[2][N][5];
int tmp[N];
int solve1(int n, int m, int ansDif, vector<vector<int> >& a) {
vector<int> perm = {0, 1, 2, 3};
vector<vector<int> > temp(n, vector<int>(m, 0));
do {
int curDif = 0;
for (int i = 0; i < n; i++) {
int firstN = perm[0];
int secondN = perm[1];
if (i % 2) {
firstN = perm[2];
secondN = perm[3];
}
for (int j = 0; j < m; j += 2) {
tmp[j] = firstN;
tmp[j + 1] = secondN;
}
int cntNorm = 0;
for (int j = 0; j < m; j++)
if (a[i][j] != tmp[j]) cntNorm++;
for (int j = 0; j <= m; j += 2) {
tmp[j] = secondN;
tmp[j + 1] = firstN;
}
int cntSw = 0;
for (int j = 0; j < m; j++)
if (a[i][j] != tmp[j]) cntSw++;
if (cntNorm < cntSw) {
for (int j = 0; j < m; j += 2) {
tmp[j] = firstN;
tmp[j + 1] = secondN;
}
curDif += cntNorm;
} else {
curDif += cntSw;
}
for (int j = 0; j < m; j++) temp[i][j] = tmp[j];
}
if (curDif < ansDif) {
ansDif = curDif;
ans = temp;
}
} while (next_permutation(perm.begin(), perm.end()));
return ansDif;
}
int solve2(int n, int m, int ansDif, vector<vector<int> >& a) {
vector<int> perm = {0, 1, 2, 3};
vector<vector<int> > temp(n, vector<int>(m, 0));
do {
int curDif = 0;
temp[0][0] = perm[0];
temp[0][1] = perm[1];
temp[1][0] = perm[2];
temp[1][1] = perm[3];
for (int j = 2; j < m; j++) {
if (j % 2 == 0) {
if (d[0][j][temp[0][0]] + d[1][j][temp[1][0]] <
d[1][j][temp[0][0]] + d[0][j][temp[1][0]]) {
temp[0][j] = temp[1][0];
temp[1][j] = temp[0][0];
} else {
temp[0][j] = temp[0][0];
temp[1][j] = temp[1][0];
}
} else {
if (d[0][j][temp[0][1]] + d[1][j][temp[1][1]] <
d[1][j][temp[0][1]] + d[0][j][temp[1][1]]) {
temp[0][j] = temp[1][1];
temp[1][j] = temp[0][1];
} else {
temp[0][j] = temp[0][1];
temp[1][j] = temp[1][1];
}
}
}
for (int i = 2; i < n; i++)
for (int j = 0; j < m; j++) temp[i][j] = temp[i % 2][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] != temp[i][j]) curDif++;
if (curDif < ansDif) {
ansDif = curDif;
ans = temp;
}
} while (next_permutation(perm.begin(), perm.end()));
return ansDif;
}
void solve() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; i++) {
scanf("%s", &ch);
for (int j = 0; j < m; j++) {
a[i][j] = NUM(ch[j]);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) d[i % 2][j][a[i][j]]++;
int dif = n * m + 1;
int dif1 = solve1(n, m, dif, a);
int tmp = solve2(n, m, dif1, a);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << CH[ans[i][j]];
cout << endl;
}
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
const int INF = (int)1e9;
char base[] = {'A', 'C', 'G', 'T'};
vector<string> v;
char s[MAXN];
char aux[MAXN];
int n, m;
vector<char> r1[2];
vector<char> r2[2];
vector<char> c1[2];
vector<char> c2[2];
vector<vector<char> > best_row;
vector<vector<char> > best_col;
int mini_row = INF;
int mini_col = INF;
vector<vector<char> > aux_row[2];
vector<vector<char> > aux_col[2];
pair<int, int> calc_row(int row, vector<char>& a, vector<char>& b) {
int va = 0;
int vb = 0;
for (int t = 0; t < m; t++) {
if (v[row][t] != a[t]) va++;
if (v[row][t] != b[t]) vb++;
}
if (va < vb) {
return {0, va};
}
return {1, vb};
}
pair<int, int> calc_col(int col, vector<char>& a, vector<char>& b) {
int va = 0;
int vb = 0;
for (int t = 0; t < n; t++) {
if (v[t][col] != a[t]) va++;
if (v[t][col] != b[t]) vb++;
}
if (va < vb) {
return {0, va};
}
return {1, vb};
}
void solve_row(int i, int j, int k, int p) {
for (int t = 0; t < m; t++) {
if (t % 2 == 0) {
r1[0][t] = base[i];
r1[1][t] = base[j];
r2[0][t] = base[k];
r2[1][t] = base[p];
} else {
r1[0][t] = base[j];
r1[1][t] = base[i];
r2[0][t] = base[p];
r2[1][t] = base[k];
}
}
int v1 = 0;
int v2 = 0;
for (int t = 0; t < n; t++) {
if (t % 2 == 0) {
pair<int, int> score;
score = calc_row(t, r1[0], r1[1]);
if (score.first == 0) {
aux_row[0].push_back(r1[0]);
} else {
aux_row[0].push_back(r1[1]);
}
v1 += score.second;
score = calc_row(t, r2[0], r2[1]);
if (score.first == 0) {
aux_row[1].push_back(r2[0]);
} else {
aux_row[1].push_back(r2[1]);
}
v2 += score.second;
} else {
pair<int, int> score = calc_row(t, r2[0], r2[1]);
if (score.first == 0) {
aux_row[0].push_back(r2[0]);
} else {
aux_row[0].push_back(r2[1]);
}
v1 += score.second;
score = calc_row(t, r1[0], r1[1]);
if (score.first == 0) {
aux_row[1].push_back(r1[0]);
} else {
aux_row[1].push_back(r1[1]);
}
v2 += score.second;
}
}
if (v1 <= v2 && mini_row > v1) {
mini_row = v1;
best_row = aux_row[0];
}
if (v2 <= v1 && mini_row > v2) {
mini_row = v2;
best_row = aux_row[1];
}
for (int t = 0; t < 2; t++) {
aux_row[t].clear();
}
return;
}
void solve_row() {
for (int i = 0; i < 2; i++) {
r1[i].resize(m);
r2[i].resize(m);
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int p = 0; p < 4; p++) {
if (i != j && i != k && i != p && j != k && j != p && k != p) {
solve_row(i, j, k, p);
}
}
}
}
}
return;
}
void solve_col(int i, int j, int k, int p) {
for (int t = 0; t < n; t++) {
if (t % 2 == 0) {
c1[0][t] = base[i];
c1[1][t] = base[j];
c2[0][t] = base[k];
c2[1][t] = base[p];
} else {
c1[0][t] = base[j];
c1[1][t] = base[i];
c2[0][t] = base[p];
c2[1][t] = base[k];
}
}
int v1 = 0;
int v2 = 0;
for (int t = 0; t < m; t++) {
if (t % 2 == 0) {
pair<int, int> score = calc_col(t, c1[0], c1[1]);
if (score.first == 0) {
aux_col[0].push_back(c1[0]);
} else {
aux_col[0].push_back(c1[1]);
}
v1 += score.second;
score = calc_col(t, c2[0], c2[1]);
if (score.first == 0) {
aux_col[1].push_back(c2[0]);
} else {
aux_col[1].push_back(c2[1]);
}
v2 += score.second;
} else {
pair<int, int> score = calc_col(t, c2[0], c2[1]);
if (score.first == 0) {
aux_col[0].push_back(c2[0]);
} else {
aux_col[0].push_back(c2[1]);
}
v1 += score.second;
score = calc_col(t, c1[0], c1[1]);
if (score.first == 0) {
aux_col[1].push_back(c1[0]);
} else {
aux_col[1].push_back(c1[1]);
}
v2 += score.second;
}
}
if (v1 <= v2 && mini_col > v1) {
mini_col = v1;
best_col = aux_col[0];
}
if (v2 <= v1 && mini_col > v2) {
mini_col = v2;
best_col = aux_col[1];
}
for (int t = 0; t < 2; t++) {
aux_col[t].clear();
}
return;
}
void solve_col() {
for (int i = 0; i < 2; i++) {
c1[i].resize(n);
c2[i].resize(n);
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int p = 0; p < 4; p++) {
if (i != j && i != k && i != p && j != k && j != p && k != p) {
solve_col(i, j, k, p);
}
}
}
}
}
return;
}
void print_col(void) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", best_col[j][i]);
}
printf("\n");
}
return;
}
void print_row(void) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", best_row[i][j]);
}
printf("\n");
}
return;
}
int main(void) {
scanf(" %d %d", &n, &m);
v.resize(n);
for (int i = 0; i < n; i++) {
scanf(" %s", aux);
v[i] = string(aux);
}
solve_row();
solve_col();
if (mini_row < mini_col) {
print_row();
} else {
print_col();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int n = 300005;
int N, Mcnt;
vector<vector<int>> M;
string toC = "ACGT";
int dp[n][4][4];
int dp2[n][4][4];
pair<int, int> cur[6] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
int oth[6] = {5, 4, 3, 2, 1, 0};
int howMany(int y, int x, int val) {
int cnt = 0;
for (int i = x; i < Mcnt; i += 2) {
if (M[y][i] != val) cnt++;
}
return cnt;
}
void change(int y, int x, int val) {
for (int i = x; i < Mcnt; i += 2) {
M[y][i] = val;
}
}
int howMany2(int x, int y, int val) {
int cnt = 0;
for (int i = y; i < N; i += 2) {
if (M[i][x] != val) cnt++;
}
return cnt;
}
void change2(int x, int y, int val) {
for (int i = y; i < N; i += 2) {
M[i][x] = val;
}
}
int main() {
cin >> N >> Mcnt;
M = vector<vector<int>>(N, vector<int>(Mcnt));
for (int i = 0; i < N; i++) {
for (int j = 0; j < Mcnt; j++) {
char x;
cin >> x;
switch (x) {
case 'A':
M[i][j] = 0;
break;
case 'C':
M[i][j] = 1;
break;
case 'G':
M[i][j] = 2;
break;
case 'T':
M[i][j] = 3;
break;
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
dp[i][j][k] = n;
}
}
}
for (int i = 0; i < Mcnt; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
dp2[i][j][k] = n;
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 6; j++) {
int a, b, toa, tob;
tie(a, b) = cur[j];
tie(toa, tob) = cur[oth[j]];
int minCur = min(howMany(i, 0, a) + howMany(i, 1, b),
howMany(i, 1, a) + howMany(i, 0, b));
int minOth = 0;
if (i > 0) {
minOth = dp[i - 1][toa][tob];
}
if (minOth + minCur < dp[i][a][b]) {
dp[i][a][b] = minCur + minOth;
}
}
}
int best = n;
int bestI = -1;
for (int i = 0; i < 6; i++) {
int a, b;
tie(a, b) = cur[i];
if (dp[N - 1][a][b] < best) {
best = dp[N - 1][a][b];
bestI = i;
}
}
for (int i = 0; i < Mcnt; i++) {
for (int j = 0; j < 6; j++) {
int a, b, toa, tob;
tie(a, b) = cur[j];
tie(toa, tob) = cur[oth[j]];
int minCur = min(howMany2(i, 0, a) + howMany2(i, 1, b),
howMany2(i, 1, a) + howMany2(i, 0, b));
int minOth = 0;
if (i > 0) {
minOth = dp2[i - 1][toa][tob];
}
if (minOth + minCur < dp2[i][a][b]) {
dp2[i][a][b] = minCur + minOth;
}
}
}
int best2 = n;
int bestI2 = -1;
for (int i = 0; i < 6; i++) {
int a, b;
tie(a, b) = cur[i];
if (dp2[Mcnt - 1][a][b] < best2) {
best2 = dp2[Mcnt - 1][a][b];
bestI2 = i;
}
}
if (best < best2) {
int I = bestI;
for (int x = N - 1; x >= 0; x--) {
int a, b;
tie(a, b) = cur[I];
if (howMany(x, 0, a) + howMany(x, 1, b) <
howMany(x, 1, a) + howMany(x, 0, b)) {
change(x, 0, a);
change(x, 1, b);
} else {
change(x, 1, a);
change(x, 0, b);
}
I = oth[I];
}
} else {
int I = bestI2;
for (int x = Mcnt - 1; x >= 0; x--) {
int a, b;
tie(a, b) = cur[I];
if (howMany2(x, 0, a) + howMany2(x, 1, b) <
howMany2(x, 1, a) + howMany2(x, 0, b)) {
change2(x, 0, a);
change2(x, 1, b);
} else {
change2(x, 1, a);
change2(x, 0, b);
}
I = oth[I];
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < Mcnt; j++) {
cout << toC[M[i][j]];
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &sum) {
char ch = getchar();
int tf = 0;
sum = 0;
while ((ch < '0' || ch > '9') && (ch != '-')) ch = getchar();
tf = ((ch == '-') && (ch = getchar()));
while (ch >= '0' && ch <= '9') sum = sum * 10 + (ch - 48), ch = getchar();
(tf) && (sum = -sum);
}
int n, m;
vector<string> vec;
vector<string> res_vec, res_vec_tmp1, res_vec_tmp2;
string str = "AGCT";
int ans;
void cal(char a, char b, char c, char d) {
int ans_r = 0;
for (int i = 0; i < n; i += 2) {
int tmp_1 = 0;
for (int j = 0; j < m; j++) {
if ((j & 1) && vec[i][j] != a) tmp_1++;
if (!(j & 1) && vec[i][j] != b) tmp_1++;
}
int tmp_2 = 0;
for (int j = 0; j < m; j++) {
if ((j & 1) && vec[i][j] != b) tmp_2++;
if (!(j & 1) && vec[i][j] != a) tmp_2++;
}
for (int j = 0; j < m; j++) {
if (j & 1) res_vec_tmp1[i][j] = tmp_1 < tmp_2 ? a : b;
if (!(j & 1)) res_vec_tmp1[i][j] = tmp_1 < tmp_2 ? b : a;
}
ans_r += min(tmp_1, tmp_2);
}
for (int i = 1; i < n; i += 2) {
int tmp_1 = 0, tmp_2 = 0;
for (int j = 0; j < m; j++) {
if ((j & 1) && vec[i][j] != c) tmp_1++;
if (!(j & 1) && vec[i][j] != d) tmp_1++;
}
for (int j = 0; j < m; j++) {
if ((j & 1) && vec[i][j] != d) tmp_2++;
if (!(j & 1) && vec[i][j] != c) tmp_2++;
}
for (int j = 0; j < m; j++) {
if (j & 1) res_vec_tmp1[i][j] = tmp_1 < tmp_2 ? c : d;
if (!(j & 1)) res_vec_tmp1[i][j] = tmp_1 < tmp_2 ? d : c;
}
ans_r += min(tmp_1, tmp_2);
}
if (ans > ans_r) ans = ans_r, res_vec = res_vec_tmp1;
int ans_c = 0;
for (int j = 0; j < m; j += 2) {
int tmp_1 = 0, tmp_2 = 0;
for (int i = 0; i < n; i++) {
if ((i & 1) && vec[i][j] != a) tmp_1++;
if (!(i & 1) && vec[i][j] != b) tmp_1++;
}
for (int i = 0; i < n; i++) {
if ((i & 1) && vec[i][j] != b) tmp_2++;
if (!(i & 1) && vec[i][j] != a) tmp_2++;
}
for (int i = 0; i < n; i++) {
if (i & 1) res_vec_tmp2[i][j] = tmp_1 < tmp_2 ? a : b;
if (!(i & 1)) res_vec_tmp2[i][j] = tmp_1 < tmp_2 ? b : a;
}
ans_c += min(tmp_1, tmp_2);
}
for (int j = 1; j < m; j += 2) {
int tmp_1 = 0, tmp_2 = 0;
for (int i = 0; i < n; i++) {
if ((i & 1) && vec[i][j] != c) tmp_1++;
if (!(i & 1) && vec[i][j] != d) tmp_1++;
}
for (int i = 0; i < n; i++) {
if ((i & 1) && vec[i][j] != d) tmp_2++;
if (!(i & 1) && vec[i][j] != c) tmp_2++;
}
for (int i = 0; i < n; i++) {
if (i & 1) res_vec_tmp2[i][j] = tmp_1 < tmp_2 ? c : d;
if (!(i & 1)) res_vec_tmp2[i][j] = tmp_1 < tmp_2 ? d : c;
}
ans_c += min(tmp_1, tmp_2);
}
if (ans > ans_c) ans = ans_c, res_vec = res_vec_tmp2;
return;
}
int main() {
while (cin >> n >> m) {
vec.clear();
res_vec.clear();
res_vec_tmp1.clear();
res_vec_tmp2.clear();
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
vec.push_back(tmp);
res_vec_tmp1.push_back(tmp);
res_vec_tmp2.push_back(tmp);
}
ans = 1000000001;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int k = 0; k < 4; k++) {
if (k == i || k == j) continue;
for (int p = k + 1; p < 4; p++) {
if (p == i || p == j) continue;
cal(str[i], str[j], str[k], str[p]);
}
}
}
}
for (int i = 0; i < n; i++) {
cout << res_vec[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[400005], best[400005];
vector<int> a[400005], tmp[400005];
int t[30][5], top = 0, ans = 4000000;
int fn(char c) {
if (c == 'A')
return 1;
else if (c == 'C')
return 2;
else if (c == 'G')
return 3;
else if (c == 'T')
return 4;
}
char fc(int c) {
if (c == 1)
return 'A';
else if (c == 2)
return 'C';
else if (c == 3)
return 'G';
else if (c == 4)
return 'T';
}
void print() { cout << "That's OK!" << endl; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < m; j++) a[i].push_back(fn(s[i][j]));
}
for (int c1 = 1; c1 <= 4; c1++)
for (int c2 = 1; c2 <= 4; c2++)
for (int c3 = 1; c3 <= 4; c3++) {
int c4 = 10 - c1 - c2 - c3;
if (c1 == c2 || c2 == c3 || c1 == c3) continue;
t[++top][1] = c1;
t[top][2] = c2;
t[top][3] = c3;
t[top][4] = c4;
}
for (int tt = 1; tt <= 24; tt++) {
int c1 = t[tt][1], c2 = t[tt][2], c3 = t[tt][3], c4 = t[tt][4];
for (int b = 0; b <= 1; b++) {
int now = 0;
if (!b) {
for (int i = 0; i < n; i++) tmp[i].clear();
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (i == 0) {
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (c1 != a[i][j]) now++;
tmp[i].push_back(c1);
}
if (j % 2 == 1) {
if (c2 != a[i][j]) now++;
tmp[i].push_back(c2);
}
}
} else {
int tmp1 = 0, tmp2 = 0;
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (c1 != a[i][j]) tmp1++;
if (c2 != a[i][j]) tmp2++;
} else {
if (c1 != a[i][j]) tmp2++;
if (c2 != a[i][j]) tmp1++;
}
}
if (tmp1 <= tmp2) {
now += tmp1;
for (int j = 0; j < m; j++)
if (j % 2 == 0)
tmp[i].push_back(c1);
else
tmp[i].push_back(c2);
} else {
now += tmp2;
for (int j = 0; j < m; j++)
if (j % 2 == 0)
tmp[i].push_back(c2);
else
tmp[i].push_back(c1);
}
}
} else {
if (i == 1) {
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (c3 != a[i][j]) now++;
tmp[i].push_back(c3);
}
if (j % 2 == 1) {
if (c4 != a[i][j]) now++;
tmp[i].push_back(c4);
}
}
} else {
int tmp1 = 0, tmp2 = 0;
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (c3 != a[i][j]) tmp1++;
if (c4 != a[i][j]) tmp2++;
} else {
if (c3 != a[i][j]) tmp2++;
if (c4 != a[i][j]) tmp1++;
}
}
if (tmp1 <= tmp2) {
now += tmp1;
for (int j = 0; j < m; j++)
if (j % 2 == 0)
tmp[i].push_back(c3);
else
tmp[i].push_back(c4);
} else {
now += tmp2;
for (int j = 0; j < m; j++)
if (j % 2 == 0)
tmp[i].push_back(c4);
else
tmp[i].push_back(c3);
}
}
}
}
if (now < ans) {
ans = now;
for (int i = 0; i < n; i++) best[i].clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) best[i].push_back(fc(tmp[i][j]));
}
} else {
for (int j = 0; j < m; j++) tmp[j].clear();
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (j == 0) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (c1 != a[i][j]) now++;
tmp[j].push_back(c1);
}
if (i % 2 == 1) {
if (c3 != a[i][j]) now++;
tmp[j].push_back(c3);
}
}
} else {
int tmp1 = 0, tmp2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (c1 != a[i][j]) tmp1++;
if (c3 != a[i][j]) tmp2++;
} else {
if (c1 != a[i][j]) tmp2++;
if (c3 != a[i][j]) tmp1++;
}
}
if (tmp1 <= tmp2) {
now += tmp1;
for (int i = 0; i < n; i++)
if (i % 2 == 0)
tmp[j].push_back(c1);
else
tmp[j].push_back(c3);
} else {
now += tmp2;
for (int i = 0; i < n; i++)
if (i % 2 == 0)
tmp[j].push_back(c3);
else
tmp[j].push_back(c1);
}
}
} else {
if (j == 1) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (c2 != a[i][j]) now++;
tmp[j].push_back(c2);
}
if (i % 2 == 1) {
if (c4 != a[i][j]) now++;
tmp[j].push_back(c4);
}
}
} else {
int tmp1 = 0, tmp2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (c2 != a[i][j]) tmp1++;
if (c4 != a[i][j]) tmp2++;
} else {
if (c2 != a[i][j]) tmp2++;
if (c4 != a[i][j]) tmp1++;
}
}
if (tmp1 <= tmp2) {
now += tmp1;
for (int i = 0; i < n; i++)
if (i % 2 == 0)
tmp[j].push_back(c2);
else
tmp[j].push_back(c4);
} else {
now += tmp2;
for (int i = 0; i < n; i++)
if (i % 2 == 0)
tmp[j].push_back(c4);
else
tmp[j].push_back(c2);
}
}
}
}
if (now < ans) {
ans = now;
for (int i = 0; i < n; i++) best[i].clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) best[i].push_back(fc(tmp[j][i]));
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", best[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
const int ms = 3e5 + 19;
using namespace std;
string per = "ACGT";
int n, m, ans = ms;
string c[ms], cer[ms];
bool w[ms];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> c[i];
cer[i] = c[i];
}
do {
int cur = 0;
for (int i = 0; i < n; i++) {
int c1 = 0, c2 = 0;
for (int j = 0; j < m; j++) {
c1 += per[(i & 1) * 2 + (j & 1)] != c[i][j];
c2 += per[(i & 1) * 2 + !(j & 1)] != c[i][j];
}
w[i] = c1 < c2;
cur += min(c1, c2);
}
if (cur < ans) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cer[i][j] =
w[i] ? per[(i & 1) * 2 + (j & 1)] : per[(i & 1) * 2 + !(j & 1)];
}
}
ans = cur;
}
cur = 0;
for (int i = 0; i < m; i++) {
int c1 = 0, c2 = 0;
for (int j = 0; j < n; j++) {
c1 += per[(i & 1) * 2 + (j & 1)] != c[j][i];
c2 += per[(i & 1) * 2 + !(j & 1)] != c[j][i];
}
w[i] = c1 < c2;
cur += min(c1, c2);
}
if (cur < ans) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
cer[j][i] =
w[i] ? per[(i & 1) * 2 + (j & 1)] : per[(i & 1) * 2 + !(j & 1)];
ans = cur;
}
} while (next_permutation(per.begin(), per.end()));
for (int i = 0; i < n; i++) cout << cer[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const string str = "ATGC";
vector<string> s, tmp, ans;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string st;
cin >> st;
s.push_back(st);
}
int ansmin = INF, now;
for (int c1 = 0; c1 < 4; c1++)
for (int c2 = c1 + 1; c2 < 4; c2++) {
string t;
set<int> st;
for (int i = 0; i < 4; i++) st.insert(i);
st.erase(c1);
st.erase(c2);
set<int>::iterator it = st.begin();
t.push_back(str[c1]);
t.push_back(str[c2]);
t.push_back(str[*(it++)]);
t.push_back(str[*it]);
now = 0;
tmp.clear();
for (int i = 0; i < n; i++) {
tmp.push_back("");
int b = (i & 1) << 1;
int cnt1 = 0, cnt2 = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] != t[b + (j & 1)]) ++cnt1;
if (s[i][j] != t[b + ((j & 1) ^ 1)]) ++cnt2;
}
if (cnt1 < cnt2)
for (int j = 0; j < m; j++) tmp[i].push_back(t[b + (j & 1)]);
else
for (int j = 0; j < m; j++) tmp[i].push_back(t[b + ((j & 1) ^ 1)]);
now += min(cnt1, cnt2);
}
if (now < ansmin) {
ans = tmp;
ansmin = now;
}
now = 0;
tmp.clear();
for (int i = 0; i < n; i++) tmp.push_back("");
for (int j = 0; j < m; j++) {
int b = (j & 1) << 1;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] != t[b + (i & 1)]) ++cnt1;
if (s[i][j] != t[b + ((i & 1) ^ 1)]) ++cnt2;
}
if (cnt1 < cnt2)
for (int i = 0; i < n; i++) tmp[i].push_back(t[b + (i & 1)]);
else
for (int i = 0; i < n; i++) tmp[i].push_back(t[b + ((i & 1) ^ 1)]);
now += min(cnt1, cnt2);
}
if (now < ansmin) {
ans = tmp;
ansmin = now;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 312345;
const int INF = int(1e9);
string s[N], ans[N], cur[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int r, c;
cin >> r >> c;
for (int i = 0; i < r; i++) cin >> s[i];
for (int i = 0; i < r; i++) cur[i].resize(c);
string chars = "ACGT";
int tim = INF;
do {
int tot = 0;
for (int i = 0; i < r; i++) {
int cnt0 = 0, cnt1 = 0;
for (int j = 0; j < c; j++) {
if (s[i][j] != chars[(i & 1) * 2 + (j & 1)]) cnt0++;
if (s[i][j] != chars[(i & 1) * 2 + ((j ^ 1) & 1)]) cnt1++;
}
if (cnt0 < cnt1) {
for (int j = 0; j < c; j++) cur[i][j] = chars[(i & 1) * 2 + (j & 1)];
tot += cnt0;
} else {
for (int j = 0; j < c; j++)
cur[i][j] = chars[(i & 1) * 2 + ((j ^ 1) & 1)];
tot += cnt1;
}
}
if (tot < tim) {
for (int i = 0; i < r; i++) ans[i] = cur[i];
tim = tot;
}
tot = 0;
for (int j = 0; j < c; j++) {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < r; i++) {
if (s[i][j] != chars[(i & 1) * 2 + (j & 1)]) cnt0++;
if (s[i][j] != chars[((i ^ 1) & 1) * 2 + (j & 1)]) cnt1++;
}
if (cnt0 < cnt1) {
for (int i = 0; i < r; i++) cur[i][j] = chars[(i & 1) * 2 + (j & 1)];
tot += cnt0;
} else {
for (int i = 0; i < r; i++)
cur[i][j] = chars[((i ^ 1) & 1) * 2 + (j & 1)];
tot += cnt1;
}
}
if (tot < tim) {
for (int i = 0; i < r; i++) ans[i] = cur[i];
tim = tot;
}
} while (next_permutation((chars).begin(), (chars).end()));
for (int i = 0; i < r; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
const int M = 1e6;
const long long oo = 1e18;
const int mod = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n), ans;
for (int i = 0; i < n; i++) cin >> s[i];
string a = "AGCT";
int mn = 1e9;
do {
vector<string> tmp = s;
int cst = 0;
for (int i = 0; i < n; i++) {
int dif1 = 0, dif2 = 0;
for (int j = 0; j < m; j++) {
dif1 += (tmp[i][j] != a[2 * (i & 1) + (j & 1)]);
dif2 += (tmp[i][j] != a[2 * (i & 1) + ((j ^ 1) & 1)]);
}
cst += min(dif1, dif2);
for (int j = 0; j < m; j++) {
if (dif1 < dif2)
tmp[i][j] = a[2 * (i & 1) + (j & 1)];
else
tmp[i][j] = a[2 * (i & 1) + ((j ^ 1) & 1)];
}
}
if (cst < mn) {
mn = cst;
ans = tmp;
}
tmp = s;
cst = 0;
for (int j = 0; j < m; j++) {
int dif1 = 0, dif2 = 0;
for (int i = 0; i < n; i++) {
dif1 += (tmp[i][j] != a[2 * (i & 1) + (j & 1)]);
dif2 += (tmp[i][j] != a[2 * ((i ^ 1) & 1) + (j & 1)]);
}
cst += min(dif1, dif2);
for (int i = 0; i < n; i++) {
if (dif1 < dif2)
tmp[i][j] = a[2 * (i & 1) + (j & 1)];
else
tmp[i][j] = a[2 * ((i ^ 1) & 1) + (j & 1)];
}
}
if (cst < mn) {
mn = cst;
ans = tmp;
}
} while (next_permutation(a.begin(), a.end()));
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 200005;
string s[6] = {"AGCT", "ACGT", "ATGC", "CTAG", "GTAC", "GCAT"};
string a[N], b[N], tmp[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int u = 0; u < 6; u++) {
int sum = 0;
for (int i = 0; i < n; i++) {
char x, y;
if (i % 2 == 0) {
x = s[u][0], y = s[u][1];
} else {
x = s[u][2], y = s[u][3];
}
int cnt1 = 0, cnt2 = 0;
string t1, t2;
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
if (x == a[i][j]) cnt1++;
if (y == a[i][j]) cnt2++;
t1.push_back(x);
t2.push_back(y);
} else {
if (y == a[i][j]) cnt1++;
if (x == a[i][j]) cnt2++;
t1.push_back(y);
t2.push_back(x);
}
}
if (cnt1 >= cnt2) {
tmp[i] = t1;
sum += cnt1;
} else {
tmp[i] = t2;
sum += cnt2;
}
}
if (sum > ans) {
ans = sum;
for (int i = 0; i < n; i++) {
b[i] = tmp[i];
}
}
}
for (int u = 0; u < 6; u++) {
int sum = 0;
for (int j = 0; j < m; j++) {
char x, y;
if (j % 2 == 0) {
x = s[u][0], y = s[u][1];
} else {
x = s[u][2], y = s[u][3];
}
int cnt1 = 0, cnt2 = 0;
string t1, t2;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (x == a[i][j]) cnt1++;
if (y == a[i][j]) cnt2++;
t1.push_back(x);
t2.push_back(y);
} else {
if (y == a[i][j]) cnt1++;
if (x == a[i][j]) cnt2++;
t1.push_back(y);
t2.push_back(x);
}
}
if (cnt1 >= cnt2) {
tmp[j] = t1;
sum += cnt1;
} else {
tmp[j] = t2;
sum += cnt2;
}
}
if (sum > ans) {
ans = sum;
for (int i = 0; i < n; i++) {
b[i].clear();
for (int j = 0; j < m; j++) {
b[i].push_back(tmp[j][i]);
}
}
}
}
for (int i = 0; i < n; i++) {
cout << b[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, m, mnr = 1e9, mnc = 1e9;
vector<char> cr;
vector<string> ans, ans1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cr.push_back('A');
cr.push_back('G');
cr.push_back('C');
cr.push_back('T');
cin >> n >> m;
char gr[n + 3][m + 3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> gr[i][j];
}
}
for (int z = 0; z < 4; z++) {
for (int k = 0; k < 4; k++) {
vector<string> v;
int dif = 0, dif1 = 0, dif2 = 0;
if (z == k) continue;
for (int i = 0; i < n; i++) {
string s, s1;
if (i % 2 == 0) {
s.push_back(cr[z]);
s.push_back(cr[k]);
} else {
for (int zz = 0; zz < 4; zz++) {
for (int kk = 0; kk < 4; kk++) {
if (z != zz && k != kk && z != kk && k != zz && zz != kk) {
s.push_back(cr[zz]);
s.push_back(cr[kk]);
break;
}
}
if (s.size() > 0) break;
}
}
for (int j = 0; j < m; j++) {
if (j > 1) s.push_back(s[j - 2]);
if (s[j] != gr[i][j]) dif1++;
}
if (i % 2 == 0) {
s1.push_back(cr[k]);
s1.push_back(cr[z]);
} else {
for (int zz = 0; zz < 4; zz++) {
for (int kk = 0; kk < 4; kk++) {
if (z != zz && k != kk && z != kk && k != zz && zz != kk) {
s1.push_back(cr[kk]);
s1.push_back(cr[zz]);
break;
}
}
if (s1.size() > 0) break;
}
}
for (int j = 0; j < m; j++) {
if (j > 1) s1.push_back(s1[j - 2]);
if (s1[j] != gr[i][j]) dif2++;
}
if (dif1 > dif2)
v.push_back(s1);
else
v.push_back(s);
dif += min(dif1, dif2);
dif1 = 0, dif2 = 0;
}
if (mnr > dif) ans = v;
mnr = min(mnr, dif);
dif = 0;
v.clear();
}
}
for (int z = 0; z < 4; z++) {
for (int k = 0; k < 4; k++) {
vector<string> v;
int dif = 0, dif1 = 0, dif2 = 0;
if (z == k) continue;
for (int i = 0; i < m; i++) {
string s, s1;
if (i % 2 == 0) {
s.push_back(cr[z]);
s.push_back(cr[k]);
} else {
for (int zz = 0; zz < 4; zz++) {
for (int kk = 0; kk < 4; kk++) {
if (z != zz && k != kk && z != kk && k != zz && zz != kk) {
s.push_back(cr[zz]);
s.push_back(cr[kk]);
break;
}
}
if (s.size() > 0) break;
}
}
for (int j = 0; j < n; j++) {
if (j > 1) s.push_back(s[j - 2]);
if (s[j] != gr[j][i]) dif1++;
}
if (i % 2 == 0) {
s1.push_back(cr[k]);
s1.push_back(cr[z]);
} else {
for (int zz = 0; zz < 4; zz++) {
for (int kk = 0; kk < 4; kk++) {
if (z != zz && k != kk && z != kk && k != zz && zz != kk) {
s1.push_back(cr[kk]);
s1.push_back(cr[zz]);
break;
}
}
if (s1.size() > 0) break;
}
}
for (int j = 0; j < n; j++) {
if (j > 1) s1.push_back(s1[j - 2]);
if (s1[j] != gr[j][i]) dif2++;
}
if (dif1 > dif2)
v.push_back(s1);
else
v.push_back(s);
dif += min(dif1, dif2);
dif1 = 0, dif2 = 0;
}
if (mnc > dif) ans1 = v;
mnc = min(mnc, dif);
dif = 0;
v.clear();
}
}
if (mnr < mnc)
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans1[j][i];
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = (int)1e9 + 7;
const int N = (int)4e5 + 7;
char t[] = "AGCT";
int cnt[N][4][2];
int gao(vector<char> v[], int n, int m, char o[][2]) {
memset(cnt, 0, sizeof(cnt));
for (int i = (0); i < (n); ++i)
for (int c = (0); c < (4); ++c) {
for (int j = (0); j < (m); ++j) {
if (v[i][j] == t[c]) {
cnt[i][c][j & 1]++;
}
}
}
int c[4] = {0, 1, 2, 3};
int ans = 0;
do {
if (c[1] < c[0] || c[3] < c[2]) continue;
int sum = 0;
for (int i = (0); i < (n); ++i) {
if (i & 1) {
sum += max(cnt[i][c[2]][0] + cnt[i][c[3]][1],
cnt[i][c[2]][1] + cnt[i][c[3]][0]);
} else {
sum += max(cnt[i][c[0]][0] + cnt[i][c[1]][1],
cnt[i][c[0]][1] + cnt[i][c[1]][0]);
}
}
if (sum > ans) {
ans = sum;
for (int i = (0); i < (n); ++i) {
if (i & 1) {
if (cnt[i][c[2]][0] + cnt[i][c[3]][1] >
cnt[i][c[2]][1] + cnt[i][c[3]][0]) {
o[i][0] = t[c[2]], o[i][1] = t[c[3]];
} else {
o[i][1] = t[c[2]], o[i][0] = t[c[3]];
}
} else {
if (cnt[i][c[0]][0] + cnt[i][c[1]][1] >
cnt[i][c[0]][1] + cnt[i][c[1]][0]) {
o[i][0] = t[c[0]], o[i][1] = t[c[1]];
} else {
o[i][1] = t[c[0]], o[i][0] = t[c[1]];
}
}
}
}
} while (next_permutation(c, c + 4));
return n * m - ans;
}
char ans[2][N];
int id[36];
vector<char> v[N];
char s[N];
char o[2][N][2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); ++i) scanf("%s", s + i * m);
for (int i = (0); i < (n); ++i) v[i].resize(m);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) v[i][j] = s[i * m + j];
int ans = gao(v, n, m, o[0]);
for (int i = (0); i < (m); ++i) v[i].resize(n);
for (int i = (0); i < (m); ++i)
for (int j = (0); j < (n); ++j) v[i][j] = s[j * m + i];
if (ans > gao(v, m, n, o[1])) {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) cout << o[1][j][i & 1];
cout << endl;
}
} else {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) cout << o[0][i][j & 1];
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<char, int> char2num = {{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}};
string num2char = "ACGT";
int a[300020];
char s[300020];
int temp_a[300020], best_a[300020];
int best_ans;
int get(int row, int col, int tran) {
if (!tran) return row * m + col;
return col * m + row;
}
void check(int i, int j, int tran) {
int kk = -1, pp = -1;
for (int temp = 0; temp < 4; temp++) {
if (temp != i && temp != j) {
if (kk < 0)
kk = temp;
else
pp = temp;
}
}
int num_row = tran ? m : n, num_col = m + n - num_row;
int gain = 0;
for (int row = 0; row < num_row; row++) {
int k = i, p = j;
if (row & 1) k = kk, p = pp;
int kp_gain = 0, pk_gain = 0;
for (int col = 0; col < num_col; col++) {
int val = a[get(row, col, tran)];
if (col & 1) {
if (val == p) kp_gain++;
if (val == k) pk_gain++;
} else {
if (val == k) kp_gain++;
if (val == p) pk_gain++;
}
}
gain += max(kp_gain, pk_gain);
for (int col = 0; col < num_col; col++) {
int loc = get(row, col, tran);
if (col & 1) {
if (kp_gain > pk_gain)
temp_a[loc] = p;
else
temp_a[loc] = k;
} else {
if (kp_gain > pk_gain)
temp_a[loc] = k;
else
temp_a[loc] = p;
}
}
}
if (gain > best_ans) {
best_ans = gain;
for (int it = 0; it < n * m; it++) best_a[it] = temp_a[it];
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) a[i * m + j] = char2num[s[j]];
}
best_ans = -1;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int tran = 0; tran < 2; tran++) {
check(i, j, tran);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(num2char[best_a[i * m + j]]);
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char t[12][3] = {{"AG"}, {"GA"}, {"AC"}, {"CA"}, {"AT"}, {"TA"},
{"GC"}, {"CG"}, {"GT"}, {"TG"}, {"TC"}, {"CT"}},
**s;
int n, m, m1[300002], m2[300002], M1[300002], M2[300002];
int solveh() {
int ret = 0;
for (int i = 2; i <= n; i++) {
int minn = 1050000000;
for (int j = 0; j < 12; j++) {
if (t[m1[i - 1]][0] == t[j][0] || t[m1[i - 1]][0] == t[j][1] ||
t[m1[i - 1]][1] == t[j][0] || t[m1[i - 1]][1] == t[j][1])
continue;
int res = 0;
for (int k = 1; k <= m; k++) {
if (t[j][(k & 1) ^ 1] != s[i][k]) res++;
}
if (res < minn) {
minn = res;
m1[i] = j;
}
}
ret += minn;
}
return ret;
}
int solvel() {
int ret = 0;
for (int i = 2; i <= m; i++) {
int minn = 1050000000;
for (int j = 0; j < 12; j++) {
if (t[m2[i - 1]][0] == t[j][0] || t[m2[i - 1]][0] == t[j][1] ||
t[m2[i - 1]][1] == t[j][0] || t[m2[i - 1]][1] == t[j][1])
continue;
int res = 0;
for (int k = 1; k <= n; k++) {
if (t[j][(k & 1) ^ 1] != s[k][i]) res++;
}
if (res < minn) {
minn = res;
m2[i] = j;
}
}
ret += minn;
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
s = new char*[n + 1];
for (int i = 1; i <= n; i++) {
s[i] = new char[m + 2];
scanf("%s", s[i] + 1);
}
int ans1 = 1050000000, ans2 = 1050000000;
for (int j = 0; j < 12; j++) {
m1[1] = j;
int tmp = 0;
for (int k = 1; k <= m; k++) {
if (t[j][(k & 1) ^ 1] != s[1][k]) tmp++;
}
tmp += solveh();
if (tmp < ans1) {
ans1 = tmp;
for (int i = 1; i <= n; i++) M1[i] = m1[i];
}
}
for (int j = 0; j < 12; j++) {
m2[1] = j;
int tmp = 0;
for (int k = 1; k <= n; k++) {
if (t[j][(k & 1) ^ 1] != s[k][1]) tmp++;
}
tmp += solvel();
if (tmp < ans2) {
ans2 = tmp;
for (int i = 1; i <= m; i++) M2[i] = m2[i];
}
}
if (ans1 < ans2) {
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= m; k++) {
putchar(t[M1[i]][(k & 1) ^ 1]);
}
putchar('\n');
}
} else {
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= m; k++) {
putchar(t[M2[k]][(i & 1) ^ 1]);
}
putchar('\n');
}
}
for (int i = 1; i <= n; i++) {
delete s[i];
}
delete s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power[6] = {0};
map<char, long long int> mp;
map<long long int, char> inv;
pair<long long int, long long int> ok(long long int j) {
long long int cnt = 0;
for (long long int i = 0; i <= 3; i++) {
if (power[i] & j) cnt++;
}
if (cnt != 2) {
return {-1, -1};
}
pair<long long int, long long int> p = {-1, -1};
for (long long int i = 0; i <= 3; i++) {
if (power[i] & j) {
if (p.first == -1) {
p.first = i + 1;
} else {
p.second = i + 1;
}
}
}
return p;
}
void solve() {
long long int n, m;
cin >> n >> m;
vector<vector<long long int>> v(n, vector<long long int>(m));
for (long long int j = 0; j < n; j++) {
string s;
cin >> s;
for (long long int i = 0; i < m; i++) {
v[j][i] = mp[s[i]];
}
}
vector<pair<long long int, pair<long long int, long long int>>> rows;
vector<pair<long long int, pair<long long int, long long int>>> cols;
for (long long int j = 3; j <= 12; j++) {
pair<long long int, long long int> p1 = ok(j);
pair<long long int, long long int> p2 = {0, 0};
for (long long int j = 1; j <= 4; j++) {
if (p1.first != j && p1.second != j) {
if (p2.first)
p2.second = j;
else
p2.first = j;
}
}
long long int mn = 0;
if (p1.first != -1) {
for (long long int j = 0; j < n; j++) {
long long int mn1 = 0;
long long int mn2 = 0;
if (j % 2 == 0) {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
if (v[j][i] != p1.first) mn1++;
if (v[j][i] != p1.second) mn2++;
} else {
if (v[j][i] != p1.second) mn1++;
if (v[j][i] != p1.first) mn2++;
}
}
} else {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
if (v[j][i] != p2.first) mn1++;
if (v[j][i] != p2.second) mn2++;
} else {
if (v[j][i] != p2.second) mn1++;
if (v[j][i] != p2.first) mn2++;
}
}
}
mn += min(mn1, mn2);
}
rows.push_back({mn, p1});
}
}
for (long long int j = 3; j <= 12; j++) {
pair<long long int, long long int> p1 = ok(j);
pair<long long int, long long int> p2 = {0, 0};
for (long long int j = 1; j <= 4; j++) {
if (p1.first != j && p1.second != j) {
if (p2.first)
p2.second = j;
else
p2.first = j;
}
}
long long int mn = 0;
if (p1.first != -1) {
for (long long int j = 0; j < m; j++) {
long long int mn1 = 0;
long long int mn2 = 0;
if (j % 2 == 0) {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i][j] != p1.first) mn1++;
if (v[i][j] != p1.second) mn2++;
} else {
if (v[i][j] != p1.second) mn1++;
if (v[i][j] != p1.first) mn2++;
}
}
} else {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i][j] != p2.first) mn1++;
if (v[i][j] != p2.second) mn2++;
} else {
if (v[i][j] != p2.second) mn1++;
if (v[i][j] != p2.first) mn2++;
}
}
}
mn += min(mn1, mn2);
}
cols.push_back({mn, p1});
}
}
sort(rows.begin(), rows.end());
sort(cols.begin(), cols.end());
vector<vector<long long int>> ans(n, vector<long long int>(m));
cout << "\n";
if (rows[0].first < cols[0].first) {
pair<long long int, long long int> p1 = rows[0].second;
pair<long long int, long long int> p2 = {0, 0};
for (long long int j = 1; j <= 4; j++) {
if (p1.first != j && p1.second != j) {
if (p2.first)
p2.second = j;
else
p2.first = j;
}
}
if (p1.first != -1) {
for (long long int j = 0; j < n; j++) {
long long int mn1 = 0;
long long int mn2 = 0;
if (j % 2 == 0) {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
if (v[j][i] != p1.first) mn1++;
if (v[j][i] != p1.second) mn2++;
} else {
if (v[j][i] != p1.second) mn1++;
if (v[j][i] != p1.first) mn2++;
}
}
} else {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
if (v[j][i] != p2.first) mn1++;
if (v[j][i] != p2.second) mn2++;
} else {
if (v[j][i] != p2.second) mn1++;
if (v[j][i] != p2.first) mn2++;
}
}
}
if (mn1 < mn2) {
if (j % 2 == 0) {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
ans[j][i] = p1.first;
} else {
ans[j][i] = p1.second;
}
}
} else {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
ans[j][i] = p2.first;
} else {
ans[j][i] = p2.second;
}
}
}
} else {
if (j % 2 == 0) {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
ans[j][i] = p1.second;
} else {
ans[j][i] = p1.first;
}
}
} else {
for (long long int i = 0; i < m; i++) {
if (i % 2 == 0) {
ans[j][i] = p2.second;
} else {
ans[j][i] = p2.first;
}
}
}
}
}
}
} else {
pair<long long int, long long int> p1 = cols[0].second;
pair<long long int, long long int> p2 = {0, 0};
for (long long int j = 1; j <= 4; j++) {
if (p1.first != j && p1.second != j) {
if (p2.first)
p2.second = j;
else
p2.first = j;
}
}
if (p1.first != -1) {
for (long long int j = 0; j < m; j++) {
long long int mn1 = 0;
long long int mn2 = 0;
if (j % 2 == 0) {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i][j] != p1.first) mn1++;
if (v[i][j] != p1.second) mn2++;
} else {
if (v[i][j] != p1.second) mn1++;
if (v[i][j] != p1.first) mn2++;
}
}
} else {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i][j] != p2.first) mn1++;
if (v[i][j] != p2.second) mn2++;
} else {
if (v[i][j] != p2.second) mn1++;
if (v[i][j] != p2.first) mn2++;
}
}
}
if (mn1 < mn2) {
if (j % 2 == 0) {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans[i][j] = p1.first;
} else {
ans[i][j] = p1.second;
}
}
} else {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans[i][j] = p2.first;
} else {
ans[i][j] = p2.second;
}
}
}
} else {
if (j % 2 == 0) {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans[i][j] = p1.second;
} else {
ans[i][j] = p1.first;
}
}
} else {
for (long long int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans[i][j] = p2.second;
} else {
ans[i][j] = p2.first;
}
}
}
}
}
}
}
long long int cnt = 0;
for (long long int j = 0; j < n; j++) {
for (long long int i = 0; i < m; i++) {
if (ans[j][i] != v[j][i]) cnt++;
cout << inv[ans[j][i]];
}
cout << "\n";
}
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
mp['A'] = 1;
mp['G'] = 2;
mp['C'] = 3;
mp['T'] = 4;
inv[1] = 'A';
inv[2] = 'G';
inv[3] = 'C';
inv[4] = 'T';
power[0] = 1;
power[1] = 2;
power[2] = 4;
power[3] = 8;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300050;
int n, m;
char ss[MAXN];
string G[MAXN], W[MAXN], DNA = "ACGT";
void getstring(string &s) {
scanf(" %s", ss);
s = ss;
}
int to_id(char ch) {
if (ch == 'A') return 0;
if (ch == 'C') return 1;
if (ch == 'G') return 2;
return 3;
}
char ch(int c) { return DNA[c]; }
int paint_row(int i, char ch1, char ch2) {
int match = 0;
for (int j = (0); j < (int)(m); j++) {
W[i][j] = (j % 2) ? ch1 : ch2;
if (G[i][j] == W[i][j]) match++;
}
return match;
}
int paint_col(int j, char ch1, char ch2) {
int match = 0;
for (int i = (0); i < (int)(n); i++) {
W[i][j] = (i % 2) ? ch1 : ch2;
if (G[i][j] == W[i][j]) match++;
}
return match;
}
int solve_row(int c1, int c2, int c3, int c4) {
char ch1 = ch(c1);
char ch2 = ch(c2);
char ch3 = ch(c3);
char ch4 = ch(c4);
int ans = 0;
for (int i = (0); i < (int)(n); i++) {
if (paint_row(i, ch1, ch2) > paint_row(i, ch2, ch1)) {
ans += paint_row(i, ch1, ch2);
} else {
ans += paint_row(i, ch2, ch1);
}
swap(ch1, ch3);
swap(ch2, ch4);
}
return ans;
}
int solve_col(int c1, int c2, int c3, int c4) {
char ch1 = ch(c1);
char ch2 = ch(c2);
char ch3 = ch(c3);
char ch4 = ch(c4);
int ans = 0;
for (int j = (0); j < (int)(m); j++) {
if (paint_col(j, ch1, ch2) > paint_col(j, ch2, ch1)) {
ans += paint_col(j, ch1, ch2);
} else {
ans += paint_col(j, ch2, ch1);
}
swap(ch1, ch3);
swap(ch2, ch4);
}
return ans;
}
int main() {
while (scanf("%d %d", &n, &m) >= 1) {
for (int i = (0); i < (int)(n); i++) {
getstring(G[i]);
W[i] = G[i];
}
int best = -1;
vector<int> ans;
bool row = false;
vector<int> V = {0, 1, 2, 3};
do {
int cand = solve_row(V[0], V[1], V[2], V[3]);
if (cand > best) {
best = cand;
ans = V;
row = true;
}
cand = solve_col(V[0], V[1], V[2], V[3]);
if (cand > best) {
best = cand;
ans = V;
row = false;
}
} while (next_permutation(V.begin(), V.end()));
if (row)
solve_row(ans[0], ans[1], ans[2], ans[3]);
else
solve_col(ans[0], ans[1], ans[2], ans[3]);
for (int i = (0); i < (int)(n); i++) {
printf("%s\n", W[i].c_str());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char letters[] = {'A', 'G', 'C', 'T'};
const int NMAX = 3e5 + 5;
int N, M;
int A, G, C, T;
int best;
vector<vector<int> > a, b;
vector<int> prm, bestprm;
int fqlin[NMAX][2][4], fqcol[NMAX][2][4];
char gletter() {
char ch = getchar();
while (ch < 'A' || 'Z' < ch) ch = getchar();
return ch;
}
int main() {
scanf("%d%d\n", &N, &M);
a.resize(N + 1);
for (int i = 1; i <= N; i++) {
a[i].resize(M + 1);
for (int j = 1; j <= M; j++) {
char ch = gletter();
if (ch == 'A')
a[i][j] = 0;
else if (ch == 'G')
a[i][j] = 1;
else if (ch == 'C')
a[i][j] = 2;
else if (ch == 'T')
a[i][j] = 3;
fqlin[i][j % 2][a[i][j]]++;
fqcol[j][i % 2][a[i][j]]++;
}
}
best = -1;
int who = -1;
for (int i = 0; i < 4; i++) prm.push_back(i);
do {
{
int cost = 0;
A = prm[0], G = prm[1], C = prm[2], T = prm[3];
cost += fqcol[1][1][A] + fqcol[1][0][C] + fqcol[2][1][G] + fqcol[2][0][T];
for (int i = 3; i <= M; i++) {
if (i % 2 == 0)
cost += max(fqcol[i][1][G] + fqcol[i][0][T],
fqcol[i][0][G] + fqcol[i][1][T]);
else
cost += max(fqcol[i][1][A] + fqcol[i][0][C],
fqcol[i][0][A] + fqcol[i][1][C]);
}
if (cost > best) {
best = cost;
bestprm = prm;
who = 0;
}
}
{
int cost = 0;
A = prm[0], G = prm[1], C = prm[2], T = prm[3];
cost += fqlin[1][1][A] + fqlin[2][1][C] + fqlin[1][0][G] + fqlin[2][0][T];
for (int i = 3; i <= N; i++) {
if (i % 2 == 0)
cost += max(fqlin[i][1][C] + fqlin[i][0][T],
fqlin[i][0][C] + fqlin[i][1][T]);
else
cost += max(fqlin[i][1][A] + fqlin[i][0][G],
fqlin[i][0][A] + fqlin[i][1][G]);
}
if (cost > best) {
best = cost;
bestprm = prm;
who = 1;
}
}
} while (next_permutation(prm.begin(), prm.end()));
b = a;
prm = bestprm;
if (who == 0) {
A = prm[0], G = prm[1], C = prm[2], T = prm[3];
b[1][1] = A, b[2][1] = C, b[1][2] = G, b[2][2] = T;
for (int i = 3; i <= M; i++) {
if (i % 2 == 1) {
if (fqcol[i][1][A] + fqcol[i][0][C] > fqcol[i][0][A] + fqcol[i][1][C])
b[1][i] = A, b[2][i] = C;
else
b[1][i] = C, b[2][i] = A;
} else {
if (fqcol[i][1][G] + fqcol[i][0][T] > fqcol[i][0][G] + fqcol[i][1][T])
b[1][i] = G, b[2][i] = T;
else
b[1][i] = T, b[2][i] = G;
}
}
for (int i = 3; i <= N; i++)
for (int j = 1; j <= M; j++) b[i][j] = b[i - 2][j];
} else {
A = prm[0], G = prm[1], C = prm[2], T = prm[3];
b[1][1] = A, b[2][1] = C, b[1][2] = G, b[2][2] = T;
for (int i = 3; i <= N; i++) {
if (i % 2 == 1) {
if (fqlin[i][1][A] + fqlin[i][0][G] > fqlin[i][0][A] + fqlin[i][1][G])
b[i][1] = A, b[i][2] = G;
else
b[i][1] = G, b[i][2] = A;
} else {
if (fqlin[i][1][C] + fqlin[i][0][T] > fqlin[i][0][C] + fqlin[i][1][T])
b[i][1] = C, b[i][2] = T;
else
b[i][1] = T, b[i][2] = C;
}
}
for (int i = 3; i <= M; i++)
for (int j = 1; j <= N; j++) b[j][i] = b[j][i - 2];
}
for (int i = 1; i <= N; i++, printf("\n"))
for (int j = 1; j <= M; j++) printf("%c", letters[b[i][j]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DN = 3e5 + 5;
int n, m, sol, f, cnt, mi = 1e9, sum;
char ch[6], a[5][5], car;
string s[DN], r[DN];
void solve1() {
cnt++;
sum = 0;
int f, mi;
for (int i = 1; i <= n; i++) {
f = 0;
for (int j = 1; j <= m; j++) {
car = a[i % 2][j % 2];
if (s[i][j] != car) f++;
r[i][j] = car;
}
mi = f;
f = 0;
for (int j = 1; j <= m; j++) {
car = a[i % 2][1 - j % 2];
if (s[i][j] != car) f++;
}
if (f < mi) {
mi = f;
for (int j = 1; j <= m; j++) {
car = a[i % 2][1 - j % 2];
r[i][j] = car;
}
}
sum += mi;
}
}
void solve2() {
cnt++;
sum = 0;
int f, mi;
for (int j = 1; j <= m; j++) {
f = 0;
for (int i = 1; i <= n; i++) {
car = a[i % 2][j % 2];
if (s[i][j] != car) f++;
r[i][j] = car;
}
mi = f;
f = 0;
for (int i = 1; i <= n; i++) {
car = a[1 - i % 2][j % 2];
if (s[i][j] != car) f++;
}
if (f < mi) {
mi = f;
for (int i = 1; i <= n; i++) {
car = a[1 - i % 2][j % 2];
r[i][j] = car;
}
}
sum += mi;
}
}
void solve() {
cnt = 0;
ch[1] = 'A';
ch[2] = 'G';
ch[3] = 'C';
ch[4] = 'T';
do {
a[0][0] = ch[1];
a[0][1] = ch[2];
a[1][0] = ch[3];
a[1][1] = ch[4];
solve1();
if (sum < mi) {
mi = sum;
f = cnt;
}
if (sum == sol) return;
solve2();
if (sum < mi) {
mi = sum;
f = cnt;
}
if (sum == sol) return;
} while (next_permutation(ch + 1, ch + 5));
sol = mi;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i <= n; i++) getline(cin, s[i]);
for (int i = 1; i <= n; i++) {
s[i] = " " + s[i];
r[i] = s[i];
}
solve();
solve();
for (int i = 1; i <= n; i++) r[i].erase(r[i].begin());
for (int i = 1; i <= n; i++) cout << r[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int kInf = numeric_limits<int>::max();
string chrs = "ACGT";
int n, m, minDiff = kInf, p[5];
vector<string> conf, finConf;
int getColumnCost(int col, char c1, char c2) {
int cost = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0 && conf[i][col] != c1) {
cost++;
}
if (i % 2 == 1 && conf[i][col] != c2) {
cost++;
}
}
return cost;
}
void applyColumn(vector<string>& crtConf, int col, char c1, char c2) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
crtConf[i][col] = c1;
} else {
crtConf[i][col] = c2;
}
}
}
int solveColumn(vector<string>& crtConf, int col, char c1, char c2) {
int diff12 = getColumnCost(col, c1, c2);
int diff21 = getColumnCost(col, c2, c1);
if (diff12 < diff21) {
applyColumn(crtConf, col, c1, c2);
} else {
applyColumn(crtConf, col, c2, c1);
}
return min(diff12, diff21);
}
void tryVert(char c1, char c2, char c3, char c4) {
vector<string> crtConf(n, string(m, ' '));
int crtDiff = 0;
for (int j = 0; j < m; j++) {
if (j % 2 == 0) {
crtDiff += solveColumn(crtConf, j, c1, c2);
} else {
crtDiff += solveColumn(crtConf, j, c3, c4);
}
}
if (crtDiff < minDiff) {
minDiff = crtDiff;
finConf = crtConf;
}
}
int getLineCost(int line, char c1, char c2) {
int cost = 0;
for (int i = 0; i < m; i++) {
if (i % 2 == 0 && conf[line][i] != c1) {
cost++;
}
if (i % 2 == 1 && conf[line][i] != c2) {
cost++;
}
}
return cost;
}
void applyLine(vector<string>& crtConf, int line, char c1, char c2) {
for (int i = 0; i < m; i++) {
if (i % 2 == 0) {
crtConf[line][i] = c1;
} else {
crtConf[line][i] = c2;
}
}
}
int solveLine(vector<string>& crtConf, int line, char c1, char c2) {
int diff12 = getLineCost(line, c1, c2);
int diff21 = getLineCost(line, c2, c1);
if (diff12 < diff21) {
applyLine(crtConf, line, c1, c2);
} else {
applyLine(crtConf, line, c2, c1);
}
return min(diff12, diff21);
}
void tryHoriz(char c1, char c2, char c3, char c4) {
vector<string> crtConf(n, string(m, ' '));
int crtDiff = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
crtDiff += solveLine(crtConf, i, c1, c2);
} else {
crtDiff += solveLine(crtConf, i, c3, c4);
}
}
if (crtDiff < minDiff) {
minDiff = crtDiff;
finConf = crtConf;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string line;
cin >> line;
conf.push_back(line);
}
for (int i = 0; i < 4; i++) {
p[i] = i;
}
do {
tryVert(chrs[p[0]], chrs[p[1]], chrs[p[2]], chrs[p[3]]);
} while (next_permutation(p, p + 4));
for (int i = 0; i < 4; i++) {
p[i] = i;
}
do {
tryHoriz(chrs[p[0]], chrs[p[1]], chrs[p[2]], chrs[p[3]]);
} while (next_permutation(p, p + 4));
for (int i = 0; i < n; i++) {
cout << finConf[i] << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long M = 1e9 + 7;
const long long N = 5002;
int fun(vector<string> &s) {
int res = M;
vector<string> tmp = s;
int n = s.size(), m = s[0].size();
for (int F = 0; F < 3; F++)
for (int S = F + 1; S < 4; S++) {
vector<char> v[2];
v[0].push_back(F + '0');
v[0].push_back(S + '0');
for (int k = 0; k < 4; k++)
if (k != F && k != S) v[1].push_back(k + '0');
int sum = 0;
for (int i = 0; i < n; i++) {
int cur[2] = {};
for (int j = 0; j < m; j++) cur[0] += v[i % 2][j % 2] != s[i][j];
for (int j = 0; j < m; j++) cur[1] += v[i % 2][1 - j % 2] != s[i][j];
sum += min(cur[0], cur[1]);
}
if (res > sum) {
res = sum;
for (int i = 0; i < n; i++) {
int cur[2] = {};
for (int j = 0; j < m; j++) cur[0] += v[i % 2][j % 2] != s[i][j];
for (int j = 0; j < m; j++) cur[1] += v[i % 2][1 - j % 2] != s[i][j];
if (cur[0] < cur[1])
for (int j = 0; j < m; j++) tmp[i][j] = v[i % 2][j % 2];
else
for (int j = 0; j < m; j++) tmp[i][j] = v[i % 2][1 - j % 2];
}
}
}
s = tmp;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
map<char, char> mp;
vector<char> v = {'A', 'C', 'G', 'T'};
vector<char> v1 = {'0', '1', '2', '3'};
for (int i = 0; i < 4; i++) mp[v[i]] = v1[i], mp[v1[i]] = v[i];
int n, m;
cin >> n >> m;
vector<string> s(n), t(m), res;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = mp[s[i][j]];
for (int i = 0; i < m; i++) {
t[i] = "";
for (int j = 0; j < n; j++) t[i] += s[j][i];
}
bool ok = true;
if (fun(s) < fun(t))
res = s;
else
res = t, ok = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ok)
cout << mp[res[i][j]];
else
cout << mp[res[j][i]];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> mat, res;
int row(int r, char a, char b) {
int ans = 0;
for (int i = 0; i < m; i++) {
ans += (mat[r][i] != (i % 2 ? b : a));
}
return ans;
}
int col(int c, char a, char b) {
int ans = 0;
for (int i = 0; i < n; i++) {
ans += (mat[i][c] != (i % 2 ? b : a));
}
return ans;
}
void fillr(int r, char a, char b) {
for (int i = 0; i < m; i++) {
res[r][i] = (i % 2 ? b : a);
}
}
void fillc(int c, int a, int b) {
for (int i = 0; i < n; i++) {
res[i][c] = (i % 2 ? b : a);
}
}
int main() {
cin >> n >> m;
mat = vector<string>(n);
for (int i = 0; i < n; i++) {
cin >> mat[i];
}
res = mat;
vector<char> vec{'A', 'C', 'G', 'T'};
int ans = 2e9;
bool r;
vector<char> fin;
do {
int here = 0;
for (int i = 0; i < n; i++) {
here += min(row(i, vec[2 - 2 * (i & 1)], vec[3 - 2 * (i & 1)]),
row(i, vec[3 - 2 * (i & 1)], vec[2 - 2 * (i & 1)]));
}
if (here < ans) {
ans = here;
fin = vec;
r = 1;
}
here = 0;
for (int j = 0; j < m; j++) {
here += min(col(j, vec[2 - 2 * (j & 1)], vec[3 - 2 * (j & 1)]),
col(j, vec[3 - 2 * (j & 1)], vec[2 - 2 * (j & 1)]));
}
if (here < ans) {
ans = here;
fin = vec;
r = 0;
}
} while (next_permutation(vec.begin(), vec.end()));
if (r) {
for (int i = 0; i < n; i++) {
if (row(i, fin[2 - 2 * (i & 1)], fin[3 - 2 * (i & 1)]) <
row(i, fin[3 - 2 * (i & 1)], fin[2 - 2 * (i & 1)])) {
fillr(i, fin[2 - 2 * (i & 1)], fin[3 - 2 * (i & 1)]);
} else {
fillr(i, fin[3 - 2 * (i & 1)], fin[2 - 2 * (i & 1)]);
}
}
} else {
for (int j = 0; j < m; j++) {
if (col(j, fin[2 - 2 * (j & 1)], fin[3 - 2 * (j & 1)]) <
col(j, fin[3 - 2 * (j & 1)], fin[2 - 2 * (j & 1)])) {
fillc(j, fin[2 - 2 * (j & 1)], fin[3 - 2 * (j & 1)]);
} else {
fillc(j, fin[3 - 2 * (j & 1)], fin[2 - 2 * (j & 1)]);
}
}
}
for (int i = 0; i < n; i++) {
cout << res[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 100005;
int n, m;
vector<vector<char>> mat;
vector<vector<char>> ans;
vector<vector<char>> ans2;
ll qtd = 1e9;
int f(char i1, char j1, char i2, char j2, vector<vector<char>> &ansi = ans) {
char x[2] = {i1, i2};
char y[2] = {j1, j2};
int aux = 0;
for (int i = 0; i < n; i++) {
int aux1 = 0, aux2 = 0;
for (int j = 0; j < m; j++) {
if (j & 1)
aux1 += x[i & 1] != mat[i][j];
else
aux1 += y[i & 1] != mat[i][j];
}
for (int j = 0; j < m; j++) {
if (!(j & 1))
aux2 += x[i & 1] != mat[i][j];
else
aux2 += y[i & 1] != mat[i][j];
}
aux += min(aux1, aux2);
}
if (aux < qtd) {
qtd = aux;
for (int i = 0; i < n; i++) {
int aux1 = 0, aux2 = 0;
for (int j = 0; j < m; j++) {
if (j & 1)
aux1 += x[i & 1] != mat[i][j];
else
aux1 += y[i & 1] != mat[i][j];
}
for (int j = 0; j < m; j++) {
if (!(j & 1))
aux2 += x[i & 1] != mat[i][j];
else
aux2 += y[i & 1] != mat[i][j];
}
if (aux1 < aux2) {
for (int j = 0; j < m; j++) {
if (j & 1)
ansi[i][j] = x[i & 1];
else
ansi[i][j] = y[i & 1];
}
} else {
for (int j = 0; j < m; j++) {
if (!(j & 1))
ansi[i][j] = x[i & 1];
else
ansi[i][j] = y[i & 1];
}
}
}
return 1;
}
return 0;
}
vector<vector<char>> transp(vector<vector<char>> &mat) {
vector<vector<char>> ret = vector<vector<char>>(m, vector<char>(n + 5));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[j][i] = mat[i][j];
}
}
return ret;
}
int main() {
scanf("%d %d", &n, &m);
mat = vector<vector<char>>(n, vector<char>(m + 5));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf(" %c", &mat[i][j]);
}
}
vector<char> v = {'A', 'C', 'G', 'T'};
ans = vector<vector<char>>(n, vector<char>(m + 5));
ans2 = vector<vector<char>>(m, vector<char>(n + 5));
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int i2 = 0; i2 < 4; i2++) {
for (int j2 = i2 + 1; j2 < 4; j2++) {
if (i != i2 && i != j2 && j != j2 && j != i2) {
f(v[i], v[j], v[i2], v[j2]);
}
}
}
}
}
mat = transp(mat);
swap(n, m);
bool tp = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
for (int i2 = 0; i2 < 4; i2++) {
for (int j2 = i2 + 1; j2 < 4; j2++) {
if (i != i2 && i != j2 && j != j2 && j != i2) {
tp |= f(v[i], v[j], v[i2], v[j2], ans2);
}
}
}
}
}
if (tp) {
ans = transp(ans2);
}
swap(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", ans[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long inf = 2e18;
const long long mod = 1e9 + 7;
const long long eps = 1e-9;
const char spc = 29;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
using namespace std;
vector<vector<char>> a;
vector<vector<char>> acp;
long long n, m;
void inverse() {
vector<vector<char>> buf1(m, vector<char>(n, '#'));
vector<vector<char>> buf2(m, vector<char>(n, '#'));
for (long long i = 0; i < m; ++i)
for (long long j = 0; j < n; ++j) buf1[i][j] = acp[j][i];
for (long long i = 0; i < m; ++i)
for (long long j = 0; j < n; ++j) buf2[i][j] = a[j][i];
acp.clear();
a.clear();
acp.resize(m, vector<char>(n, '#'));
a.resize(m, vector<char>(n, '#'));
swap(n, m);
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) acp[i][j] = buf1[i][j];
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) a[i][j] = buf2[i][j];
}
vector<char> construct(string s) {
vector<char> res;
for (long long i = 0; i + 1 < m; i += 2) {
res.push_back(s[0]);
res.push_back(s[1]);
}
if (m & 1) res.push_back(s[0]);
return move(res);
}
long long nonmat(vector<char> &s1, vector<char> &s2) {
long long res = 0;
for (long long i = 0; i < m; ++i)
if (s1[i] != s2[i]) ++res;
return res;
}
long long calc(string &p) {
long long res = 0;
long long cur = 0;
vector<char> strs[4];
string h1 = p.substr(0, 2);
string h2 = p.substr(2, 2);
strs[0] = construct(h1);
swap(h1[0], h1[1]);
strs[1] = construct(h1);
strs[2] = construct(h2);
swap(h2[0], h2[1]);
strs[3] = construct(h2);
for (long long i = 0; i < n; ++i, cur += 2) {
if (cur >= 4) cur -= 4;
long long val1 = nonmat(acp[i], strs[cur]);
long long val2 = nonmat(acp[i], strs[cur + 1]);
if (val1 < val2) {
copy((strs[cur]).begin(), (strs[cur]).end(), a[i].begin());
res += val1;
} else {
copy((strs[cur + 1]).begin(), (strs[cur + 1]).end(), a[i].begin());
res += val2;
}
}
return res;
}
long long solve() {
string p = "ACGT";
long long bst = inf;
string bstp = p;
while (true) {
long long nval = calc(p);
if (nval < bst) {
bst = nval;
bstp = p;
}
if (!next_permutation(p.begin(), p.end())) break;
}
calc(bstp);
return bst;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
a.resize(n, vector<char>(m, '#'));
acp.resize(n, vector<char>(m, '#'));
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) {
cin >> a[i][j];
acp[i][j] = a[i][j];
}
long long res1 = solve();
inverse();
long long res2 = solve();
if (res1 < res2) {
inverse();
solve();
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) cout << a[i][j];
cout << "\n";
}
return 0;
}
inverse();
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) cout << a[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<string> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
int cost_ans = n * m + 1;
vector<string> ans;
vector<char> s{'A', 'C', 'G', 'T'};
do {
{
vector<string> tmp(n, string(m, ' '));
int cost_tmp = 0;
char a, b;
for (int j = 0; j < m; j++) {
if (j & 1) {
a = s[1];
b = s[3];
} else {
a = s[0];
b = s[2];
}
int cost_tmp1 = 0, cost_tmp2 = 0;
for (int i = 0; i < n; i++) {
if (i & 1)
cost_tmp1 += (a != t[i][j]);
else
cost_tmp1 += (b != t[i][j]);
}
swap(a, b);
for (int i = 0; i < n; i++) {
if (i & 1)
cost_tmp2 += (a != t[i][j]);
else
cost_tmp2 += (b != t[i][j]);
}
if (cost_tmp1 < cost_tmp2) swap(a, b);
cost_tmp += min(cost_tmp1, cost_tmp2);
for (int i = 0; i < n; i++) {
if (i & 1)
tmp[i][j] = a;
else
tmp[i][j] = b;
}
}
if (cost_ans > cost_tmp) {
cost_ans = cost_tmp;
ans = tmp;
}
}
{
vector<string> tmp(n, string(m, ' '));
int cost_tmp = 0;
char a, b;
for (int i = 0; i < n; i++) {
if (i & 1) {
a = s[1];
b = s[3];
} else {
a = s[0];
b = s[2];
}
int cost_tmp1 = 0, cost_tmp2 = 0;
for (int j = 0; j < m; j++) {
if (j & 1)
cost_tmp1 += (a != t[i][j]);
else
cost_tmp1 += (b != t[i][j]);
}
swap(a, b);
for (int j = 0; j < m; j++) {
if (j & 1)
cost_tmp2 += (a != t[i][j]);
else
cost_tmp2 += (b != t[i][j]);
}
if (cost_tmp1 < cost_tmp2) swap(a, b);
cost_tmp += min(cost_tmp1, cost_tmp2);
for (int j = 0; j < m; j++) {
if (j & 1)
tmp[i][j] = a;
else
tmp[i][j] = b;
}
}
if (cost_ans > cost_tmp) {
cost_ans = cost_tmp;
ans = tmp;
}
}
} while (next_permutation(s.begin(), s.end()));
for (const auto &str : ans) cout << str << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
bool x;
cin >> n >> m;
vector<bool> rowAXor(n);
vector<bool> rowBXor(n);
vector<bool> colAXor(m);
vector<bool> colBXor(m);
int totalBXor = 0, totalAXor = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> x;
totalAXor ^= x;
rowAXor[i] = (rowAXor[i] ^ x);
colAXor[j] = (x ^ colAXor[j]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> x;
totalBXor ^= x;
rowBXor[i] = (rowBXor[i] ^ x);
colBXor[j] = (x ^ colBXor[j]);
}
}
bool isValid = (totalAXor == totalBXor);
for (int i = 0; i < n; ++i) {
isValid &= (rowAXor[i] == rowBXor[i]);
}
for (int i = 0; i < m; ++i) {
isValid &= (colBXor[i] == colAXor[i]);
}
if (isValid) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
long long inf = 1e16;
long long mod = 1e9 + 7;
char en = '\n';
long long abs1(long long x) {
if (x < 0) return -x;
return x;
}
long long power(long long x, long long n, long long mod) {
long long res = 1;
x %= mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long a[n + 5][m + 5];
long long b[n + 5][m + 5];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> a[i][j];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> b[i][j];
}
for (long long i = 1; i < n; i++) {
for (long long j = 1; j < m; j++) {
if (a[i][j] != b[i][j]) {
a[n][m] ^= 1;
a[i][m] ^= 1;
a[n][j] ^= 1;
a[i][j] ^= 1;
}
}
}
long long flag = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] != b[i][j]) flag = 1;
}
}
cout << ((flag == 0) ? "yes" : "no") << en;
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ull = unsigned long long;
using ld = long double;
template <typename T>
void _dbg(const char* s, T h) {
cerr << s << " = " << h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char* s, T h, Ts... t) {
int b = 0;
while (((b += *s == '(') -= *s == ')') != 0 || *s != ',') cerr << *s++;
cerr << " = " << h << ",";
_dbg(s + 1, t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
template <typename T, typename U>
void upx(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
void upn(T& x, U y) {
if (x > y) x = y;
}
const ll N = 555;
ll a[N][N];
ll b[N][N];
ll r[N], c[N];
int32_t main() {
ll n, m;
cin >> n >> m;
for (ll i = 0; i < (n); ++i) {
for (ll j = 0; j < (m); ++j) {
cin >> a[i][j];
r[i] ^= a[i][j];
c[j] ^= a[i][j];
}
}
for (ll i = 0; i < (n); ++i) {
for (ll j = 0; j < (m); ++j) {
cin >> b[i][j];
r[i] ^= b[i][j];
c[j] ^= b[i][j];
}
}
ll ok = 1;
for (ll i = 0; i < (n); ++i) ok &= r[i] == 0;
for (ll i = 0; i < (m); ++i) ok &= c[i] == 0;
if (ok)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
const int N = 510;
int n, m, sm1[N], sm2[N], sm3[N], sm4[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
scanf("%d", &x);
sm1[i] ^= x;
sm2[j] ^= x;
}
for (int i = 1, x; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
scanf("%d", &x);
sm3[i] ^= x;
sm4[j] ^= x;
}
for (int i = 1; i <= n; ++i)
if (sm1[i] != sm3[i]) return puts("No"), 0;
for (int i = 1; i <= m; ++i)
if (sm2[i] != sm4[i]) return puts("No"), 0;
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[510][510], b[510][510];
inline int read() {
int num = 0, flag = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') flag = 1;
for (; c >= '0' && c <= '9'; c = getchar())
num = (num << 3) + (num << 1) + (c ^ 48);
return flag ? -num : num;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) b[i][j] = read();
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
if (a[i][j] != b[i][j]) {
a[i][j] ^= 1;
a[n][m] ^= 1;
a[n][j] ^= 1;
a[i][m] ^= 1;
}
for (int i = 1; i <= n; i++)
if (a[i][m] != b[i][m]) {
puts("No");
return 0;
}
for (int i = 1; i <= m; i++)
if (a[n][i] != b[n][i]) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, rs[2][505], cs[2][505], tmp;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 2; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k) {
scanf("%d", &tmp);
rs[i][j] ^= tmp;
cs[i][k] ^= tmp;
}
int flag = 1;
for (int i = 0; i < n; ++i)
if (rs[0][i] != rs[1][i]) {
flag = 0;
break;
}
if (flag) {
for (int i = 0; i < m; ++i)
if (cs[0][i] != cs[1][i]) {
flag = 0;
break;
}
}
if (flag)
printf("Yes\n");
else
printf("No\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m;
cin >> n >> m;
long long int a[n][m];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
vector<long long int> row(n, 0), col(m, 0);
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int x;
cin >> x;
if (a[i][j] != x) {
row[i]++;
col[j]++;
}
}
}
bool ok = true;
for (long long int i = 0; i < n; i++) ok &= (row[i] % 2 == 0);
for (long long int i = 0; i < m; i++) ok &= (col[i] % 2 == 0);
cout << (ok == true ? "Yes" : "No");
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
int modpow(int x, int y, int md = mod) {
if (y == 0) return 1;
int ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
int n, m;
int a[505][505];
int b[505][505];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &b[i][j]);
int suma = 0, sumb = 0;
for (int i = 0; i < n; i++) {
suma = 0;
sumb = 0;
for (int j = 0; j < m; j++) {
suma ^= a[i][j];
sumb ^= b[i][j];
}
if (suma != sumb) return puts("NO") & 0;
}
for (int j = 0; j < m; j++) {
suma = 0;
sumb = 0;
for (int i = 0; i < n; i++) {
suma ^= a[i][j];
sumb ^= b[i][j];
}
if (suma != sumb) return puts("NO") & 0;
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[505][505];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
num[i][j] ^= x;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
num[i][j] ^= x;
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
if (num[i][j]) {
num[i][j] ^= 1;
num[i][j + 1] ^= 1;
num[i + 1][j] ^= 1;
num[i + 1][j + 1] ^= 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (num[i][j]) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
signed main() {
long long h, w;
cin >> h >> w;
vector<vector<long long>> a(h, vector<long long>(w)),
b(h, vector<long long>(w));
for (long long i = 0; i < h; i++) {
for (long long j = 0; j < w; j++) {
cin >> a[i][j];
}
}
for (long long i = 0; i < h; i++) {
for (long long j = 0; j < w; j++) {
cin >> b[i][j];
}
}
for (long long i = 0; i < h; i++) {
long long sum = 0;
for (long long j = 0; j < w; j++) sum += a[i][j] + b[i][j];
if (sum % 2 == 1) {
cout << "No" << endl;
return 0;
}
}
for (long long i = 0; i < w; i++) {
long long sum = 0;
for (long long j = 0; j < h; j++) sum += a[j][i] + b[j][i];
if (sum % 2 == 1) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
int a[1010][1010], b[1010][1010];
bool visn[1010], vism[1010], f = true;
bool judge() {
if (n < 2 || m < 2) return false;
for (int i = 1; i <= n; i++)
if (visn[i]) return false;
for (int i = 1; i <= m; i++)
if (vism[i]) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &b[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] != b[i][j]) f = false, visn[i] ^= 1, vism[j] ^= 1;
if (judge() || f)
printf("Yes");
else
printf("No");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int expo_fast(long long int a, long long int b) {
a = a;
long long int result = 1;
while (b) {
if (b & 1) result = (result * a);
b >>= 1;
a = (a * a);
}
return (result);
}
void take_in(vector<long long int>* arr) {
for (int i = 0; i < arr->size(); i++) cin >> (*(arr))[i];
}
void disp_arr(vector<long long int>* arr) {
for (int i = 0; i < arr->size(); i++) cout << (*(arr))[i] << " ";
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
vector<vector<int>> b(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> b[i][j];
}
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (a[i][j] != b[i][j]) {
a[i][j] ^= 1;
a[i][j + 1] ^= 1;
a[i + 1][j] ^= 1;
a[i + 1][j + 1] ^= 1;
}
}
}
bool crap = false;
for (int i = 0; i < n && !crap; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
cout << "NO\n";
crap = true;
break;
}
}
}
if (!crap) cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
vector<vector<int>> b(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> b[i][j];
}
}
bool answer = true;
for (int i = 0; i < n; ++i) {
int d = 0;
for (int j = 0; j < m; ++j) {
if (a[i][j] != b[i][j]) {
++d;
}
}
if (d % 2 != 0) {
answer = false;
}
}
for (int j = 0; j < m; ++j) {
int d = 0;
for (int i = 0; i < n; ++i) {
if (a[i][j] != b[i][j]) {
++d;
}
}
if (d % 2 != 0) {
answer = false;
}
}
cout << (answer ? "Yes" : "No") << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1100000;
const double eps = 1e-9;
using namespace std;
long long n, a[501][501], b[501][501], c[501][501], f[501][501], m;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
long long can = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> b[i][j];
for (int i = 1; i <= n - 1; ++i) {
for (int j = 1; j <= m - 1; ++j)
if (a[i][j] != b[i][j]) {
a[i][j] ^= 1;
a[i + 1][j] ^= 1;
a[i][j + 1] ^= 1;
a[i + 1][j + 1] ^= 1;
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] != b[i][j]) {
cout << "No"
<< "\n";
return 0;
}
cout << "Yes"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
const int maxn = 500 + 10;
const int maxm = 3000000 + 10;
const int mod = 1000000000;
int a[maxn][maxn], b[maxn][maxn];
int n, m;
void out() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> b[i][j];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] ^= b[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
int k, f1 = 1;
int l, f2 = 1;
for (k = i + 1; k <= n && f1; k++) {
if (a[k][j]) {
f1 = 0;
break;
}
}
for (l = j + 1; l <= m && f2; l++) {
if (a[i][l]) {
f2 = 0;
break;
}
}
if (!f1 && !f2) {
a[i][j] ^= 1;
a[i][l] ^= 1;
a[k][j] ^= 1;
a[k][l] ^= 1;
}
}
}
}
int ans = 1;
for (int i = 1; i <= n && ans; i++) {
for (int j = 1; j <= m && ans; j++) {
if (a[i][j]) {
ans = 0;
break;
}
}
}
if (ans) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long int N = 500 + 10;
const long long int INF = 2e9;
long long int MOD = 1e9 + 7;
long long int r[N], c[N];
void solve() {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int x;
cin >> x;
r[i] ^= x;
c[j] ^= x;
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int x;
cin >> x;
r[i] ^= x;
c[j] ^= x;
}
}
for (long long int i = 0; i < n; i++) {
if (r[i]) {
cout << "No";
return;
}
}
for (long long int i = 0; i < m; i++) {
if (c[i]) {
cout << "No";
return;
}
}
cout << "Yes";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[555][555], b[555][555], n, m;
void change(int i, int j) {
if (!a[i][j])
a[i][j] = 1;
else
a[i][j] = 0;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> b[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] == b[i][j])
a[i][j] = b[i][j] = 0;
else {
a[i][j] = 1;
b[i][j] = 0;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j]) {
if (i == n || j == m) {
cout << "No";
return 0;
}
change(i, j);
change(i, j + 1);
change(i + 1, j);
change(i + 1, j + 1);
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 5;
int x, y, n, m, a[maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &x), a[i][j] ^= x;
for (int i = 1; i <= n; i++) {
queue<int> Q;
for (int j = 1; j <= m; j++)
if (a[i][j]) Q.push(j);
if (Q.size() % 2) return !printf("No");
while (!Q.empty()) {
x = Q.front();
Q.pop();
y = Q.front();
Q.pop();
bool ok = false;
for (int ii = i + 1; ii <= n && !ok; ii++)
if (a[ii][x] || a[ii][y])
a[ii][x] = !a[ii][x], a[ii][y] = !a[ii][y], ok = true;
if (!ok) return !printf("No");
}
}
return !printf("Yes");
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename A, typename B>
istream& operator>>(istream& input, pair<A, B>& x) {
input >> x.F >> x.S;
return input;
}
template <typename A>
istream& operator>>(istream& input, vector<A>& x) {
for (auto& i : x) input >> i;
return input;
}
const int MOD = 1000000007;
const int MAXN = 2e5;
void preprocess() {}
void solve(int t) {
int n, m;
cin >> n >> m;
vector<vi> A(n, vi(m));
vector<vi> B(n, vi(m));
for (int i = 0; i < n; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
if (A[i][j] != B[i][j]) {
cnt++;
}
}
if (cnt % 2) {
cout << "No";
exit(0);
}
}
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (A[i][j] != B[i][j]) {
cnt++;
}
}
if (cnt % 2) {
cout << "No";
exit(0);
}
}
cout << "Yes";
}
void clear(int t) {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
preprocess();
int tests = 1;
for (int i = 1; i <= tests; i++) {
solve(i);
clear(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int a[maxn][maxn], b[maxn][maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &b[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
if (i == n - 1 || j == m - 1) {
printf("No\n");
return 0;
}
b[i][j] ^= 1;
b[i][j + 1] ^= 1;
b[i + 1][j] ^= 1;
b[i + 1][j + 1] ^= 1;
}
}
}
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mA[507][507] = {0};
int mB[507][507] = {0};
int check(int n, int m) {
int flag = 1;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (mA[i][j] != mB[i][j]) flag = 0;
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
int main() {
int n, m, flag = 0;
cin >> n >> m;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) cin >> mA[i][j];
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) cin >> mB[i][j];
if (n == 1 || m == 1) return check(n, m);
for (int j = (1); j <= (m - 1); j++) {
int sum = 0;
for (int i = (1); i <= (n); i++)
if (mA[i][j] != mB[i][j]) {
mA[i][j] = mB[i][j];
mA[i][j + 1] = 1 - mA[i][j + 1];
sum++;
}
if (sum & 1) {
flag = 1;
break;
}
}
if (flag)
cout << "No" << endl;
else
check(n, m);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 1000000009;
const double epx = 1e-6;
const double pi = acos(-1.0);
int a[maxn][maxn], b[maxn][maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> b[i][j];
int flag = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) sum++;
}
if (sum % 2) flag = 1;
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
if (a[i][j] != b[i][j]) sum++;
}
if (sum % 2) flag = 1;
}
if (flag)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 507;
int T, n, a, b, m, k, h;
int d1[N][N];
int d2[N][N];
int d[N][N];
string l, r;
int point = 0;
vector<int> v;
vector<int> v2;
set<int> hh;
set<int> lll;
int hang[N];
int lie[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> d1[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> d2[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (d1[i][j] != d2[i][j]) d[i][j] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (d[i][j]) hang[i]++, lie[j]++, hh.insert(i), lll.insert(j);
}
}
for (int i = 0; i < n; ++i)
if (hang[i] % 2) return cout << "no", 0;
for (int i = 0; i < m; ++i)
if (lie[i] % 2) return cout << "no", 0;
cout << "yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
int N, M;
int A[501][501];
int B[501][501];
bool check() {
for (int i = 0, i_len = (N); i < i_len; ++i) {
int x = 0;
for (int j = 0, j_len = (M); j < j_len; ++j) x ^= A[i][j] ^ B[i][j];
if (x & 1) return false;
}
for (int j = 0, j_len = (M); j < j_len; ++j) {
int x = 0;
for (int i = 0, i_len = (N); i < i_len; ++i) x ^= A[i][j] ^ B[i][j];
if (x & 1) return false;
}
return true;
}
void MAIN() {
scanf("%d%d", &N, &M);
for (int i = 0, i_len = (N); i < i_len; ++i)
for (int j = 0, j_len = (M); j < j_len; ++j) scanf("%d", A[i] + j);
for (int i = 0, i_len = (N); i < i_len; ++i)
for (int j = 0, j_len = (M); j < j_len; ++j) scanf("%d", B[i] + j);
puts(check() ? "Yes" : "No");
}
int main() {
int TC = 1;
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int a[n][m], b[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> b[i][j];
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < m - 1; j++) {
if (b[i][j] != a[i][j])
b[i][j] = !b[i][j], b[i + 1][j] = !b[i + 1][j],
b[i + 1][j + 1] = !b[i + 1][j + 1], b[i][j + 1] = !b[i][j + 1];
}
for (int i = 0; i < n; i++)
if (b[i][m - 1] != a[i][m - 1]) {
cout << "No";
return 0;
}
for (int i = 0; i < m; i++)
if (b[n - 1][i] != a[n - 1][i]) {
cout << "No";
return 0;
}
cout << "Yes";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
vector<vector<int>> diff(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int b;
cin >> b;
diff[i][j] = a[i][j] ^ b;
}
for (int i = 0; i < n; i++) {
int inRow = 0;
for (int j = 0; j < m; j++) inRow += diff[i][j];
if (inRow & 1) {
cout << "No\n";
return 0;
}
}
for (int j = 0; j < m; j++) {
int inCol = 0;
for (int i = 0; i < n; i++) inCol += diff[i][j];
if (inCol & 1) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n + 10][m + 10];
int b[n + 10][m + 10];
int c[n + 10][m + 10];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> b[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) c[i][j] = a[i][j] ^ b[i][j];
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (c[i][j] == 1) {
c[i][j] = 1 ^ c[i][j];
c[i + 1][j] = 1 ^ c[i + 1][j];
c[i][j + 1] = 1 ^ c[i][j + 1];
c[i + 1][j + 1] = 1 ^ c[i + 1][j + 1];
}
}
}
bool ans = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c[i][j] == 1) {
ans = false;
break;
}
}
if (!ans) break;
}
if (ans)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int d = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; d = d * 10 - 48 + c, c = getchar())
;
return d * f;
}
int n, m, a[501][501], b[5001][501], c[501];
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[i][j] = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) b[i][j] = read() ^ a[i][j];
for (int i = 1; i <= n; ++i) {
int c = 0;
for (int j = 1; j <= m; ++j) c ^= b[i][j];
if (c) {
puts("No");
return 0;
}
}
for (int j = 1; j <= m; ++j) {
int c = 0;
for (int i = 1; i <= n; ++i) c ^= b[i][j];
if (c) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int N = 5 * 1e2 + 10;
ll res;
ll a[N][N], b[N][N];
void solve() {
ll n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> b[i][j];
}
}
for (int i = 0; i < n; ++i) {
res = 0;
for (int j = 0; j < m; ++j) {
if (a[i][j] != b[i][j]) res++;
}
if (res % 2) {
cout << "NO";
return;
}
}
for (int i = 0; i < m; ++i) {
res = 0;
for (int j = 0; j < n; ++j) {
if (a[j][i] != b[j][i]) res++;
}
if (res % 2) {
cout << "NO";
return;
}
}
cout << "YES";
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int a[n][600], i, j, temp;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> temp;
a[i][j] ^= temp;
}
}
for (i = 0; i < n - 1; i++) {
for (j = 0; j < m - 1; j++) {
if (a[i][j] == 1) {
a[i][j] ^= 1;
a[i + 1][j + 1] ^= 1;
a[i + 1][j] ^= 1;
a[i][j + 1] ^= 1;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == 1) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 11;
int a[N][N], b[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> b[i][j];
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
if (a[i][j] != b[i][j]) {
a[i][j] = 1 - a[i][j];
a[i + 1][j] = 1 - a[i + 1][j];
a[i][j + 1] = 1 - a[i][j + 1];
a[i + 1][j + 1] = 1 - a[i + 1][j + 1];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] != b[i][j]) {
cout << "No";
return 0;
}
cout << "Yes";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int row[maxn], col[maxn], r[maxn], c[maxn];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
row[i] ^= x;
col[j] ^= x;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
r[i] ^= x;
c[j] ^= x;
}
}
for (int i = 0; i < n; i++)
if (row[i] != r[i]) return cout << "No\n", 0;
for (int i = 0; i < m; i++)
if (col[i] != c[i]) return cout << "No\n", 0;
cout << "Yes\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int N = 5 * 1e2 + 10;
ll res;
ll a[N][N], b[N][N];
void solve() {
ll n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> b[i][j];
}
}
for (int i = 0; i < n; ++i) {
res = 0;
for (int j = 0; j < m; ++j) {
res += (a[i][j] != b[i][j]);
}
if (res & 1) {
cout << "No";
return;
}
}
for (int i = 0; i < m; ++i) {
res = 0;
for (int j = 0; j < n; ++j) {
res += (a[j][i] != b[j][i]);
}
if (res & 1) {
cout << "No";
return;
}
}
cout << "Yes";
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int a[maxn][maxn], b[maxn][maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &b[i][j]);
bool flag = 1;
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= m; j++)
if (a[i][j] != b[i][j]) cnt++;
if (cnt % 2) flag = 0;
}
for (int j = 1; j <= m; j++) {
int cnt = 0;
for (int i = 1; i <= n; i++)
if (a[i][j] != b[i][j]) cnt++;
if (cnt % 2) flag = 0;
}
if (flag)
printf("Yes\n");
else
printf("No\n");
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int NAX = 2e5 + 5, MOD = 1000000007;
void solveCase() {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
vector<vector<int>> b(n, vector<int>(m));
int cnta = 0, cntb = 0;
for (auto &x : a)
for (auto &y : x) {
cin >> y;
cnta += y;
}
for (auto &x : b)
for (auto &y : x) {
cin >> y;
cntb += y;
}
if (n == 1 || m == 1) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
return;
};
for (size_t i = 0; i < n; i++) {
int meowa = 0, meowb = 0;
for (size_t j = 0; j < m; j++) {
meowa += a[i][j];
meowb += b[i][j];
}
if ((meowa & 1) != (meowb & 1)) {
cout << "NO\n";
return;
}
}
for (size_t j = 0; j < m; j++) {
int meowa = 0, meowb = 0;
for (size_t i = 0; i < n; i++) {
meowa += a[i][j];
meowb += b[i][j];
}
if ((meowa & 1) != (meowb & 1)) {
cout << "NO\n";
return;
}
}
if ((cnta & 1) == (cntb & 1)) {
cout << "YES\n";
} else
cout << "NO\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; ++i) solveCase();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e3 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
using namespace std;
int n, m;
int a[N][N], b[N][N];
int col[N], line[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> b[i][j];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (a[i][j] != b[i][j]) col[i]++, line[j]++;
}
int flag = 1;
for (int i = 1; i <= max(n, m); ++i)
if ((col[i] & 1) || (line[i] & 1)) flag = 0;
if (!flag)
puts("No");
else
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long mod = 1e9 + 7;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long powermod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
bool isprime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long a[n + 1][m + 1];
long long b[n + 1][m + 1];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> a[i][j];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> b[i][j];
}
vector<pair<long long, long long>> v;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] != b[i][j]) v.push_back({i, j});
}
}
if (v.size() == 1) {
cout << "No"
<< "\n";
return 0;
}
long long k = 0;
sort(v.begin(), v.end(), sortbysec);
long long cnt = 1;
for (long long i = 1; i < v.size(); i++) {
if (v[i].second == v[i - 1].second)
cnt++;
else {
if (cnt % 2 != 0) {
k = 1;
break;
}
cnt = 1;
}
}
sort(v.begin(), v.end());
cnt = 1;
for (long long i = 1; i < v.size(); i++) {
if (v[i].first == v[i - 1].first)
cnt++;
else {
if (cnt % 2 != 0) {
k = 1;
break;
}
cnt = 1;
}
}
if (k)
cout << "No"
<< "\n";
else
cout << "Yes"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b);
long long a[502][502], b[502][502];
long long n, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1, i;
while (t--) {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> a[i][j];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> b[i][j];
}
long long flag = 0;
for (long long i = 1; i <= n; i++) {
long long val1 = 0;
long long val2 = 0;
for (long long j = 1; j <= m; j++) {
val1 += a[i][j];
val2 += b[i][j];
}
if (val1 % 2 != val2 % 2) {
flag = 1;
break;
}
}
for (long long i = 1; i <= m; i++) {
long long val1 = 0;
long long val2 = 0;
for (long long j = 1; j <= n; j++) {
val1 += a[j][i];
val2 += b[j][i];
}
if (val1 % 2 != val2 % 2) {
flag = 1;
break;
}
}
if (flag)
cout << "No"
<< "\n";
else
cout << "Yes"
<< "\n";
}
return 0;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2)
b--, res = (res % 1000000007 * a % 1000000007);
else
b = b / 2, a = (a % 1000000007 * a % 1000000007) % 1000000007;
}
return res;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1005][1005], c[1005][1005], cnt;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &c[i][j]);
for (int i = 1; i <= n; i++) {
cnt = 0;
for (int j = 1; j <= m; j++)
if (a[i][j] != c[i][j]) cnt++;
if (cnt & 1) {
puts("No");
return 0;
}
}
for (int j = 1; j <= m; j++) {
cnt = 0;
for (int i = 1; i <= n; i++)
if (a[i][j] != c[i][j]) cnt++;
if (cnt & 1) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
template <typename T>
inline void read(T &x) {
int f = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
x *= f;
return;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
int n, m;
int a[N][N], b[N][N];
int s1[N], s2[N];
int main() {
int i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cin >> a[i][j];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cin >> b[i][j];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) s1[i] += (a[i][j] != b[i][j]);
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) s2[i] += (a[j][i] != b[j][i]);
}
for (i = 1; i <= n; i++) {
if (s1[i] & 1) {
cout << "NO";
return 0;
}
}
for (i = 1; i <= m; i++) {
if (s2[i] & 1) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
const long long MX = 5e2 + 105;
int ara[505][505];
int b[505][505];
void change(int i, int j) {
ara[i][j] = 1 - ara[i][j];
ara[i + 1][j] = 1 - ara[i + 1][j];
ara[i][j + 1] = 1 - ara[i][j + 1];
ara[i + 1][j + 1] = 1 - ara[i + 1][j + 1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ara[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
bool no = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (ara[i][j] != b[i][j]) {
change(i, j);
}
}
if (ara[i][m - 1] != b[i][m - 1]) {
no = 1;
break;
}
}
for (int i = 0; i < m; i++) {
if (ara[n - 1][i] != b[n - 1][i]) {
no = 1;
break;
}
}
if (no) {
cout << "NO" << endl;
;
} else {
cout << "YES" << endl;
;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int row[505], col[505];
int main() {
int mat[505][505], ans[505][505], n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ans[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mat[i][j] != ans[i][j]) {
row[i]++;
col[j]++;
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (row[i] % 2 != 0) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "No" << endl;
else {
for (int j = 1; j <= m; j++) {
if (col[j] % 2 != 0) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
}
|
#include <bits/stdc++.h>
int temp;
using namespace std;
void solve() {
int m, n;
cin >> n >> m;
int a[n][m], b[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> b[i][j];
int rec1[501] = {}, rec2[501] = {};
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (a[i][j] != b[i][j]) rec1[j]++, rec2[i]++;
for (int i = 0; i < 501; ++i)
if (rec2[i]) cerr << i << " " << rec2[i] << "\n";
for (auto i : rec1)
if (i % 2) {
cout << "No";
return;
}
for (auto i : rec2)
if (i % 2) {
cout << "No";
return;
}
cout << "Yes";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
while (t--) {
solve();
cout << "\n";
cerr << "'\\n'"
<< " " << '\n'
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
bool remove(vector<vector<long long> > &C, long long a, long long b) {
vector<long long> A, B;
C[a][b] = 0;
for (long long i = a + 1; i < n; i++) {
if (C[i][b] == 1) {
A.push_back(i);
}
}
for (long long j = b + 1; j < m; j++) {
if (C[a][j]) {
B.push_back(j);
}
}
for (long long i = 0; i < A.size(); i++) {
for (long long j = 0; j < B.size(); j++) {
if (C[A[i]][B[j]] == 1) {
C[A[i]][B[j]] = 0;
C[A[i]][b] = 0;
C[a][B[j]] = 0;
return true;
}
}
}
if (A.empty() || B.empty()) return false;
C[A[0]][B[0]] = 1;
C[A[0]][b] = 0;
C[a][B[0]] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
long long A[n][m], B[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> A[i][j];
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> B[i][j];
}
}
vector<vector<long long> > C(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (A[i][j] != B[i][j]) {
C[i][j] = 1;
} else {
C[i][j] = 0;
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (C[i][j] == 1) {
if (!remove(C, i, j)) {
cout << "NO";
return 0;
}
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (C[i][j] == 1) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int a[n + 1][m + 1], b[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> b[i][j];
}
}
int oa = 0, ob = 0, za = 0, zb = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
oa++;
} else if (a[i][j] == 0) {
za++;
}
if (b[i][j] == 1) {
ob++;
} else if (b[i][j] == 0) {
zb++;
}
}
if (abs(oa - ob) % 2 != 0 || abs(za - zb) % 2 != 0) {
cout << "No";
return 0;
}
}
oa = ob = za = zb = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (a[j][i] == 1) {
oa++;
} else if (a[j][i] == 0) {
za++;
}
if (b[j][i] == 1) {
ob++;
} else if (b[j][i] == 0) {
zb++;
}
}
if (abs(oa - ob) % 2 != 0 || abs(za - zb) % 2 != 0) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[512][512], b[512][512];
bool NO = 0;
vector<int> f, s;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> b[i][j];
for (int i = 0; i < n; i++) {
int currbr = 0;
for (int j = 0; j < m; j++) currbr += a[i][j];
f.push_back(currbr);
}
for (int j = 0; j < m; j++) {
int currbr = 0;
for (int i = 0; i < n; i++) currbr += a[i][j];
s.push_back(currbr);
}
for (int i = 0; i < n; i++) {
int currbr = 0;
for (int j = 0; j < m; j++) currbr += b[i][j];
if (f[i] % 2 != currbr % 2) {
NO = 1;
break;
}
}
for (int j = 0; j < m; j++) {
int currbr = 0;
for (int i = 0; i < n; i++) currbr += b[i][j];
if (s[j] % 2 != currbr % 2) {
NO = 1;
break;
}
}
if (NO)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
long long a[n][m], b[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> b[i][j];
}
bool f = true;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
if (i + 1 < n && j + 1 < m) {
a[i][j] = (a[i][j] ^ 1);
a[i][j + 1] = (a[i][j + 1] ^ 1);
a[i + 1][j] = (a[i + 1][j] ^ 1);
a[i + 1][j + 1] = (a[i + 1][j + 1] ^ 1);
} else
f = false;
}
}
}
if (f)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[505][505], b[505][505], c[505][505];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &b[i][j]);
if (b[i][j] != a[i][j]) c[i][j] = 1;
}
}
int cnt, x;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
cnt = 0;
for (int k = 1; k <= n; k++) {
if (!cnt && c[k][i] && c[k][j]) {
cnt = 1;
x = k;
} else if (cnt && c[k][i]) {
c[x][i] = c[x][j] = 0;
c[k][i] = 0;
c[k][j] = !c[k][j];
cnt = 0;
}
}
}
}
bool fg = false;
for (int i = 1; i <= n; i++) {
if (fg) break;
for (int j = 1; j <= m; j++) {
if (c[i][j]) {
fg = true;
break;
}
}
}
if (fg)
printf("No");
else
printf("Yes");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.