text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, ans = 0;
cin >> b;
int a[b][b];
for (int h = 0; h < b; h++)
for (int g = 0; g < b; g++) cin >> a[h][g];
for (int i = 0; i < b; i++) {
for (int j = 0; j < b; j++) {
if (a[i][j] != 1) {
ans = 0;
for (int x = 0; x < b; x++) {
for (int y = 0; y < b; y++) {
if (a[i][x] + a[y][j] == a[i][j]) ans = 1;
}
}
if (ans == 0) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
srand(time(NULL));
int n;
cin >> n;
vector<vector<int> > v(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> v[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (v[i][j] != 1) {
bool t = false;
for (int k = 0; k < n; k++) {
if (k != i) {
for (int l = 0; l < n; l++) {
if (l != j) {
if (v[i][j] == v[k][j] + v[i][l]) {
t = true;
break;
}
}
}
if (t) break;
}
}
if (!t) {
cout << "No";
return 0;
}
}
}
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100][100];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
{ cin >> a[i][j]; }
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int flag = 0;
if (a[i][j] == 1) {
continue;
}
for (int p = 0; p < n; p++) {
if (flag == 1) break;
for (int q = 0; q < n; q++) {
int sum = a[i][p] + a[q][j];
if (sum == a[i][j]) {
flag = 1;
break;
}
}
}
if (flag == 0) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m[55];
int arr[55][55];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int x = 0; x < n; x++) {
scanf("%d", &arr[i][x]);
m[i][arr[i][x]] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int x = 0; x < n; x++) {
bool b = 0;
for (int j = 0; j < n; j++) {
if (m[i][arr[i][x] - arr[j][x]]) b = 1;
}
if (!b && arr[i][x] != 1) {
printf("No");
return 0;
}
}
}
printf("Yes");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
int a[60][60];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
int flag = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int x = a[i][j];
if (x == 1) continue;
int flag2 = 0;
for (int s = 0; s < n; s++) {
for (int t = 0; t < n; t++) {
if (a[i][s] + a[t][j] == x) {
flag2 = 1;
}
}
}
if (flag2 == 0) flag = 0;
}
}
flag == 1 ? printf("Yes\n") : printf("No\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 1;
long long a[51][51], u[N];
long long n, m, k, l, r, x, y, z, cnt, ans, sum, mx = -1e18, mn = 1e18, T;
string s, t;
vector<pair<string, string> > v;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == 1) continue;
x = 0;
for (int k = 1; k <= n; k++) {
for (int l = 1; l <= n; l++) {
if (a[k][j] + a[i][l] == a[i][j] && k != i && l != j) {
x = 1;
break;
}
}
if (x) break;
}
if (!x) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, flag = 0, sum = 0;
cin >> n;
long long int a[52][52];
bool check = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1) continue;
check = false;
for (int s = 0; s < n; s++) {
if (s == i) continue;
for (int t = 0; t < n; t++) {
if (t == j) continue;
sum = a[s][j] + a[i][t];
if (sum == a[i][j]) {
check = true;
break;
}
}
if (check == true) break;
}
if (!check) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[55][55], n;
bool find(int x, int y) {
for (int i = 1; i <= n; i++) {
if (i == x) continue;
for (int j = 1; j <= n; j++) {
if (j == y) continue;
if (arr[i][y] + arr[x][j] == arr[x][y]) return true;
}
}
return false;
}
int main(int argc, char const *argv[]) {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> arr[i][j];
bool flag = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (arr[i][j] != 1) {
flag = min(flag, find(i, j));
if (!flag) break;
}
}
if (!flag) break;
}
if (flag)
puts("Yes");
else
puts("No");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 51;
int lab[N][N];
int n;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> lab[i][j];
}
}
bool flag_ = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (lab[i][j] == 1) continue;
bool flag = 0;
for (int row = 0; row < n; ++row) {
for (int col = 0; col < n; ++col) {
if (lab[i][col] + lab[row][j] == lab[i][j]) {
flag = 1;
break;
}
}
if (flag) break;
}
if (!flag) {
flag_ = 1;
break;
}
}
if (flag_) break;
}
cout << (flag_ ? "No" : "Yes") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r, c, f = 0;
bool s = true;
cin >> n;
int a[n][n];
for (int i = 0; n > i; i++) {
for (int j = 0; n > j; j++) {
cin >> a[i][j];
}
}
for (int i = 0; n > i; i++) {
for (int j = 0; n > j; j++) {
if (a[i][j] > 1) {
f = 0;
for (int k = 0; n > k; k++) {
for (int l = 0; n > l; l++) {
if (a[i][k] + a[l][j] == a[i][j]) f = 1;
}
}
if (!f) s = false;
}
}
}
if (s)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e10;
int main() {
int n;
int m[55][55];
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> m[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (m[i][j] != 1) {
bool ok = false;
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < n; jj++) {
if (m[i][jj] + m[ii][j] == m[i][j]) {
ok = true;
break;
}
}
}
if (!ok) {
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][n];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
bool flag = true;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (a[i][j] == 1) continue;
bool temp = false;
int x = 0;
while (temp == false && x < n) {
int y = 0;
while (temp == false && y < n) {
if (a[x][j] + a[i][y] == a[i][j])
temp = true;
else
++y;
}
++x;
}
if (temp == false) flag = false;
}
}
if (flag)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r, i;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long int power(long long int x, long long int y) {
long long int temp, ty, my;
long long int mod;
mod = 1000000007;
if (y == 0) return 1;
temp = power(x, y / 2);
ty = (temp % mod) * (temp % mod);
if (y % 2 == 0) {
return ty % mod;
} else {
my = (x % mod) * (ty % mod);
return my % mod;
}
}
long long int mini(long long int a, long long int b) { return a < b ? a : b; }
struct abhi {
long long int val;
long long int pos;
};
struct abhi brr[100010];
bool cmp(struct abhi x, struct abhi y) { return x.pos < y.pos; }
char ss[100010];
long long int a[1000][1000];
long long int b[100100];
vector<pair<int, int> > abhi;
int strr[1020];
int main() {
long long int t, m, i, i1, i2, n, r, c, w, j, k = 0, p, kk = 0;
cin >> n;
for (i = (0); i < (n); i++) {
for (j = (0); j < (n); j++) {
cin >> a[i][j];
}
}
long long int fg = 0;
for (i = (0); i < (n); i++) {
for (j = (0); j < (n); j++) {
if (a[i][j] != 1) {
long long int a1 = a[i][j];
long long int ft = 0;
for (i1 = 0; i1 < n; i1++) {
long long int a2 = a[i1][j];
for (i2 = 0; i2 < n; i2++) {
long long int a3 = a[i][i2];
if (a1 == (a2 + a3)) {
ft = 1;
break;
}
}
if (ft == 1) break;
}
if (ft == 0) {
fg = 1;
break;
}
}
if (fg == 1) break;
}
if (fg == 1) break;
}
if (fg == 0)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int aa[51][51];
int n, good;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &aa[i][j]);
}
}
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
if (aa[x][y] == 1) {
continue;
}
good = 0;
for (int s = 0; s < n; s++) {
for (int t = 0; t < n; t++) {
if (aa[x][s] + aa[t][y] == aa[x][y]) {
good = 1;
break;
}
}
}
if (!good) {
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> grid(n, vector<int>(n));
for (int r = 0; r < n; r++)
for (int c = 0; c < n; c++) cin >> grid[r][c];
bool is_good = true;
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++)
if (grid[x][y] != 1) {
bool decomposable = false;
for (int s = 0; s < n; s++)
for (int t = 0; t < n; t++)
decomposable |= grid[x][y] == grid[x][s] + grid[t][y];
if (!decomposable) is_good = false;
}
cout << (is_good ? "Yes" : "No") << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int SET(int n, int pos) { return n = n | (1 << pos); }
int RESET(int n, int pos) { return n = n & ~(1 << pos); }
int CHECK(int n, int pos) { return (bool)(n & (1 << pos)); }
int str2int(string s) {
stringstream ss(s);
int x;
ss >> x;
return x;
}
string int2str(int a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
string char2str(char a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
long long int bigMod(long long int n, long long int power, long long int MOD) {
if (power == 0) return 1;
if (power % 2 == 0) {
long long int ret = bigMod(n, power / 2, MOD);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((n % MOD) * (bigMod(n, power - 1, MOD) % MOD)) % MOD;
}
long long int modInverse(long long int a, long long int m) {
long long int m0 = m, t, q;
long long int x0 = 0, x1 = 1;
if (m == 1) return 0;
while (a > 1) {
q = a / m;
t = m;
m = a % m, a = t;
t = x0;
x0 = x1 - q * x0;
x1 = t;
}
if (x1 < 0) x1 += m0;
return x1;
}
int POW(int x, int y) {
int res = 1;
for (; y;) {
if ((y & 1)) {
res *= x;
}
x *= x;
y >>= 1;
}
return res;
}
int inverse(int x) {
double p = ((double)1.0) / x;
return (p) + 1e-9;
}
int gcd(int a, int b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int nC2(int n) { return n * (n - 1) / 2; }
long long int MOD(long long int n, long long int mod) {
if (n >= 0)
return n % mod;
else if (-n == mod)
return 0;
else
return mod + (n % mod);
}
int data[55][55];
int main() {
int t, cas = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &data[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (data[i][j] == 1) continue;
bool ff = 0;
for (int k = 0; k < n; k++) {
for (int l = 0; l < n; l++) {
if (data[i][k] + data[l][j] == data[i][j]) {
ff = 1;
}
}
}
if (!ff) {
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int s = 0;
int a[50][50];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
int h = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != 1) {
int e = 0;
for (int q = 0; q < n; q++) {
for (int w = 0; w < n; w++) {
if (a[i][q] + a[w][j] == a[i][j]) {
e++;
}
}
}
if (e == 0) {
s++;
}
}
}
}
if (s != 0) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][n];
int chk = 0;
bool temp = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[i][j] != 1) {
temp = false;
for (int k = 0; k < n; k++) {
for (int a = 0; a < n; a++) {
if (arr[i][j] == arr[i][k] + arr[a][j]) {
temp = true;
}
}
}
if (temp == false) {
i = n;
break;
}
}
}
}
if (temp == true || (n == 1 && arr[0][0] == 1))
cout << "yes";
else
cout << "no";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[60][60], ok;
bool isOk(int i, int j) {
for (int p = 0; p < n; ++p)
for (int q = 0; q < n; ++q)
if (a[i][p] + a[q][j] == a[i][j]) return true;
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (a[i][j] != 1 && !isOk(i, j)) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const nmax = 50;
int v[1 + nmax][1 + nmax];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> v[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (1 < v[i][j]) {
bool ok = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
if (v[i][y] + v[x][j] == v[i][j]) ok = 1;
if (ok == 0) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
const int OO = 0x3f3f3f3f;
const double EPS = 1e-9;
int main() {
int n, arr[55][55];
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> arr[i][j];
bool fl = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
bool b = (arr[i][j] == 1);
for (int s = 0; s < n; s++) {
for (int t = 0; t < n; t++) {
if (arr[i][j] != 1 and arr[i][j] == arr[i][s] + arr[t][j]) b = true;
if (b) break;
}
if (b) break;
}
fl = b;
if (!fl) break;
}
if (!fl) break;
}
cout << (fl ? "Yes\n" : "No\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int INF = 105000;
int a[N][N];
int n, ans = 0;
int get(int x, int y) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[x][i] + a[j][y] == a[x][y]) {
return true;
}
}
}
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1) {
ans++;
continue;
}
if (get(i, j)) {
ans++;
}
}
}
if (ans == n * n) {
cout << "Yes";
return 0;
}
cout << "No";
}
|
#include <bits/stdc++.h>
struct Problem {
virtual void main() = 0;
};
using namespace std;
struct A : Problem {
int n;
vector<vector<int>> v;
void main() override {
while (cin >> n) {
cout << solve() << endl;
}
}
bool check(int r, int c, int s) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s == v[r][i] + v[j][c]) {
return true;
}
}
}
return false;
}
string solve() {
v.resize(n, vector<int>(n));
for (auto& row : v)
for (auto& e : row) cin >> e;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (v[i][j] > 1 && !check(i, j, v[i][j])) {
return "No";
}
}
}
return "Yes";
}
};
struct B : Problem {
void main() override {}
};
struct C : Problem {
void main() override {}
};
int main() {
unique_ptr<Problem> ptr(new A());
ptr->main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100][100], n, row[55][100005], col[55][100005];
bool valid(int i, int j) {
for (int k = 0; k < n; k++) {
if (k == i) continue;
int x = a[i][j] - a[k][j];
if (x > 0 && row[i][x] && (x != a[i][j] || row[i][x] > 1)) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
row[i][a[i][j]]++;
col[j][a[i][j]]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j] != 1 && !valid(i, j)) {
printf("No\n");
return 0;
}
printf("Yes\n");
}
|
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
std::vector<std::vector<int>> lab(n);
for (int i = 0; i < n; ++i) lab[i].resize(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) std::cin >> lab[i][j];
}
bool good = true;
for (int i = 0; good && i < n; ++i)
for (int j = 0; good && j < n; ++j) {
if (lab[i][j] > 1) {
auto row = lab[i];
std::vector<int> col;
for (int k = 0; k < n; ++k) col.push_back(lab[k][j]);
bool found = false;
for (size_t p = 0; !found && p < row.size(); ++p)
for (size_t q = 0; !found && q < col.size(); ++q)
if (row[p] + col[q] == lab[i][j]) found = true;
if (!found) good = false;
}
}
if (good)
std::cout << "Yes" << std::endl;
else
std::cout << "No" << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, a[N][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] != 1) {
int flag = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
if (a[i][j] == a[i][x] + a[y][j]) flag = 1;
if (!flag) {
puts("No");
return 0;
}
}
puts("Yes");
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int mex = 400002;
int main() {
int n;
cin >> n;
int a[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
int fg = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a[i][j] != 1) {
int fg1 = 0;
for (int l = 0; l < n; l++)
for (int k = 0; k < n; k++) {
if (l != j && k != i)
if ((a[i][l] + a[k][j] == a[i][j])) fg1 = 1;
}
if (fg1 == 0) fg = 1;
}
}
if (fg)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int N;
int a[60][60];
int main() {
ios::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (a[i][j] == 1) continue;
bool good = false;
for (int k = 0; k < N && !good; k++) {
for (int l = 0; l < N; l++) {
if (a[i][j] == a[i][k] + a[l][j]) {
good = true;
break;
}
}
}
if (!good) {
cout << "No\n";
return 0;
}
}
}
cout << "Yes\n";
return 0;
}
|
#include <bits/stdc++.h>
int n, mat[52][52];
bool valid(int x, int y) {
if (mat[x][y] == 1) return true;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (mat[x][i] + mat[j][y] == mat[x][y]) return true;
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &mat[i][j]);
bool aux = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) aux &= valid(i, j);
printf("%s\n", aux ? "Yes" : "No");
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000][1000], b[10000];
int main() {
int i, ct = 0, n, m = 0, x, j, k, l, ck;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) cin >> a[i][j];
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i][j] != 1) {
ck = 0;
for (k = 0; k < n; k++) {
for (l = 0; l < n; l++) {
if (a[k][j] + a[i][l] == a[i][j]) {
ck = 1;
goto read;
}
}
}
read:
if (ck == 0) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 1, i = 0, j = 0, k = 0, x = 0;
int area[51][51] = {0};
cin >> n;
for (i = 0; i < n; i++)
for (x = 0; x < n; x++) cin >> area[i][x];
for (i = 0; i < n; i++)
for (x = 0; x < n; x++)
if (area[i][x] != 1) {
m = 1;
for (j = 0; j < n; j++) {
if (j == i) continue;
for (k = 0; k < n; k++) {
if (k == x) continue;
if (area[i][x] == area[j][x] + area[i][k]) {
m = 0;
break;
}
}
if (m == 0) break;
}
if (m == 1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[55][55];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != 1) {
int f = 0;
for (int p = 0; p < n; p++) {
if (p != i) {
for (int q = 0; q < n; q++) {
if (q != j) {
if (a[i][j] == a[p][j] + a[i][q]) {
f = 1;
}
}
}
}
}
if (f == 0) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[123][123];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (A[i][j] == 1) continue;
int x = A[i][j];
int flag = 0;
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < n; jj++) {
if (A[i][ii] + A[jj][j] == x) flag = 1;
}
}
if (flag == 0) {
cout << "No\n";
return 0;
}
}
}
cout << "Yes\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[55][55];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int flag = 0;
if (arr[i][j] == 1) continue;
for (int k = 0; k < n; ++k) {
for (int l = 0; l < n; ++l) {
if (arr[i][k] + arr[l][j] == arr[i][j]) flag = 1;
}
}
if (flag == 0) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[55][55];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != 1) {
int flag = 0;
for (int k = 0; k < n; k++) {
flag = 0;
if (k == i) continue;
for (int l = 0; l < n; l++) {
if (l == j) continue;
if (a[k][j] + a[i][l] == a[i][j]) {
flag = 1;
}
}
if (flag) {
break;
}
}
if (!flag) {
printf("No\n");
return 0;
}
}
}
}
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mat[50][50];
int isgood(int i, int j, int n) {
int s, ig = 0;
s = mat[i][j];
for (int ii = 0; ii < n; ii++)
for (int jj = 0; jj < n; jj++) {
if (mat[i][j] == 1 || (ii == i || jj == j))
continue;
else {
if ((mat[i][jj] + mat[ii][j]) == s) {
return 1;
}
}
}
return ig;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> mat[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (mat[i][j] != 1) {
if (!isgood(i, j, n)) {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T my_pow(T n, T p) {
if (p == 0) return 1;
T x = my_pow(n, p / 2);
x = (x * x);
if (p & 1) x = (x * n);
return x;
}
template <class T>
T big_mod(T n, T p, T m) {
if (p == 0) return (T)1;
T x = big_mod(n, p / 2, m);
x = (x * x) % m;
if (p & 1) x = (x * n) % m;
return x;
}
template <typename T>
T ModInverse(T n, T m) {
return BigMod(n, m - 2, m);
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
string itos(long long int n) {
string s;
while (n) {
s += (n % 10 + 48);
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long int stoi(string s) {
long long int n = 0;
for (__typeof(s.size()) i = 0; i < (s.size()); i++) n = n * 10 + (s[i] - 48);
return n;
}
const long long N = 5e5 + 5, MOD = 1e9 + 7;
long long int ar[55][55], A[55][55];
long long int a, b, c, r, rr, n, m, t, ks;
string s, ss;
int main() {
cin >> n;
for (__typeof(n) i = 0; i < (n); i++) {
for (__typeof(n) j = 0; j < (n); j++) {
cin >> ar[i][j];
}
}
for (__typeof(n) i = 0; i < (n); i++) {
for (__typeof(n) j = 0; j < (n); j++) {
if (ar[i][j] > 1) {
for (__typeof(n) k = 0; k < (n); k++) {
long long int aa = ar[i][k];
for (__typeof(n) l = 0; l < (n); l++) {
if (aa + ar[l][j] == ar[i][j]) {
A[i][j] = 1;
break;
}
}
if (A[i][j] == 1) break;
}
}
}
}
for (__typeof(n) i = 0; i < (n); i++) {
for (__typeof(n) j = 0; j < (n); j++) {
if (ar[i][j] > 1 and A[i][j] <= 0) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printRange(T &x) {
for (auto y : x) cout << y << ' ';
cout << endl;
}
const int maxn = 110;
int l[maxn];
int r[maxn];
int n;
map<int, bool> vis;
int counter = 1;
struct S {
int sar;
int tah;
};
map<int, S> bucket;
void dfs(int i) {
vis[i] = true;
if (l[i] == 0) bucket[counter].sar = i;
if (r[i] == 0) bucket[counter].tah = i;
if (!vis[l[i]] && l[i]) dfs(l[i]);
if (!vis[r[i]] && r[i]) dfs(r[i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
set<int> sar, tah;
for (int(i) = (1); (i) <= (n); (i)++) {
cin >> l[i] >> r[i];
}
for (int(i) = (1); (i) <= (n); (i)++) {
if (!vis[i]) {
dfs(i);
counter++;
}
}
for (int(i) = (1); (i) <= (counter - 2); (i)++) {
r[bucket[i].tah] = bucket[i + 1].sar;
l[bucket[i + 1].sar] = bucket[i].tah;
}
for (int(i) = (1); (i) <= (n); (i)++) {
cout << l[i] << ' ' << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 120;
int n;
int l[maxn], r[maxn];
set<int> s;
int go(int x) {
while (r[x]) x = r[x];
return x;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) s.insert(i);
}
int me = *s.begin();
s.erase(s.begin());
while (s.size()) {
me = go(me);
int nex = *s.begin();
s.erase(nex);
r[me] = nex;
l[nex] = me;
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int l, r;
};
p P[101];
bool can_move(int x, int y) {
int qw = x;
while (1) {
if (x == y) return true;
if (P[x - 1].r == 0) return false;
x = P[x - 1].r;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
p w;
w.l = l;
w.r = r;
P[i] = w;
}
for (int i = 0; i < n; i++) {
if (P[i].r == 0) {
for (int j = 0; j < n; j++) {
if (P[j].l == 0 && j + 1 != P[i].l && !can_move(j + 1, i + 1)) {
P[i].r = j + 1;
P[j].l = i + 1;
break;
}
}
}
}
for (int i = 0; i < n; i++) {
cout << P[i].l << " " << P[i].r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int l[N], r[N];
bool vis[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", l + i, r + i);
}
int last = 0;
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
r[last] = i;
l[i] = last;
int v = i;
while (r[v] != 0) v = r[v];
last = v;
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
int l = 0;
vector<int> v2(n, -1);
map<int, int> m;
for (int i = 0; i < n; i++) {
if (v2[i] == -1) {
if (v[i].first == 0) {
int j = i;
m[l] = j;
while (j != -1) {
v2[j] = l;
j = v[j].second - 1;
}
l++;
}
}
}
for (int i = 0; i < n; i++) {
if (v[i].second == 0) {
int p = v2[i] + 1;
if (p == l) {
continue;
}
v[i].second = m[p] + 1;
v[m[p]].first = i + 1;
}
}
for (int i = 0; i < n; i++) {
cout << v[i].first << " " << v[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[110], r[110];
queue<int> Q;
int n;
int find_left(int x) {
while (l[x] != 0) {
x = l[x];
}
return x;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i];
cin >> r[i];
}
for (int i = 1; i <= n; i++) {
if (r[i] == 0) Q.push(i);
}
int tem, now = Q.front(), cur;
Q.pop();
while (!Q.empty()) {
cur = Q.front();
Q.pop();
tem = find_left(cur);
l[tem] = now;
r[now] = tem;
now = cur;
}
for (int i = 1; i <= n; i++) cout << l[i] << ' ' << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
int l[MAXN], r[MAXN];
vector<int> nlf, nrg;
bool used[MAXN];
vector<int> comp[MAXN];
void dfs(int v, int c) {
if (!v) return;
used[v] = 1;
comp[c].push_back(v);
dfs(r[v], c);
}
void solve() {
int n;
int ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
int top = 0;
for (int i = 1; i <= n; i++) {
if (used[i] || l[i]) continue;
dfs(i, top++);
}
for (int i = 0; i < top - 1; i++) {
int id = comp[i].back();
int id2 = comp[i + 1][0];
r[id] = id2;
l[id2] = id;
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l[105], r[105];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin >> n;
vector<int> left, zero;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) left.push_back(i);
}
int last = 0;
for (int i = 0; i < (left.size()); i++) {
l[left[i]] = last;
int mid = left[i], right = r[left[i]];
while (right != 0) {
mid = right;
right = r[mid];
}
if (i + 1 < left.size()) r[mid] = left[i + 1];
last = mid;
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> nexti[1005], previ[1005];
int visit[1005];
vector<int> f;
void func(int s) {
int pp = s;
while (pp != 0) {
s = pp;
pp = previ[pp][0];
}
while (s != 0) {
visit[s] = 1;
f.push_back(s);
s = nexti[s][0];
}
}
int main() {
int N, i, j, k;
cin >> N;
for (i = 1; i <= N; i++) {
int l, r;
cin >> l >> r;
nexti[i].push_back(r);
previ[i].push_back(l);
}
for (i = 1; i <= N; i++) {
if (!visit[i]) {
func(i);
}
}
for (i = 1; i <= N; i++) {
int p, n;
for (j = 0; j < f.size(); j++) {
if (f[j] == i) {
if (j == 0)
p = 0;
else
p = f[j - 1];
if (j == f.size() - 1)
n = 0;
else
n = f[j + 1];
break;
}
}
cout << p << " " << n << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> arr[1001];
vector<int> answer;
int visited[1002];
int main() {
cin >> n;
int a, b;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
arr[i] = {a, b};
}
int current = 0;
int counter = 0;
while (counter < n) {
if (counter != 0 && arr[current].second != 0) {
answer.push_back(arr[current].second);
counter++;
current = arr[current].second;
} else
for (int i = 1; i <= n; i++) {
if (arr[i].first == 0 && !visited[i]) {
visited[i] = 1;
answer.push_back(i);
counter++;
current = i;
break;
}
}
}
int lookingfor = 1;
answer.push_back(0);
answer.insert(answer.begin(), 0);
while (lookingfor <= n) {
for (int i = 0; i < answer.size(); i++)
if (answer[i] == lookingfor) {
cout << answer[i - 1] << " " << answer[i + 1] << endl;
lookingfor++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int m) {
long long int pp = (b == 0) ? 1 : power(a, b >> 1, m);
pp = (pp * pp) % m;
if (b & 1) pp = (pp * a) % m;
return pp;
}
vector<long long int> v1;
long long int l[105], r[105];
signed main() {
long long int n;
scanf("%lld", &(n));
long long int st = 0;
for (long long int i = 1; i <= n; i++) {
scanf("%lld", &(l[i]));
scanf("%lld", &(r[i]));
if (l[i] == 0 && st == 0)
st = i;
else if (l[i] == 0)
v1.emplace_back(i);
}
if (n == 1) {
cout << l[1] << " " << r[1];
return 0;
}
long long int cur = st;
long long int j = 0;
while (j < v1.size()) {
if (r[cur] != 0)
cur = r[cur];
else {
r[cur] = v1[j];
l[v1[j]] = cur;
cur = v1[j];
j++;
}
}
for (long long int i = 1; i <= n; i++) printf("%lld %lld\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int L[101] = {}, R[101] = {};
for (int i = 1; i <= n; i++) cin >> L[i] >> R[i];
bool visited[101] = {};
vector<int> ats = {0};
int pos[101] = {};
for (int i = 1; i <= n; i++)
if (!visited[i]) {
int first = i;
while (L[first] != 0) first = L[first];
while (first != 0) {
visited[first] = 1;
ats.push_back(first);
pos[first] = ats.size() - 1;
first = R[first];
}
}
ats.push_back(0);
for (int i = 1; i <= n; i++)
cout << ats[pos[i] - 1] << " " << ats[pos[i] + 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int N;
int L[MAXN];
int R[MAXN];
vector<int> v;
int main() {
ios::sync_with_stdio(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> L[i] >> R[i];
if (L[i] == 0) v.push_back(i);
}
for (int i = 0, prv = 0; i < v.size(); i++) {
int cur = v[i];
R[prv] = cur;
L[cur] = prv;
while (R[cur] != 0) cur = R[cur];
prv = cur;
}
for (int i = 1; i <= N; i++) cout << L[i] << " " << R[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_map<int64_t, pair<int64_t, int64_t>> mp;
vector<vector<int64_t>> adj, comp;
vector<bool> vis;
vector<int64_t> lis;
void dfs(int64_t s) {
if (vis[s]) return;
vis[s] = 1;
lis.push_back(s + 1);
for (auto& x : adj[s]) {
if (!vis[x]) dfs(x);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int64_t n;
cin >> n;
adj.resize(n);
vis.resize(n, false);
vector<int64_t> trav;
for (int64_t i = 0; i < n; ++i) {
int64_t l, r;
cin >> l >> r;
mp[i + 1] = {l, r};
--l, --r;
if (l == -1) trav.push_back(i);
if (l != -1) adj[i].push_back(l);
if (r != -1) adj[i].push_back(r);
}
for (int64_t i = 0; i < trav.size(); ++i) {
if (!vis[trav[i]]) {
dfs(trav[i]);
comp.push_back(lis);
lis.clear();
}
}
if (comp.size() > 1) {
for (int64_t i = 0; i < comp.size() - 1; ++i) {
mp[comp[i].back()].second = comp[i + 1].front();
mp[comp[i + 1].front()].first = comp[i].back();
}
}
for (int64_t i = 1; i <= n; ++i)
cout << mp[i].first << ' ' << mp[i].second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
int n;
while (~scanf("%d", &n)) {
vector<int> next(n, -1);
vector<int> roots;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
int l;
int r;
scanf("%d%d", &l, &r), --l, --r;
next[i] = r;
if (l == -1) roots.push_back(i);
}
vector<int> seq;
for (int i : roots) {
for (int j = i; j != -1; j = next[j]) seq.push_back(j);
}
vector<pair<int, int>> ans(n, make_pair(-1, -1));
for (int(ix) = 0; (ix) < (int)(n); ++(ix))
ans[seq[ix]] = {ix == 0 ? -1 : seq[ix - 1],
ix == n - 1 ? -1 : seq[ix + 1]};
for (int i = 0; i < (int)ans.size(); ++i)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
long long int M = 1e9 + 7;
void MultL(long long int &a, long long int b) { a = (a * b) % M; }
void AddL(long long int &a, long long int b) { a = (a + (b + M)) % M; }
long long int Mult(long long int a, long long int b) { return (a * b) % M; }
long long int Add(long long int a, long long int b) {
return (a + (b + M)) % M;
}
using namespace std;
int findR(int v, vector<int> &x1, vector<int> &x2, vector<bool> &was) {
for (int i = 0; i < x1.size(); ++i) {
if (was[i]) continue;
if (x1[i] == v) {
was[i] = true;
return i;
}
}
return -1;
}
int findL(int v, vector<int> &x1, vector<int> &x2, vector<bool> &was) {
for (int i = 0; i < x2.size(); ++i) {
if (was[i]) continue;
if (x2[i] == v) {
was[i] = true;
return i;
}
}
return -1;
}
deque<int> getList(vector<int> &x1, vector<int> &x2, vector<bool> &was) {
deque<int> list;
for (int i = 0; i < was.size(); ++i) {
if (!was[i]) {
list.push_back(x1[i]);
list.push_back(x2[i]);
was[i] = true;
break;
}
}
while (true) {
int r = list.back();
if (r == 0) {
break;
}
int e = findR(r, x1, x2, was);
if (e == -1) break;
list.push_back(x2[e]);
}
while (true) {
int r = list.front();
if (r == 0) {
break;
}
if (r == 0) break;
int e = findL(r, x1, x2, was);
if (e == -1) break;
list.push_front(x1[e]);
}
return list;
}
int main() {
int n;
cin >> n;
vector<int> x0(n);
vector<int> x1(n);
vector<int> x2(n);
vector<bool> was(n, false);
for (int i = 0; i < n; ++i) {
cin >> x0[i] >> x2[i];
x1[i] = i + 1;
}
vector<int> list;
for (int i = 0; i < n; ++i) {
if (x0[i] == 0) {
list.push_back(x1[i]);
int r = x2[i];
while (r) {
list.push_back(r);
for (int j = 0; j < n; ++j) {
if (x1[j] == r) {
r = x2[j];
break;
}
}
}
}
}
for (int i = 0; i < list.size(); ++i) {
if (i == 0)
x0[list[i] - 1] = 0;
else
x0[list[i] - 1] = list[i - 1];
if (i == list.size() - 1)
x2[list[i] - 1] = 0;
else
x2[list[i] - 1] = list[i + 1];
}
for (int i = 0; i < n; ++i) {
cout << x0[i] << ' ' << x2[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int l[200], r[200], used[200];
int cl[200], cr[200], color[200];
void dfs(int v, int col, int dir) {
color[v] = col;
if (dir == 1) {
if (l[v] == 0)
cl[col] = v;
else
dfs(l[v], col, dir);
} else {
if (r[v] == 0)
cr[col] = v;
else
dfs(r[v], col, dir);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
++cnt;
dfs(i, cnt, 1);
dfs(i, cnt, 2);
}
}
for (int i = 2; i <= cnt; i++) {
l[cl[i]] = cr[i - 1];
r[cr[i - 1]] = cl[i];
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > fr;
pair<int, int> ans[105], t[105];
int main() {
ios_base::sync_with_stdio(0);
int n, x, y, k, p;
pair<int, int> q;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
t[i] = make_pair(x, y);
if (x == 0 && y == 0) {
fr.push_back(make_pair(i, 0));
} else if (x == 0) {
fr.push_back(make_pair(i, y));
} else {
ans[i] = make_pair(x, y);
}
}
for (int i = 0; i < fr.size(); i++) {
k = fr[i].first;
p = fr[i].second;
while (p != 0) {
k = p;
p = t[k].second;
}
if (i == 0) {
ans[fr[i].first] = make_pair(0, fr[i].second);
}
if (i == fr.size() - 1) {
ans[k] = make_pair(t[k].first, 0);
} else {
ans[k] = make_pair(t[k].first, fr[i + 1].first);
ans[fr[i + 1].first] = make_pair(k, fr[i + 1].second);
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int find(vector<int> &parent, int x) {
if (parent[x] == -1) {
return x;
} else {
return parent[x] = find(parent, parent[x]);
}
}
void merge(vector<int> &parent, vector<int> &size, int u, int v) {
int x = find(parent, u);
int y = find(parent, v);
if (x != y) {
if (size[x] >= size[y]) {
parent[y] = x;
size[x] += size[y];
} else {
parent[x] = y;
size[y] += size[x];
}
}
}
int main() {
int n;
cin >> n;
vector<int> parent(n, -1);
vector<int> size(n, 1);
vector<pair<int, int>> v;
int countf = 0, counte = 0;
stack<int> ste;
stack<int> stf;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back(make_pair(x - 1, y - 1));
if (x == 0 && y != 0) {
countf++;
merge(parent, size, i, y - 1);
stf.push(i);
}
if (y == 0 && x != 0) {
counte++;
merge(parent, size, x - 1, i);
ste.push(i);
}
if (x != 0 && y != 0) {
merge(parent, size, x - 1, i);
merge(parent, size, i, y - 1);
}
if (x == 0 && y == 0) {
ste.push(i);
stf.push(i);
counte++;
countf++;
}
}
while (counte > 1) {
int a = ste.top();
int b = stf.top();
ste.pop();
stf.pop();
int c;
while (find(parent, a) == find(parent, b) && !stf.empty()) {
c = stf.top();
stf.pop();
stf.push(b);
b = c;
}
v[a].second = b;
v[b].first = a;
merge(parent, size, a, b);
counte--;
countf--;
}
for (int i = 0; i < n; i++) {
int a1 = v[i].first;
int a2 = v[i].second;
cout << a1 + 1 << " " << a2 + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using max_pq = priority_queue<T>;
template <class T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
long long int x, y;
template <class T>
T gcd(T a, T b) {
if (a == 0) {
x = 0, y = 1;
return b;
}
T gc = gcd(b % a, a);
T temp;
temp = x;
x = y - (b / a) * temp;
y = temp;
return gc;
}
long long int po(long long int a, long long int x) {
if (x == 0) {
return 1;
}
long long int ans = 1;
long long int k = 1;
while (k <= x) {
if (x & k) {
ans = ((ans * a));
}
k <<= 1;
a *= a;
}
return ans;
}
pair<int, int> val[105];
vector<int> l, r;
int main() {
int n;
cin >> n;
int i;
for (i = 1; i <= n; i++) {
cin >> val[i].first >> val[i].second;
if (!val[i].first) {
l.push_back(i);
}
if (!val[i].second) {
r.push_back(i);
}
}
if (l.size() > 1) {
int k = 1;
while (k < l.size()) {
int second = l[k - 1];
while (val[second].second != 0) {
second = val[second].second;
}
val[second].second = l[k];
val[l[k]].first = second;
k++;
}
}
for (i = 1; i <= n; i++) {
cout << val[i].first << " " << val[i].second << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int l[N], r[N], n, was[N];
void load() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
}
void solve() {
int toBind = 0;
for (int i = 1; i <= n; i++)
if (l[i] == 0 && was[i] == 0) {
if (toBind != 0) {
r[toBind] = i;
l[i] = toBind;
}
int v = i;
while (true) {
was[v] = true;
if (r[v] == 0) break;
v = r[v];
}
toBind = v;
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
load();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
vector<int> v;
vector<pair<int, int> > inp(n + 1);
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
inp[i].first = x;
inp[i].second = y;
a[x] = i;
a[i] = y;
if (x == 0) v.push_back(i);
}
int curr, prev = 0;
for (int i = 0; i < v.size(); i++) {
curr = v[i];
while (true) {
if (a[curr] == 0) break;
prev = curr;
curr = a[curr];
}
if (i < (v.size() - 1)) {
inp[curr].second = v[i + 1];
inp[v[i + 1]].first = curr;
prev = curr;
}
}
for (int i = 1; i < inp.size(); i++)
cout << inp[i].first << " " << inp[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000 + 10;
int n, m, p;
int l[maxn], r[maxn];
int a[maxn], b[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &l[i], &r[i]);
for (int i = 1; i <= n; i++) {
if (l[i] && r[l[i]] == 0) r[l[i]] = i;
if (r[i] && l[r[i]] == 0) l[r[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
p = i;
a[++m] = p;
while (r[p] != 0) p = r[p];
b[m] = p;
}
}
if (m >= 2) {
for (int i = 1; i <= m; i++) {
if (i > 1) l[a[i]] = b[i - 1];
if (i < n) r[b[i]] = a[i + 1];
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << "(";
os << v.first << "," << v.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
long long sz = v.size();
for (long long i = 0; i < sz; ++i) {
os << v[i];
if (i != sz - 1) os << ",";
}
os << "]\n";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
T last = *v.rbegin();
os << "[";
for (auto it : v) {
os << it;
if (it != last) os << ",";
}
os << "]\n";
return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const map<T, S> &v) {
for (auto it : v) {
os << it.first << " : " << it.second << "\n";
}
return os;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) {
res = (res * a) % 1000000007;
}
b /= 2;
a = (a * a) % 1000000007;
}
return res;
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long N = 105;
long long l[N], r[N];
long long head_list[N], tail_list[N];
long long vis[N], which[N], start[N], endd[N];
void dfs(long long node, long long lis) {
if (!node) return;
which[node] = lis;
vis[node] = 1;
if (l[node] == 0) head_list[lis] = node;
if (r[node] == 0) tail_list[lis] = node;
dfs(r[node], lis);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (__typeof(1) i = 1; i <= n; i++) cin >> l[i] >> r[i];
for (__typeof(1) i = 1; i <= n; i++) start[i] = l[i] == 0;
for (__typeof(1) i = 1; i <= n; i++) endd[i] = r[i] == 0;
long long lis = 0;
for (__typeof(1) i = 1; i <= n; i++) {
if (start[i] && !vis[i]) {
++lis;
dfs(i, lis);
}
}
if (lis > 1) {
for (long long i = 2; i <= lis; ++i) {
r[tail_list[i - 1]] = head_list[i];
l[head_list[i]] = tail_list[i - 1];
}
}
for (__typeof(1) i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void rs(int &x) { scanf("%d", &x); }
void rsl(long long &x) { scanf("%I64d", &x); }
void rsd(double &x) { scanf("%lf", &x); }
void rss(char *str) { scanf("%s", str); }
void ws(int &x) { printf("%d ", x); }
void wsl(long long &x) { printf("%I64d ", x); }
void wsd(double &x) { printf("%lf ", x); }
void wss(char *str) { printf("%s ", str); }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int const N = (1e5) + 5;
int const mod = (1e9) + 7;
int l[105], r[105];
vector<int> beg;
int main() {
ios::sync_with_stdio(false);
ifstream in("input.txt");
ofstream out("output.txt");
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> l[i] >> r[i];
if (l[i] == 0) {
beg.push_back(i);
}
}
int st = beg.back();
beg.pop_back();
while (r[st] > 0) {
st = r[st];
}
while (beg.size() > 0) {
int cb = beg.back();
beg.pop_back();
r[st] = cb;
l[cb] = st;
while (r[cb] > 0) {
cb = r[cb];
}
st = cb;
}
for (int i = 1; i <= n; ++i) {
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<T> &operator+=(vector<T> &v, T x) {
v.push_back(x);
return v;
}
int n, l[105], r[105];
bool v[105];
void dfs(int k) {
v[k] = 1;
if (r[k]) {
dfs(r[k]);
return;
}
for (int i = (1), _b_ = (n + 1); i < _b_; i++) {
if (i != k && !l[i] && !v[i]) {
l[i] = k;
r[k] = i;
dfs(i);
return;
}
}
}
void solve() {
cin >> n;
for (int i = (1), _b_ = (n + 1); i < _b_; i++) cin >> l[i] >> r[i];
int k = -1;
memset(v, 0, sizeof(v));
for (int i = (1), _b_ = (n + 1); i < _b_; i++)
if (!l[i]) {
k = i;
break;
}
dfs(k);
for (int i = (1), _b_ = (n + 1); i < _b_; i++)
cout << l[i] << ' ' << r[i] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-7;
const int N = 200000 + 10, maxn = 60000 + 10, inf = 0x3f3f3f;
int l[N], r[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v1, v2;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) v1.push_back(i);
if (r[i] == 0) v2.push_back(i);
}
int cnt = 0;
int be = v1[cnt], now = be;
while (cnt + 1 < v1.size()) {
while (r[now] != 0) now = r[now];
++cnt;
r[now] = v1[cnt];
l[v1[cnt]] = now;
now = v1[cnt];
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
vector<int> a;
int ans[105][2];
int fi[105];
vector<pair<int, int> > gg;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &ans[i][0], &ans[i][1]);
if (ans[i][0] == 0) a.push_back(i);
}
for (int i = 0; i < a.size(); ++i) {
int t = a[i];
while (ans[t][1]) t = ans[t][1];
gg.push_back(make_pair(a[i], t));
}
for (int i = 1; i < gg.size(); ++i) {
int x = gg[i - 1].second;
int y = gg[i].first;
ans[x][1] = y;
ans[y][0] = x;
}
for (int i = 1; i <= n; ++i) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct el {
int l, r, i;
};
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int l[102], r[102];
vector<vector<int>> lists;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
int cur = i;
vector<int> curList;
while (cur != 0) {
curList.push_back(cur);
cur = r[cur];
}
lists.push_back(curList);
}
}
for (int i = 0; i < lists.size() - 1; i++) {
vector<int> a = lists[i], b = lists[i + 1];
int ra = a[a.size() - 1], lb = b[0];
r[ra] = lb;
l[lb] = ra;
}
cout << endl;
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 110;
int l[M], r[M];
vector<int> ss;
int n;
int ansl[M], ansr[M];
void dfs(int o) {
if (o == 0) return;
ss.emplace_back(o);
dfs(r[o]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", l + i, r + i);
}
for (int i = 1; i <= n; ++i)
if (l[i] == 0) {
ss.emplace_back(i);
dfs(r[i]);
}
for (int i = 0; i < ss.size(); ++i) {
ansl[ss[i]] = i == 0 ? 0 : ss[i - 1];
ansr[ss[i]] = i == ss.size() - 1 ? 0 : ss[i + 1];
}
for (int i = 1; i <= n; ++i) {
printf("%d %d\n", ansl[i], ansr[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int d, l, r;
Node(int a, int b, int c) {
d = a;
l = b;
r = c;
}
};
int rec(vector<Node> &v, int idx) {
if (v[idx].r == 0) return idx;
return rec(v, v[idx].r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b;
cin >> n;
vector<Node> v(n + 1, Node(0, 0, 0));
queue<int> q;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
v[i] = Node(i, a, b);
if (a == 0) q.push(i);
}
vector<bool> marker(n + 1, false);
int prev = -1;
while (!q.empty()) {
int curr = q.front();
q.pop();
int nxt = rec(v, curr);
if (prev != -1) {
v[curr].l = prev;
v[prev].r = curr;
prev = nxt;
} else
prev = nxt;
}
for (int i = 1; i <= n; i++) cout << v[i].l << " " << v[i].r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> vect(n + 1);
set<int, less<int>> left_open;
for (int i = 1; i <= n; i++) {
cin >> vect[i].first >> vect[i].second;
if (vect[i].first == 0) left_open.insert(i);
}
vector<int> final_list;
final_list.push_back(0);
int x;
for (auto it = left_open.begin(); it != left_open.end(); it++) {
x = *it;
final_list.push_back(x);
while (vect[x].second != 0) {
final_list.push_back(vect[x].second);
x = vect[x].second;
}
}
final_list.push_back(0);
for (int i = 1; i <= n; i++) {
vect[final_list[i]].first = final_list[i - 1];
vect[final_list[i]].second = final_list[i + 1];
}
for (int i = 1; i <= n; i++) {
cout << vect[i].first << " " << vect[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct x {
int l;
int r;
};
int main() {
int n, k = 0, a, b;
cin >> n;
x t[n];
for (int i = 0; i < n; i++) cin >> t[i].l >> t[i].r;
for (int i = 0; i < n; i++) {
if (t[i].l == 0) k++;
}
while (k > 1) {
for (int i = 0; i < n; i++) {
if (t[i].l == 0) a = i;
b = a;
}
while (t[a].r != 0) a = t[a].r - 1;
for (int i = 0; i < n; i++) {
if (i != a && t[i].r == 0) {
t[b].l = i + 1;
t[i].r = b + 1;
break;
}
}
a = 0;
k--;
}
for (int i = 0; i < n; i++) cout << t[i].l << " " << t[i].r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> m(200005);
vector<int> v;
int k = 0;
bool vi[200005];
void dfs(int i) {
vi[i] = true;
for (int j = 0; j < m[i].size(); j++) {
if (!vi[m[i][j]]) dfs(m[i][j]);
}
if (m[i].size() == 1) k = i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
if (x > 0)
m[i].push_back(x);
else
v.push_back(i);
if (y > 0) m[i].push_back(y);
}
vi[0] = true;
for (int i = 0; i < v.size(); i++) {
if (!vi[v[i]]) {
m[k].push_back(v[i]);
m[v[i]].insert(m[v[i]].begin(), k);
dfs(v[i]);
}
}
cout << "\n";
for (int i = 1; i <= n; i++) {
if (m[i].size() == 2) {
if (m[i][1] == 0)
cout << m[i][1] << " " << m[i][0];
else
cout << m[i][0] << " " << m[i][1];
} else if (m[i].size() == 1) {
cout << m[i][0] << " 0";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[105], nxt[105];
bool vis[105];
int main() {
int n;
scanf("%d", &n);
int head = 0x3f3f3f3fLL, tail = -1;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &pre[i], &nxt[i]);
if (!pre[i]) head = min(head, i);
}
for (int i = head; i != 0; i = nxt[i]) {
vis[i] = 1;
if (nxt[i] == 0) {
for (int j = 1; j <= n; j++) {
if (!pre[j] && !vis[j]) {
pre[j] = i;
nxt[i] = j;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", pre[i], nxt[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, arr[105][2], m, vis[105];
int serr(int idx) {
vis[idx] = 1;
if (!arr[idx][1]) return idx;
return serr(arr[idx][1]);
}
int serl(int idx) {
vis[idx] = 1;
if (!arr[idx][0]) return idx;
return serl(arr[idx][0]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &arr[i][0], &arr[i][1]);
m += arr[i][0] == 0;
}
int idx = serr(1);
serl(1);
while (m - 1) {
int tem = 1, i;
while (tem <= n && vis[tem]) tem++;
i = serl(tem);
arr[idx][1] = i;
arr[i][0] = idx;
idx = serr(tem);
m--;
}
for (int i = 1; i <= n; i++) cout << arr[i][0] << ' ' << arr[i][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int nxt[n + 1];
vector<int> sq_st, sq;
for (int i = 1; i <= n; i++) {
int u, v;
cin >> u >> v;
if (u == 0)
sq_st.push_back(i);
else
nxt[u] = i;
nxt[i] = v;
}
for (int i = 0; i < sq_st.size(); i++) {
int x = sq_st[i];
sq.push_back(x);
while (nxt[x]) {
x = nxt[x];
sq.push_back(x);
}
}
int pre[n + 1];
memset(nxt, 0, sizeof(nxt));
int m = sq.size();
for (int i = 0; i < m; i++) {
if (!i) {
pre[sq[i]] = 0;
if (i + 1 == m)
nxt[sq[i]] = 0;
else
nxt[sq[i]] = sq[i + 1];
} else if (i + 1 == m) {
pre[sq[i]] = sq[i - 1];
nxt[sq[i]] = 0;
} else {
pre[sq[i]] = sq[i - 1];
nxt[sq[i]] = sq[i + 1];
}
}
for (int i = 1; i <= n; i++) cout << pre[i] << " " << nxt[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> r, start, res;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (!a) {
start.push_back(i + 1);
}
cin >> a;
r.push_back(a);
}
for (int i = 0; i < start.size(); i++) {
res.push_back(start[i]);
int pos = start[i] - 1;
while (r[pos]) {
res.push_back(r[pos]);
pos = r[pos] - 1;
}
}
for (int i = 1; i <= res.size(); i++) {
for (int j = 0; j < res.size(); j++) {
if (i == res[j]) {
if (!j)
cout << 0 << ' ';
else
cout << res[j - 1] << ' ';
if (j == res.size() - 1)
cout << 0 << endl;
else
cout << res[j + 1] << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
long long add(long long a, long long b, long long m = 1000000007) {
long long ret = a + b;
if (ret >= m) ret -= m;
return ret;
}
long long subtract(long long a, long long b, long long m = 1000000007) {
long long ret = a - b;
if (ret < 0) ret += m;
return ret;
}
long long mult(long long a, long long b, long long m = 1000000007) {
long long ret = a * b;
if (ret >= m) ret %= m;
return ret;
}
long long bigmod(long long a, long long b, long long m = 1000000007) {
long long ret = 1;
while (b) {
if (b & 1) ret = mult(ret, a, m);
b >>= 1;
a = mult(a, a, m);
}
return ret;
}
long long inverse(long long n, long long m = 1000000007) {
return bigmod(n, 1000000007 - 2, m);
}
int n, l[110], r[110], vis[110];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
}
int prev = 0;
for (int i = 1; i <= n; ++i)
if (l[i] == 0 && vis[i] == 0) {
int head = i;
vis[i] = 1;
int id = i;
while (r[id]) {
id = r[id];
vis[id] = 1;
}
if (prev) {
r[prev] = head;
l[head] = prev;
}
prev = id;
}
for (int i = 1; i <= n; ++i) printf("%d %d\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int used[110], l[105], r[105];
vector<int> v[110];
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] > 0) v[i].push_back(l[i]);
if (r[i] > 0) v[i].push_back(r[i]);
if (l[i] > 0) v[l[i]].push_back(i);
if (r[i] > 0) v[r[i]].push_back(i);
}
int cmp = 0, ll = 0, rr = 0;
for (int i = 1; i <= n; i++) {
int left = 0, right = 0;
if (used[i] == 0) {
queue<int> q;
q.push(i);
used[i] = 1;
while (!q.empty()) {
int t = q.front();
q.pop();
if (l[t] == 0) left = t;
if (r[t] == 0) right = t;
for (int j = 0; j < v[t].size(); j++) {
if (used[v[t][j]] == 0) {
used[v[t][j]] = 1;
q.push(v[t][j]);
if (l[v[t][j]] == 0) left = v[t][j];
if (r[v[t][j]] == 0) right = v[t][j];
}
}
}
cmp++;
if (cmp > 1) {
l[left] = rr;
r[rr] = left;
}
ll = left, rr = right;
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, i, j, L[101], R[101], H[102], Z = 1;
int main() {
cin >> N;
for (i = 1; i <= N; i++) {
cin >> L[i] >> R[i];
}
for (i = 1; i <= N; i++) {
if (L[i] == 0) {
for (j = i; j != 0; j = R[j]) {
H[Z] = j;
Z++;
}
}
}
for (i = 1; i <= N; i++) {
L[H[i]] = H[i - 1];
R[H[i]] = H[i + 1];
}
for (i = 1; i <= N; i++) {
cout << L[i] << ' ' << R[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l[128], r[128], x, y, flag;
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
x = y = flag = 1;
while (l[x]) x = l[x];
while (flag) {
flag = 0;
while (r[y]) y = r[y];
for (int i = 1; i <= n; i++)
if (!l[i] && i != x) {
l[i] = y;
r[y] = i;
flag = 1;
break;
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const size_t MAXN = 123;
class Node {
public:
int left, right;
Node() : left(0), right(0) {}
Node(int left, int right) : left(left), right(right) {}
};
Node cell[MAXN];
vector<Node> segments;
bitset<MAXN> visited;
int walkLeft(int node) {
visited[node] = 1;
if (cell[node].left == 0) return node;
return walkLeft(cell[node].left);
}
int walkRight(int node) {
visited[node] = 1;
if (cell[node].right == 0) return node;
return walkRight(cell[node].right);
}
void transverse(int node) {
segments.push_back({walkLeft(node), walkRight(node)});
visited[node] = 1;
}
void connectSegments(int first, int second) {
cell[first].right = second;
cell[second].left = first;
}
int main() {
int N;
scanf(" %d", &N);
for (int i = 1; i <= N; i++) {
scanf(" %d %d", &cell[i].left, &cell[i].right);
}
for (int i = 1; i <= N; i++) {
if (!visited[i]) transverse(i);
}
for (int i = 0; i + 1 < segments.size(); i++) {
connectSegments(segments[i].right, segments[i + 1].left);
}
for (int i = 1; i <= N; i++) {
printf("%d %d\n", cell[i].left, cell[i].right);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)2e5 + 7;
const long long inf = (long long)1e18;
const int infint = (int)2e9;
int l[MAXN], r[MAXN], visited[MAXN];
vector<int> v[MAXN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
int j = i;
while (l[j] != 0) j = l[j];
while (true) {
v[ans].push_back(j);
visited[j] = 1;
if (r[j] == 0)
break;
else
j = r[j];
}
ans++;
}
}
for (int i = 0; i < ans - 1; i++) {
r[v[i].back()] = v[i + 1][0];
l[v[i + 1][0]] = v[i].back();
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[101][3], k, z;
vector<int> v[100];
bool f;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][2];
a[i][1] = i + 1;
}
while (k < n) {
f = false;
for (int i = 0; i < n; i++)
if (a[i][1] != -1) {
v[z].push_back(a[i][0]);
v[z].push_back(a[i][1]);
v[z].push_back(a[i][2]);
a[i][1] = -1;
k++;
f = true;
break;
}
if (f)
for (int j = 0; j < n; j++)
for (int i = 0; i < n; i++)
if (a[i][1] != -1) {
if (a[i][0] == v[z][v[z].size() - 2] && a[i][1] == v[z].back()) {
v[z].push_back(a[i][2]);
a[i][1] = -1;
k++;
} else if (a[i][1] == v[z][0] && a[i][2] == v[z][1]) {
v[z].insert(v[z].begin(), a[i][0]);
a[i][1] = -1;
k++;
}
}
z++;
}
v[0].erase(v[0].end() - 1);
for (int i = 1; i < z; i++)
for (int j = 1; j < v[i].size() - 1; j++) v[0].push_back(v[i][j]);
v[0].push_back(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j < v[0].size() - 1; j++)
if (v[0][j] == i) cout << v[0][j - 1] << " " << v[0][j + 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const signed long long int INF = 1e9;
vector<int> l, r;
vector<bool> us;
pair<int, int> dfs(int x) {
int Gl(x), Gr(x);
us[x] = 1;
while (1) {
us[Gr] = 1;
if (r[Gr] == 0) break;
Gr = r[Gr];
}
while (1) {
us[Gl] = 1;
if (l[Gl] == 0) break;
Gl = l[Gl];
}
return make_pair(Gl, Gr);
}
bool solve() {
int n;
cin >> n;
l.resize(n + 1);
r.resize(n + 1);
us.resize(n + 1);
vector<int> L, R;
for (int i(1); i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
if (l[i] == 0) L.push_back(i);
if (r[i] == 0) R.push_back(i);
}
vector<pair<int, int> > sec;
for (int i(1); i <= n; i++) {
if (!us[i]) {
sec.push_back(dfs(i));
}
}
for (int i(1); i < sec.size(); i++) {
r[sec[i - 1].second] = sec[i].first;
l[sec[i].first] = sec[i - 1].second;
}
for (int i(1); i <= n; i++) {
printf("%d %d\n", l[i], r[i]);
}
return 1;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
int n, l[104], r[104];
int prv;
void dfs(int u) {
if (r[u] != 0)
dfs(r[u]);
else {
prv = u;
return;
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d %d", &l[i], &r[i]);
prv = 0;
for (int i = (1); i <= (n); i++) {
if (l[i] != 0) continue;
l[i] = prv;
r[prv] = i;
dfs(i);
}
for (int i = (1); i <= (n); i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
long long sum, k;
int a[1000], l[101], r[101];
vector<int> v;
int com[101];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
}
int C = 1;
for (int i = 1; i <= n; i++) {
int x = i;
while (!com[x] && x) {
com[x] = C;
x = r[x];
}
x = l[i];
while (!com[x] && x) {
com[x] = C;
x = l[x];
}
C++;
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
for (int j = 1; j <= n; j++) {
if (r[j] == 0 && com[i] != com[j]) {
l[i] = j;
r[j] = i;
int tmp = com[j];
for (int k = 1; k <= n; k++) {
if (com[k] == tmp) {
com[k] = com[i];
}
}
break;
}
}
}
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101][2], x, n;
vector<int> ans;
bool s[101];
void slc(int i) {
int j, k, l;
if (s[i]) return;
if (a[i][0] || a[i][1]) s[i] = true;
k = ans.size();
for (j = 0; j < k; j++) {
if (ans[j] == i) {
if (a[i][0]) {
if ((j - 1 >= 0 && a[i][0] != ans[j - 1]) || !j) {
ans.push_back(ans[k - 1]);
for (l = k - 1; l >= j; l--) ans[l + 1] = ans[l];
ans[j] = a[i][0];
}
}
if (a[i][1]) {
if (j == k - 1) ans.push_back(a[i][1]);
}
if (a[i][0]) slc(a[i][0]);
if (a[i][1]) slc(a[i][1]);
break;
}
}
if (j == k) {
if (!a[i][0] && !a[i][1]) return;
if (a[i][0]) ans.push_back(a[i][0]);
ans.push_back(i);
if (a[i][1]) ans.push_back(a[i][1]);
if (a[i][0]) slc(a[i][0]);
if (a[i][1]) slc(a[i][1]);
}
return;
}
int main() {
int i, j, k;
memset(s, false, sizeof s);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i][0] >> a[i][1];
for (i = 1; i <= n; i++) slc(i);
for (i = 1; i <= n; i++)
if (!s[i]) ans.push_back(i);
k = ans.size();
for (i = 1; i <= n; i++) {
for (j = 0; j < k; j++) {
if (ans[j] == i) {
if (!j)
cout << 0 << ' ';
else
cout << ans[j - 1] << ' ';
if (j == k - 1)
cout << 0 << ' ';
else
cout << ans[j + 1] << ' ';
cout << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const long long int int_max = 1e18;
const long long int int_min = -1e18;
const long double PI = acos(-1);
using namespace std;
void solve() {
long long int n;
cin >> n;
map<long long int, long long int> after;
vector<long long int> v;
for (long long int i = 1; i <= n; i++) {
long long int l, r;
cin >> l >> r;
if (l == 0) {
v.push_back(i);
after[i] = r;
} else {
after[i] = r;
}
}
map<long long int, vector<long long int>> vectors;
for (int i = 0; i < v.size(); i++) {
long long int temp = v[i];
while (1) {
vectors[i].push_back(temp);
if (after[temp] == 0) break;
temp = after[temp];
}
}
vector<long long int> final(n + 1, 0);
for (auto i : vectors) {
vector<long long int> v1 = i.second;
for (long long int j : v1) final.push_back(j);
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 0; j <= final.size() - 1; j++) {
if (final[j] == i) {
if (j == 0)
cout << 0 << ' ' << final[j + 1] << '\n';
else if (j == final.size() - 1) {
cout << final[j - 1] << ' ' << 0 << '\n';
} else {
cout << final[j - 1] << ' ' << final[j + 1] << '\n';
}
break;
}
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 102;
pair<int, int> ar[N];
bool used[N];
vector<deque<int>> vc;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> ar[i].first >> ar[i].second;
for (int i = 1; i <= n; ++i) {
if (used[i]) continue;
deque<int> q;
q.push_back(i);
int cur = i;
while (ar[cur].first) {
used[cur] = true;
cur = ar[cur].first;
q.push_front(cur);
}
used[cur] = true;
cur = i;
while (ar[cur].second) {
used[cur] = true;
cur = ar[cur].second;
q.push_back(cur);
}
used[cur] = true;
vc.push_back(q);
}
for (int i = 1; i < vc.size(); ++i) {
while (!vc[i].empty()) {
vc[0].push_back(vc[i].front());
vc[i].pop_front();
}
}
auto cur = vc[0];
ar[cur.front()].first = ar[cur.back()].second = 0;
for (int i = 0; i < (int)cur.size() - 1; ++i) ar[cur[i]].second = cur[i + 1];
for (int i = (int)cur.size() - 1; i > 0; --i) ar[cur[i]].first = cur[i - 1];
for (int i = 1; i <= n; ++i)
cout << ar[i].first << " " << ar[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[105], b[105], cnt, v[105], nod, p;
int32_t main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
if (!a[i]) cnt++;
}
for (int i = 1; i <= n; i++) {
if (!a[i]) nod = i;
}
p = nod;
do {
v[nod] = 1;
if (!b[nod]) {
for (int j = 1; j <= n; j++) {
if (!v[j] && !a[j]) {
b[nod] = j;
a[j] = nod;
break;
}
}
}
nod = b[nod];
} while (nod);
for (int i = 1; i <= n; i++) {
cout << a[i] << ' ' << b[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> V;
const int MAXN = 105;
int l[MAXN], r[MAXN], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", l + i, r + i);
for (int i = 1; i <= n; i++) {
if (l[i]) continue;
V.push_back(i);
int cur = i;
while (r[cur]) cur = r[cur], V.push_back(cur);
}
memset(l, 0, sizeof l);
memset(r, 0, sizeof r);
for (int i = 0; i < V.size(); i++) {
if (i) l[V[i]] = V[i - 1];
if (i != V.size() - 1) r[V[i]] = V[i + 1];
}
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
long l[n + 1], r[n + 1], c = -1;
for (long i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) c++;
}
long i = 1, c1 = c;
long a[n + 1];
while (c) {
for (; i <= n; i++) {
if (l[i] == 0) break;
}
long j = i;
while (1) {
a[j] = i;
if (r[j] == 0) break;
j = r[j];
}
c--;
i++;
}
for (long i = 1; i <= n; i++) {
if (r[i] || c1 <= 0) continue;
for (long j = 1; j <= n; j++) {
if (l[j] == 0 && j != a[i]) {
r[i] = j;
l[j] = i;
for (long k = 1; k <= n; k++) {
if (a[k] == j) a[k] = a[i];
}
c1--;
break;
}
}
}
for (long i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int l[1000], r[1000], n, cur, rgt, ans, tmp;
vector<pair<int, int> > v;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &l[i], &r[i]);
l[i]--;
r[i]--;
}
for (int i = 0; i < n; i++) {
if (l[i] == -1) {
cur = i;
rgt = i;
while (r[rgt] != -1) rgt = r[rgt];
v.push_back(pair<int, int>(cur, rgt));
}
}
for (int i = 0; i < v.size() - 1; i++) {
int a = v[i].second;
int b = v[i + 1].first;
r[a] = b;
l[b] = a;
}
for (int i = 0; i < n; i++) {
printf("%d %d\n", l[i] + 1, r[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:108777216")
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
struct elem {
int val;
elem *prev, *next;
elem(int val_) {
val = val_;
prev = next = nullptr;
}
};
int main() {
int n;
scanf("%d", &n);
vector<elem *> a(n);
for (int i = 0; i < n; i++) a[i] = new elem(i + 1);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x == 0)
a[i]->prev = a[i];
else
a[i]->prev = a[x - 1];
if (y == 0)
a[i]->next = a[i];
else
a[i]->next = a[y - 1];
}
vector<bool> used(n, false);
vector<elem *> b;
for (int i = 0; i < n; i++) {
if (!used[i]) {
elem *v = a[i];
used[i] = true;
while (v->next != v) {
v = v->next;
used[v->val - 1] = true;
}
elem *tmp = new elem(-47);
tmp->next = v;
v = a[i];
while (v->prev != v) {
v = v->prev;
used[v->val - 1] = true;
}
tmp->prev = v;
b.push_back(tmp);
}
}
for (int i = 0; i < (int)b.size() - 1; i++) {
b[i]->next->next = b[i + 1]->prev;
b[i + 1]->prev->prev = b[i]->next;
}
for (int i = 0; i < n; i++) {
printf("%d %d\n", (a[i]->prev->val == a[i]->val ? 0 : a[i]->prev->val),
(a[i]->next->val == a[i]->val ? 0 : a[i]->next->val));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T next_int() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return p * x;
}
string next_token() {
char ch;
string ans = "";
do {
ch = getchar();
} while (ch <= ' ');
while (ch > ' ') {
ans += ch;
ch = getchar();
}
return ans;
}
const long long INF = (long long)1e18;
const int INFINT = (int)1e9 + 227 + 1;
const int maxn = (int)1e6 + 227 + 1;
const int MOD = (int)1e9 + 7;
const long double EPS = 1e-9;
long long bin_pow(long long a, long long b) {
if (!b) return 1;
long long ans = bin_pow(a, b / 2);
ans = ans * ans;
if (b % 2) ans = ans * a;
return ans;
}
int l[111];
int r[111];
bool vis[111];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
vector<int> g;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
vis[i] = 1;
vector<int> v;
int p = i;
while (true) {
if (l[p] == 0) break;
vis[l[p]] = 1;
v.push_back(l[p]);
p = l[p];
}
reverse(v.begin(), v.end());
v.push_back(i);
p = i;
while (true) {
if (r[p] == 0) break;
vis[r[p]] = 1;
v.push_back(r[p]);
p = r[p];
}
for (int j = 0; j < v.size(); j++) {
g.push_back(v[j]);
}
}
for (int i = 0; i < n; i++) {
if (i == 0)
l[g[i]] = 0;
else
l[g[i]] = g[i - 1];
if (i == n - 1)
r[g[i]] = 0;
else
r[g[i]] = g[i + 1];
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dsu;
int trace(int x) {
if (x != dsu[x]) dsu[x] = trace(dsu[x]);
return dsu[x];
}
void unite(int x, int y) {
x = trace(x), y = trace(y);
dsu[y] = x;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
dsu.resize(n);
for (int i = 0; i < n; i++) {
dsu[i] = i;
}
vector<int> p(n, -1), c(n, -1);
for (int u, v, i = 0; i < n; i++) {
cin >> u >> v;
--u, --v;
if (u >= 0) {
p[i] = u, c[u] = i;
unite(u, i);
}
if (v >= 0) {
p[v] = i, c[i] = v;
unite(i, v);
}
}
int t = -1;
for (int i = 0; i < n; i++) {
if (c[i] == -1) {
if (t == -1)
t = trace(i);
else {
c[i] = t;
p[t] = i;
unite(i, c[i]);
t = trace(i);
}
}
}
for (int i = 0; i < n; i++) {
cout << p[i] + 1 << " " << c[i] + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, index;
cin >> n;
long long a[n + 1], b[n + 1];
for (i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (i = 1; i <= n; i++) {
if (a[i] == 0) {
vector<long long> v1;
v1.push_back(i);
index = b[i];
while (index != 0) {
v1.push_back(index);
index = b[index];
}
for (j = i + 1; j <= n; j++) {
if (b[j] == 0) {
vector<long long> v2;
v2.push_back(j);
index = a[j];
while (index != 0) {
v2.push_back(index);
index = a[index];
}
long long f = 1;
for (long long ii = 0; ii < v1.size(); ii++) {
for (long long jj = 0; jj < v2.size(); jj++) {
if (v1[ii] == v2[jj]) {
f = 0;
}
}
}
if (f == 1) {
a[i] = j;
b[j] = i;
break;
}
}
}
}
if (b[i] == 0) {
vector<long long> v1;
v1.push_back(i);
index = a[i];
while (index != 0) {
v1.push_back(index);
index = a[index];
}
for (j = i + 1; j <= n; j++) {
if (a[j] == 0) {
vector<long long> v2;
v2.push_back(j);
index = b[j];
while (index != 0) {
v2.push_back(index);
index = b[index];
}
long long f = 1;
for (long long ii = 0; ii < v1.size(); ii++) {
for (long long jj = 0; jj < v2.size(); jj++) {
if (v1[ii] == v2[jj]) {
f = 0;
}
}
}
if (f == 1) {
b[i] = j;
a[j] = i;
break;
}
}
}
}
}
for (i = 1; i <= n; i++) cout << a[i] << " " << b[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[111];
int dfs(int v) {
if (a[v].second == 0) return v;
return dfs(a[v].second);
}
int main() {
srand('D' + 'E' + 'N' + 'I' + 'S' + 'S' + 'O' + 'N' + time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
vector<pair<int, int> > t;
for (int i = 1; i <= n; i++)
if (a[i].first == 0) {
auto now = dfs(i);
t.push_back(make_pair(i, now));
}
for (int i = 1; i < t.size(); i++) {
a[t[i - 1].second].second = t[i].first;
a[t[i].first].first = t[i - 1].second;
}
for (int i = 1; i <= n; i++) cout << a[i].first << ' ' << a[i].second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l[101], r[101], sum = 0, list[100][100] = {0}, sumCol[100] = {0},
x = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> l[i];
cin >> r[i];
if (l[i] == 0) {
list[sum][sumCol[sum]] = i;
sumCol[sum]++;
sum++;
}
}
if (sum > 1) {
while (x < n - sum)
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < sum; ++j) {
if (l[i] == list[j][sumCol[j] - 1]) {
list[j][sumCol[j]] = i;
sumCol[j]++;
x++;
}
}
}
for (int i = 1; i < sum; ++i) {
l[list[i][0]] = list[i - 1][sumCol[i - 1] - 1];
r[list[i - 1][sumCol[i - 1] - 1]] = list[i][0];
}
}
for (int i = 1; i <= n; ++i) {
cout << l[i] << " " << r[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 10000000000;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long fastexp(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result *= x;
x *= x;
n = n / 2;
}
return result;
}
long long modularExp(long long x, long long n, long long mod) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return (result) % mod;
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
bool mycomp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
vector<long long> v(105), visited(105, 0);
long long dfs(long long node) {
long long p = 0;
long long curr = node;
while (!visited[curr]) {
visited[curr] = 1;
curr = v[curr];
p++;
}
if (curr != node)
return -1;
else
return p;
}
void solve() {
long long n;
cin >> n;
long long i;
vector<long long> l(n + 1), r(n + 1);
for (i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
l[i] = x;
r[i] = y;
}
vector<long long> visited(n + 1, 0);
vector<pair<long long, long long> > prs;
for (i = 1; i <= n; i++) {
if (!visited[i]) {
long long le = i, re = i;
while (l[le] != 0) {
visited[le] = 1;
le = l[le];
}
while (r[re] != 0) {
visited[re] = 1;
re = r[re];
}
visited[re] = 1;
visited[le] = 1;
prs.push_back({le, re});
}
}
long long lstart = prs[0].first;
long long rstart = prs[0].second;
for (i = 1; i < prs.size(); i++) {
long long x = prs[i].first;
long long y = prs[i].second;
r[rstart] = x;
l[x] = rstart;
rstart = y;
}
for (i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
long long i;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105], b[105], c[105];
vector<int> v1, v2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int k = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
if (a[i] == 0) c[k++] = i;
}
for (int i = 0; i < k; i++) {
int j = c[i];
while (b[j] != 0) j = b[j];
b[j] = c[i + 1];
a[c[i + 1]] = j;
}
for (int i = 1; i <= n; i++) cout << a[i] << " " << b[i] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.