solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
struct UnionFind {
vector<int> ig;
vector<vector<int>> gi;
int gn;
UnionFind(int N) {
ig.resize(N);
gi.resize(N);
for (int i = 0; i < N; i++) {
ig[i] = i;
gi[i] = {i};
}
gn = N;
}
void merge(int a, int b) {
if (same(a, b)) return;
gn--;
int x = ig[a], y = ig[b];
if (gi[x].size() < gi[y].size()) swap(x, y);
for (int j : gi[y]) {
ig[j] = x;
}
gi[x].insert(gi[x].end(), gi[y].begin(), gi[y].end());
gi[y].clear();
}
bool same(int a, int b) { return ig[a] == ig[b]; }
};
const int MN = 200200;
int n;
int a[MN];
bool used[MN];
int par(int p) {
if (used[p]) return p;
used[p] = true;
return par(a[p]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
a[i]--;
}
int ans = 0;
int rt = -1;
for (int i = 0; i < n; i++) {
if (a[i] == i) rt = i;
}
if (rt == -1) {
rt = par(0);
ans++;
a[rt] = rt;
fill_n(used, MN, false);
}
UnionFind uf(n);
for (int i = 0; i < n; i++) {
uf.merge(i, a[i]);
}
for (int i = 0; i < n; i++) {
if (uf.same(rt, i)) continue;
int nw = par(i);
ans++;
a[nw] = rt;
uf.merge(rt, i);
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
printf("%d ", a[i] + 1);
}
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int pre[maxn], a[maxn];
int Find(int x) { return x == pre[x] ? x : pre[x] = Find(pre[x]); }
void Union(int x, int y) {
int fx = Find(x), fy = Find(y);
if (fx != fy) pre[fx] = fy;
}
int main() {
int n, root = -1, cnt = 0;
scanf("%d", &n);
bool flag = false;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = i;
if (i == a[i]) root = a[i], flag = true;
}
for (int i = 1; i <= n; i++) {
if (a[i] == i)
Union(i, root), a[i] = root, cnt++;
else if (Find(i) != Find(a[i]))
Union(i, a[i]);
else {
if (root == -1) root = i;
Union(i, root), a[i] = root, cnt++;
}
}
printf("%d\n", cnt - flag);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], parent[200005];
vector<int> komponen;
int findParent(int x) {
return parent[x] == x ? x : parent[x] = findParent(parent[x]);
}
void merge(int x, int y) {
x = findParent(x);
y = findParent(y);
if (x != y) {
parent[y] = x;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
parent[i] = i;
}
for (int i = 1; i <= n; i++) {
merge(a[i], i);
}
int root = -1;
for (int i = 1; i <= n; i++) {
if (a[i] == i) root = i;
}
for (int i = 1; i <= n; i++) {
if (findParent(i) == i) {
if (root == -1) root = i;
komponen.push_back(i);
}
}
int ans = 0;
for (int i = 0; i < komponen.size(); i++) {
if (a[komponen[i]] != root) {
a[komponen[i]] = root;
ans++;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%d", a[i]);
}
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> p(n + 1);
set<int> done, visited;
vector<vector<int> > S(n + 1);
int index = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
S[p[i]].push_back(i);
if (p[i] == i) index = i;
}
int node, counter = 0;
for (int i = 1; i <= n; i++) {
if (done.find(i) != done.end()) continue;
visited.clear();
stack<int> dfs;
dfs.push(i);
while (!dfs.empty()) {
node = dfs.top();
dfs.pop();
if (visited.find(node) != visited.end()) {
if (index == -1) {
index = node;
counter++;
p[node] = node;
} else {
p[node] = index;
if (p[node] != node) counter++;
}
break;
}
visited.insert(node);
for (int j = 0; j < S[node].size(); j++) {
if (done.find(S[node][j]) == done.end()) {
dfs.push(S[node][j]);
}
}
}
for (set<int>::iterator it = visited.begin(); it != visited.end(); it++) {
done.insert(*it);
}
}
printf("%d\n", counter);
for (int i = 1; i <= n; i++) {
printf("%d ", p[i]);
}
}
| 8 | CPP |
input()
A = list(map(int, input().split(' ')))
root = -1
for i,a in enumerate(A) :
if i == a-1 :
root = i
break
v = [False]*len(A)
if root>-1 :
v[root]=True
changed = 0
for i,a in enumerate(A) :
if v[i] :
continue
v[i]= True
l=[i]
a-=1
while not v[a] :
l.append(a)
v[a]=True
a=A[a]-1
if a in l:
if root==-1:
A[a]=a+1
root=a
changed+=1
else :
A[a]=root+1
changed+=1
print(changed)
print(' '.join(map(str,A)))
# Made By Mostafa_Khaled | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, in[200005], a[200005], sta[200005], top, now, root, ans, flag;
bool vis[200005], mark[200005];
int read() {
int x, f = 1;
char ch;
while (!(isdigit(ch = getchar()))) ch == '-' ? f = -1 : f;
x = ch - 48;
while ((isdigit(ch = getchar()))) x = x * 10 + ch - 48;
return f * x;
}
void Topology() {
while (now < top) {
now++;
int tmp = sta[now];
vis[tmp] = 1;
in[a[tmp]]--;
if (!in[a[tmp]]) sta[++top] = a[tmp];
}
}
void dfs(int u) {
vis[u] = 1;
if (!vis[a[u]]) dfs(a[u]);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
in[a[i]]++;
if (a[i] == i) {
flag = 1;
root = i;
}
}
for (int i = 1; i <= n; i++)
if (!in[i]) sta[++top] = i;
Topology();
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (!root) root = i;
ans++;
dfs(a[i]);
a[i] = root;
mark[i] = 1;
}
}
printf("%d\n", ans - flag);
for (int i = 1; i <= n; i++) {
if (mark[i]) a[i] = root;
printf("%d ", a[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int f[200005], a[200005];
int ans[200005];
int find(int x) {
if (x == f[x])
return x;
else
return f[x] = find(f[x]);
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx != fy) f[fx] = fy;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = 0;
int t = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (find(a[i]) == find(i)) {
ans[cnt++] = i;
if (a[i] == i) {
t = find(i);
}
}
Union(i, a[i]);
}
int cnt1 = 0;
if (t == 0) {
for (int i = 1; i <= n; i++) {
if (find(i) == find(a[i])) {
t = find(i);
}
}
}
for (int i = 0; i < cnt; i++) {
if (a[ans[i]] != t) {
a[ans[i]] = t;
cnt1++;
}
}
cout << cnt1 << endl;
for (int i = 1; i <= n; i++) {
if (i == 1)
printf("%d", a[i]);
else
printf(" %d", a[i]);
}
cout << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
struct Dscc {
public:
pair<vector<vector<int>>, vector<vector<int>>> get(
const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) dfs2(i, num, edges);
}
unis[id] = num;
return;
}
} dscc;
int main() {
int N;
cin >> N;
vector<int> as(N);
for (int i = 0; i < N; ++i) {
cin >> as[i];
as[i]--;
}
vector<int> selfs;
for (int i = 0; i < N; ++i) {
selfs.push_back(as[i] == i);
}
int ans = 0;
int pa;
if (accumulate(selfs.begin(), selfs.end(), 0) == 0) {
bool flag = false;
vector<vector<int>> edges(N);
for (int i = 0; i < N; ++i) {
edges[i].push_back(as[i]);
}
auto p = dscc.get(edges);
for (int i = 0; i < p.first.size(); ++i) {
if (p.second[i].empty()) {
if (!flag) {
pa = p.first[i][0];
as[pa] = pa;
ans++;
flag = true;
} else {
as[p.first[i][0]] = pa;
ans++;
}
}
}
} else {
bool flag = false;
for (int i = 0; i < N; ++i) {
if (!flag) {
if (as[i] == i) {
pa = i;
flag = true;
}
} else {
if (as[i] == i) {
as[i] = pa;
ans++;
}
}
}
vector<vector<int>> edges(N);
for (int i = 0; i < N; ++i) {
edges[i].push_back(as[i]);
}
auto p = dscc.get(edges);
for (int i = 0; i < p.first.size(); ++i) {
if (p.second[i].empty()) {
if (!flag) {
pa = p.first[i][0];
as[pa] = pa;
ans++;
flag = true;
} else {
if (as[p.first[i][0]] != pa) {
as[p.first[i][0]] = pa;
ans++;
}
}
}
}
}
cout << ans << endl;
for (int i = 0; i < as.size(); ++i) {
cout << as[i] + 1;
if (i == as.size() - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int a[200001];
int visited[200001];
vector<long long> fixedpt;
vector<long long> repair;
bool empt;
void dfs(int u) {
visited[u] = 2;
int v = a[u];
if (v == u) {
} else if (visited[v] == 2) {
repair.push_back(v);
} else if (visited[v] == 1) {
} else {
dfs(v);
}
visited[u] = 1;
}
int main() {
int n;
int cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
if (a[i] == i) fixedpt.push_back(i);
}
empt = false;
if (fixedpt.empty()) empt = true;
if (!fixedpt.empty()) {
for (int i = 0; i < fixedpt.size(); i++) {
a[fixedpt[i]] = fixedpt[0];
if (i > 0) cnt++;
}
}
for (int i = 0; i < n; i++) {
if (!visited[i]) dfs(i);
}
for (int i = 0; i < repair.size(); i++) {
if (fixedpt.empty()) {
a[repair[i]] = repair[0];
} else {
a[repair[i]] = fixedpt[0];
}
cnt++;
}
printf("%d\n", cnt);
for (int i = 0; i < n; i++) {
printf("%d ", a[i] + 1);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
vector<long long> r;
vector<vector<long long> > c;
long long a[200005], col[200005];
signed main() {
long long n;
cin >> n;
for (long long i = (0); i < (n); i++) {
cin >> a[i];
a[i]--;
if (i == a[i]) r.push_back(i);
}
long long color = 1;
for (long long i = (0); i < (n); i++)
if (!col[i]) {
long long pos = i;
vector<long long> vv;
while (1) {
if (col[pos] && col[pos] != color) break;
if (col[pos] == color) {
c.push_back(vector<long long>(1, pos));
for (long long j = ((long long)vv.size()) - 2; j >= 0; j--)
if (vv[i] == pos)
break;
else
c[((long long)c.size()) - 1].push_back(vv[i]);
break;
}
if (a[pos] == pos) break;
col[pos] = color;
pos = a[pos];
}
color++;
}
if (!((long long)r.size())) {
cout << ((long long)c.size()) << '\n';
a[c[0][0]] = c[0][0];
for (long long i = (1); i < (((long long)c.size())); i++)
a[c[i][0]] = c[0][0];
for (long long i = (0); i < (n); i++) cout << a[i] + 1 << ' ';
} else {
cout << ((long long)r.size()) + ((long long)c.size()) - 1 << '\n';
for (long long i = (1); i < (((long long)r.size())); i++) a[r[i]] = r[0];
for (long long i = (0); i < (((long long)c.size())); i++) a[c[i][0]] = r[0];
for (long long i = (0); i < (n); i++) cout << a[i] + 1 << ' ';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int f[N], n, a[N], p[N], opt, b[N], rt = -1, ans;
bool d;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == i) rt = i;
if (i == find(a[i]))
b[++opt] = i;
else
f[i] = a[i];
}
if (rt == -1)
rt = b[opt];
else
d = 1;
for (int i = 1; i <= opt; i++) a[b[i]] = rt;
printf("%d\n", opt - d);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
inline void Wte(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) {
Wte(x / 10);
}
putchar(x % 10 + '0');
}
inline void Write(int x) {
Wte(x);
putchar(' ');
}
const int MAXN = 200010;
int N;
bool vis[MAXN];
int a[MAXN], ans[MAXN];
bool cmp(int x, int y) { return abs(x - a[x]) < abs(y - a[y]); }
void solve() {
int cost = 0;
N = Read();
for (int i = 0; i < N; i++) {
a[i] = Read() - 1;
ans[i] = a[i];
}
vector<int> v;
for (int i = 0; i < N; i++) {
set<int> st;
int j;
for (j = i; !vis[j]; j = a[j]) {
vis[j] = 1;
st.insert(j);
}
if (!st.count(j)) {
continue;
}
v.push_back(j);
}
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < v.size(); i++) {
ans[v[i]] = v[0];
}
for (int i = 0; i < N; i++) {
cost += (ans[i] != a[i]);
}
Write(cost);
puts("");
for (int i = 0; i < N; i++) {
Write(ans[i] + 1);
}
puts("");
}
void Times(int T) {
while (T--) {
solve();
}
}
int main() {
int T;
T = 1;
Times(T);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int N, A[MAXN], ans[MAXN];
vector<int> cyc[MAXN];
bool vis[MAXN];
int main() {
scanf("%d", &N);
int isame = -1;
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
if (i == A[i]) {
isame = i;
}
}
for (int i = 1; i <= N; i++) {
ans[i] = A[i];
}
for (int i = 1; i <= N; i++) {
if (vis[i]) {
continue;
}
vector<int> vc;
int cur = i;
while (true) {
vc.push_back(cur);
vis[cur] = true;
int ncur = A[cur];
if (vis[ncur]) {
auto it = find(vc.begin(), vc.end(), ncur);
if (it == vc.end()) {
break;
}
vc.erase(vc.begin(), it);
if (i == 1 && isame == -1) {
isame = vc.back();
ans[isame] = isame;
} else {
ans[vc.back()] = isame;
}
break;
}
cur = A[cur];
}
}
int ndiff = 0;
for (int i = 1; i <= N; i++) {
ndiff += (A[i] != ans[i]);
}
printf("%d\n", ndiff);
for (int i = 1; i <= N; i++) {
printf("%d ", ans[i]);
}
puts("");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
const int mod = 1e9 + 7;
const ll inf = ll(0x3f3f3f3f3f3f3f3f);
const double PI = acos(-1), eps = 1e-9;
const int mxn = 2e5, mxa = 1e5, mxk = 2e3;
int n, p[mxn + 5], vis[mxn + 5];
void solve() {
cin >> n;
int par = -1;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
if (p[i] == i) par = i;
}
int ans = 0, id = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
++id;
int x = i;
while (!vis[x]) {
vis[x] = id;
x = p[x];
}
if (vis[x] != id) continue;
if (par == -1) {
par = x;
p[x] = par;
++ans;
}
if (x != par) {
p[x] = par;
++ans;
}
}
cout << ans << '\n';
for (int i = 1; i <= n; ++i) cout << p[i] << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t-- > 0) solve();
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
const int INF = 0x3f3f3f3f;
int a[maxn], fa[maxn], b[maxn];
int vis[maxn], c[maxn], tot = 0;
int findfa(int x) { return fa[x] == x ? x : fa[x] = findfa(fa[x]); }
void uni(int x, int y) {
int fax = findfa(x);
int fay = findfa(y);
if (fax != fay)
fa[fax] = fay;
else
b[++tot] = x;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < maxn; i++) fa[i] = i;
int p = 0;
int root;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == i) {
p++;
if (p == 1)
root = i;
else
b[++tot] = i;
} else
uni(i, a[i]);
}
int st = 1;
if (p == 0) {
a[b[1]] = b[1];
root = b[1];
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) {
if (b[i] == root) continue;
if (findfa(root) == findfa(b[i])) continue;
a[b[i]] = root;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
int N, P[MAX_N + 5], V[MAX_N + 5], r, g, ans;
void dfs(int nw) {
if (nw == r) return;
if (V[nw] == g) {
P[nw] = r;
ans++;
return;
} else if (V[nw])
return;
V[nw] = g;
dfs(P[nw]);
}
int main() {
int i;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", P + i);
for (i = 1; i <= N; i++)
if (P[i] == i) r = i;
for (i = 1; i <= N; i++) {
++g;
dfs(i);
}
printf("%d\n", ans);
for (i = 1; i <= N; i++) {
if (!P[i]) {
if (!r) r = i;
printf("%d ", r);
} else
printf("%d ", P[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, p[maxn], old[maxn], rt, vis[maxn];
void gen_root() {
for (int i = 0; i < n; i++) {
if (p[i] == i) {
rt = i;
return;
}
}
int cur = 0;
while (!vis[cur]) {
vis[cur] = true;
cur = p[cur];
}
p[cur] = cur;
rt = cur;
}
void connect() {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
if (p[i] == i) {
p[i] = rt;
vis[i] = true;
}
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
int cur = i;
while (vis[cur] == 0) {
vis[cur] = 100 + i;
cur = p[cur];
}
if (vis[cur] == 100 + i) {
p[cur] = rt;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
--p[i];
}
memcpy(old, p, sizeof(old));
gen_root();
connect();
int res = 0;
for (int i = 0; i < n; i++) {
if (p[i] != old[i]) {
++res;
}
}
cout << res << '\n';
for (int i = 0; i < n; i++) {
cout << p[i] + 1;
if (i + 1 < n) {
cout << ' ';
}
}
cout << '\n';
return 0;
}
| 8 | CPP |
from collections import deque
# Para revisar la correctitud pueden probar el codigo en el codeforce que va a dar accepted
# ver si hay un camino que llega a el a partir
# de su padre entonces hay un ciclo
def Padre(x, padre):
while x != padre[x]:
x = padre[x]
return x
def FixATree():
n = int(input())
A = list(map(lambda x: int(x)-1, input().split()))
padre = [x for x in range(0, n)]
ciclosC = 0
ciclos = deque([])
root = []
# ir haciendo Merge a cada arista
for i in range(0, n):
p = Padre(A[i], padre)
# Si dicha arista perticipa en un ciclo
if p == i:
# Si es un ciclo del tipo raiz y no hay raiz
if not root and (i == A[i]):
root = [i, A[i]]
else:
ciclos.append([i, A[i]])
ciclosC += 1
# Si no hay ciclo
else:
padre[i] = A[i]
print(str(ciclosC))
# si existe al menos un ciclo diferente d raiz
if ciclosC:
i = 0
# si no hay raiz el primer ciclo lo hago raiz
if not root:
root = ciclos.popleft()
i = 1
# los restantes ciclos hago que su padre sea la raiz
while ciclos:
ciclo = ciclos.popleft()
padre[ciclo[0]] = root[0]
PC = [x + 1 for x in padre]
print(*PC, sep=" ")
FixATree()
# Casos de prueba:
# 4
# 2 3 3 4
# respuesta
# 1
# 2 3 3 3
# 5
# 3 2 2 5 3
# respuesta
# 0
# 3 2 2 5 3
# 8
# 2 3 5 4 1 6 6 7
# respuesta
# 2
# 2 3 5 4 1 4 6 7
# El codigo da accepted en el codeforce por lo que los casos de prueba que emplee son los que ahi estan
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = mod * mod;
int p[210000];
int v[210000];
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d", p + i);
p[i]--;
}
int ret = 0;
int par = -1;
int sec = -1;
for (int i = 0; i < a; i++) {
if (v[i]) continue;
int at = i;
vector<int> vis;
v[at] = 2;
vis.push_back(at);
while (1) {
int to = p[at];
if (v[to] == 1) break;
if (v[to] == 2) {
if (to != at) {
ret++;
p[at] = -1;
sec = at;
} else {
if (!~par) {
par = at;
} else {
ret++;
p[at] = par;
}
}
break;
}
v[to] = 2;
at = to;
vis.push_back(to);
}
for (int j = 0; j < vis.size(); j++) {
v[vis[j]] = 1;
}
}
for (int i = 0; i < a; i++) {
if (p[i] == -1) {
if (~par)
p[i] = par;
else
p[i] = sec;
}
}
printf("%d\n", ret);
for (int i = 0; i < a; i++) {
if (i) printf(" ");
printf("%d", p[i] + 1);
}
printf("\n");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct nod {
int pre, con, hao;
} edge[410000];
int use2[210000], ans, use[210000], num[210000], dl[210000], n, i, j, all, p,
pos[210000];
void build(int a, int b) {
p++;
edge[p].pre = pos[a];
edge[p].con = b;
edge[p].hao = i;
pos[a] = p;
}
void search(int d, int fa) {
int w;
if (num[d] == d && use2[d] == 0) dl[++all] = d, use2[d] = 1;
use[d] = 1;
for (w = pos[d]; w; w = edge[w].pre)
if (edge[w].hao != fa) {
if (use[edge[w].con] == 1) {
if (use2[edge[w].hao] == 0) {
dl[++all] = edge[w].hao;
use2[edge[w].hao] = 1;
}
continue;
}
search(edge[w].con, edge[w].hao);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (num[i] != i) {
build(num[i], i);
build(i, num[i]);
}
}
for (i = 1; i <= n; i++)
if (use[i] == 0) search(i, 0);
if (all != 0) {
for (i = 1; i <= all; i++)
if (num[dl[i]] == dl[i]) break;
if (i > all) i = 1, ans++;
num[dl[i]] = dl[i];
for (j = 1; j <= all; j++)
if (j != i) {
num[dl[j]] = num[dl[i]];
ans++;
}
}
printf("%d\n", ans);
for (i = 1; i <= n; i++) printf("%d ", num[i]);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[200005];
int n;
int a[200005];
int on[200005];
int fa[200005];
int ans;
int gf(int x) {
if (x == fa[x])
return x;
else {
return fa[x] = gf(fa[x]);
}
}
int main() {
cin >> n;
int r = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == i) {
r = i;
}
fa[i] = i;
}
for (int i = 1; i <= n; i++) {
int u = gf(i);
int v = gf(a[i]);
if (u == v) {
if (r == 0) r = i;
on[i] = 1;
} else {
fa[u] = v;
}
}
for (int i = 1; i <= n; i++) {
if (on[i] && a[i] != r) {
ans++;
a[i] = r;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
using pii = pair<int, int>;
const li INF = 1e18;
const int M = 1e9 + 7;
const int N = 2e5 + 13;
int p[N];
vector<int> g[N];
int ans = 0;
int used[N];
int root = -1;
int dfs1(int v) {
if (v == root) {
return -1;
}
used[v] = 1;
int u = p[v];
int res = -1;
if (used[u] == 0) {
res = dfs1(u);
} else if (used[u] == 1) {
res = u;
}
used[v] = 2;
return res;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
for (int i = 0; i < n; i++) {
if (p[i] == i) {
if (root == -1) {
root = i;
} else {
ans++;
p[i] = root;
}
}
g[p[i]].push_back(i);
}
if (root == -1) {
root = dfs1(0);
p[root] = root;
ans++;
}
for (int i = 0; i < n; i++) {
if (used[i] == 0) {
int v = dfs1(i);
if (v != -1) {
ans++;
p[v] = root;
}
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
cout << p[i] + 1 << ' ';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int vis[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
int cnt = 1;
int rt = -1;
int num = 0;
memset(vis, 0, sizeof(vis));
for (int i = (1); i <= (n); i++) {
cin >> a[i];
if (a[i] == i) rt = i;
}
for (int i = (1); i <= (n); i++) {
int id = i;
while (vis[id] == 0) {
vis[id] = cnt;
if (vis[a[id]] == cnt) {
if (a[id] != rt) {
a[id] = -1;
num++;
break;
}
}
id = a[id];
}
cnt++;
}
printf("%d\n", num);
for (int i = (1); i <= (n); i++) {
if (a[i] == -1 && rt == -1) rt = i;
if (a[i] != -1)
printf("%d ", a[i]);
else
printf("%d ", rt);
}
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long int parent[N], connected[N];
struct DSU {
void intialize(int x) {
for (long long int i = 1; i < x; i++) {
parent[i] = i;
connected[i] = 1;
}
}
long long int getparent(long long int k) {
while (k != parent[k]) {
parent[k] = parent[parent[k]];
k = parent[k];
}
return k;
}
long long int getsize(long long int k) { return connected[getparent(k)]; }
bool unionn(long long int u, long long int v) {
long long int parent1 = getparent(u), parent2 = getparent(v);
if (parent1 == parent2) return 0;
if (connected[parent1] > connected[parent2]) swap(parent1, parent2);
connected[parent2] += connected[parent1];
connected[parent1] = 0;
parent[parent1] = parent[parent2];
return 1;
}
};
void solve() {
long long int n;
cin >> n;
DSU dsu;
dsu.intialize(n + 3);
long long int root = -1;
long long int a[n + 1];
for (long long int i = 1; i <= n; i++) cin >> a[i];
long long int ans = 0;
vector<long long int> v;
for (long long int i = 1; i <= n; i++) {
if (a[i] == i) root = i;
}
for (long long int i = 1; i <= n; i++) {
bool chk = dsu.unionn(a[i], i);
if (!chk) {
if (root == -1) root = i;
dsu.unionn(i, root);
if (a[i] == root) continue;
ans++;
a[i] = root;
}
}
cout << ans << "\n";
for (long long int i = 1; i <= n; i++) cout << a[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long int t = 1;
while (t--) {
solve();
}
}
| 8 | CPP |
from collections import deque
# ver si hay un camino que llega a el a partir
# de su padre entonces hay un ciclo
def Padre(x, padre):
while x != padre[x]:
x = padre[x]
return x
def DFS(x, color, padre, ciclos, adyacentes, raiz):
color[x] = 1 # nodo gris
for y in adyacentes[x]:
# el adyacente es blanco
if color[y] == 0:
DFS(y, color, padre, ciclos, adyacentes, raiz)
padre[y] = x
elif color[y] == 2:
padre[y] = x
# ese adyacente es gris entonces <u,v> rista de retroceso
else:
if y == x and not raiz:
raiz = x
else:
ciclos.append([x, y])
color[x] = 2 # nodo negro
def Solucion():
n = int(input())
A = list(map(lambda x: int(x)-1, input().split()))
padre = [x for x in range(0, n)]
ciclosC = 0
ciclos = deque([])
root = []
# ir haciendo Merge a cada arista
for i in range(0, n):
p = Padre(A[i], padre)
# Si dicha arista perticipa en un ciclo
if p == i:
# Si es un ciclo del tipo raiz y no hay raiz
if not root and (i == A[i]):
root = [i, A[i]]
else:
ciclos.append([i, A[i]])
ciclosC += 1
# Si no hay ciclo
else:
padre[i] = A[i]
print(str(ciclosC))
# si existe al menos un ciclo diferente d raiz
if ciclosC:
i = 0
# si no hay raiz el primer ciclo lo hago raiz
if not root:
root = ciclos.popleft()
i = 1
# los restantes ciclos hago que su padre sea la raiz
while ciclos:
ciclo = ciclos.popleft()
padre[ciclo[0]] = root[0]
PC = [x + 1 for x in padre]
print(*PC, sep=" ")
Solucion()
# Casos de prueba:
# 4
# 2 3 3 4
# respuesta
# 1
# 2 3 3 3
# 5
# 3 2 2 5 3
# respuesta
# 0
# 3 2 2 5 3
# 8
# 2 3 5 4 1 6 6 7
# respuesta
# 2
# 2 3 5 4 1 4 6 7
# 200000
# hacer con el generador
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int p[200010], vs[200010];
vector<int> cyc;
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &p[i]);
int vc = 0, root = -1;
for (int i = 1; i <= N; i++) {
if (vs[i] > 0) continue;
int st = vc, now = i;
for (;;) {
if (vs[now] == 0) {
vs[now] = ++vc;
} else {
if (vs[now] > st) {
int sz = vc - vs[now] + 1;
if (sz == 1) root = now;
cyc.push_back(now);
}
break;
}
now = p[now];
}
}
int ans = 0;
if (!cyc.empty()) {
if (root == -1) root = cyc[0];
for (int x : cyc) {
if (p[x] != root) {
p[x] = root;
ans++;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= N; i++) printf("%d ", p[i]);
printf("\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
long long a[N], vis[N], root[N];
long long dfs(long long k) {
if (vis[k]) return root[k];
vis[k] = 1;
root[k] = k;
root[k] = dfs(a[k]);
return root[k];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) dfs(a[i]);
long long ans = -1, actualroot = -1;
for (long long i = 1; i <= n; i++) {
ans += (i == dfs(a[i]));
if (i == a[i]) actualroot = i;
}
if (actualroot == -1) {
ans++;
for (long long i = 1; i <= n; i++) {
if (i == dfs(a[i])) {
actualroot = i;
a[i] = i;
break;
}
}
}
for (long long i = 1; i <= n; i++) {
if (i == dfs(a[i])) {
a[i] = actualroot;
}
}
cout << ans << "\n";
for (long long i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
int n, fa[N], p[N], cnt, mk, la[N], size[N];
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void merge(int x, int y) {
int fx = getfa(x), fy = getfa(y);
if (fx == fy) return;
fa[fx] = fy;
size[fy] += size[fx];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) {
fa[i] = i;
size[i] = 1;
if (p[i] == i) {
if (!mk)
mk = i;
else
p[i] = mk, cnt++;
}
}
if (!mk) {
for (int i = 1; i <= n; i++) merge(i, p[i]);
int now = 0;
for (int i = 1; i <= n; i++) {
if (size[i] > now) {
now = size[i];
mk = i;
}
}
for (int i = 1; i <= n; i++) fa[i] = i;
p[mk] = mk;
cnt++;
}
for (int i = 1; i <= n; i++) {
if (p[i] == i) continue;
if (getfa(i) == getfa(p[i])) p[i] = mk, cnt++;
merge(i, p[i]);
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) cout << p[i] << " ";
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int up[N], n, a[N], root, cnt;
int f(int u) {
if (up[u] == u) return u;
return up[u] = f(up[u]);
}
void uni(int u, int v) { up[f(u)] = f(v); }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) up[i] = i;
for (int i = 1; i <= n; i++) {
cin >> a[i];
uni(i, a[i]);
}
for (int i = 1; i <= n; i++) {
if (f(i) == i) {
if (a[i] == i) root = i;
cnt++;
}
}
if (root)
cout << cnt - 1 << endl;
else
cout << cnt << endl;
if (!root) root = f(1);
for (int i = 1; i <= n; i++) {
if (f(i) == i)
cout << root << ' ';
else
cout << a[i] << ' ';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long par[N], vis[N], root, changes = 0;
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> par[i];
if (par[i] == i) root = i;
}
for (long long i = 1, T = 0; i <= n; i++) {
if (!vis[i]) {
T++;
long long cur = i;
while (!vis[cur]) {
vis[cur] = T;
cur = par[cur];
}
if (vis[cur] == T) {
if (!root) {
par[cur] = cur;
root = cur;
changes++;
} else if (par[cur] != root) {
par[cur] = root;
changes++;
}
}
}
}
cout << changes << '\n';
for (long long i = 1; i <= n; i++) cout << par[i] << ' ';
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long T = 1;
for (long long i = 1; i <= T; i++) {
solve();
}
cerr << "\nTime: " << clock() << " ms\n";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int pre[N];
int t[N];
vector<int> s;
int Find(int x) { return x == pre[x] ? x : pre[x] = Find(pre[x]); }
void Union(int x, int y) {
int fx = Find(x), fy = Find(y);
if (fx != fy) pre[fx] = fy;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) pre[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
Union(i, t[i]);
}
int cot = 0;
int e = 0;
for (int i = 1; i <= n; i++)
if (i == Find(pre[i]) && t[i] == i) {
e = i;
break;
}
for (int i = 1; i <= n; i++) {
if (i == e) continue;
if (i == Find(pre[i])) {
cot++;
if (e)
t[i] = e;
else {
t[i] = i;
e = i;
}
}
}
cout << cot << endl;
for (int i = 1; i < n; i++) printf("%d ", t[i]);
cout << t[n] << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
const int maxn = (int)2e5 + 13;
const long long INFL = 9223372036854775807;
const int INF = 2147483646;
const long long MOD = (int)1e9 + 21;
const long long base = 257;
vector<int> gr[maxn];
bool vis[maxn];
void dfs(int v, vector<int> &c, int &r, int p = -1) {
vis[v] = 1;
c.push_back(v);
for (auto t : gr[v]) {
if (!vis[t] && t != p) {
dfs(t, c, r, v);
} else if (t != p) {
r = t;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
vector<int> p(n + 1);
vector<int> roots;
int ans = 0;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
if (i != p[i])
gr[i].push_back(p[i]), gr[p[i]].push_back(i);
else
roots.push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
vector<int> v;
int r = -1;
dfs(i, v, r);
if (r != -1 && roots.size() != 0)
p[r] = roots[0], ans++;
else if (r != -1 && roots.size() == 0)
p[r] = r, ans++, roots.push_back(r);
}
}
for (int i = 1; i < roots.size(); ++i) {
p[roots[i]] = roots[0];
ans++;
}
cout << ans << "\n";
for (int i = 1; i <= n; ++i) cout << p[i] << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int vis[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
memset(vis, 0, sizeof(vis));
for (int i = (1); i <= (n); i++) cin >> a[i];
int cnt = 1;
int rt = -1;
int num = 0;
for (int i = (1); i <= (n); i++) {
if (a[i] == i && rt == -1) {
rt = i;
vis[i] = 1;
cnt++;
continue;
}
if (vis[i] == 0) {
int id = i;
while (vis[id] == 0) {
vis[id] = cnt;
id = a[id];
if (vis[id] == cnt) {
if (id != a[id] || rt != -1) {
a[id] = -1;
num++;
} else
rt = id;
}
}
cnt++;
}
}
printf("%d\n", num);
for (int i = (1); i <= (n); i++) {
if (a[i] == -1 && rt == -1) rt = i;
if (a[i] != -1)
printf("%d ", a[i]);
else
printf("%d ", rt);
}
printf("\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int p[200001], a[200001], b[200001];
int Find(int x) {
if (a[x] == x) return x;
return Find(a[x]);
}
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (x != y) a[x] = y;
}
int main() {
int n, cnt = 0, sgn = 0;
cin >> n;
for (int i = 0; i <= n; ++i) a[i] = i, b[i] = false;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
if (p[i] != i && Find(i) == Find(p[i]))
p[i] = i, sgn++, b[i] = true;
else
Union(i, p[i]);
}
int flag = 0, root = 0, tmp = 0;
for (int i = 1; i <= n; ++i) {
if (p[i] == i) {
if (b[i] == false) {
root = i, flag = 1;
break;
}
tmp = i;
}
}
if (flag != 1) root = tmp, cnt++;
flag = 0;
for (int i = 1; i <= n; ++i) {
if (i != root && p[i] == i) {
tmp = Find(i);
a[tmp] = root;
p[i] = root;
cnt++, flag++;
}
}
cout << cnt << endl << p[1];
for (int i = 2; i <= n; ++i) cout << " " << p[i];
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1000 * 1000 * 1000 + 7;
int n;
vector<int> P;
vector<bool> marked;
vector<int> root;
void dfs(int v) {
if (marked[v]) return;
marked[v] = true;
set<int> seen{v};
while (seen.find(P[v]) == seen.end()) {
v = P[v];
if (marked[v]) return;
marked[v] = true;
seen.insert(v);
}
root.push_back(v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
P.resize(n);
marked.resize(n);
for (int i = 0; i < n; ++i) {
int par;
cin >> par;
P[i] = --par;
}
for (int i = 0; i < n; ++i) dfs(i);
int real_root = -1;
for (int i = 0; i < root.size(); ++i)
if (P[root[i]] == root[i]) {
real_root = root[i];
break;
}
int ans = root.size() - 1;
if (real_root == -1) {
real_root = root[0];
++ans;
}
for (int i = 0; i < root.size(); ++i) P[root[i]] = real_root;
cout << ans << endl;
for (int i = 0; i < n; ++i)
if (i < n - 1)
cout << P[i] + 1 << ' ';
else
cout << P[i] + 1 << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ar[200001];
bool visited[200001];
bool visiting[200001];
int root = 0;
int c = 0;
int n;
void func(int u) {
if (visited[u]) return;
visited[u] = true;
visiting[u] = true;
if (visiting[ar[u]]) {
if (root == 0 && ar[u] == u) {
root = u;
} else if (ar[u] != root) {
c++;
ar[u] = 0;
}
} else
func(ar[u]);
visiting[u] = false;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
visiting[i] = false;
visited[i] = false;
cin >> ar[i];
}
for (int i = 1; i <= n; ++i) func(i);
int pr = 0;
for (int i = 1; i <= n; ++i) {
if (ar[i] != 0) continue;
if (root != 0) {
if (ar[i] == 0) ar[i] = root;
} else {
if (pr == 0) {
pr = i;
ar[i] = pr;
} else
ar[i] = pr;
}
}
cout << c << "\n";
for (int i = 1; i <= n; ++i) cout << ar[i] << " ";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <int um>
class UF {
public:
vector<int> par;
UF() {
par = vector<int>(um, 0);
for (int i = 0; i < um; i++) par[i] = i;
}
int operator[](int x) {
return par[x] == x ? x : par[x] = operator[](par[x]);
}
void operator()(int x, int y) {
x = operator[](x);
y = operator[](y);
if (x != y) par[x] = y;
}
};
int n;
int a[201010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), a[i]--;
UF<201010> uf;
vector<int> roots, loops;
for (int i = 0; i < n; i++) {
if (a[i] == i) {
roots.push_back(i);
continue;
}
if (uf[i] == uf[a[i]])
loops.push_back(i);
else
uf(i, a[i]);
}
int ans = 0;
if (roots.size() == 0) {
if (loops.size() != 0) {
int root = loops[0];
a[root] = root;
ans++;
for (int i = 1; i < loops.size(); i++) a[loops[i]] = root, ans++;
}
} else {
int root = roots[0];
a[root] = root;
for (int i = 1; i < roots.size(); i++) a[roots[i]] = root, ans++;
for (int i = 0; i < loops.size(); i++) a[loops[i]] = root, ans++;
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) printf("%d ", a[i] + 1);
printf("\n");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
int n;
int a[200010];
int par[200010];
int find(int x) { return (par[x] == x) ? x : (par[x] = find(par[x])); }
int unio(int x, int y) {
int _x = find(x);
int _y = find(y);
if (_x != _y) par[_x] = _y;
}
int main() {
cin >> n;
int root = 0, ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
par[i] = i;
if (a[i] == i) root = i;
}
for (int i = 1; i <= n; i++) {
if (i == root) continue;
if (i == a[i] && i != root) {
a[i] = root;
ans++;
} else {
if (find(i) != find(a[i])) {
unio(i, a[i]);
} else {
ans++;
if (!root) {
a[i] = i;
root = i;
continue;
}
a[i] = root;
}
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (~(1 << 31)) - 5;
int n, rt;
int a[200005], vis[200005], cnt, ans;
void work(int x) {
++cnt;
int t = x;
vis[x] = cnt;
while (!vis[a[t]]) {
vis[a[t]] = cnt;
t = a[t];
}
if (vis[a[t]] == cnt) {
if (!rt) rt = t;
if (a[t] != rt) a[t] = rt, ans++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == i) rt = i;
}
for (int i = 1; i <= n; i++)
if (!vis[i]) work(i);
cout << ans << endl;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int var, p[200001], root = -1, n, cnt, T = 0, v[200001];
void dfs(int s) {
v[s] = T;
if (!v[p[s]])
dfs(p[s]);
else {
if (v[p[s]] == T) {
if (root == -1) {
cnt++;
p[s] = s;
root = s;
} else if (s != root) {
cnt++;
p[s] = root;
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (i == p[i]) root = i;
}
for (int i = 1; i <= n; i++) {
if (!v[i]) {
T++;
dfs(i);
}
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) cout << p[i] << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int s[200005];
int p[200005];
vector<int> uv;
int fd(int x) { return (p[x] == x) ? x : (p[x] = fd(p[x])); }
int gp;
vector<int> v;
void merge(int x, int y) {
int tx = fd(x), ty = fd(y);
if (tx != ty) {
gp--;
p[tx] = ty;
} else {
v.push_back(x);
}
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
p[i] = i;
if (s[i] == i) uv.push_back(i);
}
}
void process() {
gp = n;
for (int i = 1; i <= n; i++) {
merge(i, s[i]);
}
if (uv.size() == 0) {
s[v[0]] = v[0];
uv.push_back(v[0]);
gp++;
}
printf("%d\n", gp - 1);
for (int i = 0; i < (int)v.size(); i++)
if (v[i] != uv[0]) {
s[v[i]] = uv[0];
}
for (int i = 1; i <= n; i++) printf("%d%c", s[i], " \n"[i == n]);
}
int main() {
init();
process();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 998244353;
const int inf = 0x3fffffff;
int n, p[maxn], father[maxn], b[maxn];
void init() {
for (int i = 1; i <= n; i++) father[i] = i;
}
int find_father(int x) {
int a = x;
while (x != father[x]) x = father[x];
while (a != father[a]) {
int z = a;
a = father[a];
father[z] = x;
}
return x;
}
void Union(int a, int b) {
int faA = find_father(a);
int faB = find_father(b);
if (faA != faB) father[faA] = faB;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
init();
int root = 0;
for (int i = 1; i <= n; i++) {
cin >> p[i];
Union(i, p[i]);
if (i == p[i]) root = i;
}
int k = find_father(root);
int cnt = 0;
for (int i = 1; i <= n; i++) {
int t = find_father(i);
if (b[t] == 0) {
cnt++;
if (t != k) p[t] = root;
}
b[t]++;
}
bool flag = false;
for (int i = 1; i <= n; i++) {
if (p[i] == 0) {
if (!flag) {
p[i] = i;
root = i;
flag = true;
} else
p[i] = root;
}
}
if (flag)
cout << cnt;
else
cout << cnt - 1;
cout << endl;
for (int i = 1; i <= n; i++) cout << p[i] << " ";
return ~~(0 - 0);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct outFloat {
int precision;
long double value;
outFloat(long double v, int p) : precision(p), value(v) {}
};
template <typename T>
struct debugInfo {
string name;
T val;
debugInfo(const char* n, T v) : name(n), val(v){};
};
template <typename T>
debugInfo<T> makeDebugInfo(const char* n, T v) {
return debugInfo<T>(n, v);
}
const int inf = 123456789;
const long long llInf = 123456789012345678LL;
const long double pi = 3.14159265358979323846;
const int maxN = 2000000;
int init() {
ios_base::sync_with_stdio(0);
srand(time(NULL));
return 0;
}
int initializer = init();
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& p) {
for (int i = 0; i < p.size(); i++) is >> p[i];
return is;
}
class inputer {
private:
istream* istr;
public:
inputer(istream& is) : istr(&is) {}
template <typename T>
void get(T& n) {
(*istr) >> n;
}
template <typename T, typename... Args>
void get(T& n, Args&... args) {
get(n);
get(args...);
}
template <typename... Args>
void getLn(Args&... args) {
get(args...);
getLn();
}
template <typename T>
operator T() {
T n;
get(n);
return n;
}
void getLn() {
string s;
getline(cin, s);
}
template <typename T>
void getv(vector<T>& v, int size) {
v.resize(size);
(*istr) >> v;
}
};
string delim = " ";
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << p.first << delim << p.second;
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& p) {
for (int i = 0; i < p.size(); i++) {
if (i != 0) os << delim;
os << p[i];
}
return os;
}
ostream& operator<<(ostream& os, const outFloat& of) {
os << setprecision(of.precision) << of.value;
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const debugInfo<T>& dbg) {
os << "\"" << dbg.name << "\" = \"" << dbg.val << "\""
<< "\n";
}
class outputer {
private:
ostream* ostr;
public:
outputer(ostream& os) : ostr(&os) {}
template <typename T>
void put(const T& n) {
(*ostr) << n;
}
template <typename T, typename... Args>
void put(const T& n, const Args&... args) {
put(n);
put(args...);
}
template <typename... Args>
void putLn(const Args&... args) {
put(args...);
putLn();
}
template <typename T>
outputer& operator=(const T& n) {
putLn(n);
return *this;
}
void putLn() { (*ostr) << "\n"; }
template <typename T>
void putv(vector<T> v, int size, string delim) {
for (int i = 0; i < size; i++) {
if (i != 0) (*ostr) << delim;
(*ostr) << v[i];
}
}
};
inputer in(cin);
outputer out(cout);
char getChar() {
char c = 0;
while (c <= ' ') cin >> c;
return c;
}
bool willItBeAC() {
return true;
;
}
int getMyRating() { return 2048; }
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<long long> divs(long long n) {
vector<long long> v;
long long i = 2;
while (i * i <= n)
if (n % i == 0) {
n /= i;
v.push_back(i);
} else
i++;
v.push_back(n);
return v;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long extGcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1, d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
class fenwick {
private:
vector<T> t;
int n;
public:
fenwick(int nn) { init(nn); }
void init(int nn) {
n = nn;
t.assign(n, 0);
}
T sum(int r) {
T result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, T delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
T sum(int l, int r) { return sum(r) - sum(l - 1); }
T get(int i) { return sum(i, i); }
void put(int i, T v) { inc(i, v - sum(i, i)); }
int size() { return n; }
};
int n = in;
int cnt = 0;
vector<int> q, tQ;
vector<int> used(n, false);
vector<vector<int> > g(n);
vector<int> roots;
int ses = 1;
void dfs(int v, int sID) {
used[v] = sID;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (used[to] == sID) q[to] = -1;
if (used[to]) continue;
dfs(to, sID);
}
}
int main() {
in.getv(q, n);
tQ = q;
for (int i = 0; i < n; i++) q[i]--;
for (int i = 0; i < n; i++)
if (q[i] == i)
roots.push_back(i);
else
g[q[i]].push_back(i);
for (int i : roots) dfs(i, ses++);
for (int i = 0; i < n; i++)
if (!used[i]) dfs(i, ses++);
int fM1 = -1;
for (int i = 0; i < n; i++)
if (q[i] < 0) fM1 = i;
for (int i = 0; i < n; i++)
if (q[i] == i) q[i] = -1;
if ((int)roots.size() == 0) roots.push_back(fM1);
for (int i = 0; i < n; i++)
if (q[i] < 0) q[i] = roots[0];
for (int i = 0; i < n; i++) q[i]++;
for (int i = 0; i < n; i++)
if (tQ[i] != q[i]) cnt++;
out = cnt;
out = q;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, p[210000], used[210000], used2[210000], root, ans, good_root = -1;
vector<int> l[210000];
vector<int> comp;
vector<int> roots;
void dfs(int v) {
used[v] = 1;
comp.push_back(v);
int k = l[v].size();
for (int i = 0; i < k; i++) {
int v2 = l[v][i];
if (!used[v2]) dfs(v2);
}
return;
}
void cycle_dfs(int v) {
used2[v] = 1;
while (used2[p[v]] == 0) {
v = p[v];
used2[v] = 1;
}
root = p[v];
return;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (i != p[i]) {
l[i].push_back(p[i]);
l[p[i]].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
comp.clear();
dfs(i);
root = -1;
int k = comp.size();
for (int j = 0; j < k; j++)
if (p[comp[j]] == comp[j] || p[p[comp[j]]] == comp[j]) {
root = comp[j];
break;
}
if (root == -1) {
cycle_dfs(i);
}
roots.push_back(root);
}
}
int k = roots.size();
for (int i = 0; i < k; i++) {
if (p[roots[i]] == roots[i]) {
good_root = roots[i];
break;
}
}
if (good_root == -1) {
good_root = roots[0];
p[roots[0]] = roots[0];
ans++;
}
for (int i = 0; i < k; i++) {
int rt = roots[i];
if (rt != good_root) {
p[rt] = good_root;
ans++;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
vector<pair<int, int> > adj[MAXN];
int n;
bool mark[MAXN];
int p[MAXN];
int curv;
void dfs(int v, int ind = -1) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
pair<int, int> u = adj[v][i];
if (!mark[u.first]) {
dfs(u.first, u.second);
} else if (u.second != ind) {
curv = u.first;
}
}
}
int main() {
cin >> n;
int x;
int d = -1;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x == i) {
d = i;
}
p[i] = x;
adj[i].push_back({x, i});
adj[x].push_back({i, i});
}
int cnt = 0;
vector<int> ve;
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
dfs(i);
cnt++;
ve.push_back(curv);
}
}
if (d != -1) {
cout << cnt - 1 << '\n';
for (int i = 0; i < ve.size(); i++) {
p[ve[i]] = d;
}
for (int i = 1; i <= n; i++) {
cout << p[i] << ' ';
}
return 0;
}
cout << cnt << '\n';
for (int i = 0; i < ve.size(); i++) {
p[ve[i]] = ve[0];
}
for (int i = 1; i <= n; i++) {
cout << p[i] << ' ';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
int a[SIZE], u[SIZE], in[SIZE], tt;
int main() {
int r = 0;
int(n);
scanf("%d", &n);
for (int i = (1); i < (n + 1); ++i) scanf("%d", &(a[i]));
vector<int> an;
for (int i = (1); i < (n + 1); ++i) {
if (!u[i]) {
tt++;
int x = i;
in[x] = tt;
u[x] = 1;
for (x = a[x]; !u[x]; x = a[x]) u[x] = 1, in[x] = tt;
if (in[x] == tt) {
if (x == a[x] || !r) r = x;
an.push_back(x);
}
}
}
int ker = (a[r] == r);
for (int i = 0; i < (((int)(an).size())); ++i) a[an[i]] = r;
printf("%d\n", ((int)(an).size()) - ker);
for (int i = (1); i < (n + 1); ++i) printf("%d ", a[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long fac[1000006];
inline long long exp(long long x, long long n) {
long long r = 1;
x = x;
while (n) {
if (n % 2) r = (r * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return r;
}
inline long long mmi(long long a) {
return exp(a, 1000000007 - 2) % 1000000007;
}
inline long long fact(long long n) {
long long res = 1;
for (long long i = 1; i < (n + 1); ++i) {
res = (res * i) % 1000000007;
}
return res;
}
inline void fact_a() {
fac[0] = 1;
fac[1] = 1;
for (long long i = 1; i < (105); ++i) {
fac[i] = (fac[i - 1] * i) % 1000000007;
}
}
inline long long inv_fact(long long n) {
long long par = fac[n];
long long res = mmi(par);
return res;
}
inline long long comb(long long n, long long r) {
if (n == r && r == 0) return 1;
if (n < r) return 0;
return ((fac[n] * inv_fact(r)) % 1000000007 * inv_fact(n - r)) % 1000000007;
}
struct triplet {
long long a, b, c;
};
bool operator<(const triplet &t1, const triplet &t2) {
if (t1.a < t2.a) return true;
if (t1.a == t2.a && t1.b < t2.b) return true;
if (t1.a == t2.a && t1.b == t2.b && t1.c < t2.c) return true;
return false;
}
pair<long long, pair<long long, long long> > ex_gcd(long long a, long long b) {
if (b == 0) {
return make_pair(a, make_pair(1, 0));
}
pair<long long, pair<long long, long long> > p = ex_gcd(b, a % b);
long long gcd = p.first;
long long x1 = p.second.first;
long long y1 = p.second.second;
long long x = y1;
long long y = x1 - (a / b) * y1;
return make_pair(gcd, make_pair(x, y));
}
long long prime[3000006];
long long spf_prime[3000006];
void sieve() {
prime[1] = 1;
for (long long i = 2; i * i <= 3000000; i++)
if (prime[i] == 0)
for (long long j = i * i; j <= 3000000; j += i) prime[j] = 1;
}
void spf() {
for (long long i = 2; i * i <= 3000000; i++)
if (!spf_prime[i])
for (long long j = i * i; j <= 3000000; j += i)
if (!spf_prime[j]) spf_prime[j] = i;
for (long long i = 2; i <= 3000000; i++)
if (!spf_prime[i]) spf_prime[i] = i;
}
long long getparent_BIT(long long idx) { return idx - (idx & -idx); }
long long getnext_BIT(long long idx) { return idx + (idx & -idx); }
long long getsum_BIT(long long idx, long long BIT[], long long n) {
long long sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx = getparent_BIT(idx);
}
return sum;
}
void update_BIT(long long idx, long long BIT[], long long val, long long n) {
while (idx <= n) {
BIT[idx] += val;
idx = getnext_BIT(idx);
}
}
void build_BIT(long long BIT[], long long a[], long long n) {
for (long long i = 0; i < (n); ++i) {
update_BIT(i, BIT, a[i], n);
}
}
void comp_lps(string s, long long lps[], long long n) {
long long i = 1, j = 0;
while (i < n) {
if (s[i] == s[j]) {
lps[i++] = ++j;
} else {
if (j != 0)
j = lps[j - 1];
else
lps[i++] = 0;
}
}
}
void dfs_l(long long u, vector<vector<long long> > &adj, long long status[]) {
if (status[u] == 1) return;
status[u] = 1;
for (long long i = 0; i < (adj[u].size()); ++i) dfs_l(adj[u][i], adj, status);
}
long long dij(long long u, long long n,
vector<vector<pair<long long, long long> > > &adj,
long long status[]) {
long long dist[n];
for (long long i = 0; i < (n); ++i) dist[i] = 1000000000;
dist[0] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(0, 0));
while (!q.empty()) {
pair<long long, long long> p;
p = q.top();
q.pop();
long long x = p.second;
long long w = p.first;
if (status[x] == 1) continue;
status[x] = 1;
for (long long i = 0; i < (adj[x].size()); ++i) {
long long ww = adj[x][i].first;
long long y = adj[x][i].second;
if (dist[x] + ww < dist[y]) {
dist[y] = dist[x] + ww;
q.push(make_pair(dist[y], y));
}
}
}
if (dist[n - 1] >= 1000000000) return -1;
return dist[n - 1];
}
long long phi(long long n) {
vector<long long> v;
long long k = n;
;
for (long long i = 2; i * i <= n; i++) {
if (k % i == 0) {
v.push_back(i);
while (k % i == 0) k /= i;
}
}
if (k > 1) v.push_back(k);
long long ans = n;
for (long long i = 0; i < (v.size()); ++i) ans -= (ans / v[i]);
return ans;
}
struct trie {
struct trie *left, *right;
bool isend;
};
trie *get_trie() {
trie *ptr = new trie;
ptr->left = NULL;
ptr->right = NULL;
ptr->isend = false;
return ptr;
}
bool isempty(trie *root) {
if (root->left == NULL && root->right == NULL) return true;
return false;
}
void insert_trie(trie *root, string key) {
trie *ptr = root;
for (long long i = 0; i < (key.size()); ++i) {
if (key[i] == '0') {
if (ptr->left == NULL) {
ptr->left = get_trie();
}
ptr = ptr->left;
} else {
if (ptr->right == NULL) ptr->right = get_trie();
ptr = ptr->right;
}
}
ptr->isend = true;
}
trie *remove_trie(trie *root, string key, long long idx = 0) {
if (root == NULL) return NULL;
if (idx == key.size()) {
if (isempty(root)) {
delete (root);
root = NULL;
}
return root;
}
if (key[idx] == '0')
root->left = remove_trie(root->left, key, idx + 1);
else
root->right = remove_trie(root->right, key, idx + 1);
if (isempty(root)) {
delete (root);
root = NULL;
}
return root;
}
long long search_trie(trie *root, string key) {
trie *ptr = root;
string s = "";
for (long long i = 0; i < (key.size()); ++i) {
if (key[i] == '0') {
if (ptr->right != NULL) {
ptr = ptr->right;
s += '1';
} else {
ptr = ptr->left;
s += '0';
}
} else {
if (ptr->left != NULL) {
ptr = ptr->left;
s += '1';
} else {
ptr = ptr->right;
s += '0';
}
}
}
long long res = 0;
reverse(s.begin(), s.end());
for (long long i = s.length() - 1; i >= (0); --i)
res = res * 2 + (s[i] - '0');
return res;
}
struct Comp {
bool operator()(const std::pair<int, int> &a, const std::pair<int, int> &b) {
if (a.first != b.first) {
return a.first < b.first;
}
return a.second > b.second;
}
};
void dearr() {
long long dar[1005];
dar[0] = 1;
dar[1] = 0;
dar[2] = 1;
for (long long i = 3; i < (1002); ++i) {
dar[i] = (i - 1) * (dar[i - 1] + dar[i - 2]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < (n); ++i) cin >> a[i];
for (long long i = 0; i < (n); ++i) a[i]--;
vector<long long> v;
long long status[n];
memset(status, 0, sizeof(status));
long long last;
long long ff = 1;
long long qq = 0;
long long id = -1;
for (long long i = 0; i < (n); ++i) {
if (status[i] == 0) {
long long k = i;
while (status[k] == 0) {
status[k] = ff;
last = k;
k = a[k];
}
if (status[k] == ff) {
if (a[last] != last)
qq++;
else
id = last;
a[last] = last;
v.push_back(last);
}
ff++;
}
}
long long ans = v.size() - 1;
if (v.size() == qq) ans++;
cout << ans << "\n";
if (id != -1) {
for (long long i = 0; i < (v.size()); ++i) {
a[v[i]] = id;
}
} else {
for (long long i = 0; i < (v.size() - 1); ++i) {
a[v[i]] = v[v.size() - 1];
}
}
for (long long i = 0; i < (n); ++i) a[i]++;
for (auto i : a) cout << i << " ";
cout << "\n";
;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int a[maxn];
int f[maxn];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
int main() {
int n;
int cot = 0;
int root = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == i) {
cot++;
root = i;
} else {
int bossx = find(i);
int bossy = find(a[i]);
if (bossx == bossy) {
cot++;
a[i] = i;
} else
f[bossx] = bossy;
}
}
if (root == 0) {
for (int i = 1; i <= n; i++) {
if (f[i] == i) {
root = i;
cot++;
break;
}
}
}
printf("%d\n", cot - 1);
for (int i = 1; i <= n; i++) {
if (f[i] == i) a[i] = root;
if (i < n)
printf("%d ", a[i]);
else
printf("%d\n", a[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
inline int read() {
int x = 0;
bool f = true;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = false;
c = getchar();
}
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? x : -x;
}
int f[N];
int get(int x) { return x == f[x] ? x : f[x] = get(f[x]); }
int n, p[N];
int ans, root;
int main() {
n = read();
for (register int i = 1; i <= n; ++i) f[i] = i;
for (register int i = 1; i <= n; ++i) {
p[i] = read();
}
for (register int i = 1; i <= n; ++i) {
if (i == p[i]) {
root = i;
break;
}
}
for (register int i = 1; i <= n; ++i) {
if (i == root) continue;
int fp = get(p[i]), fi = get(i);
if (fp == fi) {
if (!root) root = i;
fi = root, p[i] = root, ++ans;
}
f[fi] = fp;
}
printf("%d\n", ans);
for (register int i = 1; i <= n; ++i) printf("%d ", p[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int fa[maxn];
int rt;
int n, vis[maxn];
vector<int> vec;
int num;
void dfs(int u) {
vec.push_back(u);
vis[u] = 2;
if (vis[fa[u]] == 1) return;
if (vis[fa[u]] == 2) {
num++;
if (rt == 0) {
rt = u;
fa[u] = u;
} else {
fa[u] = rt;
}
} else {
dfs(fa[u]);
}
}
void solve() {
int tag = 0;
rt = 0;
for (int i = 1; i <= n; i++) {
if (i == fa[i]) {
tag = 1;
rt = i;
break;
}
}
num = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vec.clear();
dfs(i);
for (int j = 0; j < vec.size(); j++) {
vis[vec[j]] = 1;
}
}
}
printf("%d\n", num - tag);
for (int i = 1; i <= n; i++) {
printf("%d%c", fa[i], (i == n ? '\n' : ' '));
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &fa[i]);
}
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long s[200005];
long long p[200005];
long long np[200005];
long long n;
bool cmp(long long a, long long b) { return abs(p[a] - a) < abs(p[b] - b); }
signed main() {
cin >> n;
for (long long i = (0); i < (n); i++) {
cin >> p[i];
p[i]--;
np[i] = p[i];
}
vector<long long> v;
for (long long i = (0); i < (n); i++) {
set<long long> u;
long long j = i;
for (; !s[j]; j = p[j]) {
u.insert(j);
s[j] = 1;
}
if (u.count(j)) v.push_back(j);
}
sort(v.begin(), v.end(), cmp);
for (long long i : v) np[i] = v[0];
long long ans = 0;
for (long long i : v) ans += (p[i] != np[i]);
cout << ans << '\n';
for (long long i = (0); i < (n); i++) cout << np[i] + 1 << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
vector<int> used(n, 0);
vector<int> loops;
int root = -1;
int curUse = 1;
int cur, next;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
cur = 0;
for (int i = 0; i < n; i++) {
if (used[i]) {
continue;
}
cur = i;
while (true) {
used[cur] = curUse;
next = a[cur];
if (cur == next) {
if (root == -1) {
root = cur;
} else {
loops.push_back(cur);
}
break;
} else if (used[next] == curUse) {
loops.push_back(cur);
break;
} else if (used[next]) {
break;
}
cur = next;
}
curUse++;
}
int startIndex = 0;
if (root == -1) {
root = loops[0];
a[root] = root;
startIndex++;
}
for (int i = startIndex; i < loops.size(); i++) {
a[loops[i]] = root;
}
cout << loops.size() << endl;
for (int i : a) {
cout << i + 1 << " ";
}
cout << endl;
return 0;
}
| 8 | CPP |
# [https://codeforces.com/contest/698/submission/42129034]
input()
A = list(map(int, input().split(' ')))
root = -1
for i,a in enumerate(A) :
if i == a-1 :
root = i
break
v = [False]*len(A)
if root>-1 :
v[root]=True
changed = 0
for i,a in enumerate(A) :
if v[i] :
continue
v[i]= True
l=[i]
a-=1
while not v[a] :
l.append(a)
v[a]=True
a=A[a]-1
if a in l:
if root==-1:
A[a]=a+1
root=a
changed+=1
else :
A[a]=root+1
changed+=1
print(changed)
print(' '.join(map(str,A))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
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 << endl;
err(++it, args...);
}
template <class T, class U>
inline void checkmin(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void checkmax(T &x, U y) {
if (y > x) x = y;
}
template <class T, class U>
inline bool ifmax(T &x, U y) {
if (y > x) return x = y, true;
return false;
}
template <class T, class U>
inline bool ifmin(T &x, U y) {
if (y < x) return x = y, true;
return false;
}
long long fstpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long powm(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
void fukof() {}
void problem() {}
const long long mod = 1e9 + 7;
const long long N = 200005;
const long long inf = 1e9;
vector<int> adj[N];
int dsu[N];
bool vis[N];
void dfs(int src) {
if (vis[src])
return;
else
vis[src] = true;
if (src != adj[src][0]) dfs(adj[src][0]);
dsu[src] = dsu[adj[src][0]];
}
void solve() {
int n;
cin >> n;
memset(vis, 0, sizeof(vis));
vector<int> a(n);
for (long long i = 0; i < (n); i++) {
cin >> a[i];
};
for (long long i = (1); i < (1 + n); i++)
adj[i].push_back(a[i - 1]), dsu[i] = i;
for (long long i = 0; i < (n); i++) dfs(i + 1);
vector<int> v;
for (long long i = (1); i < (1 + n); i++) {
v.push_back(dsu[i]);
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
;
if (v.size() == 1) {
if (a[v[0] - 1] != v[0]) {
cout << 1 << endl;
a[v[0] - 1] = v[0];
for (long long i = 0; i < (n); i++) {
cout << a[i] << " ";
}
cout << endl;
;
;
return;
} else {
cout << 0 << endl;
for (long long i = 0; i < (n); i++) {
cout << a[i] << " ";
}
cout << endl;
;
;
return;
}
} else {
int par = v[0];
int ans = v.size() - 1;
for (long long i = 0; i < (v.size()); i++) {
if (a[v[i] - 1] == v[i]) par = v[i];
}
if (a[par - 1] != par) ans++;
for (long long i = 0; i < (v.size()); i++) {
a[v[i] - 1] = par;
}
cout << ans << endl;
for (long long i = 0; i < (n); i++) {
cout << a[i] << " ";
}
cout << endl;
;
;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc = 1;
while (tc--) {
problem();
fukof();
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> a(n);
long long b = -1;
long long ans = -1;
for (long long i = (0); i < (n); i++) cin >> a[i], a[i]--;
for (long long i = (0); i < (n); i++)
if (i == a[i]) a[i] = b, b = i, ans++;
for (long long i = (0); i < (n); i++)
if (a[i] == -1) a[i] = i, b = i;
vector<long long> use(n, -1);
for (long long i = (0); i < (n); i++)
if (use[i] < 0 && i != b) {
long long fl = 0, c = i;
while (1) {
use[c] = i;
c = a[c];
if (c == b) break;
if (use[c] != i && use[c] >= 0) break;
if (use[c] == i) {
fl = 1;
break;
}
}
if (fl)
if (b != -1) a[c] = b, ans++;
if (fl)
if (b < 0) b = c, a[c] = c, ans = 1;
}
cout << ans << '\n';
for (long long i = (0); i < (n); i++) cout << (a[i] + 1) << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[200001] = {};
bool v[200001] = {};
int find(int x) {
memset(v, 0, sizeof(v));
int k, j, r;
r = x;
v[r] = 1;
while (r != f[r]) {
if (v[f[r]]) {
f[r] = r;
break;
}
r = f[r];
v[r] = 1;
}
k = x;
while (k != r) {
j = f[k];
f[k] = r;
k = j;
}
return r;
}
int rf[200001] = {};
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
f[i] = i;
}
for (int i = 1; i <= n; i++) {
cin >> f[i];
rf[i] = f[i];
}
for (int i = 1; i <= n; i++) {
find(i);
}
int count = 0;
int orig = 0;
bool orig_great = false;
for (int i = 1; i <= n; i++) {
if (f[i] == i) {
if (rf[i] == i) {
orig = i, orig_great = true;
break;
} else {
orig = i;
}
}
}
for (int i = 1; i <= n; i++) {
if (f[i] == i) {
if (rf[i] != orig) count++;
rf[i] = orig;
}
}
cout << count << endl;
for (int i = 1; i <= n; i++) {
cout << rf[i] << (i < n ? " " : "\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], fa[maxn], cnt = 0;
pair<int, int> pa[maxn];
int find(int x) {
if (x != fa[x]) {
fa[x] = find(fa[x]);
}
return fa[x];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
fa[i] = i;
}
int pos = -1;
for (int i = 1; i <= n; i++) {
int x = find(i), y = find(a[i]);
if (x != y) {
fa[x] = y;
} else {
if (i == a[i]) {
pos = cnt;
}
pa[cnt++] = make_pair(i, a[i]);
}
}
if (pos == -1) {
pos = 0;
cnt++;
a[pa[0].first] = pa[0].first;
}
for (int i = 0; i < cnt; i++) {
if (i == pos) continue;
a[pa[i].first] = pa[pos].first;
}
printf("%d\n", cnt - 1);
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 200005;
int fa[maxn], N, in[maxn], vis[maxn];
void tuopu(int x) {
while (!in[x]) {
vis[x] = 1;
x = fa[x];
in[x]--;
if (vis[x]) break;
}
}
int fcir(int x) {
while (!vis[x]) {
vis[x] = 2;
x = fa[x];
}
return x;
}
int main() {
int fir = -1, ans = 0;
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &fa[i]);
if (i == fa[i]) {
if (-1 != fir) {
ans++;
fa[i] = fir;
in[fir]++;
} else
fir = fa[i];
} else
in[fa[i]]++;
}
for (int i = 1; i <= N; i++)
if (!in[i] && !vis[i]) tuopu(i);
if (-1 != fir) {
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
ans++;
int x = fcir(i);
fa[x] = fir;
}
}
} else {
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
vis[i] = 2;
int x = fa[i];
while (!vis[x]) {
vis[x] = 2;
x = fa[x];
}
fir = i;
fa[i] = i;
ans++;
break;
}
}
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
ans++;
int x = fcir(i);
fa[x] = fir;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= N; i++) printf("%d ", fa[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a[200001], flag[200001], cnt(0), root(0), j, res(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (i == a[i]) root = i;
}
fill(flag + 1, flag + 200001, 0);
for (i = 1; i <= n; i++) {
if (flag[i] == 0) {
cnt++;
j = i;
while (flag[j] == 0) {
flag[j] = cnt;
j = a[j];
}
if (flag[j] == cnt) {
if (root == 0) {
root = j;
a[j] = j;
res++;
}
if (root != j) {
a[j] = root;
res++;
}
}
}
}
cout << res << '\n';
for (i = 1; i <= n; i++) cout << a[i] << " ";
}
| 8 | CPP |
# Why do we fall ? So we can learn to pick ourselves up.
root = -1
def find(i,time):
parent[i] = time
while not parent[aa[i]]:
i = aa[i]
parent[i] = time
# print(parent,"in",i)
if parent[aa[i]] == time:
global root
if root == -1:
root = i
if aa[i] != root:
aa[i] = root
global ans
ans += 1
n = int(input())
aa = [0]+[int(i) for i in input().split()]
parent = [0]*(n+1)
ans = 0
time = 0
for i in range(1,n+1):
if aa[i] == i:
root = i
break
for i in range(1,n+1):
if not parent[i]:
# print(i,"pp")
time += 1
find(i,time)
# print(parent)
print(ans)
print(*aa[1:])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int par[400005];
int arr[400005];
int find_par(int n) {
if (par[n] == n)
return n;
else
return par[n] = find_par(par[n]);
}
int visited[500005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
par[i] = i;
}
int root = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
int x = find_par(i);
int y = find_par(arr[i]);
if (arr[i] == i) root = i;
if (x != y) par[x] = y;
if (x == y) {
visited[i] = 1;
}
}
if (!root) {
for (int i = 1; i <= n; i++) {
int x = find_par(i);
int y = find_par(arr[i]);
if (x == y) {
root = x;
break;
}
}
}
int index;
for (int i = 1; i <= n; i++) {
if (visited[i]) {
if (arr[i] != root) {
cnt++;
arr[i] = root;
}
}
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
}
| 8 | CPP |
n = int(input())
arr = list(map(int, input().split(' ')))
root=-1
for i,a in enumerate(arr) :
if i == a-1 :
root = i
break
v = [False]*len(arr)
if root>-1 :
v[root]=True
ans = 0
for i,a in enumerate(arr) :
if v[i] :
continue
v[i]= True
l=[i]
a-=1
while not v[a] :
l.append(a)
v[a]=True
a=arr[a]-1
if a in l: #new cycle
if root==-1:
arr[a]=a+1
root=a
ans+=1
else :
arr[a]=root+1
ans+=1
print(ans)
print(' '.join(map(str,arr)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
set<int> Set;
vector<int> v[250001];
int a[250001], p[250001], n, i, j, ans;
bool pole[250001], x;
void Merge(int nom1, int nom2) {
int i;
if (nom1 == p[1]) {
for (i = 0; i < v[nom2].size(); i++) Set.erase(v[nom2][i]);
}
if (nom2 == p[1]) {
for (i = 0; i < v[nom1].size(); i++) Set.erase(v[nom1][i]);
}
if (v[nom1].size() < v[nom2].size()) {
for (i = 0; i < v[nom1].size(); i++) {
v[nom2].push_back(v[nom1][i]);
p[v[nom1][i]] = nom2;
}
v[nom1].clear();
} else {
for (i = 0; i < v[nom2].size(); i++) {
v[nom1].push_back(v[nom2][i]);
p[v[nom2][i]] = nom1;
}
v[nom2].clear();
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == i) x = true;
}
for (i = 1; i <= n; i++) {
v[i].push_back(i);
p[i] = i;
}
for (i = 2; i <= n; i++) Set.insert(i);
if (!x) {
for (i = 1; i <= n; i++)
if (p[i] != p[a[i]]) {
pole[i] = true;
Merge(p[i], p[a[i]]);
}
for (i = 1; i <= n; i++)
if (!pole[i]) {
if (!x) {
ans++;
x = true;
a[i] = i;
continue;
}
ans++;
if (p[i] != p[1]) {
Merge(p[i], p[1]);
a[i] = 1;
} else {
a[i] = *Set.begin();
Merge(p[i], p[*Set.begin()]);
}
}
} else {
x = false;
for (i = 1; i <= n; i++)
if (p[i] != p[a[i]]) {
pole[i] = true;
Merge(p[i], p[a[i]]);
}
for (i = 1; i <= n; i++)
if (!pole[i]) {
if (a[i] == i && !x) {
x = true;
continue;
}
ans++;
if (p[i] != p[1]) {
Merge(p[i], p[1]);
a[i] = 1;
} else {
a[i] = *Set.begin();
Merge(p[i], p[*Set.begin()]);
}
}
}
cout << ans << '\n';
for (i = 1; i <= n; i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
| 8 | CPP |
tree_size = int(input())
parents = [int(x)-1 for x in input().split(' ')]
num_changes = 0
root = tree_size
for node, parent in enumerate(parents):
if parent == node:
root = node
break
visited = set()
finished = set()
visited.add(root)
finished.add(root)
stack = []
fringe = []
for node in range(len(parents)):
if node not in visited:
fringe.append(node)
while fringe:
cur = fringe.pop()
visited.add(cur)
stack.append(cur)
if parents[cur] not in finished:
if parents[cur] in visited:
parents[cur] = root
num_changes += 1
else:
fringe.append(parents[cur])
while stack:
finished.add(stack.pop())
if root == tree_size:
new_root = None
for node, parent in enumerate(parents):
if parent == root:
if new_root is None:
new_root = node
parents[node] = new_root
for i in range(len(parents)):
parents[i] += 1
print(num_changes)
print(*parents) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n = 2 * 1e5 + 1;
long long root = 0;
vector<vector<long long>> adj(n);
vector<long long> c, vi(n);
vector<bool> visited(n);
void dfs(long long s, long long anc) {
if (visited[s]) return;
visited[s] = true;
for (auto u : adj[s]) {
if (visited[u] == true && u != anc && u != s && vi[s] == 0) {
c.push_back(u);
vi[u] = 1;
}
dfs(u, s);
}
}
int main() {
long long m;
cin >> m;
long long res = -1;
vector<long long> a(m);
for (long long i = 0; i < m; i++) {
cin >> a[i];
adj[a[i]].push_back(i + 1);
adj[i + 1].push_back(a[i]);
if (a[i] == i + 1 && root == 0) root = a[i];
}
for (long long i = 1; i < m + 1; i++) {
if (visited[i] == false) {
dfs(i, -1);
res++;
}
}
if (res == 0 && root == 0) {
res++;
a[c[0] - 1] = c[0];
} else if (res > 0 && root == 0) {
res++;
root = c[0];
for (long long i = 0; i < c.size(); i++) a[c[i] - 1] = root;
} else if (res > 0 && root > 0) {
for (long long i = 0; i < m; i++) {
if (a[i] == i + 1 && a[i] != root) a[i] = root;
}
for (long long i = 0; i < c.size(); i++) a[c[i] - 1] = root;
}
cout << res << endl;
for (auto i = a.begin(); i != a.end(); i++) {
cout << *i << " ";
}
cout << "\n";
;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int siz = 2e5 + 5;
int ans, cnt, root = -1, n, p[siz], vis[siz];
void go(int v) {
vis[v] = cnt;
if (!vis[p[v]])
go(p[v]);
else if (vis[p[v]] == cnt) {
if (root != -1) {
if (root != v) {
ans++;
p[v] = root;
}
} else {
root = v;
p[v] = v;
ans++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (i == p[i]) root = i;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
go(i);
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) cout << p[i] << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int act, root = -1;
int to[200010];
int u[200010];
vector<int> cycleV;
void dfs(int v) {
u[v] = 1;
if (to[v] == v) {
if (root == -1) {
root = v;
} else {
act++;
to[v] = root;
}
} else if (u[to[v]] == 1) {
cycleV.push_back(v);
} else if (u[to[v]] == 0) {
dfs(to[v]);
}
u[v] = 2;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> to[i];
to[i]--;
}
for (int i = 0; i < n; i++) {
if (!u[i]) {
dfs(i);
}
}
for (int v : cycleV) {
if (root == -1) {
act++;
to[v] = v;
root = v;
} else {
act++;
to[v] = root;
}
}
cout << act << "\n";
for (int i = 0; i < n; i++) {
cout << to[i] + 1 << " ";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 222222;
vector<int> roots, newroots;
int vis[NMAX];
int p[NMAX];
int vcnt;
void query(int x) {
while (1) {
vis[x] = vcnt;
int y = p[x];
if (x == y) {
roots.push_back(x);
return;
}
if (vis[y] == vcnt) {
p[x] = x;
newroots.push_back(x);
return;
}
if (vis[y]) return;
x = y;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
vcnt++;
query(i);
}
if (roots.empty()) {
for (int i = 1; i < newroots.size(); i++) p[newroots[i]] = newroots[0];
printf("%d\n", newroots.size());
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
} else {
for (int i = 1; i < roots.size(); i++) p[roots[i]] = roots[0];
for (int i : newroots) p[i] = roots[0];
printf("%d\n", (int)(roots.size() + newroots.size() - 1));
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
}
}
| 8 | CPP |
# from debug import debug
import sys; input = sys.stdin.readline
n = int(input())
lis = [0, *map(int , input().split())]
v = [0]*(n+1)
cycles = set()
roots = set()
for i in range(1, n+1):
if v[i] == 0:
node = i
while v[node] == 0:
v[node] = 1
node = lis[node]
if v[node] == 2: continue
start = node
ignore = 0
l = 1
while lis[node] != start:
if v[node] == 2: ignore = 1; break
v[node] = 2
node = lis[node]
l+=1
if ignore: continue
v[node] = 2
if l == 1: roots.add(node)
else: cycles.add(node)
ans = 0
if roots:
base = roots.pop()
for i in roots: lis[i] = base; ans+=1
for i in cycles: lis[i] = base; ans+=1
elif cycles:
base = cycles.pop()
cycles.add(base)
for i in roots: lis[i] = base; ans+=1
for i in cycles: lis[i] = base; ans+=1
print(ans)
print(*lis[1:])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod1 = 998244353;
const long long mod2 = 1000000007;
int n, p[200005];
vector<int> cycles;
vector<int> s[200005];
int vis[200005];
vector<int> trees;
void find_tree(int i) {
if (vis[i] == 1) {
cycles.push_back(i);
return;
}
vis[i] = 1;
for (int j = 0; j < (s[i].size()); j++) {
if (s[i][j] != i) find_tree(s[i][j]);
}
vis[i] = 2;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
s[p[i]].push_back(i);
if (i == p[i]) trees.push_back(i);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) find_tree(i);
if (trees.size() != 0) {
cout << trees.size() + cycles.size() - 1 << endl;
for (int i = 1; i < trees.size(); i++) {
p[trees[i]] = trees[0];
}
for (int i = 0; i < (cycles.size()); i++) {
p[cycles[i]] = trees[0];
}
} else {
cout << cycles.size() << endl;
for (int i = 0; i < (cycles.size()); i++) {
p[cycles[i]] = cycles[0];
}
}
for (int i = 0; i < (n); i++) cout << p[i + 1] << ' ';
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long double INF = 1e9;
int n;
int a[N];
int used[N];
int answer[N];
int main() {
scanf("%d", &n);
int r = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
answer[i] = a[i];
if (i == a[i]) r = i;
}
int color = 0;
for (int i = 0; i < n; i++) {
if (used[i] > 0) continue;
int j = i;
color = color + 1;
while (true) {
used[j] = color;
int nxt = a[j];
if (used[nxt] == color) {
if (r == -1) {
r = j;
}
answer[j] = r;
break;
}
if (used[nxt] > 0) {
break;
}
j = nxt;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (answer[i] != a[i]) ans++;
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
printf("%d ", 1 + answer[i]);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, root;
int p[200001], cp[200001];
vector<int> adj[200001];
int vis[200001], delta = 0;
void dfs(int u) {
if (vis[u]) return;
if (u == root) return;
vis[u] = 1;
int& v = p[u];
if (v == u) {
if (root == -1)
root = u;
else {
v = root;
delta++;
}
} else {
dfs(v);
if (vis[v] == 1) {
if (root == -1) root = u;
v = root;
delta++;
}
}
vis[u] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
root = -1;
for (int i = 1; i <= n; i++) {
cin >> p[i];
cp[i] = p[i];
if (i == p[i]) root = i;
}
for (int i = 1; i <= n; i++) dfs(i);
for (int i = 1; i <= n; i++) {
if (p[i] == i && i != root) {
p[i] = root;
delta++;
}
}
delta = 0;
for (int i = 1; i <= n; i++) delta += (cp[i] != p[i]);
cout << delta << '\n';
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
cout << '\n';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int vis[222222];
int main() {
int n;
scanf("%d", &n);
int a[n + 11];
int root = -1, ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] == i) root = a[i];
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
int j = i;
while (!vis[j]) {
vis[j] = i;
j = a[j];
}
if (vis[j] != i) continue;
if (root == -1) {
root = j;
a[root] = root;
ans++;
continue;
}
if (j != root) {
a[j] = root;
ans++;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, root, a[200010], f[200010];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
int main() {
cin >> n;
int num = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++)
if (a[i] == i) root = i;
for (int i = 1; i <= n; i++) {
int x = find(i), y = find(a[i]);
if (x == y)
if (root > 0)
a[i] = root, num += (i != root);
else
root = i, num++, a[i] = i;
else
f[x] = y;
}
cout << num << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 8 | CPP |
n=int(input())
a=list(map(int,input().split()))
par=[]
for i in range(n):
if a[i]==i+1:
par.append(i)
v=[False for i in range(n)]
for i in par:
v[i]=True
ccl=[]
for i in range(n):
if v[i]:continue
s=[i]
v[i]=True
p=set(s)
t=True
while s and t:
x=s.pop()
j=a[x]-1
if j in p:
ccl.append(j)
t=False
else:
s.append(j)
p.add(j)
if v[j]:t=False
else:v[j]=True
if len(par)==0:
print(len(ccl))
c=ccl[0]
a[c]=c+1
for i in range(1,len(ccl)):
a[ccl[i]]=c+1
print(*a)
else:
print(len(ccl)+len(par)-1)
c=par[0]
for i in range(1,len(par)):
a[par[i]]=c+1
for i in range(len(ccl)):
a[ccl[i]]=c+1
print(*a) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
vector<int> heads, circs;
int par[200005], color[200005];
void DFS(int s) {
color[s] = 1;
if (color[par[s]] == 0)
DFS(par[s]);
else if (color[par[s]] == 1) {
if (par[s] == s)
heads.push_back(s);
else
circs.push_back(s);
}
color[s] = 2;
}
int main() {
int n, i, chng, s;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &par[i]);
par[i]--;
color[i] = 0;
}
for (i = 0; i < n; i++)
if (color[i] == 0) DFS(i);
chng = 0;
s = 0;
if (heads.size() == 0) {
par[circs[0]] = circs[0];
heads.push_back(circs[0]);
chng = s = 1;
}
for (i = 1; i < heads.size(); i++) {
par[heads[i]] = heads[0];
chng++;
}
for (i = s; i < circs.size(); i++) {
par[circs[i]] = heads[0];
chng++;
}
printf("%d\n", chng);
for (i = 0; i < n - 1; i++) printf("%d ", par[i] + 1);
printf("%d\n", par[i] + 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 41;
int n, p[N], root, ans, was[N];
vector<int> cyc;
void print() {
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) {
if (i > 1) {
printf(" ");
}
printf("%d", p[i]);
}
exit(0);
}
void findRoot() {
for (int i = 1; i <= n; ++i) {
if (p[i] == i) {
if (root) {
++ans;
p[i] = root;
} else {
root = i;
}
}
}
}
void dfs(int u) {
was[u] = 1;
int to = p[u];
if (to == u) {
was[u] = 2;
return;
}
if (was[to] == 2) {
} else {
if (was[to] == 1) {
cyc.push_back(u);
} else {
dfs(to);
}
}
was[u] = 2;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i]);
}
findRoot();
for (int i = 1; i <= n; ++i) {
if (!was[i]) {
dfs(i);
}
}
if (!root) {
root = cyc[0];
}
for (int i = 0; i < cyc.size(); ++i) {
p[cyc[i]] = root;
++ans;
}
print();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, vis1[200007], a[200007], vis[200007], k, r, f, i1 = -1;
vector<int> v[200007], ans;
void DFS(int x) {
cout << x << " ";
vis[x] = 1e7;
for (int i = 0; i < v[x].size(); i++) {
if (!vis[v[x][i]]) DFS(v[x][i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v[i].push_back(a[i]);
v[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
int x = i;
while (!vis1[x]) {
vis1[x] = i;
x = a[x];
}
if (i != vis1[x]) continue;
k++;
ans.push_back(x);
}
for (int i = 0; i < ans.size(); i++) {
if (a[ans[i]] == ans[i]) {
i1 = i;
break;
}
}
if (i1 == -1) {
a[ans[0]] = ans[0];
i1 = 0;
k++;
}
for (int i = 0; i < ans.size(); i++) {
if (i == i1) continue;
a[ans[i]] = ans[i1];
}
cout << k - 1 << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int f[maxn];
int vis[maxn] = {};
int n;
int main() {
cin >> n;
for (int i = (1); i <= (n); i++) {
scanf("%d", f + i);
}
int huan = 0, root = 0;
vector<int> hh;
hh.clear();
for (int i = (1); i <= (n); i++) {
if (!vis[i]) {
int num = 0;
int u = i;
do {
num++;
vis[u] = i;
u = f[u];
} while (!vis[u]);
if (vis[u] == vis[i]) {
huan++;
if (u == f[u] && !root)
root = u;
else
hh.push_back(u);
}
}
}
printf("%d\n", hh.size());
if (!root) {
root = hh[hh.size() - 1];
hh.pop_back();
f[root] = root;
}
for (int i = (0); i <= (((int)hh.size()) - 1); i++) f[hh[i]] = root;
for (int i = (1); i <= (n); i++) printf("%d ", f[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n >> s;
int swap[2] = {0};
int color[2][2] = {0};
for (int i = 0; i < n; i++) {
if (i % 2 == 0 && s[i] == 'r') color[0][0] += 1;
if (i % 2 == 1 && s[i] == 'b') color[0][1] += 1;
if (i % 2 == 0 && s[i] == 'b') color[1][0] += 1;
if (i % 2 == 1 && s[i] == 'r') color[1][1] += 1;
}
cout << min(max(color[0][0], color[0][1]), max(color[1][0], color[1][1]))
<< endl;
}
| 8 | CPP |
#http://codeforces.com/problemset/problem/719/B
#solved
n = int(input())
s = input()
red_black = True
swap_red = {"b": 0, "r": 0}
swap_black = {"b": 0, "r": 0}
for c in s:
if red_black is True and c != "b":
swap_black["r"] += 1
elif red_black is False and c != "r":
swap_black["b"] += 1
if red_black is True and c != "r":
swap_red["b"] += 1
elif red_black is False and c != "b":
swap_red["r"] += 1
red_black = True if red_black is False else False
black = (swap_black[max(swap_black, key=swap_black.get)] - swap_black[min(swap_black, key=swap_black.get)]) + swap_black[min(swap_black, key=swap_black.get)]
red = (swap_red[max(swap_red, key=swap_red.get)] - swap_red[min(swap_red, key=swap_red.get)]) + swap_red[min(swap_red, key=swap_red.get)]
print(int(min(red, black)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int x = 0, y = 0, a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (i % 2) {
if (s[i] != 'b')
x++;
else
y++;
} else {
if (s[i] != 'r')
a++;
else
b++;
}
}
cout << min(max(x, a), max(y, b)) << endl;
return 0;
}
| 8 | CPP |
n = int(input())
stroy = input()
order = stroy[0]
wrong_r1 = 0
wrong_b1 = 0
wrong_b2 = 0
wrong_r2 = 0
for i in range(n):
if i%2 == 0:
if stroy[i] == 'b':
wrong_b1 += 1
else:
wrong_r1 += 1
else:
if stroy[i] == 'b':
wrong_b2 += 1
else:
wrong_r2 += 1
print(min(max(wrong_b1,wrong_r2),max(wrong_r1,wrong_b2))) | 8 | PYTHON3 |
def check(ch):
other = 'r' if ch == 'b' else 'b'
wrong_ch = 0
wrong_ot = 0
for i in range(n):
if i % 2 != 0 and st[i] == ch:
wrong_ch += 1
if i % 2 == 0 and st[i] == other:
wrong_ot += 1
# print(wrong_ot, wrong_ch)
return max(wrong_ot, wrong_ch)
def func():
ans1 = check('r')
ans2 = check('b')
print(min(ans1, ans2))
# tot_r = st.count('r')
# tot_b = st.count('b')
# if tot_r == tot_b:
# ans = check('r')
# print(ans)
# return
# elif tot_r > tot_b:
# ans = check('r')
# print(ans+(tot_r-tot_b))
# else:
# ans = check('b')
# print(ans + (tot_b - tot_r))
n = int(input())
st = list(input())
func()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int main() {
int n;
int oor, ob;
int er, eb;
while (scanf("%d", &n) != EOF) {
scanf("%s", s + 1);
oor = ob = er = eb = 0;
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
if (i % 2 == 1) {
if (s[i] == 'r')
oor++;
else
ob++;
} else {
if (s[i] == 'r')
er++;
else
eb++;
}
}
int ans = min(max(er, ob), max(oor, eb));
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
getchar();
int corrR = 0, corrB = 0;
int corr1R = 0, corr1B = 0;
for (int i = 0; i < n; i++) {
char c = getchar();
if (c == 'r') {
if (i % 2 == 0) {
corrR++;
} else {
corr1R++;
}
} else {
if (i % 2 != 0) {
corrB++;
} else {
corr1B++;
}
}
}
int first = max((n + 1) / 2 - corrR, n / 2 - corrB);
int second = max((n + 1) / 2 - corr1B, n / 2 - corr1R);
cout << min(first, second);
return 0;
}
| 8 | CPP |
n = int(input())
cockroaches = input()
def get_color_range(start_color):
color = start_color
while True:
if color == 'b':
color = 'r'
else:
color ='b'
yield color
color_range1 = get_color_range('r')
color_range2 = get_color_range('b')
r1 = r2 = b1 = b2 = 0
for color in cockroaches:
if color != next(color_range1):
if color == 'r':
r1 += 1
else:
b1 += 1
if color != next(color_range2):
if color == 'r':
r2 += 1
else:
b2 += 1
variant1 = min(r1, b1) + abs(r1 - b1)
variant2 = min(r2, b2) + abs(r2 - b2)
print(min(variant1, variant2))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int mod(int x) {
if (x < 0) return -x;
return x;
}
string x;
int n;
int a[100001], a_1[100001], pos1[100001], pos2[100001];
void showarray(int a[]) {
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
int Convert(int p[], int q[]) {
int sump = 0, sumq = 0;
for (int i = 1; i <= n; i++) sump += p[i], sumq += q[i];
int ans = mod(sumq - sump);
for (int i = 1; i <= n; i++) {
if (sump < sumq)
if (p[i] == 0 && q[i] == 1) {
p[i] = 1;
sump++;
}
if (sump > sumq)
if (p[i] == 1 && q[i] == 0) {
p[i] = 0;
sump--;
}
}
for (int i = 1; i <= n; i++) {
if (sump < sumq)
if (p[i] == 0) p[i] = 1, sump++;
if (sump > sumq)
if (p[i] == 1) p[i] = 0, sump--;
}
int hdist = 0;
for (int i = 1; i <= n; i++)
if (p[i] != q[i]) hdist++;
ans = ans + hdist / 2;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> x;
for (int i = 0; i < x.size(); i++) {
a[i + 1] = (x[i] == 'r') ? 1 : 0;
a_1[i + 1] = a[i + 1];
}
for (int i = 1; i <= n; i = i + 2) pos1[i] = 1, pos2[i] = 0;
for (int i = 2; i <= n; i = i + 2) pos1[i] = 0, pos2[i] = 1;
cout << min(Convert(a, pos1), Convert(a_1, pos2)) << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long int n;
while (cin >> n) {
cin >> s;
int r1 = 0, b1 = 0, r2 = 0, b2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[i] == 'b') r1++;
} else {
if (s[i] == 'r') b1++;
}
if (i % 2 == 0) {
if (s[i] == 'r') r2++;
} else {
if (s[i] == 'b') b2++;
}
}
int temp1 = (r1 > b1 ? r1 : b1);
int temp2 = (r2 > b2 ? r2 : b2);
printf("%d\n", (temp1 < temp2 ? temp1 : temp2));
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[100000 + 5];
int main() {
int a = 0, b = 0, n, c, d;
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++)
if (s[i] == 'r')
a++;
else
b++;
c = a;
d = b;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[i] == 'r') a--;
} else {
if (s[i] == 'b') b--;
}
if (i % 2 == 0) {
if (s[i] == 'b') d--;
} else {
if (s[i] == 'r') c--;
}
}
printf("%d", min(max(a, b), max(c, d)));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int mxN = 1e5 + 5;
const long long int MOD = 1e9 + 7;
long long int one = 0;
long long int ceil1(long long int a, long long int b) {
if (a % b == 0)
return (a / b);
else
return ((a / b) + 1);
}
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int x = 0, y = 0;
for (long long int i = 0; i < n; i++) {
if (i & 1) {
if (s[i] != 'r') x++;
} else {
if (s[i] != 'b') y++;
}
}
long long int ans = INT_MAX;
ans = min(ans, max(x, y));
x = 0, y = 0;
for (long long int i = 0; i < n; i++) {
if (i & 1) {
if (s[i] != 'b') x++;
} else {
if (s[i] != 'r') y++;
}
}
ans = min(ans, max(x, y));
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
one++;
solve();
}
return 0;
}
| 8 | CPP |
n = int(input())
a = list(input())
ans = (float("+inf"), float("+inf"))
x = 0
y = 0
for i in range(n):
if i&1 and a[i] != "r":
x += 1
elif not(i&1) and a[i] != "b":
y += 1
ans = min(ans, (x, y))
x = 0
y = 0
for i in range(n):
if not(i&1) and a[i] != "r":
x += 1
elif i&1 and a[i] != "b":
y += 1
ans = min(ans, (x, y))
print(max(ans))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
scanf("%d", &n);
cin >> s;
int b1 = 0, b2 = 0, r1 = 0, r2 = 0;
for (int i = 0; i < s.length(); i++) {
if (i % 2 == 0) {
if (s[i] != 'b') b1++;
if (s[i] != 'r') b2++;
}
if (i % 2 == 1) {
if (s[i] != 'r') r1++;
if (s[i] != 'b') r2++;
}
}
int t1 = abs(b1 - r1) + min(b1, r1);
int t2 = abs(b2 - r2) + min(b2, r2);
int t = min(t1, t2);
cout << t << endl;
return 0;
}
| 8 | CPP |
import os
import sys
from io import BytesIO, IOBase
import math
from itertools import permutations
from decimal import Decimal, getcontext
getcontext().prec = 25
MOD = pow(10, 9) + 7
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# n, k = map(int, input().split(" "))
# l = list(map(int, input().split(" ")))
n = int(input())
s = list(input())
a = b = c = d = 0
for i in range(n):
if i%2:
if s[i]!="r":
a+=1
if s[i]!="b":
d+=1
else:
if s[i]!="r":
c+=1
if s[i]!="b":
b+=1
print(min(max(a,b), max(c,d)))
| 8 | PYTHON3 |
num = input()
s = input()
cnt_b1, cnt_r1, cnt_b2, cnt_r2 = 0, 0, 0, 0
for i, c in enumerate(s):
if i % 2:
if c == 'r':
cnt_r1 += 1
else:
cnt_b1 += 1
else:
if c == 'r':
cnt_r2 += 1
else:
cnt_b2 += 1
print(min(max(cnt_b2, cnt_r1), max(cnt_r2, cnt_b1)))
| 8 | PYTHON3 |
n = int(input())
s = [_ for _ in input()]
p = ['b', 'r']
b2 = []
b1 = []
for i in range(n):
b1.append(p[i % 2])
b2.append(p[(i + 1) % 2])
x = y = 0
for i in range(n):
if s[i] != b1[i] and b1[i] == 'b':
x += 1
if s[i] != b1[i] and b1[i] == 'r':
y += 1
k1 = max(x, y)
x = y = 0
for i in range(n):
if s[i] != b2[i] and b2[i] == 'b':
x += 1
if s[i] != b2[i] and b2[i] == 'r':
y += 1
k2 = max(x, y)
print(min(k1, k2))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, b[2][2];
char c;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> c, ++b[i % 2][c == 'r'];
cout << min(max(b[0][0], b[1][1]), max(b[0][1], b[1][0])) << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 100005;
int n;
char s[MAXN];
int B = 0, R = 0;
int main() {
while (scanf("%d", &n) != EOF) {
scanf("%s", s);
int res = 0;
B = 0, R = 0;
char pre;
for (int i = 0; i < n; i++) {
if (i == 0) {
pre = s[0];
continue;
}
if (s[i] != pre) {
pre = s[i];
continue;
}
if (s[i] == 'r') {
if (R == 0) {
res++;
pre = 'b';
B++;
} else {
pre = 'b';
R--;
}
} else {
if (B == 0) {
res++;
pre = 'r';
R++;
} else {
pre = 'r';
B--;
}
}
}
int ans = res;
res = 0;
B = 0, R = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
if (s[0] == 'b') {
pre = 'r';
R++;
res++;
} else {
pre = 'b';
B++;
res++;
}
continue;
}
if (s[i] != pre) {
pre = s[i];
continue;
}
if (s[i] == 'r') {
if (R == 0) {
res++;
pre = 'b';
B++;
} else {
pre = 'b';
R--;
}
} else {
if (B == 0) {
res++;
pre = 'r';
R++;
} else {
pre = 'r';
B--;
}
}
}
printf("%d\n", res < ans ? res : ans);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (long long)1e6 + 7;
const long long INF = (long long)2147483647;
const long long LINF = (long long)1e18;
const int MOD = (long long)1e4 + 7;
int n, a[100003], k;
string s;
int main() {
int bb1 = 0, bb2 = 0, br1 = 0, br2 = 0, ans1, ans2;
cin >> n;
cin >> s;
for (int i = 0; i < (int)n; i++) {
if (s[i] == 'r' && i % 2 == 0) br1++;
if (s[i] == 'b' && i % 2 == 1) bb1++;
}
ans1 = max(bb1, br1);
for (int i = 0; i < (int)n; i++) {
if (s[i] == 'r' && i % 2 == 1) br2++;
if (s[i] == 'b' && i % 2 == 0) bb2++;
}
ans2 = max(bb2, br2);
cout << min(ans1, ans2);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, i, counta, countb;
string s;
long long int rbr() {
long long int nb = 0, nr = 0, count = 0;
for (i = 0; i < n; i++) {
if ((i % 2) == 0) {
if (s[i] != 'r') nr++;
} else {
if (s[i] != 'b') nb++;
}
}
count = min(nr, nb);
count += (abs(nr - nb));
return count;
}
long long int brb() {
long long int nb = 0, nr = 0, count = 0;
for (i = 0; i < n; i++) {
if ((i % 2) == 0) {
if (s[i] != 'b') nb++;
} else {
if (s[i] != 'r') nr++;
}
}
count = min(nr, nb);
count += (abs(nr - nb));
return count;
}
int main() {
cin >> n >> s;
counta = rbr();
countb = brb();
cout << (min(counta, countb));
return 0;
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.