problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p02275
|
C++
|
Runtime Error
|
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int arr[1000100], c[100001], ans[1000100];
int main() {
int i, n;
scanf("%d", &n);
memset(c, 0, sizeof(c));
for (i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
++c[arr[i]];
}
for (i = 1; i < 100001; ++i)
c[i] = c[i] + c[i - 1];
for (i = n; i > 0; --i) {
ans[c[arr[i]]] = arr[i];
--c[arr[i]];
}
for (i = 1; i < n; ++i)
printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
|
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int arr[2000100], c[100001], ans[2000100];
int main() {
int i, n;
scanf("%d", &n);
memset(c, 0, sizeof(c));
for (i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
++c[arr[i]];
}
for (i = 1; i < 100001; ++i)
c[i] = c[i] + c[i - 1];
for (i = n; i > 0; --i) {
ans[c[arr[i]]] = arr[i];
--c[arr[i]];
}
for (i = 1; i < n; ++i)
printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#define MAX 2000001
#define VMAX 10000
int main() {
unsigned short *A, *B;
int C[VMAX + 1];
int n, i, j;
scanf("%d", &n);
A = (unsigned short *)malloc(MAX);
B = (unsigned short *)malloc(MAX);
for (i = 0; i <= VMAX; i++)
C[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%hu", &A[i + 1]);
C[A[i + 1]]++;
}
for (int i = 1; i <= VMAX; i++)
C[i] = C[i] + C[i - 1];
for (int j = 1; j <= n; j++) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
for (i = 1; i <= n; i++) {
if (i > 1)
printf(" ");
printf("%d", B[i]);
}
printf("\n");
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#define MAX 2000001
#define VMAX 10000
int main() {
unsigned short *A, *B;
int C[VMAX + 1];
int n, i, j;
scanf("%d", &n);
A = (unsigned short *)malloc(sizeof(short) * n + 1);
B = (unsigned short *)malloc(sizeof(short) * n + 1);
for (i = 0; i <= VMAX; i++)
C[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%hu", &A[i + 1]);
C[A[i + 1]]++;
}
for (int i = 1; i <= VMAX; i++)
C[i] = C[i] + C[i - 1];
for (int j = 1; j <= n; j++) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
for (i = 1; i <= n; i++) {
if (i > 1)
printf(" ");
printf("%d", B[i]);
}
printf("\n");
return 0;
}
|
replace
| 14 | 16 | 14 | 16 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#define MAX 2000001
#define vMAX 10000
int main() {
int n;
int C[vMAX];
for (int i = 0; i < vMAX; i++)
C[i] = 0;
scanf("%d", &n);
int *A = new int[n];
int *B = new int[n];
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
C[A[i]] += 1;
}
for (int i = 1; i < vMAX; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = n; i >= 1; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
for (int i = 1; i <= n; i++) {
if (i > 1)
printf(" ");
printf("%d", B[i]);
}
printf("\n");
delete[] A;
delete[] B;
return 0;
}
|
#include <iostream>
#include <stdio.h>
#define MAX 2000001
#define vMAX 10000
int main() {
int n;
int C[vMAX];
for (int i = 0; i < vMAX; i++)
C[i] = 0;
scanf("%d", &n);
int *A = new int[n + 1];
int *B = new int[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
C[A[i]] += 1;
}
for (int i = 1; i < vMAX; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = n; i >= 1; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
for (int i = 1; i <= n; i++) {
if (i > 1)
printf(" ");
printf("%d", B[i]);
}
printf("\n");
delete[] A;
delete[] B;
return 0;
}
|
replace
| 13 | 15 | 13 | 15 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX_LEN 200001
#define MAX_VAL 10001
void countingSort(int n, int A[], int B[], int C[]) {
int i;
for (i = 0; i < MAX_VAL; i++) {
C[i] = 0;
}
for (i = 0; i < n; i++) {
C[A[i]]++;
}
int idx = 0;
for (i = 0; i < MAX_VAL; i++) {
if (C[i] == 0)
continue;
for (int j = 0; j < C[i]; j++) {
B[idx++] = i;
}
}
}
int main() {
int n, A[MAX_LEN], B[MAX_LEN], C[MAX_VAL];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
countingSort(n, A, B, C);
cout << B[0];
for (int i = 1; i < n; i++) {
cout << " " << B[i];
}
cout << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX_LEN 2000000
#define MAX_VAL 10000
void countingSort(int n, int A[], int B[], int C[]) {
int i;
for (i = 0; i < MAX_VAL; i++) {
C[i] = 0;
}
for (i = 0; i < n; i++) {
C[A[i]]++;
}
int idx = 0;
for (i = 0; i < MAX_VAL; i++) {
if (C[i] == 0)
continue;
for (int j = 0; j < C[i]; j++) {
B[idx++] = i;
}
}
}
int main() {
int n, A[MAX_LEN], B[MAX_LEN], C[MAX_VAL];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
countingSort(n, A, B, C);
cout << B[0];
for (int i = 1; i < n; i++) {
cout << " " << B[i];
}
cout << endl;
return 0;
}
|
replace
| 3 | 5 | 3 | 5 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <cmath>
#include <iostream>
#include <stdio.h>
using namespace std;
#define MAX 500000;
#define SENTINEL 2000000000;
// int count=0;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[500000 / 2 + 2], R[500000 / 2 + 2];
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
// count++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
};
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r) {
if (p < r) {
int q = partition(A, p, r);
quicksort(A, p, q - 1);
quicksort(A, q + 1, r);
}
}
int C[2000001];
int k = 10000;
void countingSort(int A[], int B[], int n) {
for (int i = 0; i < k; i++)
C[i] = 0;
for (int j = 1; j <= n; j++)
C[A[j]]++;
for (int i = 1; i < k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n; j > 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
}
int main() {
int n, i;
scanf("%d", &n);
int A[100001];
int B[100001];
for (int i = 0; i < n; i++)
scanf("%d", &A[i + 1]);
countingSort(A, B, n);
for (i = 1; i <= n; i++) {
if (i > 1)
cout << " ";
cout << B[i];
}
cout << endl;
return 0;
}
|
#include <cmath>
#include <iostream>
#include <stdio.h>
using namespace std;
#define MAX 500000;
#define SENTINEL 2000000000;
// int count=0;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[500000 / 2 + 2], R[500000 / 2 + 2];
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
// count++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
};
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r) {
if (p < r) {
int q = partition(A, p, r);
quicksort(A, p, q - 1);
quicksort(A, q + 1, r);
}
}
int C[2000001];
int k = 10000;
void countingSort(int A[], int B[], int n) {
for (int i = 0; i < k; i++)
C[i] = 0;
for (int j = 1; j <= n; j++)
C[A[j]]++;
for (int i = 1; i < k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n; j > 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
}
int main() {
int n, i;
scanf("%d", &n);
int A[n + 1];
int B[n + 1];
for (int i = 0; i < n; i++)
scanf("%d", &A[i + 1]);
countingSort(A, B, n);
for (i = 1; i <= n; i++) {
if (i > 1)
cout << " ";
cout << B[i];
}
cout << endl;
return 0;
}
|
replace
| 77 | 79 | 77 | 79 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#define N 10001
using namespace std;
void Counting_Sort(int *A, int n, int *B, int k) {
int *C = new int[N];
for (int i = 0; i <= k; i++)
C[i] = 0;
for (int j = 0; j < n; j++)
C[A[j]] = C[A[j]] + 1;
for (int i = 1; i <= k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]] = C[A[j]] - 1;
}
delete[] C;
}
int main() {
int n;
cin >> n;
int *A = new int[n];
int *B = new int[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
Counting_Sort(A, n, B, N - 1);
for (int i = 1; i < n + 1; i++) {
cout << B[i];
if (i == n)
cout << endl;
else
cout << " ";
}
delete[] A;
delete[] B;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#define N 10001
using namespace std;
void Counting_Sort(int *A, int n, int *B, int k) {
int *C = new int[N];
for (int i = 0; i <= k; i++)
C[i] = 0;
for (int j = 0; j < n; j++)
C[A[j]] = C[A[j]] + 1;
for (int i = 1; i <= k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]] = C[A[j]] - 1;
}
delete[] C;
}
int main() {
int n;
cin >> n;
int *A = new int[n];
int *B = new int[n + 1];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
Counting_Sort(A, n, B, N - 1);
for (int i = 1; i < n + 1; i++) {
cout << B[i];
if (i == n)
cout << endl;
else
cout << " ";
}
delete[] A;
delete[] B;
return 0;
}
|
replace
| 25 | 26 | 25 | 26 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
#define N 20001
int n;
void Counting_Sort(int a[], int b[], int k) {
int i, j, c[N];
for (i = 0; i <= k; i++)
c[i] = 0;
for (j = 1; j <= n; j++)
c[a[j]]++;
for (i = 1; i <= k; i++)
c[i] += c[i - 1];
for (j = n; j > 0; j--) {
b[c[a[j]]] = a[j];
c[a[j]]--;
}
for (i = 1; i <= n; i++) {
printf("%d", b[i]);
if (i != n)
printf(" ");
}
printf("\n");
}
int main() {
int i, max = 0;
static int a[N], b[N];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > max)
max = a[i];
}
Counting_Sort(a, b, max);
return 0;
}
|
#include <stdio.h>
#define N 2000001
int n;
void Counting_Sort(int a[], int b[], int k) {
int i, j, c[N];
for (i = 0; i <= k; i++)
c[i] = 0;
for (j = 1; j <= n; j++)
c[a[j]]++;
for (i = 1; i <= k; i++)
c[i] += c[i - 1];
for (j = n; j > 0; j--) {
b[c[a[j]]] = a[j];
c[a[j]]--;
}
for (i = 1; i <= n; i++) {
printf("%d", b[i]);
if (i != n)
printf(" ");
}
printf("\n");
}
int main() {
int i, max = 0;
static int a[N], b[N];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > max)
max = a[i];
}
Counting_Sort(a, b, max);
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int A[200000];
int B[200000];
int C[10001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
C[A[i]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] += C[i - 1];
}
for (int j = n - 1; j >= 0; j--) {
B[--C[A[j]]] = A[j];
}
for (int i = 0; i < n; i++) {
cout << B[i];
if (i == n - 1) {
cout << endl;
} else {
cout << ' ';
}
}
}
|
#include <iostream>
using namespace std;
int A[2000000];
int B[2000000];
int C[10001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
C[A[i]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] += C[i - 1];
}
for (int j = n - 1; j >= 0; j--) {
B[--C[A[j]]] = A[j];
}
for (int i = 0; i < n; i++) {
cout << B[i];
if (i == n - 1) {
cout << endl;
} else {
cout << ' ';
}
}
}
|
replace
| 4 | 6 | 4 | 6 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int b[200005];
signed main() {
int a;
scanf("%d", &a);
for (int c = 0; c < a; c++) {
scanf("%d", &b[c]);
}
sort(b, b + a);
for (int i = 0; i < a; i++) {
if (i)
cout << " ";
cout << b[i];
}
puts("");
}
|
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int b[2000005];
signed main() {
int a;
scanf("%d", &a);
for (int c = 0; c < a; c++) {
scanf("%d", &b[c]);
}
sort(b, b + a);
for (int i = 0; i < a; i++) {
if (i)
cout << " ";
cout << b[i];
}
puts("");
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <array>
#include <iostream>
#include <string>
using namespace std;
int n;
array<short, 2000001> A;
array<short, 2000001> B;
array<short, 10001> C;
void CountingSort(int k) {
for (int j = 0; j < n; j++) {
C[A[j]]++;
}
for (int i = 1; i <= k; i++) {
C[i] = C[i] + C[i - 1];
}
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]] - 1] = A[j];
C[A[j]]--;
}
for (int i = 0; i < n - 1; i++)
cout << B.at(i) << " ";
cout << B.at(n - 1) << endl;
}
int main() {
int k = -1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (k < A[i])
k = A[i];
}
CountingSort(k);
return 0;
}
|
#include <array>
#include <iostream>
#include <string>
using namespace std;
int n;
array<short, 2000001> A;
array<short, 2000001> B;
array<int, 10001> C;
void CountingSort(int k) {
for (int j = 0; j < n; j++) {
C[A[j]]++;
}
for (int i = 1; i <= k; i++) {
C[i] = C[i] + C[i - 1];
}
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]] - 1] = A[j];
C[A[j]]--;
}
for (int i = 0; i < n - 1; i++)
cout << B.at(i) << " ";
cout << B.at(n - 1) << endl;
}
int main() {
int k = -1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (k < A[i])
k = A[i];
}
CountingSort(k);
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
const int MAX_N = 200000;
int main() {
int n, A[MAX_N] = {0}, B[MAX_N] = {0}, C[10000] = {0}, max;
scanf("%d", &n);
max = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
if (max < A[i]) {
max = A[i];
}
}
for (int i = 0; i < n; i++) {
C[A[i]]++;
}
for (int i = 1; i <= max; i++) {
C[i] += C[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
for (int i = 1; i <= n; i++) {
if (i == n) {
printf("%d\n", B[i]);
} else {
printf("%d ", B[i]);
}
}
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
const int MAX_N = 2000000;
int main() {
int n, A[MAX_N] = {0}, B[MAX_N] = {0}, C[10000] = {0}, max;
scanf("%d", &n);
max = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
if (max < A[i]) {
max = A[i];
}
}
for (int i = 0; i < n; i++) {
C[A[i]]++;
}
for (int i = 1; i <= max; i++) {
C[i] += C[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
for (int i = 1; i <= n; i++) {
if (i == n) {
printf("%d\n", B[i]);
} else {
printf("%d ", B[i]);
}
}
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void counting_sort(vector<int> &A, int n) {
int k = *max_element(A.begin(), A.end());
vector<int> B(n);
vector<int> C(k + 1);
for (int i = 0; i < k; i++)
C[i] = 0;
for (int j = 0; j < n; j++)
C[A[j]]++;
for (int i = 1; i <= k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
for (int i = 1; i <= n; i++) {
if (i != n) {
cout << B[i] << " ";
} else {
cout << B[i] << endl;
}
}
}
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++)
cin >> A[i];
counting_sort(A, n);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void counting_sort(vector<int> &A, int n) {
int k = *max_element(A.begin(), A.end());
vector<int> B(n + 1);
vector<int> C(k + 1);
for (int i = 0; i < k; i++)
C[i] = 0;
for (int j = 0; j < n; j++)
C[A[j]]++;
for (int i = 1; i <= k; i++)
C[i] = C[i] + C[i - 1];
for (int j = n - 1; j >= 0; j--) {
B[C[A[j]]] = A[j];
C[A[j]]--;
}
for (int i = 1; i <= n; i++) {
if (i != n) {
cout << B[i] << " ";
} else {
cout << B[i] << endl;
}
}
}
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++)
cin >> A[i];
counting_sort(A, n);
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
int main() {
int n, i, max;
scanf("%d", &n);
int A[n + 1];
int B[n + 1];
max = (1 << 30) * -1;
for (i = 0; i < n; i++) {
scanf("%hu", &A[i + 1]);
max = MAX(max, A[i + 1]);
}
int C[max + 1];
memset(C, 0, sizeof(C));
for (i = 0; i < n; i++)
C[A[i + 1]]++;
for (i = 1; i <= max; i++)
C[i] += C[i - 1];
for (i = n; i >= 1; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
printf("%d", B[1]);
for (i = 2; i <= n; i++) {
printf(" %d", B[i]);
}
printf("\n");
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
int main() {
int n, i, max;
scanf("%d", &n);
unsigned short A[n + 1];
unsigned short B[n + 1];
max = (1 << 30) * -1;
for (i = 0; i < n; i++) {
scanf("%hu", &A[i + 1]);
max = MAX(max, A[i + 1]);
}
int C[max + 1];
memset(C, 0, sizeof(C));
for (i = 0; i < n; i++)
C[A[i + 1]]++;
for (i = 1; i <= max; i++)
C[i] += C[i - 1];
for (i = n; i >= 1; i--) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
printf("%d", B[1]);
for (i = 2; i <= n; i++) {
printf(" %d", B[i]);
}
printf("\n");
return 0;
}
|
replace
| 10 | 12 | 10 | 12 |
-11
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ctype.h>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int n;
int *B, *A;
void countingsort(int N[], int max) {
int S[max + 1];
for (int i = 0; i < n; i++) {
S[i] = 0;
}
for (int j = 0; j < n; j++) {
S[N[j]]++;
}
int p = 0;
for (int k = 0; k < max + 1; k++) {
for (int l = 1; l <= S[k]; l++) {
B[p] = k;
p++;
}
}
}
int main() {
cin >> n;
int max = -1;
A = new int[n];
B = new int[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
if (A[i] >= max) {
max = A[i];
}
}
countingsort(A, max);
for (int i = 0; i < n; i++) {
if (i != n - 1) {
cout << B[i] << " ";
} else {
cout << B[i] << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ctype.h>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int n;
int *B, *A;
void countingsort(int N[], int max) {
int S[max + 1];
for (int i = 0; i < max + 1; i++) {
S[i] = 0;
}
for (int j = 0; j < n; j++) {
S[N[j]]++;
}
int p = 0;
for (int k = 0; k < max + 1; k++) {
for (int l = 1; l <= S[k]; l++) {
B[p] = k;
p++;
}
}
}
int main() {
cin >> n;
int max = -1;
A = new int[n];
B = new int[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
if (A[i] >= max) {
max = A[i];
}
}
countingsort(A, max);
for (int i = 0; i < n; i++) {
if (i != n - 1) {
cout << B[i] << " ";
} else {
cout << B[i] << endl;
}
}
return 0;
}
|
replace
| 32 | 33 | 32 | 33 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
#define N 10000
int A[200000], C[N], B[200000];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
#include <stdio.h>
#define N 10000
int A[2000001], C[N], B[2000001];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
#define N 10000
int A[10000], C[N], B[2000001];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
#include <stdio.h>
#define N 10000
int A[2000001], C[N], B[2000001];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
int A[n + 1], B[n + 1], C[10000 + 1];
for (int i = 0; i < 10000 + 1; i++) {
C[i] = 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", &A[i + 1]);
C[A[i + 1]]++;
}
for (int i = 0; i < 10000 + 1; i++)
C[i + 1] = C[i + 1] + C[i];
for (int j = 0; j < n; j++) {
B[C[A[j + 1]]] = A[j + 1];
C[A[j]]--;
}
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", B[i + 1]);
}
printf("\n");
return 0;
}
|
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
int A[n + 1], B[n + 1], C[10000 + 1];
for (int i = 0; i < 10000 + 1; i++) {
C[i] = 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", &A[i + 1]);
C[A[i + 1]]++;
}
for (int i = 0; i < 10000 + 1; i++)
C[i + 1] = C[i + 1] + C[i];
for (int j = 0; j < n; j++) {
B[C[A[j + 1]]] = A[j + 1];
C[A[j + 1]]--;
}
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", B[i + 1]);
}
printf("\n");
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
const int MAX = 10010;
void countingSort(std::vector<int> &A, std::vector<int> &sorted) {
int count[MAX];
int n = A.size();
memset(count, 0, sizeof(count));
for (int i = 0; i < n; i++)
count[A[i]]++;
for (int i = 0; i < MAX; i++)
count[i + 1] += count[i];
for (int i = n - 1; i >= 0; i++)
sorted[--count[A[i]]] = A[i];
}
int main(void) {
int n;
std::cin >> n;
std::vector<int> A(n);
for (int i = 0; i < n; i++)
std::cin >> A[i];
std::vector<int> sorted(n);
countingSort(A, sorted);
for (int i = 0; i < n; i++)
std::cout << (i ? " " : "") << sorted[i];
std::cout << std::endl;
return 0;
}
|
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
const int MAX = 10010;
void countingSort(std::vector<int> &A, std::vector<int> &sorted) {
int count[MAX];
int n = A.size();
memset(count, 0, sizeof(count));
for (int i = 0; i < n; i++)
count[A[i]]++;
for (int i = 0; i < MAX; i++)
count[i + 1] += count[i];
for (int i = n - 1; i >= 0; i--)
sorted[--count[A[i]]] = A[i];
}
int main(void) {
int n;
std::cin >> n;
std::vector<int> A(n);
for (int i = 0; i < n; i++)
std::cin >> A[i];
std::vector<int> sorted(n);
countingSort(A, sorted);
for (int i = 0; i < n; i++)
std::cout << (i ? " " : "") << sorted[i];
std::cout << std::endl;
return 0;
}
|
replace
| 15 | 16 | 15 | 16 |
-11
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm> // next_permutation
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric> //accumulate
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
// #include <unordered_map> //???????????\??¢??°
#include <fstream> //ifstream, ofstream
#define NDEBUG // NDEBUG???#include
// <cassert>???????????????????????????????????´???assert?????????????????????????????????NDEBUG????????????????????¨
#include <cassert> //assert
using namespace std;
//???????????°??????TEST????????????????????¬???????????????????????????????????¢????????????
#define TEST //*******************************************************************************************************************************************
//?????????????????¨??§?????\????????????????????????????????°?????????????¨???????????????????dout???????????????????????§???????????¬??????????????????????????????????????????
//??????????????????????????????????????????????????????????§?CPU???????£??????????????????§???TLE?????????????????????????????????????????§????????¨???
//????????????????????????cerr????????£????????????????????????????????????
#ifdef TEST
#define dout cout
#else
stringstream dummy; //???????????°??????dout?????????????????????????????????
#define dout \
dummy.str(""); \
dummy.clear(stringstream::goodbit); \
dummy // dummy?????????????????????????????????????????¨?????¢?????¢???????????????
//???????????¨??????????????????goodbit?????????????????????????????¨???????????´????????????????????????????????¨?????°?????????????????§????????????????????????????????????
//http://d.hatena.ne.jp/linden/20060427/p1
#endif
//?¨??????????????????????????????????????????????????????´??????OUTPUT2TEXTFILE????????????????????¬???????????????????????????????????¢????????????
// #define OUTPUT2TEXTFILE
// //*******************************************************************************************************************************************
#ifdef OUTPUT2TEXTFILE
#define dout \
outputfile //??¨????????????TLE????????§?????????dout?????¨??¨??????????????¢????????????????????????????????????????????§????¨????????????´??????????????£??????????????????????¨?????????????????????????????????????????????§?????????????????????
// TEST??????????????????????????¨???outputfile??????????????????????????????
#define OUTPUTFILENAME "output.txt"
ofstream outputfile(OUTPUTFILENAME);
#define OutputFilePath \
"/Users/Nag/Documents/Prgm/Test/DerivedData/Test/Build/Products/Debug/" \
"output.txt"
#endif
#define disp(A) dout << #A << " = " << (A) << endl
#define disP(A) \
dout << setw(3) << (A) << " " // << setw(3) ??????????????\????????????
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define dispAll(A, n) \
dout << #A << " = "; \
rep(j, 0, (n)) { disP(A[j]); } \
dout << endl
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef unsigned long long ll;
const int INF = 1e9 + 999;
int main() {
const int a_max = 10;
int N;
cin >> N;
int a[N];
rep(i, 0, N) cin >> a[i];
int c[a_max + 1]; // a[]???????´???????????????°???????????????????????¨
int output[N]; // a[]????????????????????????????????????????????????
// counting sort
rep(i, 0,
a_max +
1) { // 0??§???????????????????????????????????¨???????´???°?????§???????????§??????????????????????????????????????\??£??????????????????
c[i] = 0;
}
// dispAll(c, a_max+1);
rep(i, 0, N) { // a[]??????????????°???c[]????????????c[i] =
// i???a[]??????????????????????????????
c[a[i]]++;
}
// dispAll(c, a_max+1);
rep(i, 1, a_max + 1) { //?´?????????°????????????c[i] =
//i??\??????a[]??????????????????????????????
c[i] += c[i - 1];
}
// dispAll(c, a_max+1);
for (
int i = N - 1; i >= 0;
i--) { //?´?????????°?????????????????????????????§???a[]?????????????????°???????????????
output[c[a[i]] - 1] = a[i]; // a[i]??\????????°??????c[a[i]]????????????????????§???b[]???
// (c[a[i]]???1)???????????????????????°??????
c[a[i]]--; //?¬????????????°?????????????????¨??????1????????????????????????????????????1?????????????????????????????°????????????????????§?????????????????¨??????
}
// dispAll(output, N);
rep(i, 0, N) {
if (i == 0)
cout << output[i];
else
cout << " " << output[i];
}
cout << endl;
#ifdef OUTPUT2TEXTFILE
outputfile.close();
cout << "\"" << OutputFilePath << "\"" << endl;
#endif
return 0;
}
|
#include <algorithm> // next_permutation
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric> //accumulate
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
// #include <unordered_map> //???????????\??¢??°
#include <fstream> //ifstream, ofstream
#define NDEBUG // NDEBUG???#include
// <cassert>???????????????????????????????????´???assert?????????????????????????????????NDEBUG????????????????????¨
#include <cassert> //assert
using namespace std;
//???????????°??????TEST????????????????????¬???????????????????????????????????¢????????????
#define TEST //*******************************************************************************************************************************************
//?????????????????¨??§?????\????????????????????????????????°?????????????¨???????????????????dout???????????????????????§???????????¬??????????????????????????????????????????
//??????????????????????????????????????????????????????????§?CPU???????£??????????????????§???TLE?????????????????????????????????????????§????????¨???
//????????????????????????cerr????????£????????????????????????????????????
#ifdef TEST
#define dout cout
#else
stringstream dummy; //???????????°??????dout?????????????????????????????????
#define dout \
dummy.str(""); \
dummy.clear(stringstream::goodbit); \
dummy // dummy?????????????????????????????????????????¨?????¢?????¢???????????????
//???????????¨??????????????????goodbit?????????????????????????????¨???????????´????????????????????????????????¨?????°?????????????????§????????????????????????????????????
//http://d.hatena.ne.jp/linden/20060427/p1
#endif
//?¨??????????????????????????????????????????????????????´??????OUTPUT2TEXTFILE????????????????????¬???????????????????????????????????¢????????????
// #define OUTPUT2TEXTFILE
// //*******************************************************************************************************************************************
#ifdef OUTPUT2TEXTFILE
#define dout \
outputfile //??¨????????????TLE????????§?????????dout?????¨??¨??????????????¢????????????????????????????????????????????§????¨????????????´??????????????£??????????????????????¨?????????????????????????????????????????????§?????????????????????
// TEST??????????????????????????¨???outputfile??????????????????????????????
#define OUTPUTFILENAME "output.txt"
ofstream outputfile(OUTPUTFILENAME);
#define OutputFilePath \
"/Users/Nag/Documents/Prgm/Test/DerivedData/Test/Build/Products/Debug/" \
"output.txt"
#endif
#define disp(A) dout << #A << " = " << (A) << endl
#define disP(A) \
dout << setw(3) << (A) << " " // << setw(3) ??????????????\????????????
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define dispAll(A, n) \
dout << #A << " = "; \
rep(j, 0, (n)) { disP(A[j]); } \
dout << endl
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef unsigned long long ll;
const int INF = 1e9 + 999;
int main() {
const int a_max = 10000;
int N;
cin >> N;
int a[N];
rep(i, 0, N) cin >> a[i];
int c[a_max + 1]; // a[]???????´???????????????°???????????????????????¨
int output[N]; // a[]????????????????????????????????????????????????
// counting sort
rep(i, 0,
a_max +
1) { // 0??§???????????????????????????????????¨???????´???°?????§???????????§??????????????????????????????????????\??£??????????????????
c[i] = 0;
}
// dispAll(c, a_max+1);
rep(i, 0, N) { // a[]??????????????°???c[]????????????c[i] =
// i???a[]??????????????????????????????
c[a[i]]++;
}
// dispAll(c, a_max+1);
rep(i, 1, a_max + 1) { //?´?????????°????????????c[i] =
//i??\??????a[]??????????????????????????????
c[i] += c[i - 1];
}
// dispAll(c, a_max+1);
for (
int i = N - 1; i >= 0;
i--) { //?´?????????°?????????????????????????????§???a[]?????????????????°???????????????
output[c[a[i]] - 1] = a[i]; // a[i]??\????????°??????c[a[i]]????????????????????§???b[]???
// (c[a[i]]???1)???????????????????????°??????
c[a[i]]--; //?¬????????????°?????????????????¨??????1????????????????????????????????????1?????????????????????????????°????????????????????§?????????????????¨??????
}
// dispAll(output, N);
rep(i, 0, N) {
if (i == 0)
cout << output[i];
else
cout << " " << output[i];
}
cout << endl;
#ifdef OUTPUT2TEXTFILE
outputfile.close();
cout << "\"" << OutputFilePath << "\"" << endl;
#endif
return 0;
}
|
replace
| 69 | 70 | 69 | 70 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cout << ((i != 0) ? " " : "") << A[i];
}
cout << endl;
}
static vector<int> C(10000 + 1, 0);
static inline void countingSort(int A[], int B[], int num) {
for (int i = 0; i < num; i++) {
C[A[i + 1]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = num; i > 0; i--) {
// for (int i = 1; i <= num; i++) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
}
static vector<int> A(2000000 + 1), B(100000 + 1);
int main() {
int n;
cin >> n;
inputArray(&A[1], n);
countingSort(&A[0], &B[0], n);
printArray(&B[1], n);
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cout << ((i != 0) ? " " : "") << A[i];
}
cout << endl;
}
static vector<int> C(10000 + 1, 0);
static inline void countingSort(int A[], int B[], int num) {
for (int i = 0; i < num; i++) {
C[A[i + 1]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = num; i > 0; i--) {
// for (int i = 1; i <= num; i++) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
}
static vector<int> A(2000000 + 1), B(2000000 + 1);
int main() {
int n;
cin >> n;
inputArray(&A[1], n);
countingSort(&A[0], &B[0], n);
printArray(&B[1], n);
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <stdio.h>
#define N 10000
int A[200000], C[N], B[2000001];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
#include <stdio.h>
#define N 10000
int A[2000001], C[N], B[2000001];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < N; i++) {
C[i] = 0;
}
for (i = 1; i < n + 1; i++) {
C[A[i]] += 1;
}
for (i = 0; i < N; i++) {
C[i] += C[i - 1];
}
for (i = n + 1; i > 0; i--) {
B[C[A[i]]] = A[i];
C[A[i]] -= 1;
}
for (i = 1; i < n; i++) {
printf("%d ", B[i]);
}
printf("%d", B[i]);
printf("\n");
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02275
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
using namespace std;
const int num = 20001, num1 = 10000;
int main() {
int n, a[num], c[num1 + 1], b[num];
cin >> n;
for (int i = 0; i <= num1; i++)
c[i] = 0;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
c[a[i]]++;
for (int i = 1; i <= num1; i++)
c[i] += c[i - 1];
for (int i = 0; i < n; i++)
b[(c[a[i]]--) - 1] = a[i];
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << b[i];
}
cout << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string>
using namespace std;
const int num = 2000001, num1 = 10000;
int main() {
int n, a[num], c[num1 + 1], b[num];
cin >> n;
for (int i = 0; i <= num1; i++)
c[i] = 0;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
c[a[i]]++;
for (int i = 1; i <= num1; i++)
c[i] += c[i - 1];
for (int i = 0; i < n; i++)
b[(c[a[i]]--) - 1] = a[i];
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << b[i];
}
cout << endl;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02275
|
C++
|
Time Limit Exceeded
|
#include "string.h"
#include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using intll_t = long long;
int main() {
int N;
scanf("%d", &N);
vector<int> AIS;
AIS.reserve(N);
for (int i = 0; i < N; i++) {
int AI;
scanf("%d", &AI);
AIS.push_back(AI);
}
vector<int> c(10001, 0);
for (int number : AIS) {
c[number]++;
}
for (int i = 1; i < c.size(); i++) {
c[i] += c[i - 1];
}
vector<int> out(N, 0);
for (int j = N - 1; j >= 0; j--) {
int number = AIS[j];
int &cntAtMostNumber = c[number];
out[cntAtMostNumber - 1] = number;
cntAtMostNumber--;
}
auto outIt = out.begin();
while (true) {
printf("%d", *outIt);
if (outIt == out.end()) {
break;
} else {
printf(" ");
}
}
printf("\n");
return 0;
}
|
#include "string.h"
#include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using intll_t = long long;
int main() {
int N;
scanf("%d", &N);
vector<int> AIS;
AIS.reserve(N);
for (int i = 0; i < N; i++) {
int AI;
scanf("%d", &AI);
AIS.push_back(AI);
}
vector<int> c(10001, 0);
for (int number : AIS) {
c[number]++;
}
for (int i = 1; i < c.size(); i++) {
c[i] += c[i - 1];
}
vector<int> out(N, 0);
for (int j = N - 1; j >= 0; j--) {
int number = AIS[j];
int &cntAtMostNumber = c[number];
out[cntAtMostNumber - 1] = number;
cntAtMostNumber--;
}
auto outIt = out.begin();
while (true) {
printf("%d", *outIt);
++outIt;
if (outIt == out.end()) {
break;
} else {
printf(" ");
}
}
printf("\n");
return 0;
}
|
insert
| 45 | 45 | 45 | 46 |
TLE
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cout << ((i != 0) ? " " : "") << A[i];
}
cout << endl;
}
static vector<int> C(10000 + 1, 0);
static inline void countingSort(int A[], int B[], int num) {
for (int i = 0; i < num; i++) {
C[A[i + 1]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = num; i > 0; i--) {
// for (int i = 1; i <= num; i++) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
}
static vector<int> A(10000 + 1), B(10000 + 1);
int main() {
int n;
cin >> n;
inputArray(&A[1], n);
countingSort(&A[0], &B[0], n);
printArray(&B[1], n);
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(int A[], int num) {
for (int i = 0; i < num; i++) {
cout << ((i != 0) ? " " : "") << A[i];
}
cout << endl;
}
static vector<int> C(10000 + 1, 0);
static inline void countingSort(int A[], int B[], int num) {
for (int i = 0; i < num; i++) {
C[A[i + 1]]++;
}
for (int i = 1; i <= 10000; i++) {
C[i] = C[i] + C[i - 1];
}
for (int i = num; i > 0; i--) {
// for (int i = 1; i <= num; i++) {
B[C[A[i]]] = A[i];
C[A[i]]--;
}
}
static vector<int> A(2000000 + 1), B(2000000 + 1);
int main() {
int n;
cin >> n;
inputArray(&A[1], n);
countingSort(&A[0], &B[0], n);
printArray(&B[1], n);
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
0
| |
p02276
|
C++
|
Runtime Error
|
#include <stdio.h>
#define N 10000
int partition(int, int);
int A[N];
int main() {
int i, n, q;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
q = partition(0, n - 1);
for (i = 0; i < n; i++) {
if (i != 0)
printf(" ");
if (i == q)
printf("[");
printf("%d", A[i]);
if (i == q)
printf("]");
}
printf("\n");
return 0;
}
int partition(int y, int x) {
int i, j, n, m;
n = A[x];
j = y - 1;
for (i = 0; i < x; i++) {
if (A[i] <= n) {
j++;
m = A[j];
A[j] = A[i];
A[i] = m;
}
}
m = A[j + 1];
A[j + 1] = A[x];
A[x] = m;
return j + 1;
}
|
#include <stdio.h>
#define N 100000
int partition(int, int);
int A[N];
int main() {
int i, n, q;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
q = partition(0, n - 1);
for (i = 0; i < n; i++) {
if (i != 0)
printf(" ");
if (i == q)
printf("[");
printf("%d", A[i]);
if (i == q)
printf("]");
}
printf("\n");
return 0;
}
int partition(int y, int x) {
int i, j, n, m;
n = A[x];
j = y - 1;
for (i = 0; i < x; i++) {
if (A[i] <= n) {
j++;
m = A[j];
A[j] = A[i];
A[i] = m;
}
}
m = A[j + 1];
A[j + 1] = A[x];
A[x] = m;
return j + 1;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p02276
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
int n;
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
cerr << "j:" << j << endl;
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
int main() {
for (; cin >> n;) {
int data[n];
for (int i = 0; i < n; i++)
cin >> data[i];
int q = partition(data, 0, n - 1);
for (int i = 0; i < n; i++) {
if (i == q)
cout << "[";
cout << data[i];
if (i == q)
cout << "]";
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
}
|
#include <iostream>
#include <vector>
using namespace std;
int n;
int partition(int A[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
int main() {
for (; cin >> n;) {
int data[n];
for (int i = 0; i < n; i++)
cin >> data[i];
int q = partition(data, 0, n - 1);
for (int i = 0; i < n; i++) {
if (i == q)
cout << "[";
cout << data[i];
if (i == q)
cout << "]";
if (i != n - 1)
cout << " ";
else
cout << endl;
}
}
}
|
delete
| 9 | 10 | 9 | 9 |
0
|
j:0
j:1
j:2
j:3
j:4
j:5
j:6
j:7
j:8
j:9
j:10
|
p02276
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
using namespace std;
int n[100003] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++)
cin >> n[i];
int x = 0, y = 0;
while (x < N && y < N) {
if (n[x] < n[N - 1]) {
x++;
y = x + 1;
} else if (n[x] > n[N - 1] && n[y] > n[N - 1])
y++;
else if (n[x] > n[N - 1] && n[y] <= n[N - 1]) {
int t = n[y];
n[y] = n[x];
n[x] = t;
x++;
y++;
}
}
// cout<<n[N-1];
// int t=n[N-1];n[N-1]=n[x-1];n[x-1]=t;
for (int i = 0; i < N; i++) {
if (i > 0)
cout << " ";
if (i != x - 1)
cout << n[i];
if (i == x - 1)
cout << "[" << n[i] << "]";
}
cout << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
using namespace std;
int n[100003] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++)
cin >> n[i];
int x = 0, y = 0;
while (x < N && y < N) {
if (n[x] <= n[N - 1]) {
x++;
y = x + 1;
} else if (n[x] > n[N - 1] && n[y] > n[N - 1])
y++;
else if (n[x] > n[N - 1] && n[y] <= n[N - 1]) {
int t = n[y];
n[y] = n[x];
n[x] = t;
x++;
y++;
}
}
// cout<<n[N-1];
// int t=n[N-1];n[N-1]=n[x-1];n[x-1]=t;
for (int i = 0; i < N; i++) {
if (i > 0)
cout << " ";
if (i != x - 1)
cout << n[i];
if (i == x - 1)
cout << "[" << n[i] << "]";
}
cout << endl;
return 0;
}
|
replace
| 17 | 18 | 17 | 19 |
TLE
| |
p02276
|
C++
|
Runtime Error
|
#include <stdio.h>
int main() {
int i, a, A[50000], z, jsta = 0, jend = 0, B[50000], j;
scanf("%d", &a);
for (i = 0; i < a; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < a; i++) {
if (A[i] <= A[a - 1]) {
z = A[jsta];
A[jsta] = A[i];
A[i] = z;
jsta++;
jend++;
} else
jend++;
}
for (i = 0; i < a; i++) {
if (i == jsta - 1)
printf("[%d] ", A[i]);
else if (i != a - 1)
printf("%d ", A[i]);
else
printf("%d", A[i]);
}
printf("\n");
}
|
#include <stdio.h>
int main() {
int i, a, A[100000], z, jsta = 0, jend = 0, B[100000], j;
scanf("%d", &a);
for (i = 0; i < a; i++) {
scanf("%d", &A[i]);
}
for (i = 0; i < a; i++) {
if (A[i] <= A[a - 1]) {
z = A[jsta];
A[jsta] = A[i];
A[i] = z;
jsta++;
jend++;
} else
jend++;
}
for (i = 0; i < a; i++) {
if (i == jsta - 1)
printf("[%d] ", A[i]);
else if (i != a - 1)
printf("%d ", A[i]);
else
printf("%d", A[i]);
}
printf("\n");
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02276
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
// Exchange
void exchange(int A[], int i, int j) {
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
// Partition
int partition(int A[], int l, int r) {
int threshold = A[r - 1];
int i = l - 1;
for (int j = l; j < r - 1; j++) {
if (A[j] <= threshold) {
i++;
// Exchange
exchange(A, i, j);
}
}
i++;
// Insert threshold
exchange(A, i, r - 1);
return i;
}
// MAIN FUNCTION
int main(int argc, char **argv) {
// Input
int A[50000];
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
// Partition
int pivot = partition(A, 0, n);
// Print all elements
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
if (i == pivot) {
cout << "[" << A[i] << "]";
} else {
cout << A[i];
}
}
cout << endl;
return 0;
}
|
#include <iostream>
using namespace std;
// Exchange
void exchange(int A[], int i, int j) {
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
// Partition
int partition(int A[], int l, int r) {
int threshold = A[r - 1];
int i = l - 1;
for (int j = l; j < r - 1; j++) {
if (A[j] <= threshold) {
i++;
// Exchange
exchange(A, i, j);
}
}
i++;
// Insert threshold
exchange(A, i, r - 1);
return i;
}
// MAIN FUNCTION
int main(int argc, char **argv) {
// Input
int A[1000000];
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
// Partition
int pivot = partition(A, 0, n);
// Print all elements
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
if (i == pivot) {
cout << "[" << A[i] << "]";
} else {
cout << A[i];
}
}
cout << endl;
return 0;
}
|
replace
| 31 | 32 | 31 | 32 |
0
| |
p02276
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *A = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
cin >> A[i];
}
int x = A[n];
int i = 0;
int tmp = 0;
for (int j = 1; j <= n - 1; j++) {
if (A[j] <= x) {
i = i + 1;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
tmp = A[i + 1];
A[i + 1] = A[n];
A[n] = tmp;
i = i + 1;
for (int j = 1; j < n + 1; j++) {
if (j == i) {
cout << '[' << A[j] << ']';
} else {
cout << A[j];
}
if (j = n - 1) {
cout << ' ';
} else {
cout << endl;
}
}
delete[] A;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *A = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
cin >> A[i];
}
int x = A[n];
int i = 0;
int tmp = 0;
for (int j = 1; j <= n - 1; j++) {
if (A[j] <= x) {
i = i + 1;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
tmp = A[i + 1];
A[i + 1] = A[n];
A[n] = tmp;
i = i + 1;
for (int j = 1; j < n + 1; j++) {
if (j == i) {
cout << '[' << A[j] << ']';
} else {
cout << A[j];
}
if (j < n) {
cout << ' ';
} else {
cout << endl;
}
}
delete[] A;
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
TLE
| |
p02276
|
C++
|
Runtime Error
|
#include <cstdlib>
#include <iostream>
#include <list>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, s[10000], small = 0, large = 0, cnt = 0;
cin >> n;
bool b = true;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
if (s[i] <= s[n - 1]) {
small = i;
cnt++;
if (small > large) {
swap(s[small], s[large]);
large += 1;
}
} else if (b == true) {
b = false;
large = i;
}
if (b == true) {
large++;
}
}
for (int i = 0; i < n; i++) {
if (i == cnt - 1) {
printf(" [%d]", s[i]);
} else {
if (i != 0) {
cout << " ";
}
cout << s[i];
}
}
cout << endl;
return 0;
}
|
#include <cstdlib>
#include <iostream>
#include <list>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, s[100000], small = 0, large = 0, cnt = 0;
cin >> n;
bool b = true;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
if (s[i] <= s[n - 1]) {
small = i;
cnt++;
if (small > large) {
swap(s[small], s[large]);
large += 1;
}
} else if (b == true) {
b = false;
large = i;
}
if (b == true) {
large++;
}
}
for (int i = 0; i < n; i++) {
if (i == cnt - 1) {
printf(" [%d]", s[i]);
} else {
if (i != 0) {
cout << " ";
}
cout << s[i];
}
}
cout << endl;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02277
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
struct Card {
char suit;
int value;
};
struct Card L[100000 / 2 + 2], R[100000 / 2 + 2];
void merge(struct Card A[], int n, int left, int mid, int right) {
int i, j;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = 10000000;
i = j = 0;
for (int k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(struct Card A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int partition(struct Card A[], int n, int p, int r) {
struct Card x;
int i, j;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quickSort(struct Card A[], int n, int p, int r) {
int q;
if (p < r) {
q = partition(A, n, p, r);
quickSort(A, n, p, q - 1);
quickSort(A, n, q + 1, r);
}
}
int main() {
int n, v;
struct Card A[10000], B[10000];
char ch;
// 入力
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ch >> v;
A[i].suit = B[i].suit = ch;
A[i].value = B[i].value = v;
}
mergeSort(A, n, 0, n);
quickSort(B, n, 0, n - 1);
// 安定しているかどうか調べる
int stable = 1;
for (int i = 0; i < n; i++) {
if (A[i].suit != B[i].suit)
stable = 0;
}
if (stable == 1)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
// 出力
for (int i = 0; i < n; i++) {
cout << B[i].suit << " " << B[i].value << endl;
}
}
|
#include <iostream>
using namespace std;
struct Card {
char suit;
int value;
};
struct Card L[100000 / 2 + 2], R[100000 / 2 + 2];
void merge(struct Card A[], int n, int left, int mid, int right) {
int i, j;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = 10000000;
i = j = 0;
for (int k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(struct Card A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int partition(struct Card A[], int n, int p, int r) {
struct Card x;
int i, j;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[r]);
return i + 1;
}
void quickSort(struct Card A[], int n, int p, int r) {
int q;
if (p < r) {
q = partition(A, n, p, r);
quickSort(A, n, p, q - 1);
quickSort(A, n, q + 1, r);
}
}
int main() {
int n, v;
struct Card A[100000], B[100000];
char ch;
// 入力
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ch >> v;
A[i].suit = B[i].suit = ch;
A[i].value = B[i].value = v;
}
mergeSort(A, n, 0, n);
quickSort(B, n, 0, n - 1);
// 安定しているかどうか調べる
int stable = 1;
for (int i = 0; i < n; i++) {
if (A[i].suit != B[i].suit)
stable = 0;
}
if (stable == 1)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
// 出力
for (int i = 0; i < n; i++) {
cout << B[i].suit << " " << B[i].value << endl;
}
}
|
replace
| 65 | 66 | 65 | 66 |
0
| |
p02277
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
#define NMAX 10000
#define SENTINEL 1000000001
int Partition(int A[], char B[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j <= r - 1; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
swap(B[i], B[j]);
}
}
swap(A[i + 1], A[r]);
swap(B[i + 1], B[r]);
return i + 1;
}
void Quicksort(int A[], char B[], int p, int r) {
if (p < r) {
int q = Partition(A, B, p, r);
Quicksort(A, B, p, q - 1);
Quicksort(A, B, q + 1, r);
}
return;
}
void merge(int A[], char B[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[NMAX], R[NMAX];
char LL[NMAX], RR[NMAX];
for (int i = 0; i <= n1 - 1; i++) {
L[i] = A[left + i];
LL[i] = B[left + i];
}
for (int i = 0; i <= n2 - 1; i++) {
R[i] = A[mid + i];
RR[i] = B[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k <= right - 1; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
B[k] = LL[i];
i++;
} else {
A[k] = R[j];
B[k] = RR[j];
j++;
}
}
}
void merge_sort(int A[], char B[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, B, left, mid);
merge_sort(A, B, mid, right);
merge(A, B, left, mid, right);
}
}
int main(void) {
std::ios_base::sync_with_stdio(false);
int n, qA[NMAX], mA[NMAX];
char qB[NMAX], mB[NMAX];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> qB[i] >> qA[i];
mA[i] = qA[i];
mB[i] = qB[i];
}
Quicksort(qA, qB, 0, n - 1);
merge_sort(mA, mB, 0, n);
bool f = true;
for (int i = 0; i < n; i++) {
if (qB[i] != mB[i]) {
f = false;
break;
}
}
if (f)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; i++) {
cout << qB[i] << " " << qA[i] << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
#define NMAX 100000
#define SENTINEL 1000000001
int Partition(int A[], char B[], int p, int r) {
int x = A[r];
int i = p - 1;
for (int j = p; j <= r - 1; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
swap(B[i], B[j]);
}
}
swap(A[i + 1], A[r]);
swap(B[i + 1], B[r]);
return i + 1;
}
void Quicksort(int A[], char B[], int p, int r) {
if (p < r) {
int q = Partition(A, B, p, r);
Quicksort(A, B, p, q - 1);
Quicksort(A, B, q + 1, r);
}
return;
}
void merge(int A[], char B[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[NMAX], R[NMAX];
char LL[NMAX], RR[NMAX];
for (int i = 0; i <= n1 - 1; i++) {
L[i] = A[left + i];
LL[i] = B[left + i];
}
for (int i = 0; i <= n2 - 1; i++) {
R[i] = A[mid + i];
RR[i] = B[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k <= right - 1; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
B[k] = LL[i];
i++;
} else {
A[k] = R[j];
B[k] = RR[j];
j++;
}
}
}
void merge_sort(int A[], char B[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, B, left, mid);
merge_sort(A, B, mid, right);
merge(A, B, left, mid, right);
}
}
int main(void) {
std::ios_base::sync_with_stdio(false);
int n, qA[NMAX], mA[NMAX];
char qB[NMAX], mB[NMAX];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> qB[i] >> qA[i];
mA[i] = qA[i];
mB[i] = qB[i];
}
Quicksort(qA, qB, 0, n - 1);
merge_sort(mA, mB, 0, n);
bool f = true;
for (int i = 0; i < n; i++) {
if (qB[i] != mB[i]) {
f = false;
break;
}
}
if (f)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; i++) {
cout << qB[i] << " " << qA[i] << endl;
}
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02277
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
const int INF = (1 << 30);
const int N = 100005;
struct Card {
char suit;
int value;
} card[N], t[N], temp;
Card L[N / 2 + 1], R[N / 2 + 1];
void _merge(Card a[], int l, int m, int r) //[l, r)
{
int i, j, k;
int n1 = m - l;
int n2 = r - m;
for (i = 0; i < n1; ++i)
L[i] = a[l + i];
for (i = 0; i < n2; ++i)
R[i] = a[m + i];
L[n1].value = R[n2].value = INF;
i = j = 0;
for (k = l; k < r; ++k) {
if (L[i].value <= R[j].value)
a[k] = L[i++];
else
a[k] = R[j++];
}
}
void _merge_sort(Card arr[], int l, int r) {
if (l + 1 >= r)
return;
int m = (l + r) >> 2;
_merge_sort(arr, l, m);
_merge_sort(arr, m, r);
_merge(arr, l, m, r);
}
int partition(Card arr[], int p,
int r) //[p, r)????????????,????????????pivot??????
{
int pivot = arr[r - 1].value;
int i = p;
for (int j = p; j < r - 1; ++j) {
if (arr[j].value <= pivot) {
temp = arr[i];
arr[i++] = arr[j];
arr[j] = temp;
}
}
temp = arr[i];
arr[i] = arr[r - 1];
arr[r - 1] = temp;
return i;
}
void q_sort(Card arr[], int l, int r) {
if (l + 1 < r) {
int t = partition(arr, l, r);
q_sort(arr, l, t);
q_sort(arr, t, r);
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> card[i].suit >> card[i].value;
t[i] = card[i];
}
q_sort(card, 0, n);
_merge_sort(t, 0, n);
bool flag = true;
for (int i = 0; i < n; ++i) {
if (card[i].suit != t[i].suit) {
flag = false;
break;
}
}
if (flag)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; ++i)
cout << card[i].suit << ' ' << card[i].value << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
const int INF = (1 << 30);
const int N = 100005;
struct Card {
char suit;
int value;
} card[N], t[N], temp;
Card L[N / 2 + 1], R[N / 2 + 1];
void _merge(Card a[], int l, int m, int r) //[l, r)
{
int i, j, k;
int n1 = m - l;
int n2 = r - m;
for (i = 0; i < n1; ++i)
L[i] = a[l + i];
for (i = 0; i < n2; ++i)
R[i] = a[m + i];
L[n1].value = R[n2].value = INF;
i = j = 0;
for (k = l; k < r; ++k) {
if (L[i].value <= R[j].value)
a[k] = L[i++];
else
a[k] = R[j++];
}
}
void _merge_sort(Card arr[], int l, int r) {
if (l + 1 >= r)
return;
int m = (l + r) >> 1;
_merge_sort(arr, l, m);
_merge_sort(arr, m, r);
_merge(arr, l, m, r);
}
int partition(Card arr[], int p,
int r) //[p, r)????????????,????????????pivot??????
{
int pivot = arr[r - 1].value;
int i = p;
for (int j = p; j < r - 1; ++j) {
if (arr[j].value <= pivot) {
temp = arr[i];
arr[i++] = arr[j];
arr[j] = temp;
}
}
temp = arr[i];
arr[i] = arr[r - 1];
arr[r - 1] = temp;
return i;
}
void q_sort(Card arr[], int l, int r) {
if (l + 1 < r) {
int t = partition(arr, l, r);
q_sort(arr, l, t);
q_sort(arr, t, r);
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> card[i].suit >> card[i].value;
t[i] = card[i];
}
q_sort(card, 0, n);
_merge_sort(t, 0, n);
bool flag = true;
for (int i = 0; i < n; ++i) {
if (card[i].suit != t[i].suit) {
flag = false;
break;
}
}
if (flag)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; ++i)
cout << card[i].suit << ' ' << card[i].value << endl;
return 0;
}
|
replace
| 34 | 35 | 34 | 35 |
-11
| |
p02277
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <iostream>
using namespace std;
#define MAX 100000
#define SENTINEL 2000000000
struct Card {
char suit;
int value;
};
struct Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(struct Card A[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = SENTINEL;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(struct Card A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(struct Card A[], int p, int r) {
int i, j;
struct Card t, x;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
t = A[i];
A[i] = A[j];
A[j] = t;
}
}
t = A[i + 1];
A[i + 1] = A[r];
A[r] = t;
return i + 1;
}
void quickSort(struct Card A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
}
int main() {
int n, i, v;
struct Card A[MAX], B[MAX];
char S[10];
int stable = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %d", S, &v);
A[i].suit = B[i].suit = S[0];
A[i].value = B[i].value = v;
}
mergeSort(A, 0, n);
quickSort(B, 0, n - 1);
for (i = 0; i < n; i++) {
if (A[i].suit != B[i].suit) {
stable = 0;
break;
}
}
mergeSort(A, 0, n);
quickSort(B, 0, n - 1);
for (i = 0; i < n; i++) {
if (A[i].suit != B[i].suit) {
stable = 0;
break;
}
}
if (stable == 1)
printf("Stable\n");
else
printf("Not stable\n");
for (int i = 0; i < n; i++) {
printf("%c %d\n", B[i].suit, B[i].value);
// printf("%c %d\n", A[i].suit, A[i].value);
}
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
#define MAX 100000
#define SENTINEL 2000000000
struct Card {
char suit;
int value;
};
struct Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(struct Card A[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = SENTINEL;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(struct Card A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(struct Card A[], int p, int r) {
int i, j;
struct Card t, x;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
t = A[i];
A[i] = A[j];
A[j] = t;
}
}
t = A[i + 1];
A[i + 1] = A[r];
A[r] = t;
return i + 1;
}
void quickSort(struct Card A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
}
int main() {
int n, i, v;
struct Card A[MAX], B[MAX];
char S[10];
int stable = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %d", S, &v);
A[i].suit = B[i].suit = S[0];
A[i].value = B[i].value = v;
}
mergeSort(A, 0, n);
quickSort(B, 0, n - 1);
for (i = 0; i < n; i++) {
if (A[i].suit != B[i].suit) {
stable = 0;
break;
}
}
if (stable == 1)
printf("Stable\n");
else
printf("Not stable\n");
for (int i = 0; i < n; i++) {
printf("%c %d\n", B[i].suit, B[i].value);
// printf("%c %d\n", A[i].suit, A[i].value);
}
return 0;
}
|
delete
| 95 | 105 | 95 | 95 |
TLE
| |
p02277
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
struct Card {
char suit;
int value;
bool operator<(const Card &c) const { return this->value < c.value; }
bool operator<=(const Card &c) const { return this->value <= c.value; }
Card &operator=(int val) { this->value = val; }
};
#define MAX 100000
#define SENTINEL 2000000000
Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(Card *a, int n, int l, int mid, int r) {
int n1 = mid - l;
int n2 = r - mid;
rep(i, n1) L[i] = a[l + i];
rep(i, n2) R[i] = a[mid + i];
L[n1] = R[n2] = SENTINEL;
int i, j;
i = j = 0;
for (int k = l; k < r; k++) {
if (L[i] <= R[j])
a[k] = L[i++];
else
a[k] = R[j++];
}
}
void merge_sort(Card *a, int n, int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
merge_sort(a, n, l, mid);
merge_sort(a, n, mid, r);
merge(a, n, l, mid, r);
}
}
int partition(Card *a, int p, int r) {
int i, j;
Card x;
x = a[r];
i = p - 1;
for (int j = p; j < r; j++) {
if (a[j] <= x) {
i++;
swap(a[i], a[j]);
}
}
swap(a[i + 1], a[r]);
return i + 1;
}
void quick_sort(Card *a, int n, int p, int r) {
int q;
if (p < r) {
q = partition(a, p, r);
quick_sort(a, n, p, q - 1);
quick_sort(a, n, q + 1, r);
}
}
Card A[MAX], B[MAX];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> A[i].suit >> A[i].value;
B[i] = A[i];
}
merge_sort(A, n, 0, n);
quick_sort(B, n, 0, n - 1);
bool is_stable = true;
rep(i, n) is_stable &= A[i].suit == B[i].suit;
if (is_stable)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
rep(i, n) cout << B[i].suit << " " << B[i].value << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
struct Card {
char suit;
int value;
bool operator<(const Card &c) const { return this->value < c.value; }
bool operator<=(const Card &c) const { return this->value <= c.value; }
Card &operator=(int val) { this->value = val; }
};
#define MAX 100000
#define SENTINEL 2000000000
Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(Card *a, int n, int l, int mid, int r) {
int n1 = mid - l;
int n2 = r - mid;
rep(i, n1) L[i] = a[l + i];
rep(i, n2) R[i] = a[mid + i];
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i, j;
i = j = 0;
for (int k = l; k < r; k++) {
if (L[i] <= R[j])
a[k] = L[i++];
else
a[k] = R[j++];
}
}
void merge_sort(Card *a, int n, int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
merge_sort(a, n, l, mid);
merge_sort(a, n, mid, r);
merge(a, n, l, mid, r);
}
}
int partition(Card *a, int p, int r) {
int i, j;
Card x;
x = a[r];
i = p - 1;
for (int j = p; j < r; j++) {
if (a[j] <= x) {
i++;
swap(a[i], a[j]);
}
}
swap(a[i + 1], a[r]);
return i + 1;
}
void quick_sort(Card *a, int n, int p, int r) {
int q;
if (p < r) {
q = partition(a, p, r);
quick_sort(a, n, p, q - 1);
quick_sort(a, n, q + 1, r);
}
}
Card A[MAX], B[MAX];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> A[i].suit >> A[i].value;
B[i] = A[i];
}
merge_sort(A, n, 0, n);
quick_sort(B, n, 0, n - 1);
bool is_stable = true;
rep(i, n) is_stable &= A[i].suit == B[i].suit;
if (is_stable)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
rep(i, n) cout << B[i].suit << " " << B[i].value << endl;
return 0;
}
|
replace
| 49 | 50 | 49 | 51 |
0
| |
p02277
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
using namespace std;
struct Card {
char mark;
int value;
};
int merge(struct Card A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int i, j, k;
struct Card L[25001];
struct Card R[25001];
for (i = 0; i <= n1 - 1; i++)
L[i] = A[left + i];
for (i = 0; i <= n2 - 1; i++)
R[i] = A[mid + i];
L[n1].value = 2000000001;
R[n2].value = 2000000001;
i = 0;
j = 0;
for (k = left; k <= right - 1; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
int mergeSort(struct Card A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(struct Card A[], int p, int r) {
int i, j;
struct Card x, temp;
x = A[r];
i = p - 1;
for (j = p; j <= r - 1; j++) {
if (A[j].value <= x.value) {
i++;
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
temp = A[r];
A[r] = A[i + 1];
A[i + 1] = temp;
return i + 1;
}
int quickSort(struct Card A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
}
int main() {
int i, n, v;
struct Card A[100000], B[100000];
char m[2];
int s = 0;
scanf("%d", &n);
for (i = 0; i <= n - 1; i++) {
scanf("%s %d", m, &v);
A[i].mark = B[i].mark = m[0];
A[i].value = B[i].value = v;
}
quickSort(A, 0, n - 1);
mergeSort(B, 0, n);
for (i = 0; i <= n - 1; i++) {
if (A[i].mark != B[i].mark)
s = 1;
}
if (s == 0)
printf("Stable\n");
else
printf("Not stable\n");
for (i = 0; i <= n - 1; i++) {
printf("%c %d\n", A[i].mark, A[i].value);
}
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
struct Card {
char mark;
int value;
};
int merge(struct Card A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int i, j, k;
struct Card L[50001];
struct Card R[50001];
for (i = 0; i <= n1 - 1; i++)
L[i] = A[left + i];
for (i = 0; i <= n2 - 1; i++)
R[i] = A[mid + i];
L[n1].value = 2000000001;
R[n2].value = 2000000001;
i = 0;
j = 0;
for (k = left; k <= right - 1; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
int mergeSort(struct Card A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int partition(struct Card A[], int p, int r) {
int i, j;
struct Card x, temp;
x = A[r];
i = p - 1;
for (j = p; j <= r - 1; j++) {
if (A[j].value <= x.value) {
i++;
temp = A[j];
A[j] = A[i];
A[i] = temp;
}
}
temp = A[r];
A[r] = A[i + 1];
A[i + 1] = temp;
return i + 1;
}
int quickSort(struct Card A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
}
int main() {
int i, n, v;
struct Card A[100000], B[100000];
char m[2];
int s = 0;
scanf("%d", &n);
for (i = 0; i <= n - 1; i++) {
scanf("%s %d", m, &v);
A[i].mark = B[i].mark = m[0];
A[i].value = B[i].value = v;
}
quickSort(A, 0, n - 1);
mergeSort(B, 0, n);
for (i = 0; i <= n - 1; i++) {
if (A[i].mark != B[i].mark)
s = 1;
}
if (s == 0)
printf("Stable\n");
else
printf("Not stable\n");
for (i = 0; i <= n - 1; i++) {
printf("%c %d\n", A[i].mark, A[i].value);
}
return 0;
}
|
replace
| 13 | 15 | 13 | 15 |
0
| |
p02277
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define AMAX 100001
struct card {
char mark;
int value;
int cnt;
};
card a[AMAX];
int partion(int q, int r) {
int x = a[r].value;
int i = q - 1;
for (int j = q; j < r; j++) {
if (a[j].value <= x) {
i = i + 1;
swap(a[i], a[j]);
}
}
swap(a[i + 1], a[r]);
return i + 1;
}
void quicksort(int p, int r) {
if (p < r) {
int q;
q = partion(q, r);
quicksort(p, q - 1);
quicksort(q + 1, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf(" %c %d", &a[i].mark, &a[i].value);
a[i].cnt = i;
}
quicksort(0, n - 1);
int junge = 0;
for (int i = 1; i < n; i++) {
if (a[i - 1].value == a[i].value && a[i - 1].cnt > a[i].cnt)
junge = 1;
}
if (junge == 1)
printf("Not stable\n");
else
printf("Stable\n");
for (int i = 0; i < n; i++) {
printf("%c %d\n", a[i].mark, a[i].value);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define AMAX 100001
struct card {
char mark;
int value;
int cnt;
};
card a[AMAX];
int partion(int q, int r) {
int x = a[r].value;
int i = q - 1;
for (int j = q; j < r; j++) {
if (a[j].value <= x) {
i = i + 1;
swap(a[i], a[j]);
}
}
swap(a[i + 1], a[r]);
return i + 1;
}
void quicksort(int p, int r) {
if (p < r) {
int q;
q = partion(p, r);
quicksort(p, q - 1);
quicksort(q + 1, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf(" %c %d", &a[i].mark, &a[i].value);
a[i].cnt = i;
}
quicksort(0, n - 1);
int junge = 0;
for (int i = 1; i < n; i++) {
if (a[i - 1].value == a[i].value && a[i - 1].cnt > a[i].cnt)
junge = 1;
}
if (junge == 1)
printf("Not stable\n");
else
printf("Stable\n");
for (int i = 0; i < n; i++) {
printf("%c %d\n", a[i].mark, a[i].value);
}
}
|
replace
| 29 | 30 | 29 | 30 |
TLE
| |
p02277
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <utility>
#include <vector>
int Partition(std::vector<std::pair<char, int>> &v, int p, int r) {
int x = v[r].second;
int i = p - 1;
for (int j = p; j < r; ++j) {
if (v[j].second <= x) {
v[++i].swap(v[j]);
}
}
v[i + 1].swap(v[r]);
return i + 1;
}
void QuickSort(std::vector<std::pair<char, int>> &v, int p, int r) {
if (p < r) {
int q = Partition(v, p, r);
QuickSort(v, p, q - 1);
QuickSort(v, q + 1, r);
}
}
constexpr int fIndex = -3;
int BinarySearch(std::vector<std::pair<char, int>> &v, int key) {
int left = 0;
int right = v.size();
int mid;
// std::cout << key << ": ";
while (left < right) {
mid = (left + right) / 2;
if (v[mid].second == key) {
// std::cout << key;
return mid;
} else if (key < v[mid].second) {
right = mid;
} else {
left = mid + 1;
}
if (key == 1) {
// std::cout << v[mid] << " ";
}
}
return fIndex;
}
// code below cause TLE
// std::string CheckStable( const std::vector<std::pair<char, int>>& initial,
// const std::vector<std::pair<char, int>>& sorted ){
// int N = sorted.size();
// int key;
// for( int i = 0; i < N; ++i ){
// if( sorted[i].second == sorted[i+1].second ){
// key = sorted[i].second;
// for( j = i+1; sorted[j] == key; ++j ){
// if( initial[i] )
// }
// }
// }
// return "Stable";
// }
std::string CheckStable(std::vector<std::pair<char, int>> &initial,
std::vector<std::pair<char, int>> &sorted) {
int N = sorted.size();
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if (initial[i].second == initial[j].second) {
for (int a = 0 /*BinarySearch( sorted, initial[i].second )*/; a < N;
++a) {
for (int b = a + 1; b < N; ++b) {
if (initial[i] == sorted[b] && initial[j] == sorted[a]) {
return "Not stable";
}
}
}
}
}
}
return "Stable";
}
int main() {
int n;
std::cin.tie(0);
std::cin >> n;
std::vector<std::pair<char, int>> cards(n);
int number;
char symbol;
for (auto &elem : cards) {
std::cin >> symbol >> number;
elem = std::make_pair(symbol, number);
}
std::vector<std::pair<char, int>> input(cards);
QuickSort(cards, 0, cards.size() - 1);
std::cout << CheckStable(input, cards) << "\n";
for (const auto &elem : cards) {
std::cout << elem.first << " " << elem.second << "\n";
}
}
|
#include <iostream>
#include <utility>
#include <vector>
int Partition(std::vector<std::pair<char, int>> &v, int p, int r) {
int x = v[r].second;
int i = p - 1;
for (int j = p; j < r; ++j) {
if (v[j].second <= x) {
v[++i].swap(v[j]);
}
}
v[i + 1].swap(v[r]);
return i + 1;
}
void QuickSort(std::vector<std::pair<char, int>> &v, int p, int r) {
if (p < r) {
int q = Partition(v, p, r);
QuickSort(v, p, q - 1);
QuickSort(v, q + 1, r);
}
}
constexpr int fIndex = -3;
int BinarySearch(std::vector<std::pair<char, int>> &v, int key) {
int left = 0;
int right = v.size();
int mid;
// std::cout << key << ": ";
while (left < right) {
mid = (left + right) / 2;
if (v[mid].second == key) {
// std::cout << key;
return mid;
} else if (key < v[mid].second) {
right = mid;
} else {
left = mid + 1;
}
if (key == 1) {
// std::cout << v[mid] << " ";
}
}
return fIndex;
}
// code below cause TLE
// std::string CheckStable( const std::vector<std::pair<char, int>>& initial,
// const std::vector<std::pair<char, int>>& sorted ){
// int N = sorted.size();
// int key;
// for( int i = 0; i < N; ++i ){
// if( sorted[i].second == sorted[i+1].second ){
// key = sorted[i].second;
// for( j = i+1; sorted[j] == key; ++j ){
// if( initial[i] )
// }
// }
// }
// return "Stable";
// }
std::string CheckStable(std::vector<std::pair<char, int>> &initial,
std::vector<std::pair<char, int>> &sorted) {
int N = sorted.size();
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
if (initial[i].second == initial[j].second) {
for (int a = 0 /*BinarySearch( sorted, initial[i].second )*/; a < N;
++a) {
if (sorted[a].second == initial[i].second) {
for (int b = a + 1; b < N; ++b) {
if (initial[i] == sorted[b] && initial[j] == sorted[a]) {
return "Not stable";
}
}
}
}
}
}
}
return "Stable";
}
int main() {
int n;
std::cin.tie(0);
std::cin >> n;
std::vector<std::pair<char, int>> cards(n);
int number;
char symbol;
for (auto &elem : cards) {
std::cin >> symbol >> number;
elem = std::make_pair(symbol, number);
}
std::vector<std::pair<char, int>> input(cards);
QuickSort(cards, 0, cards.size() - 1);
std::cout << CheckStable(input, cards) << "\n";
for (const auto &elem : cards) {
std::cout << elem.first << " " << elem.second << "\n";
}
}
|
replace
| 73 | 76 | 73 | 78 |
TLE
| |
p02277
|
C++
|
Runtime Error
|
// クイックソート
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
// #define MAX_N 100000
#define MAX_N 100
// const int INFTY = 2147483647;
typedef struct card {
char picture;
int number;
} CARD;
int partition(CARD A[], int p, int r);
void quickSort(CARD A[], int p, int r);
int main(void) {
int n;
CARD st_card[MAX_N], st_card_copy[MAX_N];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> st_card[i].picture >> st_card[i].number;
st_card_copy[i].picture = st_card[i].picture;
st_card_copy[i].number = st_card[i].number;
}
quickSort(&st_card[0], 0, n - 1);
int num_1, num_2;
char stable[] = "Stable\n";
char not_stable[] = "Not stable\n";
char *str = &stable[0];
// 安定なソートなのかを確認
for (int i = 0; i < n; i++) {
if (st_card[i].number == st_card[i + 1].number) {
for (int j = 0; j < n; j++) {
if ((st_card[i].picture == st_card_copy[j].picture) &&
(st_card[i].number == st_card_copy[j].number)) {
num_1 = j;
}
if ((st_card[i + 1].picture == st_card_copy[j].picture) &&
(st_card[i + 1].number == st_card_copy[j].number)) {
num_2 = j;
}
}
if (num_1 > num_2) {
str = ¬_stable[0];
// 処理終了
break;
}
}
}
printf("%s", str);
for (int i = 0; i < n; i++) {
printf("%c %d\n", st_card[i].picture, st_card[i].number);
}
return 0;
}
// クイックソートを実施する関数
// p : 範囲の先頭
// q : 範囲の最後尾
void quickSort(CARD A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
return;
}
// パーティション ソート の実施
// A[r]を基準として, 小さい要素は左側, 大きい要素は右側に並ぶ
// p : 範囲の先頭
// q : 範囲の最後尾
int partition(CARD A[], int p, int r) {
int x = 0, i = 0;
CARD tmp;
x = A[r].number;
i = p - 1;
for (int j = p; j < r; j++) {
if (A[j].number <= x) {
i++;
// A[i] と A[j]を交換
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
// A[i + 1] と A[r]を交換
tmp = A[i + 1];
A[i + 1] = A[r];
A[r] = tmp;
return i + 1;
}
|
// クイックソート
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define MAX_N 100000
// const int INFTY = 2147483647;
typedef struct card {
char picture;
int number;
} CARD;
int partition(CARD A[], int p, int r);
void quickSort(CARD A[], int p, int r);
int main(void) {
int n;
CARD st_card[MAX_N], st_card_copy[MAX_N];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> st_card[i].picture >> st_card[i].number;
st_card_copy[i].picture = st_card[i].picture;
st_card_copy[i].number = st_card[i].number;
}
quickSort(&st_card[0], 0, n - 1);
int num_1, num_2;
char stable[] = "Stable\n";
char not_stable[] = "Not stable\n";
char *str = &stable[0];
// 安定なソートなのかを確認
for (int i = 0; i < n; i++) {
if (st_card[i].number == st_card[i + 1].number) {
for (int j = 0; j < n; j++) {
if ((st_card[i].picture == st_card_copy[j].picture) &&
(st_card[i].number == st_card_copy[j].number)) {
num_1 = j;
}
if ((st_card[i + 1].picture == st_card_copy[j].picture) &&
(st_card[i + 1].number == st_card_copy[j].number)) {
num_2 = j;
}
}
if (num_1 > num_2) {
str = ¬_stable[0];
// 処理終了
break;
}
}
}
printf("%s", str);
for (int i = 0; i < n; i++) {
printf("%c %d\n", st_card[i].picture, st_card[i].number);
}
return 0;
}
// クイックソートを実施する関数
// p : 範囲の先頭
// q : 範囲の最後尾
void quickSort(CARD A[], int p, int r) {
int q;
if (p < r) {
q = partition(A, p, r);
quickSort(A, p, q - 1);
quickSort(A, q + 1, r);
}
return;
}
// パーティション ソート の実施
// A[r]を基準として, 小さい要素は左側, 大きい要素は右側に並ぶ
// p : 範囲の先頭
// q : 範囲の最後尾
int partition(CARD A[], int p, int r) {
int x = 0, i = 0;
CARD tmp;
x = A[r].number;
i = p - 1;
for (int j = p; j < r; j++) {
if (A[j].number <= x) {
i++;
// A[i] と A[j]を交換
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
// A[i + 1] と A[r]を交換
tmp = A[i + 1];
A[i + 1] = A[r];
A[r] = tmp;
return i + 1;
}
|
replace
| 12 | 14 | 12 | 13 |
0
| |
p02277
|
C++
|
Runtime Error
|
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int INF = 1 << 24;
const uint64_t MOD = 1000000000 + 7;
void merge(vector<pair<string, int>> &a, int left, int mid, int right) {
int n0 = mid - left;
int n1 = right - mid;
vector<pair<string, int>> l(n0 + 1);
vector<pair<string, int>> r(n1 + 1);
for (int i = 0; i < l.size() - 1; i++) {
l.at(i) = a.at(left + i);
}
for (int i = 0; i < r.size() - 1; i++) {
r.at(i) = a.at(mid + i);
}
l.at(n0).second = INF;
r.at(n1).second = INF;
int x = 0;
int y = 0;
for (int i = left; i < right; i++) {
if (l.at(x).second <= r.at(y).second) {
a.at(i) = l.at(x);
x++;
} else {
a.at(i) = r.at(y);
y++;
}
}
}
void merge_sort(vector<pair<string, int>> &a, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(a, left, mid);
merge_sort(a, mid, right);
merge(a, left, mid, right);
}
}
int partition(vector<pair<string, int>> &a, int p, int r) {
pair<string, int> x = a.at(r);
int id = p - 1;
for (int i = p; i < r; i++) {
if (a.at(i).second <= x.second) {
id++;
swap(a.at(i), a.at(id));
}
}
swap(a.at(id + 1), a.at(r));
return id + 1;
}
void quick_sort(vector<pair<string, int>> &a, int p, int r) {
if (p < r) {
int q = partition(a, p, r);
quick_sort(a, p, q - 1);
quick_sort(a, q + 1, r);
}
}
int main() {
int n;
cin >> n;
vector<pair<string, int>> p(n);
for (int i = 0; i < n; i++) {
string s;
int id;
cin >> s >> id;
p.at(i) = (make_pair(s, id));
}
vector<pair<string, int>> a = p;
vector<pair<string, int>> b = p;
quick_sort(a, 0, n - 1);
merge_sort(b, 0, n);
bool stable = true;
for (int i = 0; i < n; i++) {
if (a.at(i) != b.at(i)) {
stable = false;
break;
}
}
cout << (stable ? "Stable" : "Not stable") << endl;
for (int i = 0; i < n; i++) {
cout << a.at(i).first << " " << a.at(i).second << endl;
}
}
|
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
const int INF = 1 << 30;
const uint64_t MOD = 1000000000 + 7;
void merge(vector<pair<string, int>> &a, int left, int mid, int right) {
int n0 = mid - left;
int n1 = right - mid;
vector<pair<string, int>> l(n0 + 1);
vector<pair<string, int>> r(n1 + 1);
for (int i = 0; i < l.size() - 1; i++) {
l.at(i) = a.at(left + i);
}
for (int i = 0; i < r.size() - 1; i++) {
r.at(i) = a.at(mid + i);
}
l.at(n0).second = INF;
r.at(n1).second = INF;
int x = 0;
int y = 0;
for (int i = left; i < right; i++) {
if (l.at(x).second <= r.at(y).second) {
a.at(i) = l.at(x);
x++;
} else {
a.at(i) = r.at(y);
y++;
}
}
}
void merge_sort(vector<pair<string, int>> &a, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(a, left, mid);
merge_sort(a, mid, right);
merge(a, left, mid, right);
}
}
int partition(vector<pair<string, int>> &a, int p, int r) {
pair<string, int> x = a.at(r);
int id = p - 1;
for (int i = p; i < r; i++) {
if (a.at(i).second <= x.second) {
id++;
swap(a.at(i), a.at(id));
}
}
swap(a.at(id + 1), a.at(r));
return id + 1;
}
void quick_sort(vector<pair<string, int>> &a, int p, int r) {
if (p < r) {
int q = partition(a, p, r);
quick_sort(a, p, q - 1);
quick_sort(a, q + 1, r);
}
}
int main() {
int n;
cin >> n;
vector<pair<string, int>> p(n);
for (int i = 0; i < n; i++) {
string s;
int id;
cin >> s >> id;
p.at(i) = (make_pair(s, id));
}
vector<pair<string, int>> a = p;
vector<pair<string, int>> b = p;
quick_sort(a, 0, n - 1);
merge_sort(b, 0, n);
bool stable = true;
for (int i = 0; i < n; i++) {
if (a.at(i) != b.at(i)) {
stable = false;
break;
}
}
cout << (stable ? "Stable" : "Not stable") << endl;
for (int i = 0; i < n; i++) {
cout << a.at(i).first << " " << a.at(i).second << endl;
}
}
|
replace
| 22 | 23 | 22 | 23 |
0
| |
p02277
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#define SENTINEL 1000000001
struct Card {
char suit;
int value;
};
void trace(Card a[], int size) {
for (int i = 0; i < size; ++i) {
printf("%c %d\n", a[i].suit, a[i].value);
}
}
void Merge(Card A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
Card L[n1 + 1], R[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1].value = SENTINEL;
R[n2].value = SENTINEL;
int m = 0;
int n = 0;
for (int i = left; i < right; ++i) {
if (L[m].value <= R[n].value) {
A[i] = L[m];
++m;
} else {
A[i] = R[n];
++n;
}
}
}
void MergeSort(Card A[], int left, int right) {
if (left >= right - 1)
return;
int mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
int Partition(Card A[], int p, int r) {
int x = A[r].value;
int j = p;
for (int i = p; i < r; ++i) {
if (A[i].value <= x) {
std::swap(A[j], A[i]);
++j;
}
}
std::swap(A[j], A[r]);
return j;
}
void QuickSort(Card A[], int p, int r) {
if (p >= r)
return;
int q = Partition(A, p, r);
QuickSort(A, p, q - 1);
QuickSort(A, q + 1, r);
}
bool IsStable(Card A[], Card B[], int N) {
for (int i = 0; i < N; ++i) {
if (A[i].suit != B[i].suit || A[i].value != B[i].value) {
return false;
}
}
return true;
}
int main() {
int N;
Card A[100], B[100];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
std::cin >> A[i].suit >> A[i].value;
B[i] = A[i];
}
MergeSort(A, 0, N);
QuickSort(B, 0, N - 1);
IsStable(A, B, N) ? printf("Stable\n") : printf("Not stable\n");
trace(B, N);
return 0;
}
|
#include <iostream>
#include <stdio.h>
#define SENTINEL 1000000001
struct Card {
char suit;
int value;
};
void trace(Card a[], int size) {
for (int i = 0; i < size; ++i) {
printf("%c %d\n", a[i].suit, a[i].value);
}
}
void Merge(Card A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
Card L[n1 + 1], R[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1].value = SENTINEL;
R[n2].value = SENTINEL;
int m = 0;
int n = 0;
for (int i = left; i < right; ++i) {
if (L[m].value <= R[n].value) {
A[i] = L[m];
++m;
} else {
A[i] = R[n];
++n;
}
}
}
void MergeSort(Card A[], int left, int right) {
if (left >= right - 1)
return;
int mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
int Partition(Card A[], int p, int r) {
int x = A[r].value;
int j = p;
for (int i = p; i < r; ++i) {
if (A[i].value <= x) {
std::swap(A[j], A[i]);
++j;
}
}
std::swap(A[j], A[r]);
return j;
}
void QuickSort(Card A[], int p, int r) {
if (p >= r)
return;
int q = Partition(A, p, r);
QuickSort(A, p, q - 1);
QuickSort(A, q + 1, r);
}
bool IsStable(Card A[], Card B[], int N) {
for (int i = 0; i < N; ++i) {
if (A[i].suit != B[i].suit || A[i].value != B[i].value) {
return false;
}
}
return true;
}
int main() {
int N;
Card A[100000], B[100000];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
std::cin >> A[i].suit >> A[i].value;
B[i] = A[i];
}
MergeSort(A, 0, N);
QuickSort(B, 0, N - 1);
IsStable(A, B, N) ? printf("Stable\n") : printf("Not stable\n");
trace(B, N);
return 0;
}
|
replace
| 82 | 83 | 82 | 83 |
0
| |
p02277
|
C++
|
Time Limit Exceeded
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 100000
#define LARGE 2000000000
typedef struct {
char suit;
int value;
} Card;
Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(Card *, int, int, int, int);
void mergeSort(Card *, int, int, int);
int partition(Card *, int, int, int);
void quickSort(Card *, int, int, int);
void merge(Card A[], int n, int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = LARGE;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(Card A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int partition(Card A[], int n, int p, int r) {
int i, j;
Card t, x;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
t = A[i];
A[i] = A[j];
A[j] = t;
}
}
t = A[i + 1];
A[i + 1] = A[r];
A[r] = t;
return i + 1;
}
void quickSort(Card A[], int n, int p, int r) {
int q;
if (p < r) {
q = partition(A, n, q, r);
quickSort(A, n, p, q - 1);
quickSort(A, n, q + 1, r);
}
}
int main() {
int n, i, v;
Card A[MAX], B[MAX];
char command[10];
int stable = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %d", command, &v);
A[i].suit = B[i].suit = command[0];
A[i].value = B[i].value = v;
}
mergeSort(A, n, 0, n);
quickSort(B, n, 0, n - 1);
for (i = 0; i < n; i++) {
if (A[i].suit != B[i].suit)
stable = 0;
}
if (stable == 1)
printf("Stable\n");
else
printf("Not stable\n");
for (i = 0; i < n; i++) {
printf("%c %d\n", B[i].suit, B[i].value);
}
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 100000
#define LARGE 2000000000
typedef struct {
char suit;
int value;
} Card;
Card L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(Card *, int, int, int, int);
void mergeSort(Card *, int, int, int);
int partition(Card *, int, int, int);
void quickSort(Card *, int, int, int);
void merge(Card A[], int n, int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1].value = R[n2].value = LARGE;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i].value <= R[j].value) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(Card A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int partition(Card A[], int n, int p, int r) {
int i, j;
Card t, x;
x = A[r];
i = p - 1;
for (j = p; j < r; j++) {
if (A[j].value <= x.value) {
i++;
t = A[i];
A[i] = A[j];
A[j] = t;
}
}
t = A[i + 1];
A[i + 1] = A[r];
A[r] = t;
return i + 1;
}
void quickSort(Card A[], int n, int p, int r) {
int q;
if (p < r) {
q = partition(A, n, p, r);
quickSort(A, n, p, q - 1);
quickSort(A, n, q + 1, r);
}
}
int main() {
int n, i, v;
Card A[MAX], B[MAX];
char command[10];
int stable = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s %d", command, &v);
A[i].suit = B[i].suit = command[0];
A[i].value = B[i].value = v;
}
mergeSort(A, n, 0, n);
quickSort(B, n, 0, n - 1);
for (i = 0; i < n; i++) {
if (A[i].suit != B[i].suit)
stable = 0;
}
if (stable == 1)
printf("Stable\n");
else
printf("Not stable\n");
for (i = 0; i < n; i++) {
printf("%c %d\n", B[i].suit, B[i].value);
}
return 0;
}
|
replace
| 69 | 70 | 69 | 70 |
TLE
| |
p02277
|
C++
|
Runtime Error
|
#include <iostream>
#define M 100000
#define S 2000000000
using namespace std;
struct card {
int num;
char d;
};
void merge(card *a, int l, int m, int r) {
card L[m / 2 + 2];
card R[m / 2 + 2];
int n1 = m - l;
int n2 = r - m;
int b = 0, c = 0;
for (int i = 0; i < n1; i++)
L[i] = a[l + i];
for (int i = 0; i < n2; i++)
R[i] = a[m + i];
L[n1].num = R[n2].num = S;
for (int k = l; k < r; k++) {
if (L[b].num <= R[c].num) {
a[k] = L[b++];
} else {
a[k] = R[c++];
}
}
}
void mergeSort(card *a, int l, int r) {
int m;
if (l + 1 < r) {
m = (l + r) / 2;
mergeSort(a, l, m);
mergeSort(a, m, r);
merge(a, l, m, r);
}
}
int partition(card *a, int p, int r) {
int i;
card t, x;
x = a[r];
i = p - 1;
for (int j = p; j < r; j++) {
if (a[j].num <= x.num) {
i++;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
t = a[i + 1];
a[i + 1] = a[r];
a[r] = t;
return i + 1;
}
void quickSort(card *a, int p, int r) {
int q;
if (p < r) {
q = partition(a, p, r);
quickSort(a, p, q - 1);
quickSort(a, q + 1, r);
}
}
int main() {
int n;
cin >> n;
char in;
bool flag = true;
card a[100000];
card b[100000];
for (int i = 0; i < n; i++) {
cin >> a[i].d >> a[i].num;
b[i].d = a[i].d;
b[i].num = a[i].num;
}
mergeSort(a, 0, n);
quickSort(b, 0, n - 1);
for (int i = 0; i < n; i++) {
if (a[i].d != b[i].d)
flag = false;
}
if (flag)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; i++) {
cout << b[i].d << ' ' << b[i].num << endl;
}
}
|
#include <iostream>
#define M 100000
#define S 2000000000
using namespace std;
struct card {
int num;
char d;
};
void merge(card *a, int l, int m, int r) {
card L[M / 2 + 2];
card R[M / 2 + 2];
int n1 = m - l;
int n2 = r - m;
int b = 0, c = 0;
for (int i = 0; i < n1; i++)
L[i] = a[l + i];
for (int i = 0; i < n2; i++)
R[i] = a[m + i];
L[n1].num = R[n2].num = S;
for (int k = l; k < r; k++) {
if (L[b].num <= R[c].num) {
a[k] = L[b++];
} else {
a[k] = R[c++];
}
}
}
void mergeSort(card *a, int l, int r) {
int m;
if (l + 1 < r) {
m = (l + r) / 2;
mergeSort(a, l, m);
mergeSort(a, m, r);
merge(a, l, m, r);
}
}
int partition(card *a, int p, int r) {
int i;
card t, x;
x = a[r];
i = p - 1;
for (int j = p; j < r; j++) {
if (a[j].num <= x.num) {
i++;
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
t = a[i + 1];
a[i + 1] = a[r];
a[r] = t;
return i + 1;
}
void quickSort(card *a, int p, int r) {
int q;
if (p < r) {
q = partition(a, p, r);
quickSort(a, p, q - 1);
quickSort(a, q + 1, r);
}
}
int main() {
int n;
cin >> n;
char in;
bool flag = true;
card a[100000];
card b[100000];
for (int i = 0; i < n; i++) {
cin >> a[i].d >> a[i].num;
b[i].d = a[i].d;
b[i].num = a[i].num;
}
mergeSort(a, 0, n);
quickSort(b, 0, n - 1);
for (int i = 0; i < n; i++) {
if (a[i].d != b[i].d)
flag = false;
}
if (flag)
cout << "Stable" << endl;
else
cout << "Not stable" << endl;
for (int i = 0; i < n; i++) {
cout << b[i].d << ' ' << b[i].num << endl;
}
}
|
replace
| 12 | 14 | 12 | 14 |
0
| |
p02278
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 10000
#define MAX_V 65000000
#define INF 10000000000
int n, A[MAX_N], s, B[MAX_N], T[MAX_V], cur, S, m, x;
bool V[MAX_N];
int minimum_cost_sort() {
int ans = 0;
for (int i = 0; i < MAX_V; i++) {
V[i] = false;
}
for (int i = 0; i < n; i++) {
B[i] = A[i];
}
sort(B, B + n);
for (int i = 0; i < n; i++) {
T[B[i]] = i;
}
for (int i = 0; i < n; i++) {
if (V[i] == true) {
goto owata;
}
cur = i;
S = 0;
m = INF;
x = 0;
while (1) {
V[cur] = true;
x++;
int v = A[cur];
m = min(m, v);
S += v;
cur = T[v];
if (V[cur]) {
break;
}
}
ans += min(S + (x - 2) * m, m + S + (x + 1) * s);
owata:;
}
return ans;
}
int main() {
cin >> n;
s = INF;
for (int i = 0; i < n; i++) {
cin >> A[i];
s = min(s, A[i]);
}
cout << minimum_cost_sort() << endl;
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 10000
#define MAX_V 60000000
#define INF 10000000000
int n, A[MAX_N], s, B[MAX_N], T[MAX_V], cur, S, m, x;
bool V[MAX_N];
int minimum_cost_sort() {
int ans = 0;
for (int i = 0; i < MAX_V; i++) {
V[i] = false;
}
for (int i = 0; i < n; i++) {
B[i] = A[i];
}
sort(B, B + n);
for (int i = 0; i < n; i++) {
T[B[i]] = i;
}
for (int i = 0; i < n; i++) {
if (V[i] == true) {
goto owata;
}
cur = i;
S = 0;
m = INF;
x = 0;
while (1) {
V[cur] = true;
x++;
int v = A[cur];
m = min(m, v);
S += v;
cur = T[v];
if (V[cur]) {
break;
}
}
ans += min(S + (x - 2) * m, m + S + (x + 1) * s);
owata:;
}
return ans;
}
int main() {
cin >> n;
s = INF;
for (int i = 0; i < n; i++) {
cin >> A[i];
s = min(s, A[i]);
}
cout << minimum_cost_sort() << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
MLE
| |
p02278
|
C++
|
Runtime Error
|
//============================================================================
// Name : MinCostSort.cpp
// Author : Ken
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_W = 10000;
void writeVector(vector<int> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << "\n";
}
}
void writeVector(vector<bool> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << "\n";
}
}
int main() {
int n, input, min_all = MAX_W, total_sum = 0;
cin >> n;
vector<int> v, inv_v(MAX_W);
vector<bool> isIterated(n);
for (int i = 0; i < isIterated.size(); i++) {
isIterated.at(i) = false;
}
for (int i = 0; i < n; i++) {
cin >> input;
v.push_back(input);
inv_v.at(input) = i;
if (input < min_all) {
min_all = input;
}
}
sort(v.begin(), v.end());
// cout << "v:\n";
// writeVector(v);
// cout << "inv_v:\n";
// writeVector(inv_v);
// cout << "isIterated:\n";
// writeVector(isIterated);
for (int i = 0; i < v.size(); i++) {
int min_in_loop = MAX_W;
int sum_loop = 0;
int pos = i;
int elem = v.at(i);
int loop_size = 0;
if (not isIterated.at(pos)) {
isIterated.at(pos) = true;
if (inv_v.at(v.at(pos)) == pos) {
// cout << "single loop: " << v.at(pos) << "\n";
continue;
}
// cout << "multi loop: ";
while (true) {
loop_size++;
isIterated.at(pos) = true;
// cout << elem << " ";
sum_loop += elem;
if (elem < min_in_loop) {
min_in_loop = elem;
}
pos = inv_v.at(elem);
elem = v.at(pos);
if (isIterated.at(pos)) {
// cout << "sum_loop: " << sum_loop << ", min_in_loop: " <<
// min_in_loop << " "
// << "loop_size: " << loop_size << "\n";
// cout << "\n";
int add = min(min_in_loop * (loop_size - 2),
min_in_loop + min_all * (loop_size + 1));
total_sum += sum_loop + add;
break;
}
}
}
}
cout << total_sum << "\n";
return 0;
}
|
//============================================================================
// Name : MinCostSort.cpp
// Author : Ken
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_W = 10001;
void writeVector(vector<int> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << "\n";
}
}
void writeVector(vector<bool> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << "\n";
}
}
int main() {
int n, input, min_all = MAX_W, total_sum = 0;
cin >> n;
vector<int> v, inv_v(MAX_W);
vector<bool> isIterated(n);
for (int i = 0; i < isIterated.size(); i++) {
isIterated.at(i) = false;
}
for (int i = 0; i < n; i++) {
cin >> input;
v.push_back(input);
inv_v.at(input) = i;
if (input < min_all) {
min_all = input;
}
}
sort(v.begin(), v.end());
// cout << "v:\n";
// writeVector(v);
// cout << "inv_v:\n";
// writeVector(inv_v);
// cout << "isIterated:\n";
// writeVector(isIterated);
for (int i = 0; i < v.size(); i++) {
int min_in_loop = MAX_W;
int sum_loop = 0;
int pos = i;
int elem = v.at(i);
int loop_size = 0;
if (not isIterated.at(pos)) {
isIterated.at(pos) = true;
if (inv_v.at(v.at(pos)) == pos) {
// cout << "single loop: " << v.at(pos) << "\n";
continue;
}
// cout << "multi loop: ";
while (true) {
loop_size++;
isIterated.at(pos) = true;
// cout << elem << " ";
sum_loop += elem;
if (elem < min_in_loop) {
min_in_loop = elem;
}
pos = inv_v.at(elem);
elem = v.at(pos);
if (isIterated.at(pos)) {
// cout << "sum_loop: " << sum_loop << ", min_in_loop: " <<
// min_in_loop << " "
// << "loop_size: " << loop_size << "\n";
// cout << "\n";
int add = min(min_in_loop * (loop_size - 2),
min_in_loop + min_all * (loop_size + 1));
total_sum += sum_loop + add;
break;
}
}
}
}
cout << total_sum << "\n";
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
0
| |
p02278
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int n, w[1000], s;
int a[1000], d[1001]; // destination
long solve() {
long ret = 0;
bool v[1000];
for (int i = 0; i < n; ++i) {
a[i] = w[i];
v[i] = false;
}
sort(a, a + n); // a[]??????w[]???????????¢?????\???
//??????a[i]??????????????????????????´??????d[]?????\??????
for (int i = 0; i < n; ++i)
d[a[i]] = i;
for (int i = 0; i < n; ++i) {
if (v[i])
continue; //??¢???????????????????????????????????????????????§???????????????????????£?????????
//?????????????????¢???
int cur = i; //?????¨??????
int sum = 0;
int m = 10000; //???????????????????????????????°????
int an = 0; //?????????????????§??????
while (1) {
v[cur] = true; //?¨??????????????¨????
an++;
int z = w[cur];
sum += z;
m = min(m, z);
cur = d[z]; //?¬??????????
if (v[cur])
break; //?????¨??????
}
ret += min(sum + (an - 2) * m, m + sum + (an + 1) * s);
}
return ret;
}
int main() {
scanf(" %d", &n);
s = 10000;
for (int i = 0; i < n; ++i) {
scanf(" %d", &w[i]);
s = min(s, w[i]); // s???w[]?????????????°????????´?
}
printf("%ld\n", solve());
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int n, w[1000], s;
int a[1000], d[10001]; // destination
long solve() {
long ret = 0;
bool v[1000];
for (int i = 0; i < n; ++i) {
a[i] = w[i];
v[i] = false;
}
sort(a, a + n); // a[]??????w[]???????????¢?????\???
//??????a[i]??????????????????????????´??????d[]?????\??????
for (int i = 0; i < n; ++i)
d[a[i]] = i;
for (int i = 0; i < n; ++i) {
if (v[i])
continue; //??¢???????????????????????????????????????????????§???????????????????????£?????????
//?????????????????¢???
int cur = i; //?????¨??????
int sum = 0;
int m = 10000; //???????????????????????????????°????
int an = 0; //?????????????????§??????
while (1) {
v[cur] = true; //?¨??????????????¨????
an++;
int z = w[cur];
sum += z;
m = min(m, z);
cur = d[z]; //?¬??????????
if (v[cur])
break; //?????¨??????
}
ret += min(sum + (an - 2) * m, m + sum + (an + 1) * s);
}
return ret;
}
int main() {
scanf(" %d", &n);
s = 10000;
for (int i = 0; i < n; ++i) {
scanf(" %d", &w[i]);
s = min(s, w[i]); // s???w[]?????????????°????????´?
}
printf("%ld\n", solve());
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02278
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
using namespace std;
static const int MAX = 1000;
static const int VMAX = 10000;
int n, A[MAX], s;
int B[MAX], T[VMAX + 1];
int solve() {
int ans = 0;
bool V[MAX];
for (int i = 0; i < n; i++) {
B[i] = A[i];
V[i] = false;
}
sort(B, B + n);
for (int i = 0; i < n; i++)
T[B[i]] = i;
for (int i = 0; i < n; i++) {
if (V[i])
continue;
int cur = i;
int S = 0;
int m = VMAX;
int an = 0;
do {
V[cur] = true;
an++;
int v = A[cur];
m = min(m, v);
S += v;
cur = T[v];
} while (V[cur]);
ans += min(S + (an - 2) * m, m + S + (an + 1) * S);
}
return ans;
}
int main() {
cin >> n;
s = VMAX;
for (int i = 0; i < n; i++) {
cin >> A[i];
s = min(s, A[i]);
}
int ans = solve();
cout << ans << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
static const int MAX = 1000;
static const int VMAX = 10000;
int n, A[MAX], s;
int B[MAX], T[VMAX + 1];
int solve() {
int ans = 0;
bool V[MAX];
for (int i = 0; i < n; i++) {
B[i] = A[i];
V[i] = false;
}
sort(B, B + n);
for (int i = 0; i < n; i++)
T[B[i]] = i;
for (int i = 0; i < n; i++) {
if (V[i])
continue;
int cur = i;
int S = 0;
int m = VMAX;
int an = 0;
do {
V[cur] = true;
an++;
int v = A[cur];
m = min(m, v);
S += v;
cur = T[v];
} while (!V[cur]);
ans += min(S + (an - 2) * m, m + S + (an + 1) * s);
}
return ans;
}
int main() {
cin >> n;
s = VMAX;
for (int i = 0; i < n; i++) {
cin >> A[i];
s = min(s, A[i]);
}
int ans = solve();
cout << ans << endl;
}
|
replace
| 34 | 36 | 34 | 36 |
TLE
| |
p02278
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N 1005
#define INF (1 << 30)
typedef long long ll;
using namespace std;
int main() {
int weight[N];
int sorted[N];
int idx[N];
int n, x = INF, ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", weight + i);
sorted[i] = weight[i];
if (x > weight[i])
x = weight[i];
}
sort(sorted, sorted + n);
for (int i = 0; i < n; ++i)
idx[sorted[i]] = i;
bool visited[N]{false};
for (int i = 0; i < n; ++i) {
if (visited[i] || i == idx[weight[i]])
continue;
int Min = weight[i], num = 1, sum1 = weight[i];
int j = i;
while (true) {
visited[j] = true;
j = idx[weight[j]];
if (visited[j])
break;
Min = min(Min, weight[j]);
sum1 += weight[j];
++num;
}
ans += min(Min + (num + 1) * x, (num - 2) * Min) + sum1;
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N 1005
#define INF (1 << 30)
typedef long long ll;
using namespace std;
int main() {
int weight[N];
int sorted[N];
int idx[40005];
int n, x = INF, ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", weight + i);
sorted[i] = weight[i];
if (x > weight[i])
x = weight[i];
}
sort(sorted, sorted + n);
for (int i = 0; i < n; ++i)
idx[sorted[i]] = i;
bool visited[N]{false};
for (int i = 0; i < n; ++i) {
if (visited[i] || i == idx[weight[i]])
continue;
int Min = weight[i], num = 1, sum1 = weight[i];
int j = i;
while (true) {
visited[j] = true;
j = idx[weight[j]];
if (visited[j])
break;
Min = min(Min, weight[j]);
sum1 += weight[j];
++num;
}
ans += min(Min + (num + 1) * x, (num - 2) * Min) + sum1;
}
cout << ans << endl;
return 0;
}
|
replace
| 19 | 20 | 19 | 20 |
0
| |
p02278
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <sstream>
#include <stack>
#include <stdio.h>
#define MAX 100000
using namespace std;
typedef long long ll;
ll ans;
void solve(int a[], int n) {
int b[1000], t[1000], vmin, vmax = 1000;
bool vis[1000];
for (int i = 0; i < n; i++) {
b[i] = a[i];
vis[i] = false;
}
sort(b, b + n);
vmin = b[0];
for (int i = 0; i < n; i++) {
t[b[i]] = i; // 得出移动够各个元素（值不同）应该在数组中位置
}
for (int i = 0; i < n; i++) {
int cur = i, m = vmax, sum = 0, num = 0; // 查找新的环
while (1) // 开始搜索下一个环
{
vis[cur] = true; // 将这个元素加入当前环
num++; // 这个环的个数加1
sum += a[cur]; // 环的weight加1
m = min(a[cur], m); // 更新最小值，最终得到该环的最小值
cur = t[a[cur]]; // 得到将要移动到的位置
if (vis[cur])
break; // 将要移动到的位置的元素已经在环中，环已经闭合，一个环已经找到
}
ans += min(
sum + (num - 2) * m,
sum + m +
(num + 1) *
vmin); // 如果已经在某个环中或者根本不需要移动，那么成本为0，不影响结果
}
}
int main() {
int n, a[1000];
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
solve(a, n);
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <sstream>
#include <stack>
#include <stdio.h>
#define MAX 100000
using namespace std;
typedef long long ll;
ll ans;
void solve(int a[], int n) {
int b[1000], t[10005], vmin, vmax = 10000;
bool vis[1000];
for (int i = 0; i < n; i++) {
b[i] = a[i];
vis[i] = false;
}
sort(b, b + n);
vmin = b[0];
for (int i = 0; i < n; i++) {
t[b[i]] = i; // 得出移动够各个元素（值不同）应该在数组中位置
}
for (int i = 0; i < n; i++) {
int cur = i, m = vmax, sum = 0, num = 0; // 查找新的环
while (1) // 开始搜索下一个环
{
vis[cur] = true; // 将这个元素加入当前环
num++; // 这个环的个数加1
sum += a[cur]; // 环的weight加1
m = min(a[cur], m); // 更新最小值，最终得到该环的最小值
cur = t[a[cur]]; // 得到将要移动到的位置
if (vis[cur])
break; // 将要移动到的位置的元素已经在环中，环已经闭合，一个环已经找到
}
ans += min(
sum + (num - 2) * m,
sum + m +
(num + 1) *
vmin); // 如果已经在某个环中或者根本不需要移动，那么成本为0，不影响结果
}
}
int main() {
int n, a[1000];
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
solve(a, n);
cout << ans << endl;
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p02278
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int minimumCostSort(int *W, int n) {
int X[1000], R[1000];
for (int i = 0; i < n; i++) {
X[i] = W[i];
}
sort(X, X + n);
for (int i = 0; i < n; i++)
R[X[i]] = i;
int m = X[0];
int sum = 0;
for (int i = 0; i < n; i++) {
int cur = i;
if (X[cur] == -1)
continue;
int s = 0;
int mm = 10000;
int nn = 0;
int v;
while (true) {
nn++;
X[cur] = -1;
v = W[cur];
mm = min(v, mm);
s += v;
cur = R[v];
if (X[cur] == -1)
break;
}
sum += min(s + (nn - 2) * mm, s + mm + (nn + 1) * m);
}
return sum;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
int W[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> W[i];
}
int c = minimumCostSort(W, n);
cout << c << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int minimumCostSort(int *W, int n) {
int X[1000], R[10001];
for (int i = 0; i < n; i++) {
X[i] = W[i];
}
sort(X, X + n);
for (int i = 0; i < n; i++)
R[X[i]] = i;
int m = X[0];
int sum = 0;
for (int i = 0; i < n; i++) {
int cur = i;
if (X[cur] == -1)
continue;
int s = 0;
int mm = 10000;
int nn = 0;
int v;
while (true) {
nn++;
X[cur] = -1;
v = W[cur];
mm = min(v, mm);
s += v;
cur = R[v];
if (X[cur] == -1)
break;
}
sum += min(s + (nn - 2) * mm, s + mm + (nn + 1) * m);
}
return sum;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
int W[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> W[i];
}
int c = minimumCostSort(W, n);
cout << c << endl;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02278
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 200005;
int w[1005], B[1005], L[1005], flag[1005];
int main() {
int n, ans = 0, Min = INF;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w[i];
B[i] = w[i];
Min = min(Min, w[i]);
}
sort(B, B + n);
for (int i = 0; i < n; i++)
L[B[i]] = i;
for (int i = 0; i < n; i++) {
if (flag[i])
continue;
int temp = i, S = INF, m = 0, cnt = 0;
while (!flag[temp]) {
cnt++;
flag[temp] = 1;
S = min(S, w[temp]);
m += w[temp];
temp = L[w[temp]];
}
ans += min(m + (cnt - 2) * S, m + (cnt + 1) * Min + S);
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 200005;
int w[1005], B[1005], L[100005], flag[1005];
int main() {
int n, ans = 0, Min = INF;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w[i];
B[i] = w[i];
Min = min(Min, w[i]);
}
sort(B, B + n);
for (int i = 0; i < n; i++)
L[B[i]] = i;
for (int i = 0; i < n; i++) {
if (flag[i])
continue;
int temp = i, S = INF, m = 0, cnt = 0;
while (!flag[temp]) {
cnt++;
flag[temp] = 1;
S = min(S, w[temp]);
m += w[temp];
temp = L[w[temp]];
}
ans += min(m + (cnt - 2) * S, m + (cnt + 1) * Min + S);
}
cout << ans << endl;
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
/*#include<iostream>
#include<algorithm>
#include<climits>*/
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define rep1(i, a, b) for (int i = a; i <= (b); ++i)
#define per(i, a, b) for (int i = a; i > (b); --i)
#define per1(i, a, b) for (int i = a; i >= (b); --i)
#define LL long long
#define inf 0x7f7f7f7f
#define N 1010
using namespace std;
struct node {
int p, l, r;
};
node T[N];
int n, D[N];
void print(int u) {
int i, c;
printf("node %d: ", u);
printf("parent = %d, ", T[u].p);
printf("depth = %d, ", D[u]);
if (T[u].p == -1)
printf("root, ");
else if (T[u].l == -1)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
for (i = 0, c = T[u].l; c != -1; i++, c = T[c].r) {
if (i)
printf(", ");
printf("%d", c);
}
printf("]\n");
}
int rec(int u, int p) {
D[u] = p;
if (T[u].r != -1)
rec(T[u].r, p);
if (T[u].l != -1)
rec(T[u].l, p + 1);
}
int main() {
int i, j;
int n, v, d, c, r, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = -1;
}
for (i = 0; i < n; i++) {
scanf("%d %d", &v, &d);
for (j = 0; j < d; j++) {
scanf("%d", &c);
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == -1)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++) {
print(i);
}
}
|
#include <bits/stdc++.h>
/*#include<iostream>
#include<algorithm>
#include<climits>*/
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define rep1(i, a, b) for (int i = a; i <= (b); ++i)
#define per(i, a, b) for (int i = a; i > (b); --i)
#define per1(i, a, b) for (int i = a; i >= (b); --i)
#define LL long long
#define inf 0x7f7f7f7f
#define N 100010
using namespace std;
struct node {
int p, l, r;
};
node T[N];
int n, D[N];
void print(int u) {
int i, c;
printf("node %d: ", u);
printf("parent = %d, ", T[u].p);
printf("depth = %d, ", D[u]);
if (T[u].p == -1)
printf("root, ");
else if (T[u].l == -1)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
for (i = 0, c = T[u].l; c != -1; i++, c = T[c].r) {
if (i)
printf(", ");
printf("%d", c);
}
printf("]\n");
}
int rec(int u, int p) {
D[u] = p;
if (T[u].r != -1)
rec(T[u].r, p);
if (T[u].l != -1)
rec(T[u].l, p + 1);
}
int main() {
int i, j;
int n, v, d, c, r, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = -1;
}
for (i = 0; i < n; i++) {
scanf("%d %d", &v, &d);
for (j = 0; j < d; j++) {
scanf("%d", &c);
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == -1)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++) {
print(i);
}
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
struct node {
int parent, depth;
vector<int> child;
};
vector<node> tree;
void dfs(int num) {
if (tree[num].child.size() == 0)
return;
for (int i = 0; i < tree[num].child.size(); i++) {
tree[tree[num].child[i]].depth = tree[num].depth + 1;
dfs(tree[num].child[i]);
}
}
int main() {
int n, m, now, t;
cin >> n;
tree.resize(n);
for (int i = 0; i < n; i++) {
cin >> now >> m;
vector<int> vec;
for (int j = 0; j < m; j++) {
cin >> t;
vec.push_back(t);
}
tree[now] = {-1, 0, vec};
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < tree[i].child.size(); j++)
tree[tree[i].child[j]].parent = i;
}
int par;
for (int i = 0; i < n; i++) {
if (tree[i].parent == -1)
par = i;
}
dfs(par);
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << tree[i].parent
<< ", depth = " << tree[i].depth;
if (tree[i].parent == -1) {
cout << ", root, [" << tree[i].child[0];
for (int j = 1; j < tree[i].child.size(); j++)
cout << ", " << tree[i].child[j];
cout << "]" << endl;
} else if (tree[i].child.size() == 0)
cout << ", leaf, []" << endl;
else {
cout << ", internal node, [" << tree[i].child[0];
for (int j = 1; j < tree[i].child.size(); j++)
cout << ", " << tree[i].child[j];
cout << "]" << endl;
}
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
struct node {
int parent, depth;
vector<int> child;
};
vector<node> tree;
void dfs(int num) {
if (tree[num].child.size() == 0)
return;
for (int i = 0; i < tree[num].child.size(); i++) {
tree[tree[num].child[i]].depth = tree[num].depth + 1;
dfs(tree[num].child[i]);
}
}
int main() {
int n, m, now, t;
cin >> n;
tree.resize(n);
for (int i = 0; i < n; i++) {
cin >> now >> m;
vector<int> vec;
for (int j = 0; j < m; j++) {
cin >> t;
vec.push_back(t);
}
tree[now] = {-1, 0, vec};
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < tree[i].child.size(); j++)
tree[tree[i].child[j]].parent = i;
}
int par;
for (int i = 0; i < n; i++) {
if (tree[i].parent == -1)
par = i;
}
dfs(par);
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << tree[i].parent
<< ", depth = " << tree[i].depth;
if (tree[i].parent == -1) {
cout << ", root, [";
if (tree[i].child.size() != 0)
cout << tree[i].child[0];
for (int j = 1; j < tree[i].child.size(); j++)
cout << ", " << tree[i].child[j];
cout << "]" << endl;
} else if (tree[i].child.size() == 0)
cout << ", leaf, []" << endl;
else {
cout << ", internal node, [" << tree[i].child[0];
for (int j = 1; j < tree[i].child.size(); j++)
cout << ", " << tree[i].child[j];
cout << "]" << endl;
}
}
return 0;
}
|
replace
| 47 | 48 | 47 | 50 |
0
| |
p02279
|
C++
|
Time Limit Exceeded
|
#include <cstdlib>
#include <iostream>
using namespace std;
#define MAX 100005
#define NIL -1
struct Node {
int parent;
int left;
int right;
};
Node T[MAX];
int n, D[MAX];
void print(int u) {
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].parent == NIL)
cout << "root, ";
else if (T[u].left == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = 0, c = T[u].left; c != NIL; i++, c = T[c].right) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int rec(int u, int p) {
D[u] = p;
if (T[u].right != NIL)
rec(T[u].right, p);
if (T[u].left != NIL)
rec(T[u].left, p + 1);
}
int main() {
int d, v, c, l, r;
cin >> n;
for (int i = 0; i < n; i++)
T[i].parent = T[i].left = T[i].right = NIL;
for (int i = 0; i < n; i++) {
cin >> v >> d;
for (int j = 0; j < d; j++) {
cin >> c;
if (j == 0)
T[v].left = c;
else
T[l].right = c;
l = c;
T[c].parent = v;
}
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL)
r = i;
}
}
rec(r, 0);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
#include <cstdlib>
#include <iostream>
using namespace std;
#define MAX 100005
#define NIL -1
struct Node {
int parent;
int left;
int right;
};
Node T[MAX];
int n, D[MAX];
void print(int u) {
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].parent == NIL)
cout << "root, ";
else if (T[u].left == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = 0, c = T[u].left; c != NIL; i++, c = T[c].right) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int rec(int u, int p) {
D[u] = p;
if (T[u].right != NIL)
rec(T[u].right, p);
if (T[u].left != NIL)
rec(T[u].left, p + 1);
}
int main() {
int d, v, c, l, r;
cin >> n;
for (int i = 0; i < n; i++)
T[i].parent = T[i].left = T[i].right = NIL;
for (int i = 0; i < n; i++) {
cin >> v >> d;
for (int j = 0; j < d; j++) {
cin >> c;
if (j == 0)
T[v].left = c;
else
T[l].right = c;
l = c;
T[c].parent = v;
}
}
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL)
r = i;
}
rec(r, 0);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
replace
| 62 | 66 | 62 | 66 |
TLE
| |
p02279
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#define NIL -1
using namespace std;
struct node {
int parent, left, right, depth;
};
struct node tree[100010];
void searchDepth(int start) {
int currentNumber = start;
int answer = 0;
while (tree[currentNumber].parent != NIL) {
currentNumber = tree[currentNumber].parent;
answer++;
}
tree[start].depth = answer;
}
int main() {
int n, k, currentNumber, tmp1, tmp2;
cin >> n;
tree[0].parent = NIL;
tree[0].right = NIL;
tmp2 = 0;
for (int i = 0; i < n; i++) {
cin >> currentNumber >> k;
if (k == 0) {
tree[currentNumber].left = NIL;
} else {
for (int j = 0; j < k; j++) {
cin >> tmp2;
tree[tmp2].parent = currentNumber;
if (j == 0) {
tree[currentNumber].left = tmp2;
tmp1 = tmp2;
} else {
tree[tmp1].right = tmp2;
tmp1 = tmp2;
}
}
tree[tmp2].right = NIL;
}
}
int currentNode;
for (int i = 0; i < n; i++) {
searchDepth(i);
cout << "node " << i << ": parent = " << tree[i].parent
<< ", depth = " << tree[i].depth;
if (tree[i].parent == NIL) {
cout << ", root, [";
} else if (tree[i].left == NIL) {
cout << ", leaf, [";
} else {
cout << ", internal node, [";
}
currentNode = tree[i].left;
int j = 0;
while (1) {
if (currentNode == NIL)
break;
if (j != 0)
cout << ", ";
cout << currentNode;
currentNode = tree[currentNode].right;
j++;
}
cout << "]" << endl;
}
return 0;
}
|
#include <iostream>
#define NIL -1
using namespace std;
struct node {
int parent, left, right, depth;
};
struct node tree[100010];
void searchDepth(int start) {
int currentNumber = start;
int answer = 0;
while (tree[currentNumber].parent != NIL) {
currentNumber = tree[currentNumber].parent;
answer++;
}
tree[start].depth = answer;
}
int main() {
int n, k, currentNumber, tmp1, tmp2;
cin >> n;
for (int i = 0; i < n; i++)
tree[i].parent = tree[i].left = tree[i].right = NIL;
tmp2 = 0;
for (int i = 0; i < n; i++) {
cin >> currentNumber >> k;
if (k == 0) {
tree[currentNumber].left = NIL;
} else {
for (int j = 0; j < k; j++) {
cin >> tmp2;
tree[tmp2].parent = currentNumber;
if (j == 0) {
tree[currentNumber].left = tmp2;
tmp1 = tmp2;
} else {
tree[tmp1].right = tmp2;
tmp1 = tmp2;
}
}
tree[tmp2].right = NIL;
}
}
int currentNode;
for (int i = 0; i < n; i++) {
searchDepth(i);
cout << "node " << i << ": parent = " << tree[i].parent
<< ", depth = " << tree[i].depth;
if (tree[i].parent == NIL) {
cout << ", root, [";
} else if (tree[i].left == NIL) {
cout << ", leaf, [";
} else {
cout << ", internal node, [";
}
currentNode = tree[i].left;
int j = 0;
while (1) {
if (currentNode == NIL)
break;
if (j != 0)
cout << ", ";
cout << currentNode;
currentNode = tree[currentNode].right;
j++;
}
cout << "]" << endl;
}
return 0;
}
|
replace
| 24 | 26 | 24 | 28 |
TLE
| |
p02279
|
C++
|
Runtime Error
|
// 根付き木の表現
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define MAX_N 100
const int NIL = -1;
typedef struct v_node_num {
// 節点の親
int parent;
// 節点の左の子
int left_child;
// 節点の右の兄弟
int right_brother;
} Node;
Node T[MAX_N];
int n;
int D[MAX_N];
// u : 要素No.
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "depth = " << D[u] << ", ";
// -----▼▼▼▼▼ ノード情報の表示 ▼▼▼▼▼-----
if (T[u].parent == NIL) {
// 親が存在しないので、root
cout << "root, ";
} else if (T[u].left_child == NIL) {
// 左の子がいないので、leaf
cout << "leaf, ";
} else {
cout << "internal node, ";
}
// -----▲▲▲▲▲ ノード情報の表示 ▲▲▲▲▲-----
// -----▼▼▼▼▼ 各節点の子の要素の表示 ▼▼▼▼▼-----
cout << "[";
for (i = 0, c = T[u].left_child; c != NIL; i++, c = T[c].right_brother) {
if (i) {
cout << ", ";
}
cout << c;
}
cout << "]" << endl;
// -----▲▲▲▲▲ 各節点の子の要素の表示 ▲▲▲▲▲-----
return;
}
// 再帰的に深さを求める
// u : 要素No.
// p : 要素の深さ
int rec(int u, int p) {
D[u] = p;
if (T[u].right_brother != NIL) {
// 右の兄弟に同じ深さを設定
rec(T[u].right_brother, p);
}
if (T[u].left_child != NIL) {
// 最も左の子に[ 自分の深さ + 1 ]を設定
rec(T[u].left_child, p + 1);
}
return 0;
}
int main(void) {
int i, j, d, v, c, left, right;
cin >> n;
for (i = 0; i < n; i++) {
T[i].parent = NIL;
T[i].left_child = NIL;
T[i].right_brother = NIL;
}
for (i = 0; i < n; i++) {
cin >> v >> d;
for (j = 0; j < d; j++) {
cin >> c;
if (j == 0) {
T[v].left_child = c;
} else {
T[left].right_brother = c;
}
left = c;
T[c].parent = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].parent == NIL) {
right = i;
}
}
rec(right, 0);
for (i = 0; i < n; i++) {
print(i);
}
return 0;
}
|
// 根付き木の表現
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define MAX_N 100005
const int NIL = -1;
typedef struct v_node_num {
// 節点の親
int parent;
// 節点の左の子
int left_child;
// 節点の右の兄弟
int right_brother;
} Node;
Node T[MAX_N];
int n;
int D[MAX_N];
// u : 要素No.
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "depth = " << D[u] << ", ";
// -----▼▼▼▼▼ ノード情報の表示 ▼▼▼▼▼-----
if (T[u].parent == NIL) {
// 親が存在しないので、root
cout << "root, ";
} else if (T[u].left_child == NIL) {
// 左の子がいないので、leaf
cout << "leaf, ";
} else {
cout << "internal node, ";
}
// -----▲▲▲▲▲ ノード情報の表示 ▲▲▲▲▲-----
// -----▼▼▼▼▼ 各節点の子の要素の表示 ▼▼▼▼▼-----
cout << "[";
for (i = 0, c = T[u].left_child; c != NIL; i++, c = T[c].right_brother) {
if (i) {
cout << ", ";
}
cout << c;
}
cout << "]" << endl;
// -----▲▲▲▲▲ 各節点の子の要素の表示 ▲▲▲▲▲-----
return;
}
// 再帰的に深さを求める
// u : 要素No.
// p : 要素の深さ
int rec(int u, int p) {
D[u] = p;
if (T[u].right_brother != NIL) {
// 右の兄弟に同じ深さを設定
rec(T[u].right_brother, p);
}
if (T[u].left_child != NIL) {
// 最も左の子に[ 自分の深さ + 1 ]を設定
rec(T[u].left_child, p + 1);
}
return 0;
}
int main(void) {
int i, j, d, v, c, left, right;
cin >> n;
for (i = 0; i < n; i++) {
T[i].parent = NIL;
T[i].left_child = NIL;
T[i].right_brother = NIL;
}
for (i = 0; i < n; i++) {
cin >> v >> d;
for (j = 0; j < d; j++) {
cin >> c;
if (j == 0) {
T[v].left_child = c;
} else {
T[left].right_brother = c;
}
left = c;
T[c].parent = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].parent == NIL) {
right = i;
}
}
rec(right, 0);
for (i = 0; i < n; i++) {
print(i);
}
return 0;
}
|
replace
| 12 | 13 | 12 | 13 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
struct Node {
string type;
int depth;
int parent = -1;
vector<int> child;
};
int main() {
int n;
Node node[1000];
queue<Node *> q;
int depth = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int id, k;
cin >> id >> k;
for (int j = 0; j < k; j++) {
int temp;
cin >> temp;
node[id].child.push_back(temp);
node[temp].parent = id;
}
}
for (int i = 0; i < n; i++) {
if (node[i].parent == -1) {
q.push(&node[i]);
break;
}
}
while (!q.empty()) {
int size = q.size();
for (int i = 0; i < size; i++) {
if (q.front()->parent == -1) {
q.front()->type = "root";
} else if (q.front()->child.empty()) {
q.front()->type = "leaf";
} else {
q.front()->type = "internal node";
}
for (int j = 0; j < q.front()->child.size(); j++) {
q.push(&node[q.front()->child[j]]);
}
q.front()->depth = depth;
q.pop();
}
depth++;
}
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << node[i].parent << ", ";
cout << "depth = " << node[i].depth << ", ";
cout << node[i].type << ", ";
cout << "[";
for (int j = 0; j < node[i].child.size(); j++) {
cout << node[i].child[j];
if (j < node[i].child.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
struct Node {
string type;
int depth;
int parent = -1;
vector<int> child;
};
int main() {
int n;
Node node[100000];
queue<Node *> q;
int depth = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int id, k;
cin >> id >> k;
for (int j = 0; j < k; j++) {
int temp;
cin >> temp;
node[id].child.push_back(temp);
node[temp].parent = id;
}
}
for (int i = 0; i < n; i++) {
if (node[i].parent == -1) {
q.push(&node[i]);
break;
}
}
while (!q.empty()) {
int size = q.size();
for (int i = 0; i < size; i++) {
if (q.front()->parent == -1) {
q.front()->type = "root";
} else if (q.front()->child.empty()) {
q.front()->type = "leaf";
} else {
q.front()->type = "internal node";
}
for (int j = 0; j < q.front()->child.size(); j++) {
q.push(&node[q.front()->child[j]]);
}
q.front()->depth = depth;
q.pop();
}
depth++;
}
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << node[i].parent << ", ";
cout << "depth = " << node[i].depth << ", ";
cout << node[i].type << ", ";
cout << "[";
for (int j = 0; j < node[i].child.size(); j++) {
cout << node[i].child[j];
if (j < node[i].child.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 1000
struct Node {
int parent, left, right;
};
struct Node T[MAX];
int D[MAX];
int get_depth(int);
void setDepth(int, int);
int main() {
int n;
int n2;
int n3;
int node;
cin >> n;
for (int i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = -1;
}
for (int i = 0; i < n; i++) {
int prev_node = -1;
cin >> n2 >> n3;
// cout << "n2: " << n2 << ", n3:" << n3 << endl;
for (int i2 = 0; i2 < n3; i2++) {
cin >> node;
if (i2 == 0)
T[n2].left = node;
T[node].parent = n2;
if (prev_node != -1)
T[prev_node].right = node;
prev_node = node;
}
}
// for (int i = 0; i < n; i++){
// cout << "Node:" << i << ", " << T[i].parent << ", " << T[i].left << ",
// " << T[i].right << ", " << endl;
// }
//
int r;
for (int i = 0; i < n; i++) {
if (T[i].parent == -1)
r = i;
}
setDepth(r, 0);
int c;
int a[100];
int parent;
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << T[i].parent << ", depth = ";
// cout << get_depth(i) << ", " ;
cout << D[i] << ", ";
c = T[i].left;
int depth = 0;
if (T[i].parent == -1)
cout << "root, ";
else if (T[i].left == -1)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
int is_first = -1;
while (c != -1) {
if (is_first != -1)
cout << ", ";
cout << c;
c = T[c].right;
is_first = 1;
}
cout << "]";
cout << endl;
}
return 0;
}
int get_depth(int node_id) {
int depth = 0;
int c;
c = T[node_id].parent;
while (c != -1) {
depth++;
c = T[c].parent;
}
return depth;
}
int p;
int u;
void setDepth(int u, int p) {
D[u] = p;
if (T[u].right != -1)
setDepth(T[u].right, p);
if (T[u].left != -1)
setDepth(T[u].left, p + 1);
}
|
#include <iostream>
using namespace std;
#define MAX 1000000
struct Node {
int parent, left, right;
};
struct Node T[MAX];
int D[MAX];
int get_depth(int);
void setDepth(int, int);
int main() {
int n;
int n2;
int n3;
int node;
cin >> n;
for (int i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = -1;
}
for (int i = 0; i < n; i++) {
int prev_node = -1;
cin >> n2 >> n3;
// cout << "n2: " << n2 << ", n3:" << n3 << endl;
for (int i2 = 0; i2 < n3; i2++) {
cin >> node;
if (i2 == 0)
T[n2].left = node;
T[node].parent = n2;
if (prev_node != -1)
T[prev_node].right = node;
prev_node = node;
}
}
// for (int i = 0; i < n; i++){
// cout << "Node:" << i << ", " << T[i].parent << ", " << T[i].left << ",
// " << T[i].right << ", " << endl;
// }
//
int r;
for (int i = 0; i < n; i++) {
if (T[i].parent == -1)
r = i;
}
setDepth(r, 0);
int c;
int a[100];
int parent;
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << T[i].parent << ", depth = ";
// cout << get_depth(i) << ", " ;
cout << D[i] << ", ";
c = T[i].left;
int depth = 0;
if (T[i].parent == -1)
cout << "root, ";
else if (T[i].left == -1)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
int is_first = -1;
while (c != -1) {
if (is_first != -1)
cout << ", ";
cout << c;
c = T[c].right;
is_first = 1;
}
cout << "]";
cout << endl;
}
return 0;
}
int get_depth(int node_id) {
int depth = 0;
int c;
c = T[node_id].parent;
while (c != -1) {
depth++;
c = T[c].parent;
}
return depth;
}
int p;
int u;
void setDepth(int u, int p) {
D[u] = p;
if (T[u].right != -1)
setDepth(T[u].right, p);
if (T[u].left != -1)
setDepth(T[u].left, p + 1);
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdlib.h>
using namespace std;
struct Node {
int parent;
int number;
struct Node *left;
struct Node *right;
};
struct Node *N[10000];
// void show()
//
int getDepth(struct Node *node) {
int count = 0;
while (node->parent != -1) {
count++;
node = N[node->parent];
}
return count;
}
int main() {
struct Node *node1, *node2, *node3, *prev_node, *parent;
int n, m, node, parent_number, node_count, child_node;
cin >> n;
for (int i = 0; i < n; i++) {
N[i] = NULL;
}
for (int i = 0; i < n; i++) {
cin >> parent_number;
cin >> node_count;
if (N[parent_number] == NULL) {
node2 = (struct Node *)malloc(sizeof(struct Node));
node2->number = parent_number;
node2->right = NULL;
node2->left = NULL;
node2->parent = -1;
N[parent_number] = node2;
}
for (int j = 0; j < node_count; j++) {
cin >> child_node;
node1 = (struct Node *)malloc(sizeof(struct Node));
node1->number = child_node;
// slibing
if (j == 0) {
N[parent_number]->left = node1;
} else {
prev_node->right = node1;
}
// parent
node1->parent = parent_number;
prev_node = node1;
// cout << prev_node->number << endl;
if (N[child_node] == NULL) {
node1->right = NULL;
node1->left = NULL;
N[child_node] = node1;
}
// else {
//}
// cout << "child node " << parent_number;
N[child_node]->parent = parent_number;
}
}
for (int i = 0; i < n; i++) {
struct Node *a = N[i];
struct Node *b;
cout << "node " << i << ":";
cout << " parent = " << a->parent;
// depth
//
cout << ", depth = ";
cout << getDepth(a);
// type
if (a->parent == -1) {
cout << ", root";
} else if (a->left) {
cout << ", internal node";
} else if (a->left == NULL) {
cout << ", leaf";
}
cout << ", [";
b = a->left;
while (b != NULL) {
cout << b->number;
b = b->right;
if (b) {
cout << ", ";
}
}
cout << "]";
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <stdlib.h>
using namespace std;
struct Node {
int parent;
int number;
struct Node *left;
struct Node *right;
};
struct Node *N[100000];
// void show()
//
int getDepth(struct Node *node) {
int count = 0;
while (node->parent != -1) {
count++;
node = N[node->parent];
}
return count;
}
int main() {
struct Node *node1, *node2, *node3, *prev_node, *parent;
int n, m, node, parent_number, node_count, child_node;
cin >> n;
for (int i = 0; i < n; i++) {
N[i] = NULL;
}
for (int i = 0; i < n; i++) {
cin >> parent_number;
cin >> node_count;
if (N[parent_number] == NULL) {
node2 = (struct Node *)malloc(sizeof(struct Node));
node2->number = parent_number;
node2->right = NULL;
node2->left = NULL;
node2->parent = -1;
N[parent_number] = node2;
}
for (int j = 0; j < node_count; j++) {
cin >> child_node;
node1 = (struct Node *)malloc(sizeof(struct Node));
node1->number = child_node;
// slibing
if (j == 0) {
N[parent_number]->left = node1;
} else {
prev_node->right = node1;
}
// parent
node1->parent = parent_number;
prev_node = node1;
// cout << prev_node->number << endl;
if (N[child_node] == NULL) {
node1->right = NULL;
node1->left = NULL;
N[child_node] = node1;
}
// else {
//}
// cout << "child node " << parent_number;
N[child_node]->parent = parent_number;
}
}
for (int i = 0; i < n; i++) {
struct Node *a = N[i];
struct Node *b;
cout << "node " << i << ":";
cout << " parent = " << a->parent;
// depth
//
cout << ", depth = ";
cout << getDepth(a);
// type
if (a->parent == -1) {
cout << ", root";
} else if (a->left) {
cout << ", internal node";
} else if (a->left == NULL) {
cout << ", leaf";
}
cout << ", [";
b = a->left;
while (b != NULL) {
cout << b->number;
b = b->right;
if (b) {
cout << ", ";
}
}
cout << "]";
cout << endl;
}
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <stdio.h>
#define MAX 10000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX], H[MAX];
void print(int u) {
int i, c;
printf("node %d: ", u);
printf("parent = %d, ", T[u].p);
printf("depth = %d, ", D[u]);
if (T[u].p == NIL)
printf("root, ");
else if (T[u].l == NIL)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i)
printf(", ");
printf("%d", c);
}
printf("]\n");
}
void rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL)
rec(T[u].r, p);
if (T[u].l != NIL)
rec(T[u].l, p + 1);
}
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL;
for (i = 0; i < n; i++) {
scanf("%d%d", &v, &d);
for (j = 0; j < d; j++) {
scanf("%d", &c);
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++)
print(i);
return 0;
}
|
#include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX], H[MAX];
void print(int u) {
int i, c;
printf("node %d: ", u);
printf("parent = %d, ", T[u].p);
printf("depth = %d, ", D[u]);
if (T[u].p == NIL)
printf("root, ");
else if (T[u].l == NIL)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i)
printf(", ");
printf("%d", c);
}
printf("]\n");
}
void rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL)
rec(T[u].r, p);
if (T[u].l != NIL)
rec(T[u].l, p + 1);
}
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL;
for (i = 0; i < n; i++) {
scanf("%d%d", &v, &d);
for (j = 0; j < d; j++) {
scanf("%d", &c);
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++)
print(i);
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N 100005
#define INF (1 << 30)
typedef long long ll;
using namespace std;
vector<int> child[N];
int parent[N];
int GetDepth(int idx) {
int ret = 0;
while (parent[idx] != -1) {
++ret;
idx = parent[idx];
}
return ret;
}
const char *str[3] = {"root", "internal node", "leaf"};
int main() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
int n;
cin >> n;
fill(parent, parent + n, -1);
int id, k, c;
for (int i = 0; i < n; ++i) {
cin >> id >> k;
for (int j = 0; j < k; ++j) {
cin >> c;
parent[c] = id;
child[id].push_back(c);
}
}
for (int i = 0; i < n; ++i) {
int depth = GetDepth(i);
int status;
if (depth == 0)
status = 0;
else if (child[i].size()) {
status = 1;
sort(child[i].begin(), child[i].end());
} else
status = 2;
printf("node %d: parent = %d, depth = %d, %s, ", i, parent[i], depth,
str[status]);
printf("[");
for (int j = 0; j < child[i].size(); ++j) {
if (j)
printf(", ");
printf("%d", child[i][j]);
}
printf("]\n");
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define N 100005
#define INF (1 << 30)
typedef long long ll;
using namespace std;
vector<int> child[N];
int parent[N];
int GetDepth(int idx) {
int ret = 0;
while (parent[idx] != -1) {
++ret;
idx = parent[idx];
}
return ret;
}
const char *str[3] = {"root", "internal node", "leaf"};
int main() {
int n;
cin >> n;
fill(parent, parent + n, -1);
int id, k, c;
for (int i = 0; i < n; ++i) {
cin >> id >> k;
for (int j = 0; j < k; ++j) {
cin >> c;
parent[c] = id;
child[id].push_back(c);
}
}
for (int i = 0; i < n; ++i) {
int depth = GetDepth(i);
int status;
if (depth == 0)
status = 0;
else if (child[i].size()) {
status = 1;
sort(child[i].begin(), child[i].end());
} else
status = 2;
printf("node %d: parent = %d, depth = %d, %s, ", i, parent[i], depth,
str[status]);
printf("[");
for (int j = 0; j < child[i].size(); ++j) {
if (j)
printf(", ");
printf("%d", child[i][j]);
}
printf("]\n");
}
return 0;
}
|
delete
| 28 | 30 | 28 | 28 |
-11
| |
p02279
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <stdlib.h>
#define N 10000
typedef struct node {
int p;
int right;
int left;
} Node;
int main() {
int n, i, j, l, c, k, id, P, depth, r;
Node a[N], tmp;
scanf("%d", &n);
for (i = 0; i < n; i++) {
a[i].p = -1;
a[i].right = -1;
a[i].left = -1;
}
for (i = 0; i < n; i++) {
scanf("%d%d", &id, &k);
for (j = 0; j < k; j++) {
scanf("%d", &c);
if (j == 0)
a[id].left = c;
else
a[r].right = c;
a[c].p = id;
r = c;
}
}
for (i = 0; i < n; i++) {
depth = 0;
P = a[i].p;
while (P != -1) {
P = a[P].p;
depth++;
}
if (a[i].p == -1) {
printf("node %d: parent = %d, depth = %d, root, [", i, a[i].p, depth);
} else if (a[i].left == -1)
printf("node %d: parent = %d, depth = %d, leaf, [", i, a[i].p, depth);
else
printf("node %d: parent = %d, depth = %d, internal node, [", i, a[i].p,
depth);
P = a[i].left;
if (P != -1)
printf("%d", P);
while (P != -1) {
P = a[P].right;
if (P != -1)
printf(", %d", P);
}
printf("]\n");
}
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#define N 1000000
typedef struct node {
int p;
int right;
int left;
} Node;
int main() {
int n, i, j, l, c, k, id, P, depth, r;
Node a[N], tmp;
scanf("%d", &n);
for (i = 0; i < n; i++) {
a[i].p = -1;
a[i].right = -1;
a[i].left = -1;
}
for (i = 0; i < n; i++) {
scanf("%d%d", &id, &k);
for (j = 0; j < k; j++) {
scanf("%d", &c);
if (j == 0)
a[id].left = c;
else
a[r].right = c;
a[c].p = id;
r = c;
}
}
for (i = 0; i < n; i++) {
depth = 0;
P = a[i].p;
while (P != -1) {
P = a[P].p;
depth++;
}
if (a[i].p == -1) {
printf("node %d: parent = %d, depth = %d, root, [", i, a[i].p, depth);
} else if (a[i].left == -1)
printf("node %d: parent = %d, depth = %d, leaf, [", i, a[i].p, depth);
else
printf("node %d: parent = %d, depth = %d, internal node, [", i, a[i].p,
depth);
P = a[i].left;
if (P != -1)
printf("%d", P);
while (P != -1) {
P = a[P].right;
if (P != -1)
printf(", %d", P);
}
printf("]\n");
}
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MAX 10000
#define NIL -1
struct Node {
int parent, left, right;
};
Node T[MAX];
int depth(int i) {
int count = 0;
int c = i;
while (T[c].parent != NIL) {
c = T[c].parent;
count++;
}
return count;
}
string nodeType(int i) {
if (T[i].parent == NIL) {
return "root";
} else if (T[i].left == NIL) {
return "leaf";
} else {
return "internal node";
}
}
void printNodeChild(int i) {
int c = T[i].left;
while (c != NIL) {
cout << c;
c = T[c].right;
if (c != NIL) {
cout << ", ";
}
}
}
void printNodeInfo(int i) {
cout << "node " << i << ": ";
cout << "parent = " << T[i].parent << ",";
cout << " depth = " << depth(i) << ",";
cout << " " << nodeType(i) << ",";
cout << " [";
printNodeChild(i);
cout << "]";
cout << endl;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = NIL;
}
for (int i = 0; i < n; i++) {
int id, k, l;
cin >> id >> k;
for (int j = 0; j < k; j++) {
int c;
cin >> c;
if (j == 0) {
T[id].left = c;
} else {
T[l].right = c;
}
l = c;
T[c].parent = id;
}
}
int root = 0;
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL) {
root = i;
}
}
for (int i = 0; i < n; i++) {
printNodeInfo(i);
}
// cout << root << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MAX 100000
#define NIL -1
struct Node {
int parent, left, right;
};
Node T[MAX];
int depth(int i) {
int count = 0;
int c = i;
while (T[c].parent != NIL) {
c = T[c].parent;
count++;
}
return count;
}
string nodeType(int i) {
if (T[i].parent == NIL) {
return "root";
} else if (T[i].left == NIL) {
return "leaf";
} else {
return "internal node";
}
}
void printNodeChild(int i) {
int c = T[i].left;
while (c != NIL) {
cout << c;
c = T[c].right;
if (c != NIL) {
cout << ", ";
}
}
}
void printNodeInfo(int i) {
cout << "node " << i << ": ";
cout << "parent = " << T[i].parent << ",";
cout << " depth = " << depth(i) << ",";
cout << " " << nodeType(i) << ",";
cout << " [";
printNodeChild(i);
cout << "]";
cout << endl;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = NIL;
}
for (int i = 0; i < n; i++) {
int id, k, l;
cin >> id >> k;
for (int j = 0; j < k; j++) {
int c;
cin >> c;
if (j == 0) {
T[id].left = c;
} else {
T[l].right = c;
}
l = c;
T[c].parent = id;
}
}
int root = 0;
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL) {
root = i;
}
}
for (int i = 0; i < n; i++) {
printNodeInfo(i);
}
// cout << root << endl;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02279
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <random>
#include <vector>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define For(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define ALL(v) v.begin(), v.end()
const int NOT_DEFINED = -111;
class Tree {
int n;
vector<vector<int>> adjlist;
vector<vector<int>> inv_adjlist;
vector<int> depthList;
public:
Tree(int num);
int getParent(int id);
void addNode(int parentId, int childId);
int getDepth(int id);
string getType(int id);
vector<int> getChild(int id);
};
Tree::Tree(int num) {
n = num;
REP(i, num) {
vector<int> v;
adjlist.push_back(v);
inv_adjlist.push_back(v);
depthList.push_back(NOT_DEFINED);
}
}
void Tree::addNode(int parentId, int childId) {
adjlist[parentId].push_back(childId);
inv_adjlist[childId].push_back(parentId);
}
int Tree::getParent(int id) {
REP(i, n) {
if (find(ALL(adjlist[i]), id) != adjlist[i].end()) {
return i;
}
}
return -1;
}
int Tree::getDepth(int id) {
// if (depthList[id] != NOT_DEFINED) return depthList[id];
int depth = 0;
vector<int> parent = inv_adjlist[id];
while (parent.size()) {
if (depthList[parent[0]] != NOT_DEFINED) {
depth += depthList[parent[0]] + 1;
break;
}
parent = inv_adjlist[parent[0]];
depth++;
}
/* slow code
int parent = id;
while (1) {
parent = getParent(parent);
if (parent != -1) {
depth++;
}else {
break;
}
}*/
depthList[id] = depth;
return depth;
}
string Tree::getType(int id) {
if (depthList[id] == 0) {
return "root";
} else if (adjlist[id].empty()) {
return "leaf";
} else {
return "internal node";
}
return "";
}
vector<int> Tree::getChild(int id) { return adjlist[id]; }
int main() {
int n;
cin >> n;
Tree tree = Tree(n);
REP(i, n) {
int id, deg;
cin >> id >> deg;
int k;
REP(j, deg) {
cin >> k;
tree.addNode(id, k);
}
}
REP(i, n) {
vector<int> children = tree.getChild(i);
cout << "node " << i << ": parent = ";
cout << tree.getParent(i) << ", depth = ";
cout << tree.getDepth(i) << ", ";
cout << tree.getType(i) << ", [";
REP(j, children.size()) {
cout << children[j];
if (j < children.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <random>
#include <vector>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define For(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define ALL(v) v.begin(), v.end()
const int NOT_DEFINED = -111;
class Tree {
int n;
vector<vector<int>> adjlist;
vector<vector<int>> inv_adjlist;
vector<int> depthList;
public:
Tree(int num);
int getParent(int id);
void addNode(int parentId, int childId);
int getDepth(int id);
string getType(int id);
vector<int> getChild(int id);
};
Tree::Tree(int num) {
n = num;
REP(i, num) {
vector<int> v;
adjlist.push_back(v);
inv_adjlist.push_back(v);
depthList.push_back(NOT_DEFINED);
}
}
void Tree::addNode(int parentId, int childId) {
adjlist[parentId].push_back(childId);
inv_adjlist[childId].push_back(parentId);
}
int Tree::getParent(int id) {
vector<int> parent = inv_adjlist[id];
if (parent.size())
return parent[0];
return -1;
}
int Tree::getDepth(int id) {
// if (depthList[id] != NOT_DEFINED) return depthList[id];
int depth = 0;
vector<int> parent = inv_adjlist[id];
while (parent.size()) {
if (depthList[parent[0]] != NOT_DEFINED) {
depth += depthList[parent[0]] + 1;
break;
}
parent = inv_adjlist[parent[0]];
depth++;
}
/* slow code
int parent = id;
while (1) {
parent = getParent(parent);
if (parent != -1) {
depth++;
}else {
break;
}
}*/
depthList[id] = depth;
return depth;
}
string Tree::getType(int id) {
if (depthList[id] == 0) {
return "root";
} else if (adjlist[id].empty()) {
return "leaf";
} else {
return "internal node";
}
return "";
}
vector<int> Tree::getChild(int id) { return adjlist[id]; }
int main() {
int n;
cin >> n;
Tree tree = Tree(n);
REP(i, n) {
int id, deg;
cin >> id >> deg;
int k;
REP(j, deg) {
cin >> k;
tree.addNode(id, k);
}
}
REP(i, n) {
vector<int> children = tree.getChild(i);
cout << "node " << i << ": parent = ";
cout << tree.getParent(i) << ", depth = ";
cout << tree.getDepth(i) << ", ";
cout << tree.getType(i) << ", [";
REP(j, children.size()) {
cout << children[j];
if (j < children.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
|
replace
| 45 | 50 | 45 | 48 |
TLE
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define NIL -1
#define N 10005
struct Node {
int p, l, r;
};
Node T[N];
int n, r, D[N];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL)
cout << "root, ";
else if (T[u].l == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = 0, c = T[u].l; c != NIL; ++i, c = T[c].r) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
void rec(int idx, int p) {
D[idx] = p;
if (T[idx].r != NIL)
rec(T[idx].r, p);
if (T[idx].l != NIL)
rec(T[idx].l, p + 1);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
T[i].p = T[i].l = T[i].r = NIL;
for (int i = 0; i < n; ++i) {
int v, d;
cin >> v >> d;
int l;
for (int j = 0; j < d; ++j) {
int c;
cin >> c;
if (0 == j)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (int i = 0; i < n; ++i) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (int i = 0; i < n; ++i)
print(i);
return 0;
}
|
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define NIL -1
#define N 100005
struct Node {
int p, l, r;
};
Node T[N];
int n, r, D[N];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL)
cout << "root, ";
else if (T[u].l == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = 0, c = T[u].l; c != NIL; ++i, c = T[c].r) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
void rec(int idx, int p) {
D[idx] = p;
if (T[idx].r != NIL)
rec(T[idx].r, p);
if (T[idx].l != NIL)
rec(T[idx].l, p + 1);
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
T[i].p = T[i].l = T[i].r = NIL;
for (int i = 0; i < n; ++i) {
int v, d;
cin >> v >> d;
int l;
for (int j = 0; j < d; ++j) {
int c;
cin >> c;
if (0 == j)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (int i = 0; i < n; ++i) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (int i = 0; i < n; ++i)
print(i);
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <stdio.h>
int depth(int node, int d[]) { return d[node]; }
void search(int i, int depth, int d[], int mark[], int b[]) {
d[i] = depth;
int index = mark[i];
int count = b[index]; // nuber of children
for (int j = 0; j < count; j++) {
search(b[index + 1 + j], depth + 1, d, mark, b);
}
}
void pre_process(int d[], int n, int a[], int mark[], int b[]) {
int parent;
for (int i = 0; i < n; i++) {
if (a[i] == -1) {
parent = i;
break;
}
}
// printf("%d\n",parent);
d[parent] = 0;
search(parent, 0, d, mark, b);
}
void check_type(int a[], int type[], int node, int n) {
int tag = 0; // 0: leaf, 1: internal
if (a[node] == -1)
printf("root, ");
else {
if (type[node] == 2)
printf("internal node, ");
else
printf("leaf, ");
}
}
void check_children(int b[], int mark[], int node, int n) {
int index = mark[node]; //
int count = b[index]; // how many children
printf("[");
for (int i = 0; i < count - 1; i++) {
printf("%d, ", b[index + i + 1]);
}
if (count != 0)
printf("%d]", b[index + count]);
else
printf("]");
}
int main() {
int n;
scanf("%d", &n);
int a[n];
int b[100001];
int d[n];
int type[n];
for (int i = 0; i < n; i++) {
a[i] = -1;
d[i] = -1;
type[i] = 2; // 0: root, 1: leaf, 2: internal
}
int index = 0;
int mark[n];
for (int i = 0; i < n; i++) {
int parent;
scanf("%d", &parent);
int k;
scanf("%d", &k); // unmber of children
if (k == 0)
type[parent] = 1; // leaf
mark[parent] = index;
b[index++] = k;
int child;
for (int j = 0; j < k; j++) {
scanf("%d", &child);
b[index++] = child;
a[child] = parent;
}
}
pre_process(d, n, a, mark, b);
// print
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, depth = %d, ", i, a[i], depth(i, d));
check_type(a, type, i, n);
check_children(b, mark, i, n);
printf("\n");
}
return 0;
}
|
#include <stdio.h>
int depth(int node, int d[]) { return d[node]; }
void search(int i, int depth, int d[], int mark[], int b[]) {
d[i] = depth;
int index = mark[i];
int count = b[index]; // nuber of children
for (int j = 0; j < count; j++) {
search(b[index + 1 + j], depth + 1, d, mark, b);
}
}
void pre_process(int d[], int n, int a[], int mark[], int b[]) {
int parent;
for (int i = 0; i < n; i++) {
if (a[i] == -1) {
parent = i;
break;
}
}
// printf("%d\n",parent);
d[parent] = 0;
search(parent, 0, d, mark, b);
}
void check_type(int a[], int type[], int node, int n) {
int tag = 0; // 0: leaf, 1: internal
if (a[node] == -1)
printf("root, ");
else {
if (type[node] == 2)
printf("internal node, ");
else
printf("leaf, ");
}
}
void check_children(int b[], int mark[], int node, int n) {
int index = mark[node]; //
int count = b[index]; // how many children
printf("[");
for (int i = 0; i < count - 1; i++) {
printf("%d, ", b[index + i + 1]);
}
if (count != 0)
printf("%d]", b[index + count]);
else
printf("]");
}
int main() {
int n;
scanf("%d", &n);
int a[n];
int b[200001];
int d[n];
int type[n];
for (int i = 0; i < n; i++) {
a[i] = -1;
d[i] = -1;
type[i] = 2; // 0: root, 1: leaf, 2: internal
}
int index = 0;
int mark[n];
for (int i = 0; i < n; i++) {
int parent;
scanf("%d", &parent);
int k;
scanf("%d", &k); // unmber of children
if (k == 0)
type[parent] = 1; // leaf
mark[parent] = index;
b[index++] = k;
int child;
for (int j = 0; j < k; j++) {
scanf("%d", &child);
b[index++] = child;
a[child] = parent;
}
}
pre_process(d, n, a, mark, b);
// print
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, depth = %d, ", i, a[i], depth(i, d));
check_type(a, type, i, n);
check_children(b, mark, i, n);
printf("\n");
}
return 0;
}
|
replace
| 51 | 52 | 51 | 52 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
vector<int> E[10000];
int d[100000], pr[100000];
void rec(int v, int p) {
d[v] = p;
for (int u : E[v])
rec(u, p + 1);
}
int main() {
int n;
scanf("%d", &n);
memset(pr, -1, sizeof(pr));
rep(i, n) {
int id, k;
scanf("%d%d", &id, &k);
rep(j, k) {
int c;
scanf("%d", &c);
E[id].push_back(c);
pr[c] = id;
}
}
rep(i, n) {
if (!~pr[i]) {
rec(i, 0);
break;
}
}
rep(i, n) {
printf("node %d: parent = %d, depth = %d, ", i, pr[i], d[i]);
if (!~pr[i])
printf("root, [");
else if (E[i].empty())
printf("leaf, [");
else
printf("internal node, [");
rep(j, E[i].size()) {
if (j)
printf(", ");
printf("%d", E[i][j]);
}
printf("]\n");
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
vector<int> E[100000];
int d[100000], pr[100000];
void rec(int v, int p) {
d[v] = p;
for (int u : E[v])
rec(u, p + 1);
}
int main() {
int n;
scanf("%d", &n);
memset(pr, -1, sizeof(pr));
rep(i, n) {
int id, k;
scanf("%d%d", &id, &k);
rep(j, k) {
int c;
scanf("%d", &c);
E[id].push_back(c);
pr[c] = id;
}
}
rep(i, n) {
if (!~pr[i]) {
rec(i, 0);
break;
}
}
rep(i, n) {
printf("node %d: parent = %d, depth = %d, ", i, pr[i], d[i]);
if (!~pr[i])
printf("root, [");
else if (E[i].empty())
printf("leaf, [");
else
printf("internal node, [");
rep(j, E[i].size()) {
if (j)
printf(", ");
printf("%d", E[i][j]);
}
printf("]\n");
}
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 10005
#define NIL -1
typedef struct {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL) {
cout << "root, ";
} else if (T[u].l == NIL) {
cout << "leaf, ";
} else {
cout << "internal node, ";
}
cout << "[";
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i) {
cout << ", ";
}
cout << c;
}
cout << "]" << endl;
}
void rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL) {
rec(T[u].r, p);
}
if (T[u].l != NIL) {
rec(T[u].l, p + 1);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = NIL;
}
int v, d, c, l, r;
for (int i = 0; i < n; i++) {
cin >> v >> d;
for (int j = 0; j < d; j++) {
cin >> c;
if (j == 0) {
T[v].l = c;
} else {
T[l].r = c;
}
l = c;
T[c].p = v;
}
}
for (int i = 0; i < n; i++) {
if (T[i].p == NIL) {
r = i;
}
}
rec(r, 0);
for (int i = 0; i < n; i++) {
print(i);
}
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 100005
#define NIL -1
typedef struct {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL) {
cout << "root, ";
} else if (T[u].l == NIL) {
cout << "leaf, ";
} else {
cout << "internal node, ";
}
cout << "[";
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i) {
cout << ", ";
}
cout << c;
}
cout << "]" << endl;
}
void rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL) {
rec(T[u].r, p);
}
if (T[u].l != NIL) {
rec(T[u].l, p + 1);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = NIL;
}
int v, d, c, l, r;
for (int i = 0; i < n; i++) {
cin >> v >> d;
for (int j = 0; j < d; j++) {
cin >> c;
if (j == 0) {
T[v].l = c;
} else {
T[l].r = c;
}
l = c;
T[c].p = v;
}
}
for (int i = 0; i < n; i++) {
if (T[i].p == NIL) {
r = i;
}
}
rec(r, 0);
for (int i = 0; i < n; i++) {
print(i);
}
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02279
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
class Node {
public:
int parent;
int right_sibling;
int left_child;
int depth;
Node() {
parent = -1;
right_sibling = -1;
left_child = -1;
depth = -1;
}
};
void set_depth(Node *nodes, int id, int d) {
nodes[id].depth = d;
if (nodes[id].right_sibling != -1) {
set_depth(nodes, nodes[id].right_sibling, d);
}
if (nodes[id].left_child != -1) {
set_depth(nodes, nodes[id].left_child, d + 1);
}
}
string type(Node *nodes, int id) {
if (nodes[id].parent == -1) {
return "root";
} else if (nodes[id].left_child == -1) {
return "leaf";
} else {
return "internal node";
}
}
string childs(Node *nodes, int id) {
int c = nodes[id].left_child;
if (c == -1)
return "";
string childs_str = "";
int cnt = 0;
do {
if (cnt)
childs_str = childs_str + ", ";
childs_str = childs_str + to_string(c);
c = nodes[c].right_sibling;
cnt++;
} while (c != -1);
return childs_str;
}
int main() {
int n;
cin >> n;
Node nodes[n];
for (int i = 0; i < n; i++) {
int id;
cin >> id;
int k;
cin >> k;
if (k == 0)
continue;
int c[k];
for (int j = 0; j < k; j++) {
cin >> c[j];
nodes[c[j]].parent = id;
if (j == 0) {
nodes[id].left_child = c[j];
} else {
nodes[c[j - 1]].right_sibling = c[j];
}
}
}
int root;
for (int i = 0; i < n; i++) {
if (nodes[i].parent == -1)
root = i;
}
set_depth(nodes, root, 0);
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, depth = %d, %s, [%s]\n", i, nodes[i].parent,
nodes[i].depth, type(nodes, i).c_str(), childs(nodes, i).c_str());
}
}
|
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
class Node {
public:
int parent;
int right_sibling;
int left_child;
int depth;
Node() {
parent = -1;
right_sibling = -1;
left_child = -1;
depth = -1;
}
};
void set_depth(Node *nodes, int id, int d) {
nodes[id].depth = d;
if (nodes[id].right_sibling != -1) {
set_depth(nodes, nodes[id].right_sibling, d);
}
if (nodes[id].left_child != -1) {
set_depth(nodes, nodes[id].left_child, d + 1);
}
}
string type(Node *nodes, int id) {
if (nodes[id].parent == -1) {
return "root";
} else if (nodes[id].left_child == -1) {
return "leaf";
} else {
return "internal node";
}
}
string childs(Node *nodes, int id) {
int c = nodes[id].left_child;
if (c == -1)
return "";
string childs_str = "";
int cnt = 0;
do {
if (cnt)
childs_str = childs_str + ", ";
childs_str = childs_str + to_string(c);
c = nodes[c].right_sibling;
cnt++;
} while (c != -1);
return childs_str;
}
int main() {
int n;
cin >> n;
Node nodes[n];
for (int i = 0; i < n; i++) {
int id;
cin >> id;
int k;
cin >> k;
if (k == 0)
continue;
int c[k];
for (int j = 0; j < k; j++) {
cin >> c[j];
nodes[c[j]].parent = id;
if (j == 0) {
nodes[id].left_child = c[j];
} else {
nodes[c[j - 1]].right_sibling = c[j];
}
}
}
int root;
for (int i = 0; i < n; i++) {
if (nodes[i].parent == -1)
root = i;
}
set_depth(nodes, root, 0);
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, depth = %d, %s, [", i, nodes[i].parent,
nodes[i].depth, type(nodes, i).c_str());
int c = nodes[i].left_child;
int cnt = 0;
while (c != -1) {
if (cnt)
printf(", ");
printf("%d", c);
cnt++;
c = nodes[c].right_sibling;
}
printf("]\n");
}
}
|
replace
| 85 | 87 | 85 | 97 |
TLE
| |
p02279
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <limits>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
map<int, int> mpa, mpb;
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
Node T[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL)
cout << "root, ";
else if (T[u].l == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL)
rec(T[u].r, p); // 深さを入れてく
if (T[u].l != NIL)
rec(T[u].l, p + 1);
}
int main() {
int i, j, d, v, c, l, r;
cin >> n;
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL; // 初期化
for (i = 0; i < n; i++) {
cin >> v >> d;
for (j = 0; j < v; j++) {
cin >> c;
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++)
print(i);
return 0;
}
|
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <limits>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
map<int, int> mpa, mpb;
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
Node T[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if (T[u].p == NIL)
cout << "root, ";
else if (T[u].l == NIL)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (i = 0, c = T[u].l; c != NIL; i++, c = T[c].r) {
if (i)
cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int rec(int u, int p) {
D[u] = p;
if (T[u].r != NIL)
rec(T[u].r, p); // 深さを入れてく
if (T[u].l != NIL)
rec(T[u].l, p + 1);
}
int main() {
int i, j, d, v, c, l, r;
cin >> n;
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL; // 初期化
for (i = 0; i < n; i++) {
cin >> v >> d;
for (j = 0; j < d; j++) {
cin >> c;
if (j == 0)
T[v].l = c;
else
T[l].r = c;
l = c;
T[c].p = v;
}
}
for (i = 0; i < n; i++) {
if (T[i].p == NIL)
r = i;
}
rec(r, 0);
for (i = 0; i < n; i++)
print(i);
return 0;
}
|
replace
| 59 | 60 | 59 | 60 |
-11
| |
p02279
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
const int MAX = 10005;
const int NIL = -1;
struct Node {
int p, l, r;
};
Node Tree[MAX];
int n, Depth[MAX];
void print(int u) {
printf("node %d: ", u);
printf("parent = %d, ", Tree[u].p);
printf("depth = %d, ", Depth[u]);
if (Tree[u].p == NIL)
printf("root, ");
else if (Tree[u].l == NIL)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
// ????????????????????????????§???????
int c = Tree[u].l;
while (c != NIL) {
printf("%d", c);
if (Tree[c].r != NIL)
printf(", ");
// ?????°?????§?´§??????????????????
c = Tree[c].r;
}
printf("]\n");
}
// ??????????±???±???
void rec(int u, int depth) {
Depth[u] = depth;
if (Tree[u].r != NIL) // ?????§???????????????????????±???
rec(Tree[u].r, depth);
if (Tree[u].l !=
NIL) // ????????§??????????????±?????????????????±?????±??? + 1
rec(Tree[u].l, depth + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
Tree[i].p = Tree[i].l = Tree[i].r = NIL;
}
int v, num, c, l, root;
for (int i = 0; i < n; i++) {
// v?????????????????? ???num???v????????????????????°
scanf("%d %d", &v, &num);
for (int j = 0; j < num; j++) {
scanf("%d", &c);
//??????????????§?????? ??? ?´§????????§????????????
// l??°????????????????????????????°?????????????????????????l????´§????????§??????
if (j == 0)
Tree[v].l = c;
else
Tree[l].r = c;
l = c;
// ????????¶??????
Tree[c].p = v;
}
}
// ???????????????
for (int i = 0; i < n; i++) {
if (Tree[i].p == NIL)
root = i;
}
rec(root, 0);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
const int MAX = 100005;
const int NIL = -1;
struct Node {
int p, l, r;
};
Node Tree[MAX];
int n, Depth[MAX];
void print(int u) {
printf("node %d: ", u);
printf("parent = %d, ", Tree[u].p);
printf("depth = %d, ", Depth[u]);
if (Tree[u].p == NIL)
printf("root, ");
else if (Tree[u].l == NIL)
printf("leaf, ");
else
printf("internal node, ");
printf("[");
// ????????????????????????????§???????
int c = Tree[u].l;
while (c != NIL) {
printf("%d", c);
if (Tree[c].r != NIL)
printf(", ");
// ?????°?????§?´§??????????????????
c = Tree[c].r;
}
printf("]\n");
}
// ??????????±???±???
void rec(int u, int depth) {
Depth[u] = depth;
if (Tree[u].r != NIL) // ?????§???????????????????????±???
rec(Tree[u].r, depth);
if (Tree[u].l !=
NIL) // ????????§??????????????±?????????????????±?????±??? + 1
rec(Tree[u].l, depth + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
Tree[i].p = Tree[i].l = Tree[i].r = NIL;
}
int v, num, c, l, root;
for (int i = 0; i < n; i++) {
// v?????????????????? ???num???v????????????????????°
scanf("%d %d", &v, &num);
for (int j = 0; j < num; j++) {
scanf("%d", &c);
//??????????????§?????? ??? ?´§????????§????????????
// l??°????????????????????????????°?????????????????????????l????´§????????§??????
if (j == 0)
Tree[v].l = c;
else
Tree[l].r = c;
l = c;
// ????????¶??????
Tree[c].p = v;
}
}
// ???????????????
for (int i = 0; i < n; i++) {
if (Tree[i].p == NIL)
root = i;
}
rec(root, 0);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02279
|
C++
|
Runtime Error
|
#define scanf_s scanf
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define MAX 1000
// #define MAX_ 1000
int cou = 0;
struct tree {
int id;
tree *pp;
tree *next;
tree *pchbegin, *pchend;
};
int main(void) {
int n, xid, xk, xdeep = 0, xc1, xc2;
int depth, cou = 0, parent;
tree node[MAX], first;
first.id = -1;
bool node_b[MAX] = {false};
scanf_s("%d", &n);
for (int i = 0; i < n; ++i) {
scanf_s("%d %d", &xid, &xk);
node[xid].id = xid;
if (node_b[xid] == false) {
node[xid].pp = &first;
}
node[xid].pchbegin = node[xid].pchend;
for (int j = 0; j < xk; ++j) {
scanf_s("%d", &xc1);
node[xc1].pp = &node[xid];
node_b[xc1] = true;
if (j == 0) {
node[xid].pchbegin = &node[xc1];
node[xc1].next = node[xid].pchend;
} else {
node[xc2].next = &node[xc1];
node[xc1].next = node[xid].pchend;
}
xc2 = xc1;
}
}
for (int i = 0; i < n; ++i) {
depth = 0;
for (tree *p = node[i].pp; p != &first; p = p->pp) {
++depth;
}
printf("node %d: parent = %d, depth = %d, ", node[i].id, node[i].pp->id,
depth);
if (node[i].pchbegin == node[i].pchend && node[i].pp->id != -1) {
printf("leaf, [");
} else {
if (node[i].pp->id == -1) {
printf("root, [");
} else {
printf("internal node, [");
}
for (tree *j = node[i].pchbegin; j != node[i].pchend; j = j->next) {
if (j == node[i].pchbegin) {
printf("%d", j->id);
} else
printf(", %d", j->id);
}
}
printf("]\n");
}
}
|
#define scanf_s scanf
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define MAX 100000
// #define MAX_ 1000
int cou = 0;
struct tree {
int id;
tree *pp;
tree *next;
tree *pchbegin, *pchend;
};
int main(void) {
int n, xid, xk, xdeep = 0, xc1, xc2;
int depth, cou = 0, parent;
tree node[MAX], first;
first.id = -1;
bool node_b[MAX] = {false};
scanf_s("%d", &n);
for (int i = 0; i < n; ++i) {
scanf_s("%d %d", &xid, &xk);
node[xid].id = xid;
if (node_b[xid] == false) {
node[xid].pp = &first;
}
node[xid].pchbegin = node[xid].pchend;
for (int j = 0; j < xk; ++j) {
scanf_s("%d", &xc1);
node[xc1].pp = &node[xid];
node_b[xc1] = true;
if (j == 0) {
node[xid].pchbegin = &node[xc1];
node[xc1].next = node[xid].pchend;
} else {
node[xc2].next = &node[xc1];
node[xc1].next = node[xid].pchend;
}
xc2 = xc1;
}
}
for (int i = 0; i < n; ++i) {
depth = 0;
for (tree *p = node[i].pp; p != &first; p = p->pp) {
++depth;
}
printf("node %d: parent = %d, depth = %d, ", node[i].id, node[i].pp->id,
depth);
if (node[i].pchbegin == node[i].pchend && node[i].pp->id != -1) {
printf("leaf, [");
} else {
if (node[i].pp->id == -1) {
printf("root, [");
} else {
printf("internal node, [");
}
for (tree *j = node[i].pchbegin; j != node[i].pchend; j = j->next) {
if (j == node[i].pchbegin) {
printf("%d", j->id);
} else
printf(", %d", j->id);
}
}
printf("]\n");
}
}
|
replace
| 13 | 14 | 13 | 14 |
0
| |
p02279
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define INT_MAX 2147483647
#define INT_MIN -2147483647
#define NUM 10000
#define INVALID_IDX -1
using namespace std;
struct TreeNode {
int p, l, r;
};
TreeNode t[NUM];
int D[NUM];
void print(int idx) {
cout << "node " << idx << ": ";
cout << "parent = " << t[idx].p << ", ";
cout << "depth = " << D[idx] << ", ";
if (t[idx].p == INVALID_IDX)
cout << "root, ";
else if (t[idx].l == INVALID_IDX)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = t[idx].l; i != INVALID_IDX; i = t[i].r) {
cout << i;
if (t[i].r != INVALID_IDX)
cout << ", ";
}
cout << "]" << endl;
}
void getHeight(int idx, int depth) {
D[idx] = depth;
if (t[idx].r != INVALID_IDX)
getHeight(t[idx].r, depth);
if (t[idx].l != INVALID_IDX)
getHeight(t[idx].l, depth + 1);
}
int main() {
int i, j, n, idx0, idx1, d, l, r = INVALID_IDX;
cin >> n;
for (int i = 0; i < n; ++i)
t[i].p = t[i].l = t[i].r = INVALID_IDX;
for (int i = 0; i < n; ++i) {
cin >> idx0 >> d;
for (int j = 0; j < d; ++j) {
cin >> idx1;
if (0 == j)
t[idx0].l = idx1;
else
t[l].r = idx1;
l = idx1;
t[idx1].p = idx0;
}
}
for (int i = 0; i < n; ++i) {
if (t[i].p == INVALID_IDX) {
r = i;
break;
}
}
getHeight(r, 0);
for (int i = 0; i < n; ++i)
print(i);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define INT_MAX 2147483647
#define INT_MIN -2147483647
#define NUM 100005
#define INVALID_IDX -1
using namespace std;
struct TreeNode {
int p, l, r;
};
TreeNode t[NUM];
int D[NUM];
void print(int idx) {
cout << "node " << idx << ": ";
cout << "parent = " << t[idx].p << ", ";
cout << "depth = " << D[idx] << ", ";
if (t[idx].p == INVALID_IDX)
cout << "root, ";
else if (t[idx].l == INVALID_IDX)
cout << "leaf, ";
else
cout << "internal node, ";
cout << "[";
for (int i = t[idx].l; i != INVALID_IDX; i = t[i].r) {
cout << i;
if (t[i].r != INVALID_IDX)
cout << ", ";
}
cout << "]" << endl;
}
void getHeight(int idx, int depth) {
D[idx] = depth;
if (t[idx].r != INVALID_IDX)
getHeight(t[idx].r, depth);
if (t[idx].l != INVALID_IDX)
getHeight(t[idx].l, depth + 1);
}
int main() {
int i, j, n, idx0, idx1, d, l, r = INVALID_IDX;
cin >> n;
for (int i = 0; i < n; ++i)
t[i].p = t[i].l = t[i].r = INVALID_IDX;
for (int i = 0; i < n; ++i) {
cin >> idx0 >> d;
for (int j = 0; j < d; ++j) {
cin >> idx1;
if (0 == j)
t[idx0].l = idx1;
else
t[l].r = idx1;
l = idx1;
t[idx1].p = idx0;
}
}
for (int i = 0; i < n; ++i) {
if (t[i].p == INVALID_IDX) {
r = i;
break;
}
}
getHeight(r, 0);
for (int i = 0; i < n; ++i)
print(i);
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define INT_MAX 2147483647
#define Loop(i, n) for (int i = 0; i < (int)n; i++)
#define Loop1(i, n) for (int i = 1; i < (int)n; i++)
#define Loopr(i, n) for (int i = (int)n - 1; i >= 0; i--)
using namespace std;
typedef long long int ll;
struct node {
int parent, left, right;
};
int n;
vector<node> nodes(25, {-1, -1, -1});
int sib_of(int a) {
if (nodes[a].parent == -1)
return -1;
else {
int x = nodes[nodes[a].parent].left;
int y = nodes[nodes[a].parent].right;
if (x == a)
return y;
else
return x;
}
}
int deg_of(int a) {
int ret = 0;
if (nodes[a].left != -1)
ret++;
if (nodes[a].right != -1)
ret++;
return ret;
}
int depth_of(int a) {
if (nodes[a].parent == -1)
return 0;
else
return depth_of(nodes[a].parent) + 1;
}
int height_of(int a) {
if (deg_of(a) == 0)
return 0;
else
return max(height_of(nodes[a].left) + 1, height_of(nodes[a].right) + 1);
}
string type_of(int a) {
if (nodes[a].parent == -1)
return "root";
else if (deg_of(a) == 0)
return "leaf";
else
return "internal node";
}
void print(int a) {
cout << "node " << a << ": parent = " << nodes[a].parent;
cout << ", sibling = " << sib_of(a);
cout << ", degree = " << deg_of(a);
cout << ", depth = " << depth_of(a);
cout << ", height = " << height_of(a);
cout << ", " << type_of(a) << endl;
}
int main() {
cin >> n;
Loop(i, n) {
int id;
cin >> id;
int l, r;
cin >> l >> r;
nodes[id].left = l;
nodes[id].right = r;
if (l != -1)
nodes[l].parent = id;
if (r != -1)
nodes[r].parent = id;
}
Loop(i, n) { print(i); }
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define INT_MAX 2147483647
#define Loop(i, n) for (int i = 0; i < (int)n; i++)
#define Loop1(i, n) for (int i = 1; i < (int)n; i++)
#define Loopr(i, n) for (int i = (int)n - 1; i >= 0; i--)
using namespace std;
typedef long long int ll;
struct node {
int parent, left, right;
};
int n;
vector<node> nodes(25, {-1, -1, -1});
int sib_of(int a) {
if (nodes[a].parent == -1)
return -1;
else {
int x = nodes[nodes[a].parent].left;
int y = nodes[nodes[a].parent].right;
if (x == a)
return y;
else
return x;
}
}
int deg_of(int a) {
int ret = 0;
if (nodes[a].left != -1)
ret++;
if (nodes[a].right != -1)
ret++;
return ret;
}
int depth_of(int a) {
if (nodes[a].parent == -1)
return 0;
else
return depth_of(nodes[a].parent) + 1;
}
int height_of(int a) {
if (a == -1)
return -1;
else if (deg_of(a) == 0)
return 0;
else
return max(height_of(nodes[a].left) + 1, height_of(nodes[a].right) + 1);
}
string type_of(int a) {
if (nodes[a].parent == -1)
return "root";
else if (deg_of(a) == 0)
return "leaf";
else
return "internal node";
}
void print(int a) {
cout << "node " << a << ": parent = " << nodes[a].parent;
cout << ", sibling = " << sib_of(a);
cout << ", degree = " << deg_of(a);
cout << ", depth = " << depth_of(a);
cout << ", height = " << height_of(a);
cout << ", " << type_of(a) << endl;
}
int main() {
cin >> n;
Loop(i, n) {
int id;
cin >> id;
int l, r;
cin >> l >> r;
nodes[id].left = l;
nodes[id].right = r;
if (l != -1)
nodes[l].parent = id;
if (r != -1)
nodes[r].parent = id;
}
Loop(i, n) { print(i); }
return 0;
}
|
replace
| 60 | 61 | 60 | 63 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
const int N = 25;
const int NIL = -1;
struct Node {
int parent, left, right;
};
void set_depth(int id, int dep, int depth[], Node T[]) {
depth[id] = dep;
if (T[id].left != NIL)
set_depth(T[id].left, dep + 1, depth, T);
if (T[id].right != NIL)
set_depth(T[id].right, dep + 1, depth, T);
}
void set_type(int n, string type[], Node T[]) {
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL)
type[i] = "root";
else if (T[i].left == NIL && T[i].right == NIL)
type[i] = "leaf";
else
type[i] = "internal node";
}
}
int find_root(int n, string type[]) {
int root = 0;
for (int i = 0; i < n; i++) {
if (type[i] == "root") {
root = i;
break;
}
}
return root;
}
int set_height(int id, int height[], string type[], Node T[]) {
if (type[id] == "leaf") {
height[id] = 0;
return 0;
}
int h, h1, h2;
h1 = 1 + set_height(T[id].left, height, type, T);
h2 = 1 + set_height(T[id].right, height, type, T);
h = max(h1, h2);
height[id] = h;
return h;
}
int main() {
int i, n, id, left, right;
Node T[N];
int sibling[N], degree[N], depth[N], height[N];
string type[N];
cin >> n;
// init
for (i = 0; i < n; i++) {
T[i].parent = NIL;
T[i].left = NIL;
T[i].right = NIL;
sibling[i] = NIL;
}
// input
for (i = 0; i < n; i++) {
cin >> id >> left >> right;
T[id].left = left;
T[id].right = right;
if (left != NIL && right != NIL) {
T[left].parent = id;
T[right].parent = id;
sibling[left] = right;
sibling[right] = left;
degree[id] = 2;
} else if (left == NIL && right != NIL) {
T[right].parent = id;
sibling[right] = left;
degree[id] = 1;
} else if (left != NIL && right == NIL) {
T[left].parent = id;
sibling[left] = right;
degree[id] = 1;
} else {
degree[id] = 0;
}
}
set_type(n, type, T);
int root = find_root(n, type);
set_depth(root, 0, depth, T);
set_height(root, height, type, T);
// output
for (i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << T[i].parent
<< ", sibling = " << sibling[i] << ", degree = " << degree[i]
<< ", depth = " << depth[i] << ", height = " << height[i] << ", "
<< type[i] << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
const int N = 25;
const int NIL = -1;
struct Node {
int parent, left, right;
};
void set_depth(int id, int dep, int depth[], Node T[]) {
depth[id] = dep;
if (T[id].left != NIL)
set_depth(T[id].left, dep + 1, depth, T);
if (T[id].right != NIL)
set_depth(T[id].right, dep + 1, depth, T);
}
void set_type(int n, string type[], Node T[]) {
for (int i = 0; i < n; i++) {
if (T[i].parent == NIL)
type[i] = "root";
else if (T[i].left == NIL && T[i].right == NIL)
type[i] = "leaf";
else
type[i] = "internal node";
}
}
int find_root(int n, string type[]) {
int root = 0;
for (int i = 0; i < n; i++) {
if (type[i] == "root") {
root = i;
break;
}
}
return root;
}
int set_height(int id, int height[], string type[], Node T[]) {
if (type[id] == "leaf") {
height[id] = 0;
return 0;
}
int h, h1 = 0, h2 = 0;
if (T[id].left != NIL)
h1 = 1 + set_height(T[id].left, height, type, T);
if (T[id].right != NIL)
h2 = 1 + set_height(T[id].right, height, type, T);
h = max(h1, h2);
height[id] = h;
return h;
}
int main() {
int i, n, id, left, right;
Node T[N];
int sibling[N], degree[N], depth[N], height[N];
string type[N];
cin >> n;
// init
for (i = 0; i < n; i++) {
T[i].parent = NIL;
T[i].left = NIL;
T[i].right = NIL;
sibling[i] = NIL;
}
// input
for (i = 0; i < n; i++) {
cin >> id >> left >> right;
T[id].left = left;
T[id].right = right;
if (left != NIL && right != NIL) {
T[left].parent = id;
T[right].parent = id;
sibling[left] = right;
sibling[right] = left;
degree[id] = 2;
} else if (left == NIL && right != NIL) {
T[right].parent = id;
sibling[right] = left;
degree[id] = 1;
} else if (left != NIL && right == NIL) {
T[left].parent = id;
sibling[left] = right;
degree[id] = 1;
} else {
degree[id] = 0;
}
}
set_type(n, type, T);
int root = find_root(n, type);
set_depth(root, 0, depth, T);
set_height(root, height, type, T);
// output
for (i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << T[i].parent
<< ", sibling = " << sibling[i] << ", degree = " << degree[i]
<< ", depth = " << depth[i] << ", height = " << height[i] << ", "
<< type[i] << endl;
}
return 0;
}
|
replace
| 46 | 49 | 46 | 51 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct TNode {
int Id;
TNode *Parent;
TNode *LChild;
TNode *RChild;
};
//???????????????????????????TNode*???????????????(vector??????????????¢?????????????????????)
class TTable {
private:
vector<TNode *> Nodes;
void Create(int Id, vector<TNode *> &Nodes) {
if (Nodes[Id] == NULL) {
TNode *Node;
Node = new TNode;
*Node = {Id, NULL, NULL, NULL};
Nodes[Id] = Node;
}
}
public:
// TNode*?????????&?????????????????????????????????
//????????????????????§delete????????????????????????????????????????????????????????¨?????????????????????????????????????????????
//???????????????????????????Id??¨TNode*???????????????????????¨??§????????????????????????????????¨????????????????????????????????????
TNode *operator[](int n) {
Create(n, Nodes);
return Nodes[n];
}
TNode *operator[](int n) const { return Nodes[n]; }
TTable(int n) {
//????´??????°???????????????
Nodes.resize(n, NULL);
}
~TTable() {
int n = Nodes.size();
for (int i = 0; i < n; i++) {
delete Nodes[i];
}
}
int size() const { return Nodes.size(); }
};
enum TNodeType { Root, InternalNode, Leaf };
void CreateLeftRelation(TNode *ParentNode, TNode *LChildNode) {
ParentNode->LChild = LChildNode;
LChildNode->Parent = ParentNode;
}
void CreateRightRelation(TNode *ParentNode, TNode *RChildNode) {
ParentNode->RChild = RChildNode;
RChildNode->Parent = ParentNode;
}
void Input(TTable &Table) {
for (int i = 0; i < Table.size(); i++) {
int Id;
cin >> Id;
int left;
cin >> left;
if (left != -1) {
CreateLeftRelation(Table[Id], Table[left]);
}
int right;
cin >> right;
if (right != -1) {
CreateRightRelation(Table[Id], Table[right]);
}
}
}
int GetSibling(const TNode *Node) {
const TNode *Parent = Node->Parent;
if (Parent == NULL) {
return -1;
}
if (Node == Parent->LChild && Parent->RChild) {
return Parent->RChild->Id;
}
if (Node == Parent->RChild && Parent->LChild) {
return Parent->LChild->Id;
}
return -1;
}
int GetDegree(const TNode *Node) {
return (Node->LChild ? 1 : 0) + (Node->RChild ? 1 : 0);
}
int GetDepth(const TNode *Node) {
int depth = 0;
while (Node->Parent) {
depth++;
Node = Node->Parent;
}
return depth;
}
int GetHeight(const TNode *Node) {
if (Node == NULL)
return -1;
return 1 + max(GetHeight(Node->LChild), GetHeight(Node->RChild));
}
TNodeType GetType(const TNode *Node) {
if (Node->Parent == NULL) {
return Root;
}
if (Node->LChild == NULL && Node->RChild == NULL) {
return Leaf;
}
return InternalNode;
}
void Output(const TTable &Table) {
for (unsigned int i = 0; i < Table.size(); i++) {
cout << "node " << Table[i]->Id << ": ";
if (Table[i]->Parent) {
cout << "parent = " << Table[i]->Parent->Id << ", ";
} else {
cout << "parent = -1, ";
}
cout << "sibling = " << GetSibling(Table[i]) << ", ";
cout << "degree = " << GetDegree(Table[i]) << ", ";
cout << "depth = " << GetDepth(Table[i]) << ", ";
cout << "height = " << GetHeight(Table[i]) << ", ";
if (GetType(Table[i]) == Root) {
cout << "root";
} else if (GetType(Table[i]) == InternalNode) {
cout << "internal node";
} else {
cout << "leaf";
}
cout << endl;
}
}
int main() {
int n;
cin >> n;
TTable Table(n);
Input(Table);
Output(Table);
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct TNode {
int Id;
TNode *Parent;
TNode *LChild;
TNode *RChild;
};
//???????????????????????????TNode*???????????????(vector??????????????¢?????????????????????)
class TTable {
private:
vector<TNode *> Nodes;
void Create(int Id, vector<TNode *> &Nodes) {
if (Nodes[Id] == NULL) {
TNode *Node;
Node = new TNode;
*Node = {Id, NULL, NULL, NULL};
Nodes[Id] = Node;
}
}
public:
// TNode*?????????&?????????????????????????????????
//????????????????????§delete????????????????????????????????????????????????????????¨?????????????????????????????????????????????
//???????????????????????????Id??¨TNode*???????????????????????¨??§????????????????????????????????¨????????????????????????????????????
TNode *operator[](int n) {
Create(n, Nodes);
return Nodes[n];
}
TNode *operator[](int n) const { return Nodes[n]; }
TTable(int n) {
//????´??????°???????????????
Nodes.resize(n, NULL);
}
~TTable() {
int n = Nodes.size();
for (int i = 0; i < n; i++) {
delete Nodes[i];
}
}
int size() const { return Nodes.size(); }
};
enum TNodeType { Root, InternalNode, Leaf };
void CreateLeftRelation(TNode *ParentNode, TNode *LChildNode) {
ParentNode->LChild = LChildNode;
LChildNode->Parent = ParentNode;
}
void CreateRightRelation(TNode *ParentNode, TNode *RChildNode) {
ParentNode->RChild = RChildNode;
RChildNode->Parent = ParentNode;
}
void Input(TTable &Table) {
for (int i = 0; i < Table.size(); i++) {
int Id;
cin >> Id;
int left;
cin >> left;
if (left != -1) {
CreateLeftRelation(Table[Id], Table[left]);
}
int right;
cin >> right;
if (right != -1) {
CreateRightRelation(Table[Id], Table[right]);
}
}
}
int GetSibling(const TNode *Node) {
const TNode *Parent = Node->Parent;
if (Parent == NULL) {
return -1;
}
if (Node == Parent->LChild && Parent->RChild) {
return Parent->RChild->Id;
}
if (Node == Parent->RChild && Parent->LChild) {
return Parent->LChild->Id;
}
return -1;
}
int GetDegree(const TNode *Node) {
return (Node->LChild ? 1 : 0) + (Node->RChild ? 1 : 0);
}
int GetDepth(const TNode *Node) {
int depth = 0;
while (Node->Parent) {
depth++;
Node = Node->Parent;
}
return depth;
}
int GetHeight(const TNode *Node) {
if (Node == NULL)
return -1;
return 1 + max(GetHeight(Node->LChild), GetHeight(Node->RChild));
}
TNodeType GetType(const TNode *Node) {
if (Node->Parent == NULL) {
return Root;
}
if (Node->LChild == NULL && Node->RChild == NULL) {
return Leaf;
}
return InternalNode;
}
void Output(const TTable &Table) {
for (unsigned int i = 0; i < Table.size(); i++) {
cout << "node " << Table[i]->Id << ": ";
if (Table[i]->Parent) {
cout << "parent = " << Table[i]->Parent->Id << ", ";
} else {
cout << "parent = -1, ";
}
cout << "sibling = " << GetSibling(Table[i]) << ", ";
cout << "degree = " << GetDegree(Table[i]) << ", ";
cout << "depth = " << GetDepth(Table[i]) << ", ";
cout << "height = " << GetHeight(Table[i]) << ", ";
if (GetType(Table[i]) == Root) {
cout << "root";
} else if (GetType(Table[i]) == InternalNode) {
cout << "internal node";
} else {
cout << "leaf";
}
cout << endl;
}
}
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "node 0: parent = -1, sibling = -1, degree = 0, depth = 0, height "
"= 0, root"
<< endl;
return 0;
}
TTable Table(n);
Input(Table);
Output(Table);
return 0;
}
|
insert
| 146 | 146 | 146 | 152 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <cstdio>
#define MAX 10000
#define NIL -1
struct Node {
int parent, left, right;
};
Node T[MAX];
int n, D[MAX], H[MAX];
void setDepth(int u, int d) {
if (u == NIL)
return;
D[u] = d;
setDepth(T[u].left, d + 1);
setDepth(T[u].right, d + 1);
}
int setHeight(int u) {
int h1 = 0, h2 = 0;
if (T[u].left != NIL)
h1 = setHeight(T[u].left) + 1;
if (T[u].left != NIL)
h2 = setHeight(T[u].right) + 1;
return H[u] = (h1 > h2 ? h1 : h2);
}
int getSibling(int u) {
if (T[u].parent == NIL)
return NIL;
if (T[T[u].parent].left != u && T[T[u].parent].left != NIL)
return T[T[u].parent].left;
if (T[T[u].parent].right != u && T[T[u].parent].right != NIL)
return T[T[u].parent].right;
return NIL;
}
void print(int u) {
printf("node %d: ", u);
printf("parent = %d, ", T[u].parent);
printf("sibling = %d, ", getSibling(u));
int deg = 0;
if (T[u].left != NIL)
deg++;
if (T[u].right != NIL)
deg++;
printf("degree = %d, ", deg);
printf("depth = %d, ", D[u]);
printf("height = %d, ", H[u]);
if (T[u].parent == NIL) {
printf("root\n");
} else if (T[u].left == NIL && T[u].right == NIL) {
printf("leaf\n");
} else {
printf("internal node\n");
}
}
int main() {
int v, l, r, root = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
T[i].parent = NIL;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &v, &l, &r);
T[v].left = l;
T[v].right = r;
if (l != NIL)
T[l].parent = v;
if (r != NIL)
T[r].parent = v;
}
for (int i = 0; i < n; i++)
if (T[i].parent == NIL)
root = i;
setDepth(root, 0);
setHeight(root);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
#include <cstdio>
#define MAX 10000
#define NIL -1
struct Node {
int parent, left, right;
};
Node T[MAX];
int n, D[MAX], H[MAX];
void setDepth(int u, int d) {
if (u == NIL)
return;
D[u] = d;
setDepth(T[u].left, d + 1);
setDepth(T[u].right, d + 1);
}
int setHeight(int u) {
int h1 = 0, h2 = 0;
if (T[u].left != NIL)
h1 = setHeight(T[u].left) + 1;
if (T[u].right != NIL)
h2 = setHeight(T[u].right) + 1;
return H[u] = (h1 > h2 ? h1 : h2);
}
int getSibling(int u) {
if (T[u].parent == NIL)
return NIL;
if (T[T[u].parent].left != u && T[T[u].parent].left != NIL)
return T[T[u].parent].left;
if (T[T[u].parent].right != u && T[T[u].parent].right != NIL)
return T[T[u].parent].right;
return NIL;
}
void print(int u) {
printf("node %d: ", u);
printf("parent = %d, ", T[u].parent);
printf("sibling = %d, ", getSibling(u));
int deg = 0;
if (T[u].left != NIL)
deg++;
if (T[u].right != NIL)
deg++;
printf("degree = %d, ", deg);
printf("depth = %d, ", D[u]);
printf("height = %d, ", H[u]);
if (T[u].parent == NIL) {
printf("root\n");
} else if (T[u].left == NIL && T[u].right == NIL) {
printf("leaf\n");
} else {
printf("internal node\n");
}
}
int main() {
int v, l, r, root = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
T[i].parent = NIL;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &v, &l, &r);
T[v].left = l;
T[v].right = r;
if (l != NIL)
T[l].parent = v;
if (r != NIL)
T[r].parent = v;
}
for (int i = 0; i < n; i++)
if (T[i].parent == NIL)
root = i;
setDepth(root, 0);
setHeight(root);
for (int i = 0; i < n; i++)
print(i);
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#define Lens 250
#define Nil -1
using namespace std;
struct Node {
int p, l, r;
};
int N;
Node Tr[Lens];
int D[Lens], C[Lens], H[Lens];
bool V[Lens];
// 建树
void maketree() {
int m, l, r;
for (int i = 0; i < N; i++) {
cin >> m >> l >> r;
Tr[m].l = l;
Tr[l].p = m;
Tr[m].r = r;
Tr[r].p = m;
}
}
// 深度
void dns(int i, int p) {
D[i] = p;
if (Tr[i].l != Nil) {
C[i]++;
dns(Tr[i].l, p + 1);
}
if (Tr[i].r != Nil) {
C[i]++;
dns(Tr[i].r, p + 1);
}
}
int hns(int i) {
if (Tr[i].l != Nil || Tr[i].r != Nil) {
int l = Tr[i].l;
int r = Tr[i].r;
H[i] = max(hns(l), hns(r)) + 1;
// cout << i << ": " << H[i]<<endl;
return H[i];
}
return 0;
}
void printtree() {
int root;
for (int i = 0; i < N; i++) {
if (Tr[i].p == Nil)
root = i;
}
dns(root, 0);
hns(root);
for (int i = 0; i < N; i++) {
cout << "node " << i << ": parent = " << Tr[i].p << ", sibling = ";
if (i == root)
cout << Nil;
else if (i == Tr[Tr[i].p].l)
cout << Tr[Tr[i].p].r;
else
cout << Tr[Tr[i].p].l;
cout << ", degree = " << C[i] << ", depth = " << D[i]
<< ", height = " << H[i] << ", ";
if (i == root)
cout << "root";
else if (i != root && C[i] != 0)
cout << "internal node";
else
cout << "leaf";
cout << endl;
;
}
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
Tr[i].p = Tr[i].l = Tr[i].r = Nil;
V[i] = false;
}
maketree();
printtree();
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#define Lens 250
#define Nil -1
using namespace std;
struct Node {
int p, l, r;
};
int N;
Node Tr[Lens];
int D[Lens], C[Lens], H[Lens];
bool V[Lens];
// 建树
void maketree() {
int m, l, r;
for (int i = 0; i < N; i++) {
cin >> m >> l >> r;
Tr[m].l = l;
Tr[l].p = m;
Tr[m].r = r;
Tr[r].p = m;
}
}
// 深度
void dns(int i, int p) {
D[i] = p;
if (Tr[i].l != Nil) {
C[i]++;
dns(Tr[i].l, p + 1);
}
if (Tr[i].r != Nil) {
C[i]++;
dns(Tr[i].r, p + 1);
}
}
int hns(int i) {
int h1 = 0, h2 = 0;
if (Tr[i].l != Nil)
h1 = hns(Tr[i].l) + 1;
if (Tr[i].r != Nil)
h2 = hns(Tr[i].r) + 1;
H[i] = max(h1, h2);
return H[i];
}
void printtree() {
int root;
for (int i = 0; i < N; i++) {
if (Tr[i].p == Nil)
root = i;
}
dns(root, 0);
hns(root);
for (int i = 0; i < N; i++) {
cout << "node " << i << ": parent = " << Tr[i].p << ", sibling = ";
if (i == root)
cout << Nil;
else if (i == Tr[Tr[i].p].l)
cout << Tr[Tr[i].p].r;
else
cout << Tr[Tr[i].p].l;
cout << ", degree = " << C[i] << ", depth = " << D[i]
<< ", height = " << H[i] << ", ";
if (i == root)
cout << "root";
else if (i != root && C[i] != 0)
cout << "internal node";
else
cout << "leaf";
cout << endl;
;
}
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
Tr[i].p = Tr[i].l = Tr[i].r = Nil;
V[i] = false;
}
maketree();
printtree();
return 0;
}
|
replace
| 45 | 53 | 45 | 52 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
struct Node {
int id;
Node *parent, *left, *right;
};
int n;
Node **nodes;
inline int getheight(int id) {
Node *node = nodes[id];
int left_height = 0, right_height = 0;
if (node->left) {
left_height = 1 + getheight(node->left->id);
}
if (node->right) {
right_height = 1 + getheight(node->right->id);
}
return left_height > right_height ? left_height : right_height;
}
int main(void) {
scanf("%d", &n);
nodes = new Node *[n];
for (int i = 0; i < n; ++i) {
nodes[i] = NULL;
}
for (int i = 0, id, left, right; i < n; ++i) {
scanf("%d %d %d", &id, &left, &right);
Node *pnode = nodes[id];
if (pnode == NULL) {
pnode = nodes[id] = new Node;
pnode->id = id;
pnode->parent = pnode->left = pnode->right = NULL;
}
if (left != -1) {
Node *leftnode = nodes[left];
if (leftnode == NULL) {
leftnode = nodes[left] = new Node;
leftnode->id = left;
leftnode->parent = leftnode->left = leftnode->right = NULL;
}
leftnode->parent = pnode;
pnode->left = leftnode;
}
if (right != -1) {
Node *rightnode = nodes[right];
if (rightnode == NULL) {
rightnode = nodes[right] = new Node;
rightnode->id = right;
rightnode->parent = rightnode->left = rightnode->right = NULL;
}
rightnode->parent = pnode;
pnode->right = rightnode;
}
}
for (int i = 0; i < n; ++i) {
int parent = (nodes[i]->parent ? nodes[i]->parent->id : -1);
int sibling = -1;
if (parent != -1) {
if (nodes[parent]->left && nodes[parent]->left != nodes[i]) {
sibling = nodes[parent]->left->id;
} else {
sibling = nodes[parent]->right->id;
}
}
int degree = 0;
if (nodes[i]->left) {
++degree;
}
if (nodes[i]->right) {
++degree;
}
int depth = 0;
Node *node = nodes[i]->parent;
while (node) {
++depth;
node = node->parent;
}
int height = getheight(i);
const char *type = "internal node";
if (nodes[i]->parent == NULL) {
type = "root";
} else if (!nodes[i]->left && !nodes[i]->right) {
type = "leaf";
}
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d, %s\n",
nodes[i]->id, parent, sibling, degree, depth, height, type);
}
for (int i = 0; i < n; ++i) {
Node *node = nodes[i];
node->parent = node->left = node->right = NULL;
delete node;
}
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
struct Node {
int id;
Node *parent, *left, *right;
};
int n;
Node **nodes;
inline int getheight(int id) {
Node *node = nodes[id];
int left_height = 0, right_height = 0;
if (node->left) {
left_height = 1 + getheight(node->left->id);
}
if (node->right) {
right_height = 1 + getheight(node->right->id);
}
return left_height > right_height ? left_height : right_height;
}
int main(void) {
scanf("%d", &n);
nodes = new Node *[n];
for (int i = 0; i < n; ++i) {
nodes[i] = NULL;
}
for (int i = 0, id, left, right; i < n; ++i) {
scanf("%d %d %d", &id, &left, &right);
Node *pnode = nodes[id];
if (pnode == NULL) {
pnode = nodes[id] = new Node;
pnode->id = id;
pnode->parent = pnode->left = pnode->right = NULL;
}
if (left != -1) {
Node *leftnode = nodes[left];
if (leftnode == NULL) {
leftnode = nodes[left] = new Node;
leftnode->id = left;
leftnode->parent = leftnode->left = leftnode->right = NULL;
}
leftnode->parent = pnode;
pnode->left = leftnode;
}
if (right != -1) {
Node *rightnode = nodes[right];
if (rightnode == NULL) {
rightnode = nodes[right] = new Node;
rightnode->id = right;
rightnode->parent = rightnode->left = rightnode->right = NULL;
}
rightnode->parent = pnode;
pnode->right = rightnode;
}
}
for (int i = 0; i < n; ++i) {
int parent = (nodes[i]->parent ? nodes[i]->parent->id : -1);
int sibling = -1;
if (parent != -1) {
Node *pnode = nodes[parent];
if (pnode->left && pnode->left != nodes[i]) {
sibling = pnode->left->id;
} else if (pnode->right && pnode->right != nodes[i]) {
sibling = pnode->right->id;
}
}
int degree = 0;
if (nodes[i]->left) {
++degree;
}
if (nodes[i]->right) {
++degree;
}
int depth = 0;
Node *node = nodes[i]->parent;
while (node) {
++depth;
node = node->parent;
}
int height = getheight(i);
const char *type = "internal node";
if (nodes[i]->parent == NULL) {
type = "root";
} else if (!nodes[i]->left && !nodes[i]->right) {
type = "leaf";
}
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d, %s\n",
nodes[i]->id, parent, sibling, degree, depth, height, type);
}
for (int i = 0; i < n; ++i) {
Node *node = nodes[i];
node->parent = node->left = node->right = NULL;
delete node;
}
return 0;
}
|
replace
| 70 | 74 | 70 | 75 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
struct TNode {
int Index;
TNode *Parent;
TNode *Left;
TNode *Right;
TNode();
};
TNode::TNode() {
Index = -1;
Parent = NULL;
Left = NULL;
Right = NULL;
}
typedef std::vector<TNode> TBinaryTree;
void InputNode(TBinaryTree &Tree) {
int Index;
std::cin >> Index;
Tree[Index].Index = Index;
int Left;
std::cin >> Left;
if (Left >= 0) {
Tree[Index].Left = &(Tree[Left]);
Tree[Left].Parent = &(Tree[Index]);
}
int Right;
std::cin >> Right;
if (Right >= 0) {
Tree[Index].Right = &(Tree[Right]);
Tree[Right].Parent = &(Tree[Index]);
}
}
int GetParentIndex(const TNode &Node) {
return Node.Parent != NULL ? Node.Parent->Index : -1;
}
int GetSibling(const TNode &Node) {
if (!Node.Parent)
return -1;
int Sibling = Node.Parent->Left->Index;
if (Sibling != Node.Index)
return Sibling;
return Node.Parent->Right->Index;
}
int GetDegree(const TNode &Node) {
int Degree = 0;
if (Node.Left)
Degree++;
if (Node.Right)
Degree++;
return Degree;
}
int GetDepth(const TNode &Node) {
int Depth = 0;
TNode *Counter = Node.Parent;
while (Counter) {
Counter = Counter->Parent;
Depth++;
}
return Depth;
}
int GetHeight(const TNode *Node, int Height = 0) {
int LeftHeight = Height;
if (Node->Left)
LeftHeight = GetHeight(Node->Left, Height + 1);
int RightHeight = Height;
if (Node->Right)
RightHeight = GetHeight(Node->Right, Height + 1);
return std::max(LeftHeight, RightHeight);
}
std::string GetType(const TNode &Node) {
if (Node.Parent == NULL)
return "root";
if (!(Node.Left || Node.Right))
return "leaf";
return "internal node";
}
void OutputNode(const TNode &Node) {
std::cout << "node " << Node.Index << ": ";
std::cout << "parent = " << GetParentIndex(Node) << ", ";
std::cout << "sibling = " << GetSibling(Node) << ", ";
std::cout << "degree = " << GetDegree(Node) << ", ";
std::cout << "depth = " << GetDepth(Node) << ", ";
std::cout << "height = " << GetHeight(&Node) << ", ";
std::cout << GetType(Node) << std::endl;
}
int main() {
int Count;
std::cin >> Count;
TBinaryTree BinaryTree(Count);
for (int i = 0; i < Count; i++) {
InputNode(BinaryTree);
}
for (int i = 0; i < Count; i++) {
OutputNode(BinaryTree[i]);
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
struct TNode {
int Index;
TNode *Parent;
TNode *Left;
TNode *Right;
TNode();
};
TNode::TNode() {
Index = -1;
Parent = NULL;
Left = NULL;
Right = NULL;
}
typedef std::vector<TNode> TBinaryTree;
void InputNode(TBinaryTree &Tree) {
int Index;
std::cin >> Index;
Tree[Index].Index = Index;
int Left;
std::cin >> Left;
if (Left >= 0) {
Tree[Index].Left = &(Tree[Left]);
Tree[Left].Parent = &(Tree[Index]);
}
int Right;
std::cin >> Right;
if (Right >= 0) {
Tree[Index].Right = &(Tree[Right]);
Tree[Right].Parent = &(Tree[Index]);
}
}
int GetParentIndex(const TNode &Node) {
return Node.Parent != NULL ? Node.Parent->Index : -1;
}
int GetSibling(const TNode &Node) {
if (Node.Parent == NULL)
return -1;
if (Node.Parent->Left == NULL || Node.Parent->Right == NULL)
return -1;
int Sibling = Node.Parent->Left->Index;
if (Sibling != Node.Index)
return Sibling;
return Node.Parent->Right->Index;
}
int GetDegree(const TNode &Node) {
int Degree = 0;
if (Node.Left)
Degree++;
if (Node.Right)
Degree++;
return Degree;
}
int GetDepth(const TNode &Node) {
int Depth = 0;
TNode *Counter = Node.Parent;
while (Counter) {
Counter = Counter->Parent;
Depth++;
}
return Depth;
}
int GetHeight(const TNode *Node, int Height = 0) {
int LeftHeight = Height;
if (Node->Left)
LeftHeight = GetHeight(Node->Left, Height + 1);
int RightHeight = Height;
if (Node->Right)
RightHeight = GetHeight(Node->Right, Height + 1);
return std::max(LeftHeight, RightHeight);
}
std::string GetType(const TNode &Node) {
if (Node.Parent == NULL)
return "root";
if (!(Node.Left || Node.Right))
return "leaf";
return "internal node";
}
void OutputNode(const TNode &Node) {
std::cout << "node " << Node.Index << ": ";
std::cout << "parent = " << GetParentIndex(Node) << ", ";
std::cout << "sibling = " << GetSibling(Node) << ", ";
std::cout << "degree = " << GetDegree(Node) << ", ";
std::cout << "depth = " << GetDepth(Node) << ", ";
std::cout << "height = " << GetHeight(&Node) << ", ";
std::cout << GetType(Node) << std::endl;
}
int main() {
int Count;
std::cin >> Count;
TBinaryTree BinaryTree(Count);
for (int i = 0; i < Count; i++) {
InputNode(BinaryTree);
}
for (int i = 0; i < Count; i++) {
OutputNode(BinaryTree[i]);
}
return 0;
}
|
replace
| 48 | 49 | 48 | 51 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 10000
#define NIL -1
struct Node {
int parent;
int left;
int right;
};
Node T[MAX];
int D[MAX], H[MAX];
void setDepth(int u, int d) {
if (u == NIL) {
return;
}
D[u] = d;
setDepth(T[u].left, d + 1);
setDepth(T[u].right, d + 1);
}
int setHeight(int u) {
int h1 = 0, h2 = 0;
if (T[u].left != NIL) {
h1 = setHeight(T[u].left) + 1;
}
if (T[u].right != NIL) {
h2 = setHeight(T[u].right) + 1;
}
return H[u] = (h1 > h2 ? h1 : h2);
}
int getSibling(int u) {
if (T[u].parent == NIL) {
return NIL;
}
if (T[T[u].parent].left != u && T[T[u].parent].left != NIL) {
return T[T[u].parent].left;
}
if (T[T[u].parent].right != u && T[T[u].parent].right != NIL) {
return T[T[u].parent].right;
}
return NIL;
}
void print(int u) {
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "sibling = " << getSibling(u) << ", ";
int deg = 0;
if (T[u].left != NIL) {
deg++;
}
if (T[u].right != NIL) {
deg++;
}
cout << "degree = " << deg << ", ";
cout << "depth = " << D[u] << ", ";
cout << "height = " << H[u] << ", ";
if (T[u].parent == NIL) {
cout << "root" << endl;
} else if (T[u].left == NIL && T[u].right == NIL) {
cout << "leaf" << endl;
} else {
cout << "internal node" << endl;
}
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
T[i].parent = NIL;
}
int v, left, right;
for (int i = 0; i < N; i++) {
cin >> v >> left, right;
T[v].left = left;
T[v].right = right;
if (left != NIL) {
T[left].parent = v;
}
if (right != NIL) {
T[right].parent = v;
}
}
int root = 0;
for (int i = 0; i < N; i++) {
if (T[i].parent == NIL) {
root = i;
}
}
setDepth(root, 0);
setHeight(root);
for (int i = 0; i < N; i++) {
print(i);
}
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 10000
#define NIL -1
struct Node {
int parent;
int left;
int right;
};
Node T[MAX];
int D[MAX], H[MAX];
void setDepth(int u, int d) {
if (u == NIL) {
return;
}
D[u] = d;
setDepth(T[u].left, d + 1);
setDepth(T[u].right, d + 1);
}
int setHeight(int u) {
int h1 = 0, h2 = 0;
if (T[u].left != NIL) {
h1 = setHeight(T[u].left) + 1;
}
if (T[u].right != NIL) {
h2 = setHeight(T[u].right) + 1;
}
return H[u] = (h1 > h2 ? h1 : h2);
}
int getSibling(int u) {
if (T[u].parent == NIL) {
return NIL;
}
if (T[T[u].parent].left != u && T[T[u].parent].left != NIL) {
return T[T[u].parent].left;
}
if (T[T[u].parent].right != u && T[T[u].parent].right != NIL) {
return T[T[u].parent].right;
}
return NIL;
}
void print(int u) {
cout << "node " << u << ": ";
cout << "parent = " << T[u].parent << ", ";
cout << "sibling = " << getSibling(u) << ", ";
int deg = 0;
if (T[u].left != NIL) {
deg++;
}
if (T[u].right != NIL) {
deg++;
}
cout << "degree = " << deg << ", ";
cout << "depth = " << D[u] << ", ";
cout << "height = " << H[u] << ", ";
if (T[u].parent == NIL) {
cout << "root" << endl;
} else if (T[u].left == NIL && T[u].right == NIL) {
cout << "leaf" << endl;
} else {
cout << "internal node" << endl;
}
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
T[i].parent = NIL;
}
int v, left, right;
for (int i = 0; i < N; i++) {
cin >> v >> left >> right;
T[v].left = left;
T[v].right = right;
if (left != NIL) {
T[left].parent = v;
}
if (right != NIL) {
T[right].parent = v;
}
}
int root = 0;
for (int i = 0; i < N; i++) {
if (T[i].parent == NIL) {
root = i;
}
}
setDepth(root, 0);
setHeight(root);
for (int i = 0; i < N; i++) {
print(i);
}
return 0;
}
|
replace
| 84 | 85 | 84 | 85 |
-11
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
struct node {
node() {
parent = -1;
depth = 0;
s = -1;
}
void set(const int c1, const int c2) {
if (c1 != -1 && c2 != -1) {
leaf.resize(2);
leaf[0] = c1;
leaf[1] = c2;
} else if (c1 != -1 || c2 != -1) {
leaf.resize(1);
leaf[0] = c1;
} else {
leaf.resize(0);
}
}
int s;
int height;
int parent;
int depth;
vector<int> leaf;
};
int dp(int id, int d);
node dnode[100000];
int main() {
int N, id, c1, c2;
queue<int> que;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> id >> c1 >> c2;
dnode[id].set(c1, c2);
}
//*
for (int i = 0; i < N; i++) {
if (dnode[i].leaf.size()) {
for (int j = 0; j < dnode[i].leaf.size(); j++) {
dnode[dnode[i].leaf[j]].parent = i;
if (dnode[i].leaf.size() == 2) {
dnode[dnode[i].leaf[j]].s = dnode[i].leaf[1 - j];
}
}
}
} //*/
for (int i = 0; i < N; i++) {
if (dnode[i].parent == -1) {
/*
for(que.push(i);!que.empty();que.pop()){
for(int j=0;j<dnode[que.front()].leaf.size();j++){
dnode[dnode[que.front()].leaf[j]].depth=dnode[que.front()].depth+1;
if(dnode[dnode[que.front()].leaf[j]].leaf.size()){
que.push(dnode[que.front()].leaf[j]);
}
}
}//*/
dp(i, 0);
break;
}
} //*/
for (int i = 0; i < N; i++) {
cout << "node " << i << ": parent = " << dnode[i].parent
<< ", sibling = " << dnode[i].s
<< ", degree = " << dnode[i].leaf.size()
<< ", depth = " << dnode[i].depth << ", height = " << dnode[i].height;
if (dnode[i].parent == -1) {
cout << ", root";
} else if (dnode[i].leaf.size()) {
cout << ", internal node";
} else {
cout << ", leaf";
}
cout << endl;
}
}
int dp(int id, int d) {
dnode[id].depth = d;
if (dnode[id].leaf.size()) {
int h1, h2;
h1 = dp(dnode[id].leaf[0], d + 1);
if (dnode[id].leaf.size() == 2) {
h2 = dp(dnode[id].leaf[1], d + 1);
} else {
h2 = 0;
}
dnode[id].height = h1 > h2 ? h1 : h2;
return dnode[id].height + 1;
} else {
dnode[id].height = 0;
return 1;
}
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
struct node {
node() {
parent = -1;
depth = 0;
s = -1;
}
void set(const int c1, const int c2) {
if (c1 != -1 && c2 != -1) {
leaf.resize(2);
leaf[0] = c1;
leaf[1] = c2;
} else if (c1 != -1 || c2 != -1) {
leaf.resize(1);
if (c1 != -1) {
leaf[0] = c1;
} else {
leaf[0] = c2;
}
} else {
leaf.resize(0);
}
}
int s;
int height;
int parent;
int depth;
vector<int> leaf;
};
int dp(int id, int d);
node dnode[100000];
int main() {
int N, id, c1, c2;
queue<int> que;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> id >> c1 >> c2;
dnode[id].set(c1, c2);
}
//*
for (int i = 0; i < N; i++) {
if (dnode[i].leaf.size()) {
for (int j = 0; j < dnode[i].leaf.size(); j++) {
dnode[dnode[i].leaf[j]].parent = i;
if (dnode[i].leaf.size() == 2) {
dnode[dnode[i].leaf[j]].s = dnode[i].leaf[1 - j];
}
}
}
} //*/
for (int i = 0; i < N; i++) {
if (dnode[i].parent == -1) {
/*
for(que.push(i);!que.empty();que.pop()){
for(int j=0;j<dnode[que.front()].leaf.size();j++){
dnode[dnode[que.front()].leaf[j]].depth=dnode[que.front()].depth+1;
if(dnode[dnode[que.front()].leaf[j]].leaf.size()){
que.push(dnode[que.front()].leaf[j]);
}
}
}//*/
dp(i, 0);
break;
}
} //*/
for (int i = 0; i < N; i++) {
cout << "node " << i << ": parent = " << dnode[i].parent
<< ", sibling = " << dnode[i].s
<< ", degree = " << dnode[i].leaf.size()
<< ", depth = " << dnode[i].depth << ", height = " << dnode[i].height;
if (dnode[i].parent == -1) {
cout << ", root";
} else if (dnode[i].leaf.size()) {
cout << ", internal node";
} else {
cout << ", leaf";
}
cout << endl;
}
}
int dp(int id, int d) {
dnode[id].depth = d;
if (dnode[id].leaf.size()) {
int h1, h2;
h1 = dp(dnode[id].leaf[0], d + 1);
if (dnode[id].leaf.size() == 2) {
h2 = dp(dnode[id].leaf[1], d + 1);
} else {
h2 = 0;
}
dnode[id].height = h1 > h2 ? h1 : h2;
return dnode[id].height + 1;
} else {
dnode[id].height = 0;
return 1;
}
}
|
replace
| 26 | 27 | 26 | 31 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
static const int MAX = 100000;
struct Node {
int parent, left, right;
};
Node node[MAX];
int getDepth(int i) {
int j = i;
int d = 0;
while (node[j].parent != -1) {
j = node[j].parent;
d++;
}
return d;
}
int getHeight(int i) {
if (node[i].left == -1 && node[i].right == -1)
return 0;
return 1 + max(getHeight(node[i].left), getHeight(node[i].right));
}
int main() {
int n, a, tmp, deg, sib;
cin >> n;
for (int i = 0; i < n; i++) {
node[i].parent = -1;
node[i].left = -1;
node[i].right = -1;
}
for (int i = 0; i < n; i++) {
cin >> a;
cin >> node[a].left;
if (node[a].left != -1)
node[node[a].left].parent = a;
cin >> node[a].right;
if (node[a].right != -1)
node[node[a].right].parent = a;
}
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << node[i].parent;
tmp = node[i].parent;
if (tmp == -1)
sib = -1;
else if (node[tmp].left == i)
sib = node[tmp].right;
else
sib = node[tmp].left;
cout << ", sibling = " << sib;
deg = 0;
if (node[i].left != -1)
deg += 1;
if (node[i].right != -1)
deg += 1;
cout << ", degree = " << deg;
cout << ", depth = " << getDepth(i);
cout << ", height = " << getHeight(i);
if (node[i].parent == -1)
cout << ", root";
else if (node[i].left == -1 && node[i].right == -1)
cout << ", leaf";
else
cout << ", internal node";
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
static const int MAX = 100000;
struct Node {
int parent, left, right;
};
Node node[MAX];
int getDepth(int i) {
int j = i;
int d = 0;
while (node[j].parent != -1) {
j = node[j].parent;
d++;
}
return d;
}
int getHeight(int i) {
if (i == -1)
return -1;
else
return 1 + max(getHeight(node[i].left), getHeight(node[i].right));
}
int main() {
int n, a, tmp, deg, sib;
cin >> n;
for (int i = 0; i < n; i++) {
node[i].parent = -1;
node[i].left = -1;
node[i].right = -1;
}
for (int i = 0; i < n; i++) {
cin >> a;
cin >> node[a].left;
if (node[a].left != -1)
node[node[a].left].parent = a;
cin >> node[a].right;
if (node[a].right != -1)
node[node[a].right].parent = a;
}
for (int i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << node[i].parent;
tmp = node[i].parent;
if (tmp == -1)
sib = -1;
else if (node[tmp].left == i)
sib = node[tmp].right;
else
sib = node[tmp].left;
cout << ", sibling = " << sib;
deg = 0;
if (node[i].left != -1)
deg += 1;
if (node[i].right != -1)
deg += 1;
cout << ", degree = " << deg;
cout << ", depth = " << getDepth(i);
cout << ", height = " << getHeight(i);
if (node[i].parent == -1)
cout << ", root";
else if (node[i].left == -1 && node[i].right == -1)
cout << ", leaf";
else
cout << ", internal node";
cout << endl;
}
return 0;
}
|
replace
| 23 | 26 | 23 | 27 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <vector>
using namespace std;
struct Node {
Node() {
brother = parent = -1;
height = depth = num_of_children = 0;
}
int parent, brother, depth, num_of_children, height;
vector<int> children;
};
void calcDepth(Node nodes[], int root_id) {
for (int i = 0; i < nodes[root_id].num_of_children; i++) {
nodes[nodes[root_id].children[i]].depth = nodes[root_id].depth + 1;
calcDepth(nodes, nodes[root_id].children[i]);
}
}
void calcHeight(Node nodes[], int height, int parent) {
nodes[parent].height = max(nodes[parent].height, height + 1);
if (nodes[parent].parent != -1)
calcHeight(nodes, height + 1, nodes[parent].parent);
}
int main() {
int n, id, left_id, right_id, root_id;
scanf("%d", &n);
Node nodes[n];
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &id, &left_id, &right_id);
if (left_id != -1) {
nodes[id].children.push_back(left_id);
nodes[id].num_of_children++;
nodes[left_id].parent = id;
if (right_id != -1) {
nodes[id].children.push_back(right_id);
nodes[id].num_of_children++;
nodes[right_id].parent = id;
nodes[left_id].brother = right_id;
nodes[right_id].brother = left_id;
}
}
}
for (root_id = 0; root_id < n; root_id++) {
if (nodes[root_id].parent == -1)
break;
}
if (n > 1) {
calcDepth(nodes, root_id);
for (int i = 0; i < n; i++) {
if (nodes[i].num_of_children == 0)
calcHeight(nodes, 0, nodes[i].parent);
}
}
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d,",
i, nodes[i].parent, nodes[i].brother, nodes[i].num_of_children,
nodes[i].depth, nodes[i].height);
if (nodes[i].parent == -1) {
printf(" root\n");
} else if (nodes[i].num_of_children == 0) {
printf(" leaf\n");
} else {
printf(" internal node\n");
}
}
}
|
#include <stdio.h>
#include <vector>
using namespace std;
struct Node {
Node() {
brother = parent = -1;
height = depth = num_of_children = 0;
}
int parent, brother, depth, num_of_children, height;
vector<int> children;
};
void calcDepth(Node nodes[], int root_id) {
for (int i = 0; i < nodes[root_id].num_of_children; i++) {
nodes[nodes[root_id].children[i]].depth = nodes[root_id].depth + 1;
calcDepth(nodes, nodes[root_id].children[i]);
}
}
void calcHeight(Node nodes[], int height, int parent) {
nodes[parent].height = max(nodes[parent].height, height + 1);
if (nodes[parent].parent != -1)
calcHeight(nodes, height + 1, nodes[parent].parent);
}
int main() {
int n, id, left_id, right_id, root_id;
scanf("%d", &n);
Node nodes[n];
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &id, &left_id, &right_id);
if (left_id != -1) {
nodes[id].children.push_back(left_id);
nodes[id].num_of_children++;
nodes[left_id].parent = id;
}
if (right_id != -1) {
nodes[id].children.push_back(right_id);
nodes[id].num_of_children++;
nodes[right_id].parent = id;
}
if (left_id != -1 && right_id != -1) {
nodes[left_id].brother = right_id;
nodes[right_id].brother = left_id;
}
}
for (root_id = 0; root_id < n; root_id++) {
if (nodes[root_id].parent == -1)
break;
}
if (n > 1) {
calcDepth(nodes, root_id);
for (int i = 0; i < n; i++) {
if (nodes[i].num_of_children == 0)
calcHeight(nodes, 0, nodes[i].parent);
}
}
for (int i = 0; i < n; i++) {
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d,",
i, nodes[i].parent, nodes[i].brother, nodes[i].num_of_children,
nodes[i].depth, nodes[i].height);
if (nodes[i].parent == -1) {
printf(" root\n");
} else if (nodes[i].num_of_children == 0) {
printf(" leaf\n");
} else {
printf(" internal node\n");
}
}
}
|
replace
| 38 | 45 | 38 | 47 |
0
| |
p02280
|
C++
|
Time Limit Exceeded
|
#define FILE_INPUT_DEFINE
#ifdef FILE_INPUT_DEFINE
#include <fstream>
#endif // FILE_INPUT_DEFINE
#include <cstdio>
#include <iostream>
#define NIL (-1)
#define MAX 25
enum class RLI { eRoot, eInternalNode, eLeaf };
struct BinaryTree {
int parent;
int left;
int right;
int depth;
int sibling;
int degree;
int height;
RLI rli;
BinaryTree() {
parent = left = right = sibling = height = NIL;
degree = 0;
}
};
BinaryTree tree[MAX];
using namespace std;
int main() {
#ifdef FILE_INPUT_DEFINE
// input from txt
std::ifstream in(R"(C:\Temp\input.txt)");
std::cin.rdbuf(in.rdbuf());
#endif // FILE_INPUT_DEFINE
int n;
cin >> n;
int id, left, right;
for (int i = 0; i < n; i++) {
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
if (NIL != left)
tree[left].parent = id;
if (NIL != right)
tree[right].parent = id;
}
for (int i = 0; i < n; ++i) {
if (NIL == tree[i].parent) {
tree[i].rli = RLI::eRoot;
tree[i].depth = 0;
} else {
if ((NIL == tree[i].right) && (NIL == tree[i].left)) {
tree[i].rli = RLI::eLeaf;
} else {
tree[i].rli = RLI::eInternalNode;
}
}
if (RLI::eRoot != tree[i].rli) {
int index = i;
int depth = 0;
while (NIL != tree[index].parent) {
++depth;
index = tree[index].parent;
}
tree[i].depth = depth;
if (tree[tree[i].parent].right == i) {
tree[i].sibling = tree[tree[i].parent].left;
} else {
tree[i].sibling = tree[tree[i].parent].right;
}
}
if (NIL != tree[i].left) {
++tree[i].degree;
}
if (NIL != tree[i].right) {
++tree[i].degree;
}
if ((tree[i].rli == RLI::eLeaf) || (1 == n)) {
tree[i].height = 0;
}
}
bool isLoop = true;
while (isLoop) {
isLoop = false;
for (int i = 0; i < n; ++i) {
if (NIL == tree[i].height) {
int r = tree[tree[i].right].height;
int l = tree[tree[i].left].height;
if ((NIL != r) && (NIL != l)) {
if (r >= l) {
tree[i].height = r + 1;
} else {
tree[i].height = l + 1;
}
} else {
isLoop = true;
}
}
}
}
for (int i = 0; i < n; ++i) {
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d, ",
i, tree[i].parent, tree[i].sibling, tree[i].degree, tree[i].depth,
tree[i].height);
switch (tree[i].rli) {
case RLI::eRoot:
printf("root\n");
break;
case RLI::eInternalNode:
printf("internal node\n");
break;
case RLI::eLeaf:
printf("leaf\n");
break;
default:
break;
}
}
return 0;
}
|
// #define FILE_INPUT_DEFINE
#ifdef FILE_INPUT_DEFINE
#include <fstream>
#endif // FILE_INPUT_DEFINE
#include <cstdio>
#include <iostream>
#define NIL (-1)
#define MAX 25
enum class RLI { eRoot, eInternalNode, eLeaf };
struct BinaryTree {
int parent;
int left;
int right;
int depth;
int sibling;
int degree;
int height;
RLI rli;
BinaryTree() {
parent = left = right = sibling = height = NIL;
degree = 0;
}
};
BinaryTree tree[MAX];
using namespace std;
int main() {
#ifdef FILE_INPUT_DEFINE
// input from txt
std::ifstream in(R"(C:\Temp\input.txt)");
std::cin.rdbuf(in.rdbuf());
#endif // FILE_INPUT_DEFINE
int n;
cin >> n;
int id, left, right;
for (int i = 0; i < n; i++) {
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
if (NIL != left)
tree[left].parent = id;
if (NIL != right)
tree[right].parent = id;
}
for (int i = 0; i < n; ++i) {
if (NIL == tree[i].parent) {
tree[i].rli = RLI::eRoot;
tree[i].depth = 0;
} else {
if ((NIL == tree[i].right) && (NIL == tree[i].left)) {
tree[i].rli = RLI::eLeaf;
} else {
tree[i].rli = RLI::eInternalNode;
}
}
if (RLI::eRoot != tree[i].rli) {
int index = i;
int depth = 0;
while (NIL != tree[index].parent) {
++depth;
index = tree[index].parent;
}
tree[i].depth = depth;
if (tree[tree[i].parent].right == i) {
tree[i].sibling = tree[tree[i].parent].left;
} else {
tree[i].sibling = tree[tree[i].parent].right;
}
}
if (NIL != tree[i].left) {
++tree[i].degree;
}
if (NIL != tree[i].right) {
++tree[i].degree;
}
if ((tree[i].rli == RLI::eLeaf) || (1 == n)) {
tree[i].height = 0;
}
}
bool isLoop = true;
while (isLoop) {
isLoop = false;
for (int i = 0; i < n; ++i) {
if (NIL == tree[i].height) {
int r = tree[tree[i].right].height;
int l = tree[tree[i].left].height;
if ((NIL != r) && (NIL != l)) {
if (r >= l) {
tree[i].height = r + 1;
} else {
tree[i].height = l + 1;
}
} else {
isLoop = true;
}
}
}
}
for (int i = 0; i < n; ++i) {
printf("node %d: parent = %d, sibling = %d, degree = %d, depth = %d, "
"height = %d, ",
i, tree[i].parent, tree[i].sibling, tree[i].degree, tree[i].depth,
tree[i].height);
switch (tree[i].rli) {
case RLI::eRoot:
printf("root\n");
break;
case RLI::eInternalNode:
printf("internal node\n");
break;
case RLI::eLeaf:
printf("leaf\n");
break;
default:
break;
}
}
return 0;
}
|
replace
| 0 | 1 | 0 | 1 |
TLE
| |
p02280
|
C++
|
Runtime Error
|
///
// File: alds1_7_b.cpp
// Author: ymiyamoto
//
// Created on Sat Oct 14 16:06:54 2017
//
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define NIL -1
#define SIZE 100
struct tree_t {
int32_t right;
int32_t left;
int32_t parent;
tree_t() { parent = NIL; }
};
static tree_t tree[SIZE];
int32_t sibling(int32_t index) {
if (tree[index].parent == NIL) {
return NIL;
}
int32_t parent = tree[index].parent;
if (tree[parent].left != index) {
return tree[parent].left;
} else {
return tree[parent].right;
}
}
int32_t degree(int32_t index) {
return (tree[index].left != NIL) + (tree[index].right != NIL);
}
int32_t depth(int32_t index) {
int32_t parent = tree[index].parent;
int32_t count = 0;
while (parent != NIL) {
count++;
parent = tree[parent].parent;
}
return count;
}
int32_t height(int32_t index) {
if (tree[index].left == NIL && tree[index].right == NIL) {
return 0;
} else {
return 1 + max(height(tree[index].left), height(tree[index].right));
}
}
string name(int32_t index) {
if (tree[index].parent == NIL) {
return "root";
} else if (tree[index].left != NIL || tree[index].right != NIL) {
return "internal node";
} else {
return "leaf";
}
}
int32_t main() {
int32_t n;
cin >> n;
for (int32_t i = 0; i < n; i++) {
int32_t id, left, right;
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
tree[left].parent = id;
tree[right].parent = id;
}
for (int32_t i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << tree[i].parent << ", ";
cout << "sibling = " << sibling(i) << ", degree = " << degree(i) << ", ";
cout << "depth = " << depth(i) << ", height = " << height(i) << ", ";
cout << name(i) << endl;
}
return 0;
}
|
///
// File: alds1_7_b.cpp
// Author: ymiyamoto
//
// Created on Sat Oct 14 16:06:54 2017
//
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define NIL -1
#define SIZE 100
struct tree_t {
int32_t right;
int32_t left;
int32_t parent;
tree_t() { parent = NIL; }
};
static tree_t tree[SIZE];
int32_t sibling(int32_t index) {
if (tree[index].parent == NIL) {
return NIL;
}
int32_t parent = tree[index].parent;
if (tree[parent].left != index) {
return tree[parent].left;
} else {
return tree[parent].right;
}
}
int32_t degree(int32_t index) {
return (tree[index].left != NIL) + (tree[index].right != NIL);
}
int32_t depth(int32_t index) {
int32_t parent = tree[index].parent;
int32_t count = 0;
while (parent != NIL) {
count++;
parent = tree[parent].parent;
}
return count;
}
int32_t height(int32_t index) {
if (index == NIL || (tree[index].left == NIL && tree[index].right == NIL)) {
return 0;
} else {
return 1 + max(height(tree[index].left), height(tree[index].right));
}
}
string name(int32_t index) {
if (tree[index].parent == NIL) {
return "root";
} else if (tree[index].left != NIL || tree[index].right != NIL) {
return "internal node";
} else {
return "leaf";
}
}
int32_t main() {
int32_t n;
cin >> n;
for (int32_t i = 0; i < n; i++) {
int32_t id, left, right;
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
tree[left].parent = id;
tree[right].parent = id;
}
for (int32_t i = 0; i < n; i++) {
cout << "node " << i << ": parent = " << tree[i].parent << ", ";
cout << "sibling = " << sibling(i) << ", degree = " << degree(i) << ", ";
cout << "depth = " << depth(i) << ", height = " << height(i) << ", ";
cout << name(i) << endl;
}
return 0;
}
|
replace
| 56 | 57 | 56 | 57 |
0
| |
p02280
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
const int nmax = 9;
int root;
vector<int> dep(nmax), par(nmax), high(nmax);
vector<int> des[nmax];
void dep_dfs(int id) {
for (int i = 0; i < (int)des[id].size(); i++) {
dep[des[id][i]] = dep[id] + 1;
dep_dfs(des[id][i]);
}
}
void hi_dfs(int id) {
if (par[id] != -1) {
high[par[id]] = max(high[par[id]], high[id] + 1);
hi_dfs(par[id]);
}
}
int bro(int id) {
int p = par[id];
if (p == -1)
return -1;
for (int i = 0; i < (int)des[p].size(); i++)
if (des[p][i] != id)
return des[p][i];
return -1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
par[i] = -1;
high[i] = 0;
dep[i] = 0;
}
// cout<<0<<endl;
for (int i = 0; i < n; i++) {
int id, left, right;
cin >> id >> left >> right;
if (left != -1) {
des[id].push_back(left);
par[left] = id;
}
if (right != -1) {
des[id].push_back(right);
par[right] = id;
}
// cout<<i<<endl;
}
for (int i = 0; i < n; i++) {
if (par[i] == -1) {
root = i;
dep_dfs(root);
}
if ((int)des[i].size() == 0) {
high[i] = 0;
hi_dfs(i);
}
// cout<<i<<endl;
}
for (int i = 0; i < n; i++) {
string type;
if (par[i] == -1)
type = "root";
else if ((int)des[i].size() == 0)
type = "leaf";
else
type = "internal node";
cout << "node"
<< " " << i << ": parent = " << par[i] << ", sibling = " << bro(i)
<< ", degree = " << des[i].size() << ", depth = " << dep[i]
<< ", height = " << high[i] << ", " << type << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
const int nmax = 100;
int root;
vector<int> dep(nmax), par(nmax), high(nmax);
vector<int> des[nmax];
void dep_dfs(int id) {
for (int i = 0; i < (int)des[id].size(); i++) {
dep[des[id][i]] = dep[id] + 1;
dep_dfs(des[id][i]);
}
}
void hi_dfs(int id) {
if (par[id] != -1) {
high[par[id]] = max(high[par[id]], high[id] + 1);
hi_dfs(par[id]);
}
}
int bro(int id) {
int p = par[id];
if (p == -1)
return -1;
for (int i = 0; i < (int)des[p].size(); i++)
if (des[p][i] != id)
return des[p][i];
return -1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
par[i] = -1;
high[i] = 0;
dep[i] = 0;
}
// cout<<0<<endl;
for (int i = 0; i < n; i++) {
int id, left, right;
cin >> id >> left >> right;
if (left != -1) {
des[id].push_back(left);
par[left] = id;
}
if (right != -1) {
des[id].push_back(right);
par[right] = id;
}
// cout<<i<<endl;
}
for (int i = 0; i < n; i++) {
if (par[i] == -1) {
root = i;
dep_dfs(root);
}
if ((int)des[i].size() == 0) {
high[i] = 0;
hi_dfs(i);
}
// cout<<i<<endl;
}
for (int i = 0; i < n; i++) {
string type;
if (par[i] == -1)
type = "root";
else if ((int)des[i].size() == 0)
type = "leaf";
else
type = "internal node";
cout << "node"
<< " " << i << ": parent = " << par[i] << ", sibling = " << bro(i)
<< ", degree = " << des[i].size() << ", depth = " << dep[i]
<< ", height = " << high[i] << ", " << type << endl;
}
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02281
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
void Preorder(vector<vector<int>> &T, int root) {
cout << " " << root;
if (T[root][0] != -1)
Preorder(T, T[root][0]);
if (T[root][1] != -1)
Preorder(T, T[root][1]);
return;
}
void Inorder(vector<vector<int>> &T, int root) {
if (T[root][0] != -1)
Inorder(T, T[root][0]);
cout << " " << root;
if (T[root][1] != -1)
Inorder(T, T[root][1]);
return;
}
void Postorder(vector<vector<int>> &T, int root) {
if (T[root][0] != -1)
Postorder(T, T[root][0]);
if (T[root][1] != -1)
Postorder(T, T[root][1]);
cout << " " << root;
return;
}
int main() {
int n, i, j, k, d, e;
cin >> n;
vector<vector<int>> T(n);
vector<int> check(n, 0);
for (i = 0; i < n; i++) {
cin >> k;
for (j = 0; j < 2; j++) {
cin >> e;
T[k].push_back(e);
check[e] = 1;
}
}
int r;
for (i = 0; i < n; i++) {
if (check[i] == 0) {
r = i;
break;
}
}
cout << "Preorder" << endl;
Preorder(T, r);
cout << endl;
cout << "Inorder" << endl;
Inorder(T, r);
cout << endl;
cout << "Postorder" << endl;
Postorder(T, r);
cout << endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
void Preorder(vector<vector<int>> &T, int root) {
cout << " " << root;
if (T[root][0] != -1)
Preorder(T, T[root][0]);
if (T[root][1] != -1)
Preorder(T, T[root][1]);
return;
}
void Inorder(vector<vector<int>> &T, int root) {
if (T[root][0] != -1)
Inorder(T, T[root][0]);
cout << " " << root;
if (T[root][1] != -1)
Inorder(T, T[root][1]);
return;
}
void Postorder(vector<vector<int>> &T, int root) {
if (T[root][0] != -1)
Postorder(T, T[root][0]);
if (T[root][1] != -1)
Postorder(T, T[root][1]);
cout << " " << root;
return;
}
int main() {
int n, i, j, k, d, e;
cin >> n;
vector<vector<int>> T(n);
vector<int> check(n, 0);
for (i = 0; i < n; i++) {
cin >> k;
for (j = 0; j < 2; j++) {
cin >> e;
T[k].push_back(e);
if (e != -1)
check[e] = 1;
}
}
int r;
for (i = 0; i < n; i++) {
if (check[i] == 0) {
r = i;
break;
}
}
cout << "Preorder" << endl;
Preorder(T, r);
cout << endl;
cout << "Inorder" << endl;
Inorder(T, r);
cout << endl;
cout << "Postorder" << endl;
Postorder(T, r);
cout << endl;
return 0;
}
|
replace
| 43 | 44 | 43 | 45 |
-6
|
double free or corruption (out)
|
p02281
|
C++
|
Runtime Error
|
#include <cstdio>
#include <vector>
class Node {
public:
int id;
int left_id;
int right_id;
int parent_id;
Node();
};
Node::Node() {
id = -1;
left_id = -1;
right_id = -1;
parent_id = -1;
}
int search_root(std::vector<Node> &data, int id) {
if (data[id].parent_id == -1) {
return id;
} else {
return search_root(data, data[id].parent_id);
}
}
void walk_preorder(std::vector<Node> &data, int id) {
printf(" %d", id);
if (data[id].left_id != -1) {
walk_preorder(data, data[id].left_id);
}
if (data[id].right_id != -1) {
walk_preorder(data, data[id].right_id);
}
}
void walk_inorder(std::vector<Node> &data, int id) {
if (data[id].left_id != -1) {
walk_inorder(data, data[id].left_id);
}
printf(" %d", id);
if (data[id].left_id != -1) {
walk_inorder(data, data[id].right_id);
}
}
void walk_postorder(std::vector<Node> &data, int id) {
if (data[id].left_id != -1) {
walk_postorder(data, data[id].left_id);
}
if (data[id].right_id != -1) {
walk_postorder(data, data[id].right_id);
}
printf(" %d", id);
}
int main() {
int input_size;
scanf("%d", &input_size);
std::vector<Node> data(input_size);
for (int i = 0; i < data.size(); i++) {
int id, left, right;
scanf("%d %d %d", &id, &left, &right);
data[id].id = id;
if (left != -1) {
data[id].left_id = left;
data[left].parent_id = id;
}
if (right != -1) {
data[id].right_id = right;
data[right].parent_id = id;
}
}
int root_id = search_root(data, 0);
puts("Preorder");
walk_preorder(data, root_id);
putchar('\n');
puts("Inorder");
walk_inorder(data, root_id);
putchar('\n');
puts("Postorder");
walk_postorder(data, root_id);
putchar('\n');
return 0;
}
|
#include <cstdio>
#include <vector>
class Node {
public:
int id;
int left_id;
int right_id;
int parent_id;
Node();
};
Node::Node() {
id = -1;
left_id = -1;
right_id = -1;
parent_id = -1;
}
int search_root(std::vector<Node> &data, int id) {
if (data[id].parent_id == -1) {
return id;
} else {
return search_root(data, data[id].parent_id);
}
}
void walk_preorder(std::vector<Node> &data, int id) {
printf(" %d", id);
if (data[id].left_id != -1) {
walk_preorder(data, data[id].left_id);
}
if (data[id].right_id != -1) {
walk_preorder(data, data[id].right_id);
}
}
void walk_inorder(std::vector<Node> &data, int id) {
if (data[id].left_id != -1) {
walk_inorder(data, data[id].left_id);
}
printf(" %d", id);
if (data[id].right_id != -1) {
walk_inorder(data, data[id].right_id);
}
}
void walk_postorder(std::vector<Node> &data, int id) {
if (data[id].left_id != -1) {
walk_postorder(data, data[id].left_id);
}
if (data[id].right_id != -1) {
walk_postorder(data, data[id].right_id);
}
printf(" %d", id);
}
int main() {
int input_size;
scanf("%d", &input_size);
std::vector<Node> data(input_size);
for (int i = 0; i < data.size(); i++) {
int id, left, right;
scanf("%d %d %d", &id, &left, &right);
data[id].id = id;
if (left != -1) {
data[id].left_id = left;
data[left].parent_id = id;
}
if (right != -1) {
data[id].right_id = right;
data[right].parent_id = id;
}
}
int root_id = search_root(data, 0);
puts("Preorder");
walk_preorder(data, root_id);
putchar('\n');
puts("Inorder");
walk_inorder(data, root_id);
putchar('\n');
puts("Postorder");
walk_postorder(data, root_id);
putchar('\n');
return 0;
}
|
replace
| 42 | 43 | 42 | 43 |
0
| |
p02281
|
C++
|
Time Limit Exceeded
|
#include <cstring>
#include <iostream>
using namespace std;
int x[1000][5]; // 0=left,1=right,2=parent,3=sibling;
void S1(int u) {
if (u == -1) {
return;
}
cout << ' ' << u;
S1(x[u][0]);
S1(x[u][1]);
}
void S2(int u) {
if (u == -1) {
return;
}
S2(x[u][0]);
cout << ' ' << u;
S2(x[u][1]);
}
void S3(int u) {
if (u == -1) {
return;
}
S3(x[u][0]);
S3(x[u][1]);
cout << ' ' << u;
}
int main() {
memset(x, -1, sizeof(x));
int n, a, c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
cin >> x[i][0] >> x[i][1];
x[x[i][0]][2] = a;
x[x[i][0]][3] = x[i][1];
x[x[i][1]][3] = x[i][0];
}
cout << "Preorder" << endl;
for (int i = 0; i < n; i++) {
if (x[i][2] == -1) {
c = i;
break;
}
}
S1(c);
cout << endl;
cout << "Inorder" << endl;
S2(c);
cout << endl;
cout << "Postorder" << endl;
S3(c);
cout << endl;
return 0;
}
|
#include <cstring>
#include <iostream>
using namespace std;
int x[1000][5]; // 0=left,1=right,2=parent,3=sibling;
void S1(int u) {
if (u == -1) {
return;
}
cout << ' ' << u;
S1(x[u][0]);
S1(x[u][1]);
}
void S2(int u) {
if (u == -1) {
return;
}
S2(x[u][0]);
cout << ' ' << u;
S2(x[u][1]);
}
void S3(int u) {
if (u == -1) {
return;
}
S3(x[u][0]);
S3(x[u][1]);
cout << ' ' << u;
}
int main() {
memset(x, -1, sizeof(x));
int n, a, c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
cin >> x[a][0] >> x[a][1];
x[x[a][0]][2] = a;
x[x[a][1]][2] = a;
x[x[a][0]][3] = x[a][1];
x[x[a][1]][3] = x[a][0];
}
cout << "Preorder" << endl;
for (int i = 0; i < n; i++) {
if (x[i][2] == -1) {
c = i;
break;
}
}
S1(c);
cout << endl;
cout << "Inorder" << endl;
S2(c);
cout << endl;
cout << "Postorder" << endl;
S3(c);
cout << endl;
return 0;
}
|
replace
| 39 | 43 | 39 | 44 |
TLE
| |
p02281
|
C++
|
Memory Limit Exceeded
|
// ALDS1_7_C.cpp
// Tree - Tree Walk
#include <iostream>
#include <vector>
using namespace std;
struct Node {
int id;
int lchild;
int rchild;
int parent = -1;
};
void Preorder(vector<Node> &nodes, int id) {
cout << " " << nodes[id].id;
if (nodes[id].lchild == -1 && nodes[id].rchild == -1) {
return;
}
Preorder(nodes, nodes[id].lchild);
Preorder(nodes, nodes[id].rchild);
}
void Inorder(vector<Node> &nodes, int id) {
if (nodes[id].lchild != -1)
Inorder(nodes, nodes[id].lchild);
cout << " " << nodes[id].id;
if (nodes[id].rchild != -1)
Inorder(nodes, nodes[id].rchild);
}
void Postorder(vector<Node> &nodes, int id) {
if (nodes[id].lchild != -1)
Postorder(nodes, nodes[id].lchild);
if (nodes[id].rchild != -1)
Postorder(nodes, nodes[id].rchild);
cout << " " << nodes[id].id;
}
int main() {
int n;
cin >> n;
vector<Node> nodes(n);
for (int i = 0; i < n; i++) {
int id, lc, rc;
cin >> id >> lc >> rc;
nodes[id].id = id;
nodes[id].lchild = lc;
nodes[id].rchild = rc;
if (lc != -1) {
nodes[lc].parent = id;
}
if (rc != -1) {
nodes[rc].parent = id;
}
}
int root_id;
for (int i = 0; i < n; i++) {
if (nodes[i].parent == -1) {
root_id = i;
break;
}
}
cout << "Preorder" << endl;
Preorder(nodes, root_id);
cout << endl << "Inorder" << endl;
Inorder(nodes, root_id);
cout << endl << "Postorder" << endl;
Postorder(nodes, root_id);
cout << endl;
return 0;
}
|
// ALDS1_7_C.cpp
// Tree - Tree Walk
#include <iostream>
#include <vector>
using namespace std;
struct Node {
int id;
int lchild;
int rchild;
int parent = -1;
};
void Preorder(vector<Node> &nodes, int id) {
cout << " " << nodes[id].id;
if (nodes[id].lchild != -1)
Preorder(nodes, nodes[id].lchild);
if (nodes[id].rchild != -1)
Preorder(nodes, nodes[id].rchild);
}
void Inorder(vector<Node> &nodes, int id) {
if (nodes[id].lchild != -1)
Inorder(nodes, nodes[id].lchild);
cout << " " << nodes[id].id;
if (nodes[id].rchild != -1)
Inorder(nodes, nodes[id].rchild);
}
void Postorder(vector<Node> &nodes, int id) {
if (nodes[id].lchild != -1)
Postorder(nodes, nodes[id].lchild);
if (nodes[id].rchild != -1)
Postorder(nodes, nodes[id].rchild);
cout << " " << nodes[id].id;
}
int main() {
int n;
cin >> n;
vector<Node> nodes(n);
for (int i = 0; i < n; i++) {
int id, lc, rc;
cin >> id >> lc >> rc;
nodes[id].id = id;
nodes[id].lchild = lc;
nodes[id].rchild = rc;
if (lc != -1) {
nodes[lc].parent = id;
}
if (rc != -1) {
nodes[rc].parent = id;
}
}
int root_id;
for (int i = 0; i < n; i++) {
if (nodes[i].parent == -1) {
root_id = i;
break;
}
}
cout << "Preorder" << endl;
Preorder(nodes, root_id);
cout << endl << "Inorder" << endl;
Inorder(nodes, root_id);
cout << endl << "Postorder" << endl;
Postorder(nodes, root_id);
cout << endl;
return 0;
}
|
replace
| 16 | 21 | 16 | 20 |
MLE
| |
p02281
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define REP(asd, fgh) for (int asd = 0; asd < fgh; asd++)
int n;
class Node {
public:
int p;
int depth;
int height;
int sibling;
int degree;
string type;
};
vector<Node> ans;
vector<vector<int>> t;
void dfs(int ind, int prev, int depth, int order) {
if (t[ind].size() == 0 && ans[ind].type != "root") {
cout << " " << ind;
return;
}
if (order == 0) {
cout << " " << ind;
}
if (t[ind][0] != -1)
dfs(t[ind][0], ind, depth + 1, order);
if (order == 1) {
cout << " " << ind;
}
if (t[ind][1] != -1)
dfs(t[ind][1], ind, depth + 1, order);
if (order == 2) {
cout << " " << ind;
}
/*
for(int i = 0; i < t[ind].size(); i++){
dfs(t[ind][i], ind, depth+1, order);
}
*/
return;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
ans = vector<Node>(n);
t = vector<vector<int>>(n, vector<int>(0));
int root;
REP(i, n) {
int id;
cin >> id;
ans[id].type = "internal node";
REP(j, 2) {
int c;
cin >> c;
t[id].push_back(c);
}
ans[id].degree = t[id].size();
if (ans[id].degree == 1) {
ans[t[id][0]].sibling = -1;
} else if (ans[id].degree == 2) {
ans[t[id][0]].sibling = t[id][1];
ans[t[id][1]].sibling = t[id][0];
}
}
// ans[0].p = -1;
// ans[0].depth = 0;
vector<bool> used(n, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < t[i].size(); j++) {
if (t[i][j] == -1)
continue;
used[t[i][j]] = true;
}
}
for (int i = 0; i < n; i++) {
if (used[i] == false) {
root = i;
break;
}
}
cout << "Preorder" << endl;
dfs(root, -1, 0, 0);
cout << endl;
cout << "Inorder" << endl;
dfs(root, -1, 0, 1);
cout << endl;
cout << "Postorder" << endl;
dfs(root, -1, 0, 2);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(asd, fgh) for (int asd = 0; asd < fgh; asd++)
int n;
class Node {
public:
int p;
int depth;
int height;
int sibling;
int degree;
string type;
};
vector<Node> ans;
vector<vector<int>> t;
void dfs(int ind, int prev, int depth, int order) {
if (t[ind].size() == 0 && ans[ind].type != "root") {
cout << " " << ind;
return;
}
if (order == 0) {
cout << " " << ind;
}
if (t[ind][0] != -1)
dfs(t[ind][0], ind, depth + 1, order);
if (order == 1) {
cout << " " << ind;
}
if (t[ind][1] != -1)
dfs(t[ind][1], ind, depth + 1, order);
if (order == 2) {
cout << " " << ind;
}
/*
for(int i = 0; i < t[ind].size(); i++){
dfs(t[ind][i], ind, depth+1, order);
}
*/
return;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
ans = vector<Node>(n);
t = vector<vector<int>>(n, vector<int>(0));
int root;
REP(i, n) {
int id;
cin >> id;
ans[id].type = "internal node";
REP(j, 2) {
int c;
cin >> c;
t[id].push_back(c);
}
}
// ans[0].p = -1;
// ans[0].depth = 0;
vector<bool> used(n, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < t[i].size(); j++) {
if (t[i][j] == -1)
continue;
used[t[i][j]] = true;
}
}
for (int i = 0; i < n; i++) {
if (used[i] == false) {
root = i;
break;
}
}
cout << "Preorder" << endl;
dfs(root, -1, 0, 0);
cout << endl;
cout << "Inorder" << endl;
dfs(root, -1, 0, 1);
cout << endl;
cout << "Postorder" << endl;
dfs(root, -1, 0, 2);
cout << endl;
return 0;
}
|
delete
| 64 | 71 | 64 | 64 |
0
| |
p02281
|
C++
|
Runtime Error
|
#include <cstdio>
#include <vector>
enum order {
preorder = 0,
inorder = 1,
postorder = 2,
};
class BinaryTree {
private:
int numVertex;
int *parent, *left, *right;
public:
BinaryTree(int v);
~BinaryTree();
void init();
void dfs(int v, order flag);
std::vector<int> root();
};
BinaryTree::BinaryTree(int v) {
numVertex = v;
parent = new int[v];
left = new int[v];
right = new int[v];
for (int i = 0; i < v; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
}
}
BinaryTree::~BinaryTree() {
delete[] parent;
delete[] left;
delete[] right;
}
void BinaryTree::init() {
for (int i = 0; i < numVertex; i++) {
int id, l, r;
scanf("%d%d%d", &id, &l, &r);
parent[l] = id;
parent[r] = id;
left[id] = l;
right[id] = r;
}
}
std::vector<int> BinaryTree::root() {
std::vector<int> vec;
for (int i = 0; i < numVertex; i++) {
if (parent[i] == -1)
vec.push_back(i);
}
return vec;
}
void BinaryTree::dfs(int v, order flag) {
if (v >= 0) {
if (flag == preorder)
printf(" %d", v);
dfs(left[v], flag);
if (flag == inorder)
printf(" %d", v);
dfs(right[v], flag);
if (flag == postorder)
printf(" %d", v);
}
}
int main() {
int n;
scanf("%d", &n);
BinaryTree t(n);
t.init();
std::vector<int> v = t.root();
printf("Preorder\n");
t.dfs(v[0], preorder);
printf("\nInorder\n");
t.dfs(v[0], inorder);
printf("\nPostorder\n");
t.dfs(v[0], postorder);
printf("\n");
return 0;
}
|
#include <cstdio>
#include <vector>
enum order {
preorder = 0,
inorder = 1,
postorder = 2,
};
class BinaryTree {
private:
int numVertex;
int *parent, *left, *right;
public:
BinaryTree(int v);
~BinaryTree();
void init();
void dfs(int v, order flag);
std::vector<int> root();
};
BinaryTree::BinaryTree(int v) {
numVertex = v;
parent = new int[v];
left = new int[v];
right = new int[v];
for (int i = 0; i < v; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
}
}
BinaryTree::~BinaryTree() {
delete[] parent;
delete[] left;
delete[] right;
}
void BinaryTree::init() {
for (int i = 0; i < numVertex; i++) {
int id, l, r;
scanf("%d%d%d", &id, &l, &r);
if (l >= 0)
parent[l] = id;
if (r >= 0)
parent[r] = id;
left[id] = l;
right[id] = r;
}
}
std::vector<int> BinaryTree::root() {
std::vector<int> vec;
for (int i = 0; i < numVertex; i++) {
if (parent[i] == -1)
vec.push_back(i);
}
return vec;
}
void BinaryTree::dfs(int v, order flag) {
if (v >= 0) {
if (flag == preorder)
printf(" %d", v);
dfs(left[v], flag);
if (flag == inorder)
printf(" %d", v);
dfs(right[v], flag);
if (flag == postorder)
printf(" %d", v);
}
}
int main() {
int n;
scanf("%d", &n);
BinaryTree t(n);
t.init();
std::vector<int> v = t.root();
printf("Preorder\n");
t.dfs(v[0], preorder);
printf("\nInorder\n");
t.dfs(v[0], inorder);
printf("\nPostorder\n");
t.dfs(v[0], postorder);
printf("\n");
return 0;
}
|
replace
| 39 | 41 | 39 | 43 |
-6
|
double free or corruption (out)
|
p02281
|
C++
|
Runtime Error
|
///
// File: alds1_7_c.cpp
// Author: ymiyamoto
//
// Created on Sat Oct 14 18:52:33 2017
//
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
struct tree_t {
int32_t parent;
int32_t left;
int32_t right;
tree_t() {
parent = -1;
left = -1;
right = -1;
}
};
#define SIZE 100
#define NIL -1
static tree_t tree[SIZE];
static vector<int32_t> preorder;
static vector<int32_t> inorder;
static vector<int32_t> postorder;
void walk(int32_t index) {
preorder.push_back(index);
if (tree[index].left != NIL) {
walk(tree[index].left);
}
inorder.push_back(index);
if (tree[index].right != NIL) {
walk(tree[index].right);
}
postorder.push_back(index);
}
int32_t main() {
int32_t n;
cin >> n;
for (int32_t i = 0; i < n; i++) {
int32_t id, left, right;
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
tree[left].parent = id;
tree[right].parent = id;
}
int32_t root = NIL;
for (int32_t i = 0; i < n; i++) {
if (tree[i].parent == NIL) {
root = i;
}
}
walk(root);
cout << "Preorder" << endl;
for (uint32_t i = 0; i < preorder.size(); i++) {
cout << " " << preorder[i];
}
cout << endl;
cout << "Inorder" << endl;
for (uint32_t i = 0; i < inorder.size(); i++) {
cout << " " << inorder[i];
}
cout << endl;
cout << "Postorder" << endl;
for (uint32_t i = 0; i < postorder.size(); i++) {
cout << " " << postorder[i];
}
cout << endl;
return 0;
}
|
///
// File: alds1_7_c.cpp
// Author: ymiyamoto
//
// Created on Sat Oct 14 18:52:33 2017
//
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
struct tree_t {
int32_t parent;
int32_t left;
int32_t right;
tree_t() {
parent = -1;
left = -1;
right = -1;
}
};
#define SIZE 100
#define NIL -1
static tree_t tree[SIZE];
static vector<int32_t> preorder;
static vector<int32_t> inorder;
static vector<int32_t> postorder;
void walk(int32_t index) {
preorder.push_back(index);
if (tree[index].left != NIL) {
walk(tree[index].left);
}
inorder.push_back(index);
if (tree[index].right != NIL) {
walk(tree[index].right);
}
postorder.push_back(index);
}
int32_t main() {
int32_t n;
cin >> n;
for (int32_t i = 0; i < n; i++) {
int32_t id, left, right;
cin >> id >> left >> right;
tree[id].left = left;
tree[id].right = right;
if (left != NIL) {
tree[left].parent = id;
}
if (right != NIL) {
tree[right].parent = id;
}
}
int32_t root = NIL;
for (int32_t i = 0; i < n; i++) {
if (tree[i].parent == NIL) {
root = i;
}
}
walk(root);
cout << "Preorder" << endl;
for (uint32_t i = 0; i < preorder.size(); i++) {
cout << " " << preorder[i];
}
cout << endl;
cout << "Inorder" << endl;
for (uint32_t i = 0; i < inorder.size(); i++) {
cout << " " << inorder[i];
}
cout << endl;
cout << "Postorder" << endl;
for (uint32_t i = 0; i < postorder.size(); i++) {
cout << " " << postorder[i];
}
cout << endl;
return 0;
}
|
replace
| 53 | 55 | 53 | 59 |
0
| |
p02281
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
struct binarytree {
int parent, left, right;
};
int order(vector<binarytree> &node, int i, int mode) {
int e1, e2;
if (mode == 0)
cout << " " << i;
e1 = node[i].left;
if (e1 != -1)
order(node, e1, mode);
if (mode == 1)
cout << " " << i;
e2 = node[i].right;
if (e1 != -1)
order(node, e2, mode);
if (mode == 2)
cout << " " << i;
return 0;
}
int main(void) {
int n, e, tmp;
stringstream ss;
cin >> n;
vector<binarytree> node(n);
for (int i = 0; i < n; i++) {
node[i].parent = -1;
node[i].left = -1;
node[i].right = -1;
}
for (int i = 0; i < n; i++) {
cin >> e;
cin >> tmp;
node[e].left = tmp;
if (tmp != -1)
node[tmp].parent = e;
cin >> tmp;
node[e].right = tmp;
if (tmp != -1)
node[tmp].parent = e;
}
e = 0;
tmp = node[e].parent;
while (tmp != -1) {
e = tmp;
tmp = node[e].parent;
}
cout << "Preorder" << endl;
order(node, e, 0);
cout << endl;
cout << "Inorder" << endl;
order(node, e, 1);
cout << endl;
cout << "Postorder" << endl;
order(node, e, 2);
cout << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
struct binarytree {
int parent, left, right;
};
int order(vector<binarytree> &node, int i, int mode) {
int e1, e2;
if (mode == 0)
cout << " " << i;
e1 = node[i].left;
if (e1 != -1)
order(node, e1, mode);
if (mode == 1)
cout << " " << i;
e2 = node[i].right;
if (e2 != -1)
order(node, e2, mode);
if (mode == 2)
cout << " " << i;
return 0;
}
int main(void) {
int n, e, tmp;
stringstream ss;
cin >> n;
vector<binarytree> node(n);
for (int i = 0; i < n; i++) {
node[i].parent = -1;
node[i].left = -1;
node[i].right = -1;
}
for (int i = 0; i < n; i++) {
cin >> e;
cin >> tmp;
node[e].left = tmp;
if (tmp != -1)
node[tmp].parent = e;
cin >> tmp;
node[e].right = tmp;
if (tmp != -1)
node[tmp].parent = e;
}
e = 0;
tmp = node[e].parent;
while (tmp != -1) {
e = tmp;
tmp = node[e].parent;
}
cout << "Preorder" << endl;
order(node, e, 0);
cout << endl;
cout << "Inorder" << endl;
order(node, e, 1);
cout << endl;
cout << "Postorder" << endl;
order(node, e, 2);
cout << endl;
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
0
| |
p02282
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
struct node {
int left, right;
} nodes[100];
int n, pre[105], in[105], inloc[105], cnt = 0;
int rec(int s, int e) {
if (s < e) {
int m = inloc[pre[cnt++]];
int l = rec(s, m - 1);
int r = rec(m + 1, e);
nodes[in[m]].left = l;
nodes[in[m]].right = r;
return in[m];
} else if (s == e) {
return in[s];
} else {
return 0;
}
}
void post(int r) {
if (nodes[r].left != 0)
post(nodes[r].left);
if (nodes[r].right != 0)
post(nodes[r].right);
cout << r;
if (r != pre[0])
cout << " ";
}
int main() {
memset(nodes, 0, sizeof(nodes));
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> pre[i];
}
for (i = 0; i < n; i++) {
cin >> in[i];
inloc[in[i]] = i;
}
int mm = rec(0, n - 1);
post(pre[0]);
cout << endl;
return 0;
}
//
// int main(){
// int a[10]={1,2,3,4,5,32,62,23,8,33};
// int *b=find(a,a+10,62);
// int c=distance(a,b);
// cout<<c;
//}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
struct node {
int left, right;
} nodes[100];
int n, pre[105], in[105], inloc[105], cnt = 0;
int rec(int s, int e) {
if (s < e) {
int m = inloc[pre[cnt++]];
int l = rec(s, m - 1);
int r = rec(m + 1, e);
nodes[in[m]].left = l;
nodes[in[m]].right = r;
return in[m];
} else if (s == e) {
cnt++;
return in[s];
} else {
return 0;
}
}
void post(int r) {
if (nodes[r].left != 0)
post(nodes[r].left);
if (nodes[r].right != 0)
post(nodes[r].right);
cout << r;
if (r != pre[0])
cout << " ";
}
int main() {
memset(nodes, 0, sizeof(nodes));
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> pre[i];
}
for (i = 0; i < n; i++) {
cin >> in[i];
inloc[in[i]] = i;
}
int mm = rec(0, n - 1);
post(pre[0]);
cout << endl;
return 0;
}
//
// int main(){
// int a[10]={1,2,3,4,5,32,62,23,8,33};
// int *b=find(a,a+10,62);
// int c=distance(a,b);
// cout<<c;
//}
|
insert
| 20 | 20 | 20 | 21 |
0
| |
p02282
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
struct Node {
int id;
int parent;
int left;
int right;
Node() : id(), parent(-1), left(-1), right(-1) {}
};
static vector<Node> TREE(25);
static void inputNode(Node &node, int id) {
node.id = id;
cin >> node.left >> node.right;
}
static vector<int> preorder(25), inorder(25);
static void inputOrder(vector<int> &order, int num) {
for (int i = 0; i < num; i++) {
cin >> order[i];
}
}
static int current = 0, outIndex = 0;
static int next() {
int c = preorder[current];
current++;
return c;
}
static int find(int c) {
auto it = find(inorder.begin(), inorder.end(), c);
return distance(inorder.begin(), it);
}
static void reconstruction(int l, int r) {
if (l >= r) {
return;
}
int c = next();
int m = find(c);
reconstruction(l, m);
reconstruction(m + 1, r);
if (outIndex != 0) {
cout << " " << c;
} else {
cout << c;
}
outIndex++;
}
int main() {
int n;
cin >> n;
inputOrder(preorder, n);
inputOrder(inorder, n);
reconstruction(0, n);
cout << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
static vector<int> preorder(100), inorder(100);
static void inputOrder(vector<int> &order, int num) {
for (int i = 0; i < num; i++) {
cin >> order[i];
}
}
static int current = 0, outIndex = 0;
static int next() {
int c = preorder[current];
current++;
return c;
}
static int find(int c) {
auto it = find(inorder.begin(), inorder.end(), c);
return distance(inorder.begin(), it);
}
static void reconstruction(int l, int r) {
if (l >= r) {
return;
}
int c = next();
int m = find(c);
reconstruction(l, m);
reconstruction(m + 1, r);
if (outIndex != 0) {
cout << " " << c;
} else {
cout << c;
}
outIndex++;
}
int main() {
int n;
cin >> n;
inputOrder(preorder, n);
inputOrder(inorder, n);
reconstruction(0, n);
cout << endl;
return 0;
}
|
replace
| 6 | 23 | 6 | 7 |
0
| |
p02282
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, pos;
vector<int> pre, in, post;
void rec(int l, int r) {
if (l >= r)
return;
int root = pre[pos++];
int m = distance(in.begin(), find(in.begin(), in.end(), root));
rec(l, m);
rec(m + 1, r);
post.push_back(root);
}
void solve() {
pos = 0;
rec(0, pre.size());
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << post[i];
}
cout << endl;
}
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> pre[i];
}
for (int i = 0; i < n; i++) {
cin >> k;
in.push_back(k);
}
solve();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, pos;
vector<int> pre, in, post;
void rec(int l, int r) {
if (l >= r)
return;
int root = pre[pos++];
int m = distance(in.begin(), find(in.begin(), in.end(), root));
rec(l, m);
rec(m + 1, r);
post.push_back(root);
}
void solve() {
pos = 0;
rec(0, pre.size());
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << post[i];
}
cout << endl;
}
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
pre.push_back(k);
}
for (int i = 0; i < n; i++) {
cin >> k;
in.push_back(k);
}
solve();
return 0;
}
|
replace
| 35 | 36 | 35 | 37 |
-11
| |
p02282
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, pos;
vector<int> pre, in, post;
void rec(int l, int r) {
if (l = r)
return;
int root = pre[pos++];
int m = distance(in.begin(), find(in.begin(), in.end(), root));
rec(l, m);
rec(m + 1, r);
post.push_back(root);
}
void solve() {
pos = 0;
rec(0, pre.size());
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << post[i];
}
cout << endl;
}
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
pre.push_back(k);
}
for (int i = 0; i < n; i++) {
cin >> k;
in.push_back(k);
}
solve();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, pos;
vector<int> pre, in, post;
void rec(int l, int r) {
if (l == r)
return;
int root = pre[pos++];
int m = distance(in.begin(), find(in.begin(), in.end(), root));
rec(l, m);
rec(m + 1, r);
post.push_back(root);
}
void solve() {
pos = 0;
rec(0, pre.size());
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << post[i];
}
cout << endl;
}
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
pre.push_back(k);
}
for (int i = 0; i < n; i++) {
cin >> k;
in.push_back(k);
}
solve();
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
-11
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.