buggy_code stringlengths 11 625k | fixed_code stringlengths 17 625k | bug_type stringlengths 2 4.45k | language int64 0 8 | token_count int64 5 200k | change_count int64 0 100 |
|---|---|---|---|---|---|
#include <stdio.h>
#include <stdlib.h>
#define MAX 100005
#define NIL -1
int parent[MAX], left[MAX], right[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
printf("node %d:", u);
printf("parent = %d,", parent[u]);
printf("depth = %d,", D[u]);
if (parent[u] == NIL)
printf("root, ");
else if (left[u] ... | #include <stdio.h>
#include <stdlib.h>
#define MAX 100005
#define NIL -1
int parent[MAX], left[MAX], right[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
printf("node %d: ", u);
printf("parent = %d, ", parent[u]);
printf("depth = %d, ", D[u]);
if (parent[u] == NIL)
printf("root, ");
else if (left[... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 451 | 6 |
#include <stdio.h>
#define MAX 1000005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node tree[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
printf("node %d: parent = %d, depath = %d, ", u, tree[u].p, D[u]);
if (tree[u].p == NIL) {
printf("root, ");
} else if (tree[u].l == NIL) {
printf("... | #include <stdio.h>
#define MAX 1000005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node tree[MAX];
int n, D[MAX];
void print(int u) {
int i, c;
printf("node %d: parent = %d, depth = %d, ", u, tree[u].p, D[u]);
if (tree[u].p == NIL) {
printf("root, ");
} else if (tree[u].l == NIL) {
printf("l... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 490 | 2 |
#include <stdio.h>
#include <stdlib.h>
#define MAX 100005
#define NIL -1
struct node {
int p;
int r;
int l;
};
struct node T[MAX];
int n, D[MAX];
void print(int u) {
int c, i;
printf("node %d: ", u);
printf("parent = %d: ", T[u].p);
printf("depth = %d: ", D[u]);
if (T[u].p == NIL)
printf("root,... | #include <stdio.h>
#include <stdlib.h>
#define MAX 100005
#define NIL -1
struct node {
int p;
int r;
int l;
};
struct node T[MAX];
int n, D[MAX];
void print(int u) {
int c, i;
printf("node %d: ", u);
printf("parent = %d, ", T[u].p);
printf("depth = %d, ", D[u]);
if (T[u].p == NIL)
printf("root,... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 491 | 4 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[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)
... | #include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[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)
... | [["-", 8, 1, 0, 11, 12, 2, 3, 4, 0, 22], ["+", 8, 1, 0, 11, 12, 2, 3, 4, 0, 22]] | 0 | 472 | 2 |
#include <stdio.h>
#define N 100000
int n, parent[N], left[N], right[N], D[N];
int GetDepth(int);
void SetDepth(int, int);
void PrintChildren(int);
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
}
for (i = 0; i <... | #include <stdio.h>
#define N 100005
int n, parent[N], left[N], right[N], D[N];
int GetDepth(int);
void SetDepth(int, int);
void PrintChildren(int);
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
}
for (i = 0; i <... | [["-", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["+", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["-", 0, 9, 0, 1, 0, 11, 31, 69, 71, 22], ["+", 0, 9, 0, 1, 0, 11, 31, 69, 71, 22], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 7, 8, 9, 0, 57, 64, 9, 0, 45], ["-", 0, 7, 8, 9, 0, 57, 64, 9,... | 0 | 494 | 8 |
#include <stdio.h>
#define MAX 100005
int parent[MAX], left[MAX], right[MAX], n, D[MAX];
int getDepth(int u);
void setDepth(int u, int p);
void printChildren(int u);
int main() {
int i, j, d, v, c, l, r, w, t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
... | #include <stdio.h>
#define MAX 100005
int parent[MAX], left[MAX], right[MAX], n, D[MAX];
int getDepth(int u);
void setDepth(int u, int p);
void printChildren(int u);
int main() {
int i, j, d, v, c, l, r, w, t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
parent[i] = -1;
left[i] = -1;
right[i] = -1;
... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 531 | 2 |
#include <stdio.h>
#define N 200001
#define NT -1
struct Node {
int p, left, right;
};
struct Node T[N];
int getDepth(int p) {
if (T[p].p == NT)
return 0;
return getDepth(T[p].p) + 1;
}
int main() {
int n, i, key, j, c;
int id, temp;
int depth[N];
scanf("%d", &n);
for (i = 0; i < n; i++) {
... | #include <stdio.h>
#define N 200001
#define NT -1
struct Node {
int p, left, right;
};
struct Node T[N];
int getDepth(int p) {
if (T[p].p == NT)
return 0;
return getDepth(T[p].p) + 1;
}
int main() {
int n, i, key, j, c;
int id, temp;
int depth[N];
scanf("%d", &n);
for (i = 0; i < n; i++) {
... | [["-", 0, 57, 15, 23, 0, 16, 31, 118, 119, 120], ["+", 0, 57, 15, 23, 0, 16, 31, 118, 119, 120], ["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 439 | 8 |
#include <stdio.h>
#define N 100005
#define M -1
int n, Parent[N], Right[N], Left[N], D[N];
int GetDepth(int);
void SetDepth(int, int);
void Print(int);
int main() {
int i, j, v, l, c, d, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Parent[i] = Right[i] = Left[i] = M;
}
for (i = 0; i < n; i++) {
s... | #include <stdio.h>
#define N 100005
#define M -1
int n, Parent[N], Right[N], Left[N], D[N];
int GetDepth(int);
void SetDepth(int, int);
void Print(int);
int main() {
int i, j, v, l, c, d, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Parent[i] = Right[i] = Left[i] = M;
}
for (i = 0; i < n; i++) {
s... | [["+", 8, 9, 0, 57, 75, 76, 0, 9, 0, 46], ["-", 8, 9, 0, 57, 75, 76, 0, 9, 0, 46]] | 0 | 528 | 2 |
#include <stdio.h>
#define N 100000
struct Node {
int p, l, r;
};
struct Node NA[N];
int D[N];
void Set(int x, int p) {
D[x] = p;
if (NA[x].r != -1)
Set(NA[x].r, p);
if (NA[x].l != -1)
Set(NA[x].l, p);
}
int main() {
int i, j, n, id;
int k, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {... | #include <stdio.h>
#define N 100000
struct Node {
int p, l, r;
};
struct Node NA[N];
int D[N];
void Set(int x, int p) {
D[x] = p;
if (NA[x].r != -1)
Set(NA[x].r, p);
if (NA[x].l != -1)
Set(NA[x].l, p + 1);
}
int main() {
int i, j, n, id;
int k, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i+... | [["+", 64, 1, 0, 2, 3, 4, 0, 16, 17, 72], ["+", 64, 1, 0, 2, 3, 4, 0, 16, 12, 13]] | 0 | 476 | 2 |
#include <stdio.h>
#include <stdlib.h>
//#define n_size 100000
typedef struct node_ {
int kosu;
int *hyo;
int parent;
// int depth;
} Node;
int main() {
int n, node, ko, dep, tmp = 0;
Node *N;
scanf("%d", &n);
N = malloc(sizeof(Node) * n);
for (int i = 0; i < n; i++)
N[i].parent = -1;
for ... | #include <stdio.h>
#include <stdlib.h>
//#define n_size 100000
typedef struct node_ {
int kosu;
int *hyo;
int parent;
// int depth;
} Node;
int main() {
int n, node, ko, dep, tmp = 0;
Node *N;
scanf("%d", &n);
N = malloc(sizeof(Node) * n);
for (int i = 0; i < n; i++)
N[i].parent = -1;
for ... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 399 | 2 |
#include <stdio.h>
#define null -1
struct Node {
int parent;
int left;
int right;
};
struct Node node[100001];
int deep(int u) {
int d = 0;
while (node[u].parent != null) {
u = node[u].parent;
d++;
}
return d;
}
void print(int i) {
int j, c;
printf("node %d: ", i);
printf("parent %d, ", ... | #include <stdio.h>
#define null -1
struct Node {
int parent;
int left;
int right;
};
struct Node node[100001];
int deep(int u) {
int d = 0;
while (node[u].parent != null) {
u = node[u].parent;
d++;
}
return d;
}
void print(int i) {
int j, c;
printf("node %d: ", i);
printf("parent = %d, "... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 413 | 4 |
#include <stdio.h>
#define N 100001
#define NIL -1
typedef struct {
int parent, left, right;
} Node;
Node Tree[N];
void print(int);
int Depth[N];
int main(VOID) {
int i, j, n, cc, child[N], node;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = NIL;
Tree[i].left = NIL;
Tree[i].right =... | #include <stdio.h>
#define N 100001
#define NIL -1
typedef struct {
int parent, left, right;
} Node;
Node Tree[N];
void print(int);
int Depth[N];
int main(VOID) {
int i, j, n, cc, child[N], node;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = NIL;
Tree[i].left = NIL;
Tree[i].right =... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 446 | 2 |
#include <stdio.h>
#define MAX_N 100000
#define NIL -1
typedef struct node_ {
int parent;
int left;
int right;
} Node;
Node T[MAX_N];
int getDepth(int u) {
int d = 0;
while (u != NIL) {
u = T[u].parent;
d++;
}
return d;
}
void print(int u) {
int i;
printf("node %d: ", u);
printf("parent ... | #include <stdio.h>
#define MAX_N 100000
#define NIL -1
typedef struct node_ {
int parent;
int left;
int right;
} Node;
Node T[MAX_N];
int getDepth(int u) {
int d = 0;
while (T[u].parent != NIL) {
u = T[u].parent;
d++;
}
return d;
}
void print(int u) {
int i;
printf("node %d: ", u);
print... | [["+", 15, 23, 0, 16, 31, 118, 28, 69, 28, 22], ["+", 15, 23, 0, 16, 31, 118, 28, 69, 0, 70], ["+", 15, 23, 0, 16, 31, 118, 28, 69, 0, 73], ["+", 0, 52, 15, 23, 0, 16, 31, 118, 17, 131], ["+", 0, 52, 15, 23, 0, 16, 31, 118, 119, 120]] | 0 | 422 | 5 |
#include <stdio.h>
#include <stdlib.h>
#define MAX 100000
#define ROOT 0
#define INODE 1
#define LEAF 2
struct CHILDREN {
int id;
struct CHILDREN *next;
};
typedef struct CHILDREN CHILDREN;
struct NODE {
int parent;
short depth;
short type;
CHILDREN *children;
};
typedef struct NODE NODE;
int main(void)... | #include <stdio.h>
#include <stdlib.h>
#define MAX 100000
#define ROOT 0
#define INODE 1
#define LEAF 2
struct CHILDREN {
int id;
struct CHILDREN *next;
};
typedef struct CHILDREN CHILDREN;
struct NODE {
int parent;
short depth;
short type;
CHILDREN *children;
};
typedef struct NODE NODE;
int main(void)... | [["-", 15, 23, 0, 91, 28, 118, 28, 69, 71, 22], ["+", 15, 23, 0, 91, 28, 118, 28, 69, 71, 22], ["-", 0, 1, 0, 11, 31, 118, 28, 69, 71, 22], ["+", 0, 1, 0, 11, 31, 118, 28, 69, 71, 22]] | 0 | 553 | 4 |
#include <stdio.h>
#define N 100000
struct Node {
int parent;
int left;
int right;
};
struct Node tree[N];
int n, d[N];
void depth(int, int);
void print(int);
int main() {
int i, j, id, k, c, left = 0, right = 0;
scanf("%d", &n);
for (i = 0; i < n; i++)
tree[i].parent = tree[i].left = tree[i].right... | #include <stdio.h>
#define N 100000
struct Node {
int parent;
int left;
int right;
};
struct Node tree[N];
int n, d[N];
void depth(int, int);
void print(int);
int main() {
int i, j, id, k, c, left = 0, right = 0;
scanf("%d", &n);
for (i = 0; i < n; i++)
tree[i].parent = tree[i].left = tree[i].right... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 481 | 2 |
#include <stdio.h>
#define N 100000
typedef struct {
int parent, left, right;
} Node;
Node Tree[N];
void Print(int);
int depth(int);
int PrintChild(int);
main() {
int i, n, id, k, c, q, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = -1;
Tree[i].left = -1;
Tree[i].right = -1;
}... | #include <stdio.h>
#define N 100000
typedef struct {
int parent, left, right;
} Node;
Node Tree[N];
void Print(int);
int depth(int);
int PrintChild(int);
main() {
int i, n, id, k, c, q, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = -1;
Tree[i].left = -1;
Tree[i].right = -1;
}... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 421 | 2 |
#include <stdio.h>
#define NIT -1
int depth(int);
void output(int);
typedef struct {
int parent;
int left;
int right;
} vertex;
int child, mae;
int degree[100000], A[100000];
vertex Tree[100000];
main() {
int i, j, n, id;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = Tree[i].left = ... | #include <stdio.h>
#define NIT -1
int depth(int);
void output(int);
typedef struct {
int parent;
int left;
int right;
} vertex;
int child, mae;
int degree[100000], A[100000];
vertex Tree[100000];
main() {
int i, j, n, id;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = Tree[i].left = ... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 519 | 2 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node Tree[MAX];
int n;
int main() {
int a, c, d, i, j, l, v;
scanf("%d", &n);
for (i = 0; i < n; i++)
Tree[i].p = Tree[i].l = Tree[i].r = NIL;
for (i = 0; i < n; i++) {
scanf("%d %d", &v, &d);
for (j = 0... | #include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node Tree[MAX];
int n;
int main() {
int a, c, d, i, j, l, v;
scanf("%d", &n);
for (i = 0; i < n; i++)
Tree[i].p = Tree[i].l = Tree[i].r = NIL;
for (i = 0; i < n; i++) {
scanf("%d %d", &v, &d);
for (j = 0... | [["-", 8, 9, 0, 7, 8, 1, 0, 2, 63, 22], ["+", 8, 9, 0, 7, 8, 1, 0, 2, 63, 22], ["-", 8, 1, 0, 2, 3, 4, 0, 5, 0, 62], ["-", 8, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 7, 8, 1, 0, 2, 3, 4, 0, 21]] | 0 | 426 | 6 |
#include <stdio.h>
#define N 100000
struct Node {
int p;
int l;
int r;
};
struct Node T[N];
int D[N];
int Depth(int x) {
int sum = 0;
while (T[x].p != -1) {
sum++;
x = T[x].p;
}
return sum;
}
int main(void) {
int n, i, j, k, c, s, node;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[... | #include <stdio.h>
#define N 100000
struct Node {
int p;
int l;
int r;
};
struct Node T[N];
int D[N];
int Depth(int x) {
int sum = 0;
while (T[x].p != -1) {
sum++;
x = T[x].p;
}
return sum;
}
int main(void) {
int n, i, j, k, c, s, node;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 464 | 4 |
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int leftch;
int rightsib;
} Node;
int main() {
int n, i, j, id, child, k, r, depth;
Node *Tree;
scanf("%d", &n);
Tree = malloc(sizeof(Node) * n);
for (i = 0; i < n; i++) {
Tree[i].parent = -1;
Tree[i].leftch = -1;
Tree... | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int leftch;
int rightsib;
} Node;
int main() {
int n, i, j, id, child, k, r, depth;
Node *Tree;
scanf("%d", &n);
Tree = malloc(sizeof(Node) * n);
for (i = 0; i < n; i++) {
Tree[i].parent = -1;
Tree[i].leftch = -1;
Tree... | [["-", 64, 9, 0, 1, 0, 2, 3, 4, 0, 22], ["+", 64, 9, 0, 1, 0, 2, 3, 4, 0, 22], ["-", 0, 9, 0, 1, 0, 2, 3, 4, 0, 22], ["+", 0, 9, 0, 1, 0, 2, 3, 4, 0, 22]] | 0 | 414 | 4 |
#include <stdio.h>
#define N 20
#define NIL -1
typedef struct Trees {
int parent;
int right;
int left;
} tree;
tree tr[N];
int depth[N];
void print(int);
void culDepth(int, int);
int main() {
int i, j, n, node, m, right, left, c, rooti;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tr[i].parent = NIL;
... | #include <stdio.h>
#define N 200000
#define NIL -1
typedef struct Trees {
int parent;
int right;
int left;
} tree;
tree tr[N];
int depth[N];
void print(int);
void culDepth(int, int);
int main() {
int i, j, n, node, m, right, left, c, rooti;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tr[i].parent = NIL;
... | [["-", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["+", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 515 | 4 |
#include <stdio.h>
#define MAX 1000000
int rec(int, int);
void print(int);
typedef struct node {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
int main() {
int n, i, j, v, c, r, d, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = -1;
T[i].l = -1;
T[i].r = -1;
}
for (i = 0; i < n; i+... | #include <stdio.h>
#define MAX 1000000
int rec(int, int);
void print(int);
typedef struct node {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
int main() {
int n, i, j, v, c, r, d, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = -1;
T[i].l = -1;
T[i].r = -1;
}
for (i = 0; i < n; i+... | [["-", 8, 9, 0, 57, 15, 23, 0, 11, 17, 32], ["+", 8, 9, 0, 57, 15, 23, 0, 16, 17, 60]] | 0 | 502 | 2 |
/*
* Rooted tree
* output 1)node_number, 2)parent_number, 3)depth, 4)kind_of_node, 5)child_list
*/
/* inclution */
#include <stdio.h>
/* Definition */
#define MAX 100000
#define NIL -1
/* Prototype */
void printTree(int);
void getDepth(int, int);
/* Global Variables */
struct Node {
int parent, left, right;
};... | /*
* Rooted tree
* output 1)node_number, 2)parent_number, 3)depth, 4)kind_of_node, 5)child_list
*/
/* inclution */
#include <stdio.h>
/* Definition */
#define MAX 100000
#define NIL -1
/* Prototype */
void printTree(int);
void getDepth(int, int);
/* Global Variables */
struct Node {
int parent, left, right;
};... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 556 | 2 |
#include <stdio.h>
#define N 100000
typedef struct {
int id;
int parent;
int child;
int right;
int depth;
} Node;
Node node[N];
int C[N];
int main() {
int n, i, j, degree = 0, id = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
node[i].parent = -1;
node[i].child = -1;
node[i].right = -1... | #include <stdio.h>
#define N 100000
typedef struct {
int id;
int parent;
int child;
int right;
int depth;
} Node;
Node node[N];
int C[N];
int main() {
int n, i, j, degree = 0, id = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
node[i].parent = -1;
node[i].child = -1;
node[i].right = -1... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 570 | 8 |
#include <stdio.h>
#include <stdlib.h>
#define N 10
typedef struct {
int parent;
int left;
int right;
} Node;
int main() {
int point, number, i, j, a, b, n, deep = 0, place, count = 0, k;
int *Deep;
int num[N];
Node *Tree;
scanf("%d", &n);
Tree = (Node *)malloc(sizeof(Node) * n);
Deep = (int *)ma... | #include <stdio.h>
#include <stdlib.h>
#define N 10
typedef struct {
int parent;
int left;
int right;
} Node;
int main() {
int point, number, i, j, a, b, n, deep = 0, place, count = 0, k;
int *Deep;
int num[N];
Node *Tree;
scanf("%d", &n);
Tree = (Node *)malloc(sizeof(Node) * n);
Deep = (int *)ma... | [["-", 0, 57, 15, 23, 0, 16, 31, 118, 119, 120], ["+", 0, 57, 15, 23, 0, 16, 31, 118, 119, 120]] | 0 | 469 | 2 |
#include <stdio.h>
typedef struct {
int parent;
int left;
int right;
} Tree;
Tree t[100000];
int num, dep[100000];
void print(int);
void rec(int, int);
int main() {
int volume, k, l, r, c, i, j;
scanf("%d", &num);
for (i = 0; i < num; i++) {
t[i].parent = -1;
t[i].left = -1;
t[i].right = -1... | #include <stdio.h>
typedef struct {
int parent;
int left;
int right;
} Tree;
Tree t[100000];
int num, dep[100000];
void print(int);
void rec(int, int);
int main() {
int volume, k, l, r, c, i, j;
scanf("%d", &num);
for (i = 0; i < num; i++) {
t[i].parent = -1;
t[i].left = -1;
t[i].right = -1... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 482 | 2 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct node {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
void print(int u);
int rec(int u, int p);
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++) ... | #include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct node {
int p, l, r;
} Node;
Node T[MAX];
int n, D[MAX];
void print(int u);
int rec(int u, int p);
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++) ... | [["-", 15, 23, 0, 16, 31, 118, 28, 69, 71, 22], ["+", 15, 23, 0, 16, 31, 118, 28, 69, 71, 22]] | 0 | 496 | 2 |
#include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX];
void rec(int);
int main() {
int i, j, d, v, c, l, r, a;
scanf("%d", &n);
for (i = 0; i <= n - 1; i++) {
T[i].p = T[i].l = T[i].r = NIL;
}
for (i = 0; i <= n - 1; i++) {
scanf("%d... | #include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX];
void rec(int);
int main() {
int i, j, d, v, c, l, r, a;
scanf("%d", &n);
for (i = 0; i <= n - 1; i++) {
T[i].p = T[i].l = T[i].r = NIL;
}
for (i = 0; i <= n - 1; i++) {
scanf("%d... | [["+", 15, 23, 0, 16, 31, 118, 28, 69, 28, 22], ["+", 15, 23, 0, 16, 31, 118, 28, 69, 0, 70], ["+", 15, 23, 0, 16, 31, 118, 28, 69, 0, 73], ["+", 0, 57, 15, 23, 0, 16, 31, 118, 17, 131], ["+", 0, 57, 15, 23, 0, 16, 31, 118, 119, 120], ["-", 8, 9, 0, 57, 15, 23, 0, 16, 12, 13], ["+", 8, 9, 0, 57, 15, 23, 0, 16, 12, 22]] | 0 | 598 | 7 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX];
int getD(int);
void print(int);
int dik[MAX];
int main(void) {
int i, j;
int deg, ver;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
... | #include <stdio.h>
#define MAX 100005
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n, D[MAX];
int getD(int);
void print(int);
int dik[MAX];
int main(void) {
int i, j;
int deg, ver;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 454 | 2 |
#include <stdio.h>
#define N 100001
int depth(int);
void output(int);
typedef struct {
int parent;
int left;
int right;
} Node;
Node tree[N];
int count;
int main() {
int i, j, n, k, Nnode, child, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tree[i].parent = -1;
tree[i].left = -1;
... | #include <stdio.h>
#define N 100001
int depth(int);
void output(int);
typedef struct {
int parent;
int left;
int right;
} Node;
Node tree[N];
int count;
int main() {
int i, j, n, k, Nnode, child, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tree[i].parent = -1;
tree[i].left = -1;
... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 405 | 2 |
#include <stdio.h>
#define N 10001
typedef struct {
int par;
int l_child;
int r_sib;
} node;
node tree[N];
int depth(int);
int main() {
int n, i, j, id, cnum, lef, child;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tree[i].par = -1;
tree[i].l_child = -1;
tree[i].r_sib = -1;
}
for (i = ... | #include <stdio.h>
#define N 100001
typedef struct {
int par;
int l_child;
int r_sib;
} node;
node tree[N];
int depth(int);
int main() {
int n, i, j, id, cnum, lef, child;
scanf("%d", &n);
for (i = 0; i < n; i++) {
tree[i].par = -1;
tree[i].l_child = -1;
tree[i].r_sib = -1;
}
for (i =... | [["-", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["+", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 385 | 8 |
#include <stdio.h>
int depth(int);
struct Node {
int parent, leftchild, rightbro; //左子右兄弟表現
};
struct Node node[100001];
int main() {
int i, j, mom, k, n, child, x, bro;
scanf("%d", &n); // number of node
for (i = 0; i < n; i++) {
node[i].parent = -1;
node[i].leftchild = -1;
node[i].rightbro ... | #include <stdio.h>
int depth(int);
struct Node {
int parent, leftchild, rightbro; //左子右兄弟表現
};
struct Node node[100001];
int main() {
int i, j, mom, k, n, child, x, bro;
scanf("%d", &n); // number of node
for (i = 0; i < n; i++) {
node[i].parent = -1;
node[i].leftchild = -1;
node[i].rightbro ... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 455 | 2 |
#include <stdio.h>
#define NIL -1
typedef struct node {
int p;
int l;
int r;
} Node;
Node T[100000];
int D[100000];
int 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 == NIL) {
printf("root, ");
} else if (T[u].l... | #include <stdio.h>
#define NIL -1
typedef struct node {
int p;
int l;
int r;
} Node;
Node T[100000];
int D[100000];
int 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 == NIL) {
printf("root, ");
} else if (T[u].l... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 501 | 4 |
#include <stdio.h>
#define NIL -1
#define MAX 100000
typedef struct {
int p, l, r;
} Node;
Node T[MAX];
int n;
int depth(int a) {
int num = 0, s = T[a].p;
while (s != NIL) {
num++;
s = T[s].p;
}
return num;
}
int main() {
int i, j, x, d, c, l;
scanf("%d", &n);
for (i = 0; i < n; i++)
... | #include <stdio.h>
#define NIL -1
#define MAX 100000
typedef struct {
int p, l, r;
} Node;
Node T[MAX];
int n;
int depth(int a) {
int num = 0, s = T[a].p;
while (s != NIL) {
num++;
s = T[s].p;
}
return num;
}
int main() {
int i, j, x, d, c, l;
scanf("%d", &n);
for (i = 0; i < n; i++)
... | [["-", 10, 34, 12, 11, 12, 118, 28, 69, 71, 22], ["+", 10, 34, 12, 11, 12, 118, 28, 69, 71, 22]] | 0 | 388 | 2 |
#include <stdio.h>
#define max 100000
#define nil -1
typedef struct {
int parent;
int leaf;
int right;
} node;
node t[max];
int n;
int dep(int id, int c) {
int i, depth = 0;
if (t[id].parent != nil) {
depth = dep(t[id].parent, c);
return depth + 1;
} else
return 0;
}
int main(void) {
int i... | #include <stdio.h>
#define max 100000
#define nil -1
typedef struct {
int parent;
int leaf;
int right;
} node;
node t[max];
int n;
int dep(int id, int c) {
int i, depth = 0;
if (t[id].parent != nil) {
depth = dep(t[id].parent, c);
return depth + 1;
} else
return 0;
}
int main(void) {
int i... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 459 | 2 |
#include <stdio.h>
#include <stdlib.h>
#define MAX 100004
#define NIL -1
struct Node {
int p;
int num;
int depth;
int *child;
};
struct Node T[MAX];
void depth(int d, int dep) {
T[d].depth = dep;
int i;
for (i = 0; i < T[d].num; i++) {
depth(T[d].child[i], dep + 1);
}
}
void print(int q) {
i... | #include <stdio.h>
#include <stdlib.h>
#define MAX 100004
#define NIL -1
struct Node {
int p;
int num;
int depth;
int *child;
};
struct Node T[MAX];
void depth(int d, int dep) {
T[d].depth = dep;
int i;
for (i = 0; i < T[d].num; i++) {
depth(T[d].child[i], dep + 1);
}
}
void print(int q) {
i... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 552 | 2 |
#include <stdio.h>
#define N 100001
int rec(int, int);
void print(int);
struct Node {
int p;
int l;
int r;
};
struct Node T[N];
int n, D[N];
int main() {
int i, k, m, j, o, l, r;
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", &k, &m)... | #include <stdio.h>
#define N 100001
int rec(int, int);
void print(int);
struct Node {
int p;
int l;
int r;
};
struct Node T[N];
int n, D[N];
int main() {
int i, k, m, j, o, l, r;
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", &k, &m)... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 501 | 2 |
#include <stdio.h>
#define N 1000001
#define null -1
struct Node {
int parent;
int l;
int r;
};
struct Node S[N];
int count = 0;
int depth(int nodeid) {
if (S[nodeid].parent == null)
return count;
else {
count++;
return depth(S[nodeid].parent);
}
}
void degree(int nodeid) {
if (nodeid != ... | #include <stdio.h>
#define N 1000001
#define null -1
struct Node {
int parent;
int l;
int r;
};
struct Node S[N];
int count = 0;
int depth(int nodeid) {
if (S[nodeid].parent == null)
return count;
else {
count++;
return depth(S[nodeid].parent);
}
}
void degree(int nodeid) {
if (nodeid != ... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 409 | 2 |
#include <stdio.h>
#include <stdlib.h>
#define MAX 100001
typedef struct node {
int p;
int l;
int r;
} Tree;
int main() {
int n, i, j, id, k, c, r = 0, p, d;
Tree T[MAX];
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = -1;
T[i].l = -1;
T[i].r = -1;
}
for (i = 0; i < n; i++) {
... | #include <stdio.h>
#include <stdlib.h>
#define MAX 100001
typedef struct node {
int p;
int l;
int r;
} Tree;
int main() {
int n, i, j, id, k, c, r = 0, p, d;
Tree T[MAX];
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = -1;
T[i].l = -1;
T[i].r = -1;
}
for (i = 0; i < n; i++) {
... | [["-", 0, 1, 0, 11, 12, 118, 28, 69, 71, 22], ["+", 0, 1, 0, 11, 12, 118, 28, 69, 71, 22]] | 0 | 392 | 2 |
#include <stdio.h>
#define NIL -1
#define N 100005
struct Node {
int p, l, r;
};
struct Node T[N];
int depth(int);
void child(int);
int main() {
int id, k, c, m;
int i, j;
int n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
for (i = 0; i < n; i+... | #include <stdio.h>
#define NIL -1
#define N 100005
struct Node {
int p, l, r;
};
struct Node T[N];
int depth(int);
void child(int);
int main() {
int id, k, c, m;
int i, j;
int n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
for (i = 0; i < n; i++... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 412 | 2 |
#include <stdio.h>
#define MAX 100000
#define NIL -1
void print(int);
int rec(int, int);
struct Node {
int parent, left, right;
};
struct Node Nodedata[MAX];
int n; /*ノード総数*/
int D[MAX];
int main() {
int i, j, d, v, c, l, r, sumnode;
l = 0;
scanf("%d", &n);
sumnode = n;
for (i = 0; i < n; i++) {
... | #include <stdio.h>
#define MAX 100000
#define NIL -1
void print(int);
int rec(int, int);
struct Node {
int parent, left, right;
};
struct Node Nodedata[MAX];
int n; /*ノード総数*/
int D[MAX];
int main() {
int i, j, d, v, c, l, r, sumnode;
l = 0;
scanf("%d", &n);
sumnode = n;
for (i = 0; i < n; i++) {
... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 541 | 2 |
#include <stdio.h>
#define N 100000
#define node0 -1
int depth(int);
int degree(int);
typedef struct {
int p, r, l;
} Node;
Node T[N];
int main() {
int i, n, k, id, j, c, keep;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = node0;
T[i].r = node0;
T[i].l = node0;
}
for (i = 0; i < n; i++) {... | #include <stdio.h>
#define N 100000
#define node0 -1
int depth(int);
int degree(int);
typedef struct {
int p, r, l;
} Node;
Node T[N];
int main() {
int i, n, k, id, j, c, keep;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = node0;
T[i].r = node0;
T[i].l = node0;
}
for (i = 0; i < n; i++) {... | [["-", 75, 76, 0, 57, 15, 23, 0, 11, 17, 32], ["+", 75, 76, 0, 57, 15, 23, 0, 16, 17, 60], ["-", 8, 9, 0, 57, 15, 23, 0, 11, 17, 32], ["+", 8, 9, 0, 57, 15, 23, 0, 16, 17, 60]] | 0 | 430 | 4 |
#include <stdio.h>
void print(int);
int rec(int, int);
#define Max 100000
#define NIL -1
int A[Max];
struct Node {
int p;
int l;
int r;
};
struct Node T[Max];
int n;
int main() {
int child, h, i, v, e, depth, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL;
for (i = 0;... | #include <stdio.h>
void print(int);
int rec(int, int);
#define Max 100000
#define NIL -1
int A[Max];
struct Node {
int p;
int l;
int r;
};
struct Node T[Max];
int n;
int main() {
int child, h, i, v, e, depth, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].p = T[i].l = T[i].r = NIL;
for (i = 0;... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 495 | 10 |
#include <stdio.h>
#include <stdlib.h>
#define N 100000
#define NIL -1
int getDepth(int);
void print(int);
int rec(int, int);
struct Node {
int p, l, r;
};
struct Node T[N];
int D[N];
int main() {
int i, j, v, d, c, l, r, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = NIL;
... | #include <stdio.h>
#include <stdlib.h>
#define N 100000
#define NIL -1
int getDepth(int);
void print(int);
int rec(int, int);
struct Node {
int p, l, r;
};
struct Node T[N];
int D[N];
int main() {
int i, j, v, d, c, l, r, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = NIL;
}... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 547 | 8 |
#include <stdio.h>
#define Max 100000
#define NIL -1
int rec(int, int);
void print(int);
struct node {
int p, l, r;
};
struct node T[Max];
int n, D[Max];
int main() {
int i, j, v, c, l, r, d;
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... | #include <stdio.h>
#define Max 100000
#define NIL -1
int rec(int, int);
void print(int);
struct node {
int p, l, r;
};
struct node T[Max];
int n, D[Max];
int main() {
int i, j, v, c, l, r, d;
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... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 494 | 6 |
#include <stdio.h>
#define N 100005
#define EMPTY -1
typedef struct {
int parent;
int left;
int rsib;
} Node;
int depth[N];
Node node[N];
int depthcount(int x, int d) {
depth[x] = d;
if (node[x].rsib != EMPTY)
depthcount(node[x].rsib, d);
if (node[x].left != EMPTY)
depthcount(node[x].left, d + 1)... | #include <stdio.h>
#define N 100005
#define EMPTY -1
typedef struct {
int parent;
int left;
int rsib;
} Node;
int depth[N];
Node node[N];
int depthcount(int x, int d) {
depth[x] = d;
if (node[x].rsib != EMPTY)
depthcount(node[x].rsib, d);
if (node[x].left != EMPTY)
depthcount(node[x].left, d + 1)... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 469 | 2 |
#include <stdio.h>
typedef struct node {
int parent;
int br;
int child;
} Node;
Node node[100001];
void nodegene(Node *);
// void putdepth( Node*);
int depth(int);
void nodegene(Node *nod) {
nod->child = -1;
nod->br = -1;
nod->parent = -1;
}
int depth(int k) {
int dep = 0;
for (dep = 0; node[k].... | #include <stdio.h>
typedef struct node {
int parent;
int br;
int child;
} Node;
Node node[100001];
void nodegene(Node *);
// void putdepth( Node*);
int depth(int);
void nodegene(Node *nod) {
nod->child = -1;
nod->br = -1;
nod->parent = -1;
}
int depth(int k) {
int dep = 0;
for (dep = 0; node[k].... | [["+", 8, 9, 0, 57, 75, 76, 0, 9, 0, 46], ["-", 8, 9, 0, 57, 75, 76, 0, 9, 0, 46]] | 0 | 474 | 2 |
#include <stdio.h>
#define Max 10000
#define Oya -1
// int setHeight(int);
void setDepth(int, int);
void print(int);
// int getSibling(int);
typedef struct {
int parent, left, right;
} Node;
Node T[Max];
int n, D[Max], H[Max];
void setDepth(int u, int d) {
D[u] = d;
if (T[u].right != Oya)
setDepth(T[u].r... | #include <stdio.h>
#define Max 1000000
#define Oya -1
void setDepth(int, int);
void print(int);
typedef struct {
int parent, left, right;
} Node;
Node T[Max];
int n, D[Max], H[Max];
void setDepth(int u, int d) {
D[u] = d;
if (T[u].right != Oya)
setDepth(T[u].right, d);
if (T[u].left != Oya)
setDept... | [["-", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["+", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 512 | 8 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct Node {
int p, l, r;
} Node;
Node T[MAX];
int depth(int);
void print_degree(int);
int main() {
int n, i, j, node, degree, child, sibling;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
... | #include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct Node {
int p, l, r;
} Node;
Node T[MAX];
int depth(int);
void print_degree(int);
int main() {
int n, i, j, node, degree, child, sibling;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
... | [["-", 0, 9, 0, 1, 0, 11, 31, 118, 119, 120], ["+", 0, 9, 0, 1, 0, 11, 31, 118, 119, 120]] | 0 | 414 | 2 |
#include <stdio.h>
#include <stdlib.h>
#define nil -1
typedef struct {
int p;
int l;
int r;
int depth;
} Node;
Node N[100000];
int depth[100000];
int CalcDepth(int, int);
int main() {
int i, j, n, id, key, degree, tmp, root;
scanf("%d", &n);
for (i = 0; i < n; i++)
N[i].p = N[i].l = N[i].r = nil... | #include <stdio.h>
#include <stdlib.h>
#define nil -1
typedef struct {
int p;
int l;
int r;
int depth;
} Node;
Node N[100000];
int depth[100000];
int CalcDepth(int, int);
int main() {
int i, j, n, id, key, degree, tmp, root;
scanf("%d", &n);
for (i = 0; i < n; i++)
N[i].p = N[i].l = N[i].r = nil... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 471 | 2 |
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//============================================================================
#define pred(x) ((x)-1)
#define succ(x) ((x) + 1)
//============================================================================
struct Node {
... | #include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//============================================================================
#define pred(x) ((x)-1)
#define succ(x) ((x) + 1)
//============================================================================
struct Node {
... | [["+", 0, 2, 3, 4, 0, 69, 28, 118, 17, 143], ["+", 0, 2, 3, 4, 0, 69, 28, 118, 119, 120], ["+", 0, 1, 0, 2, 3, 4, 0, 69, 0, 70], ["+", 0, 1, 0, 2, 3, 4, 0, 69, 71, 22], ["+", 0, 1, 0, 2, 3, 4, 0, 69, 0, 73]] | 0 | 1,180 | 5 |
#include <stdio.h>
#define NIL -1
typedef struct {
int p;
int l;
int r;
} Node;
Node T[100005];
int n, D[100005];
void print(int u) {
int i, c;
printf("node %d: parent = %d, depth = %d, ", u, T[u].p, D[u]);
if (T[u].p == NIL)
printf("root, ");
else if (T[u].l == 0)
printf("leaf, ");
else
p... | #include <stdio.h>
#define NIL -1
typedef struct {
int p;
int l;
int r;
} Node;
Node T[100005];
int n, D[100005];
void print(int u) {
int i, c;
printf("node %d: parent = %d, depth = %d, ", u, T[u].p, D[u]);
if (T[u].p == NIL)
printf("root, ");
else if (T[u].l == NIL)
printf("leaf, ");
else
... | [["-", 75, 76, 0, 57, 15, 23, 0, 16, 12, 13], ["+", 75, 76, 0, 57, 15, 23, 0, 16, 12, 22], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 476 | 4 |
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int left;
int right;
} Node;
int main() {
int n, id, k, depth, a, i, j, b, c;
Node *T;
scanf("%d", &n);
T = malloc(sizeof(Node) * n);
for (i = 0; i < n; i++) {
T[i].parent = -1;
T[i].left = -1;
T[i].right = -1;
}
f... | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int left;
int right;
} Node;
int main() {
int n, id, k, depth, a, i, j, b, c;
Node *T;
scanf("%d", &n);
T = malloc(sizeof(Node) * n);
for (i = 0; i < n; i++) {
T[i].parent = -1;
T[i].left = -1;
T[i].right = -1;
}
f... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 57, 64, 1, 0, 2, 3, 4, 0, 21], ["-", 0, 57, 64, 1, 0, 2, 3, 4, 0, 22]] | 0 | 390 | 4 |
#include <stdio.h>
#define N 100000
#define NIL -1
int depth(int);
void degree(int);
struct Node {
int parent;
int left;
int right;
};
struct Node T[N];
int count = 0;
int main() {
int n, i, j, id, k, child, tmp;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].parent = T[i].left = T[i].right = NIL... | #include <stdio.h>
#define N 100000
#define NIL -1
int depth(int);
void degree(int);
struct Node {
int parent;
int left;
int right;
};
struct Node T[N];
int count = 0;
int main() {
int n, i, j, id, k, child, tmp;
scanf("%d", &n);
for (i = 0; i < n; i++)
T[i].parent = T[i].left = T[i].right = NIL... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 404 | 6 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct {
int parent;
int right;
int left;
} _T;
_T T[MAX];
void print(int u) {
int i = T[u].parent, depth = 0;
while (i != NIL) {
i = T[i].parent;
depth++;
}
if (depth == 0) {
printf("node %d: parent = %d, depth = %d, root, ", u, ... | #include <stdio.h>
#define MAX 100005
#define NIL -1
typedef struct {
int parent;
int right;
int left;
} _T;
_T T[MAX];
void print(int u) {
int i = T[u].parent, depth = 0;
while (i != NIL) {
i = T[i].parent;
depth++;
}
if (depth == 0) {
printf("node %d: parent = %d, depth = %d, root, ", u, ... | [["-", 0, 14, 8, 9, 0, 1, 0, 2, 63, 22], ["-", 8, 9, 0, 1, 0, 2, 3, 4, 0, 24], ["-", 8, 9, 0, 1, 0, 2, 3, 4, 0, 13], ["-", 8, 9, 0, 1, 0, 2, 3, 4, 0, 25], ["-", 0, 30, 0, 14, 8, 9, 0, 1, 0, 35]] | 0 | 424 | 5 |
#include <stdio.h>
#include <string.h>
#define N 100000
struct Node {
int parent;
int left;
int right;
};
int main() {
int n, j, p, i, d, s, t, a, id, k;
scanf("%d", &n);
struct Node T[n];
for (i = 0; i < n; i++) {
T[i].right = T[i].left = T[i].parent = -1;
}
for (i = 0; i < n; i++) {
s... | #include <stdio.h>
#include <string.h>
#define N 100000
struct Node {
int parent;
int left;
int right;
};
int main() {
int n, j, p, i, d, s, t, a, id, k;
scanf("%d", &n);
struct Node T[n];
for (i = 0; i < n; i++) {
T[i].right = T[i].left = T[i].parent = -1;
}
for (i = 0; i < n; i++) {
s... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 508 | 2 |
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int left;
int right;
} tree;
tree *TREE;
int N;
#define fr -1
void JUDGE(int);
int main() {
int id, l, child, i, j, degree;
scanf("%d", &N);
TREE = (tree *)malloc(sizeof(tree) * N);
for (i = 0; i < N; i++) {
TREE[i].parent = f... | #include <stdio.h>
#include <stdlib.h>
typedef struct {
int parent;
int left;
int right;
} tree;
tree *TREE;
int N;
#define fr -1
void JUDGE(int);
int main() {
int id, l, child, i, j, degree;
scanf("%d", &N);
TREE = (tree *)malloc(sizeof(tree) * N);
for (i = 0; i < N; i++) {
TREE[i].parent = f... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 409 | 2 |
#include <stdio.h>
#define Max 100005
#define None -1
typedef struct {
int parent, left, right;
} Node;
Node Tree[Max];
int n, Depth[Max];
void print_out(int);
int dep(int, int);
int main() {
int i, j, d, v, c, r;
int l = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = None;
Tree[i].le... | #include <stdio.h>
#define Max 100005
#define None -1
typedef struct {
int parent, left, right;
} Node;
Node Tree[Max];
int n, Depth[Max];
void print_out(int);
int dep(int, int);
int main() {
int i, j, d, v, c, r;
int l = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
Tree[i].parent = None;
Tree[i].lef... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 501 | 8 |
#include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n;
int H, D[MAX];
int getDepth(int);
void print(int);
int main() {
int i, j;
int d, v;
int c, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL... | #include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n;
int H, D[MAX];
int getDepth(int);
void print(int);
int main() {
int i, j;
int d, v;
int c, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL... | [["-", 8, 9, 0, 57, 15, 23, 0, 16, 17, 60], ["-", 8, 9, 0, 57, 15, 23, 0, 16, 12, 13]] | 0 | 499 | 2 |
#include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n;
int H, D[MAX];
int getDepth(int);
void print(int);
int main() {
int i, j;
int d, v;
int c, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL... | #include <stdio.h>
#define MAX 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[MAX];
int n;
int H, D[MAX];
int getDepth(int);
void print(int);
int main() {
int i, j;
int d, v;
int c, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 497 | 2 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
void print(int);
int rec(int, int);
typedef struct {
int p;
int l;
int r;
} Node;
Node T[MAX];
int n, D[MAX];
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}... | #include <stdio.h>
#define MAX 100005
#define NIL -1
void print(int);
int rec(int, int);
typedef struct {
int p;
int l;
int r;
} Node;
Node T[MAX];
int n, D[MAX];
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 509 | 2 |
#include <stdio.h>
#define MAX 100000
#define N -1
struct Node {
int p;
int l;
int r;
};
struct Node T[MAX];
int n, D[MAX];
void print(int x) {
int i, c;
printf("node %d: ", x);
printf("parent = %d, ", T[x].p);
printf("depth = %d, ", D[x]);
if (T[x].p == N)
printf("root, ");
else if (T[x].l == N)... | #include <stdio.h>
#define MAX 100000
#define N -1
struct Node {
int p;
int l;
int r;
};
struct Node T[MAX];
int n, D[MAX];
void print(int x) {
int i, c;
printf("node %d: ", x);
printf("parent = %d, ", T[x].p);
printf("depth = %d, ", D[x]);
if (T[x].p == N)
printf("root, ");
else if (T[x].l == N)... | [["-", 8, 9, 0, 57, 64, 1, 0, 11, 12, 13], ["+", 8, 9, 0, 57, 64, 1, 0, 11, 12, 22]] | 0 | 484 | 2 |
#include <stdio.h>
#define NIL -1
typedef struct {
int parent, left, right;
} node;
void getdepth(int, int);
void printchildren(int);
node T[100000];
int D[100000];
int main() {
int i, j, d, v, c, l, r, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = D[i] = NIL;
... | #include <stdio.h>
#define NIL -1
typedef struct {
int parent, left, right;
} node;
void getdepth(int, int);
void printchildren(int);
node T[100000];
int D[100000];
int main() {
int i, j, d, v, c, l, r, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].parent = T[i].left = T[i].right = D[i] = NIL;
... | [["+", 64, 1, 0, 2, 3, 4, 0, 16, 17, 72], ["+", 64, 1, 0, 2, 3, 4, 0, 16, 12, 13]] | 0 | 502 | 2 |
#include <stdio.h>
#define N 100000
struct Node {
int p;
int l;
int r;
};
struct Node A[N];
int n, B[N];
int rec(int x, int y) {
B[x] = y;
if (A[x].r != -1)
rec(A[x].r, y);
if (A[x].l != -1)
rec(A[x].l, y + 1);
}
int main() {
int i, j, d, v, c, l, r, n, op;
scanf("%d", &n);
for (i = 0; i ... | #include <stdio.h>
#define N 100000
struct Node {
int p;
int l;
int r;
};
struct Node A[N];
int n, B[N];
int rec(int x, int y) {
B[x] = y;
if (A[x].r != -1)
rec(A[x].r, y);
if (A[x].l != -1)
rec(A[x].l, y + 1);
}
int main() {
int i, j, d, v, c, l, r, n, op;
scanf("%d", &n);
for (i = 0; i ... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 455 | 2 |
#include <stdio.h>
#define N 100005
typedef struct {
int p;
int l;
int r;
} Node;
Node T[N];
int n, D[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, d, v, c, l, r, k;
scanf("%d", &n);
for (i = 0; i < ... | #include <stdio.h>
#define N 100005
typedef struct {
int p;
int l;
int r;
} Node;
Node T[N];
int n, D[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, d, v, c, l, r, k;
scanf("%d", &n);
for (i = 0; i < ... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 476 | 2 |
#include <stdio.h>
#define MAX 100005
#define OUT -1
struct Node {
int p;
int l;
int r;
};
void depth(int, int);
void print(int);
// using namespace std;
struct Node T[MAX];
int n, A[MAX];
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].r = OUT;
T[i].l = T[i]... | #include <stdio.h>
#define MAX 100005
#define OUT -1
struct Node {
int p;
int l;
int r;
};
void depth(int, int);
void print(int);
// using namespace std;
struct Node T[MAX];
int n, A[MAX];
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].r = OUT;
T[i].l = T[i]... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 543 | 2 |
#include <stdio.h>
#define N 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[N];
int Depth(int);
void Print(int);
int n;
int main() {
int i, j, d, v, c, l, a;
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,... | #include <stdio.h>
#define N 100000
#define NIL -1
struct Node {
int p, l, r;
};
struct Node T[N];
int Depth(int);
void Print(int);
int n;
int main() {
int i, j, d, v, c, l, a;
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,... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 44]] | 0 | 437 | 3 |
#include <stdio.h>
#define NIL -1
#define MAX 100005
struct Node {
int p;
int l;
int r;
};
struct Node T[MAX];
int n, D[MAX];
int rec(int, int);
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
for (i = 0; i < n; i... | #include <stdio.h>
#define NIL -1
#define MAX 100005
struct Node {
int p;
int l;
int r;
};
struct Node T[MAX];
int n, D[MAX];
int rec(int, int);
int main() {
int i, j, d, v, c, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = NIL;
T[i].l = NIL;
T[i].r = NIL;
}
for (i = 0; i < n; i... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 464 | 2 |
#include <stdio.h>
#define MAX 100000
#define NOT -1
struct Node {
int pa, le, ri;
};
struct Node T[MAX];
int D[MAX];
int j, c;
// depth
int recDepth(int u, int p) {
D[u] = p;
if (T[u].ri != NOT)
recDepth(T[u].ri, p);
if (T[u].le != NOT)
recDepth(T[u].le, p + 1);
}
// print
void print(int u) {
printf(... | #include <stdio.h>
#define MAX 100000
#define NOT -1
struct Node {
int pa, le, ri;
};
struct Node T[MAX];
int D[MAX];
int j, c;
// depth
int recDepth(int u, int p) {
D[u] = p;
if (T[u].ri != NOT)
recDepth(T[u].ri, p);
if (T[u].le != NOT)
recDepth(T[u].le, p + 1);
}
// print
void print(int u) {
printf(... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 475 | 4 |
#include <stdio.h>
#define MAX 100005
#define NULL -1
typedef struct {
int p, l, r; //????????????????????????
} Node;
Node T[MAX];
int depth;
void Depth(int i) {
if (T[i].p != -1) {
depth++;
Depth(T[i].p);
}
}
void typenode(int i) {
if (T[i].p == -1)
printf("root, [");
else if (T[i].l == -1)
... | #include <stdio.h>
#define MAX 100005
#define NULL -1
typedef struct {
int p, l, r; //????????????????????????
} Node;
Node T[MAX];
int depth;
void Depth(int i) {
if (T[i].p != -1) {
depth++;
Depth(T[i].p);
}
}
void typenode(int i) {
if (T[i].p == -1)
printf("root, [");
else if (T[i].l == -1)
... | [["-", 0, 1, 0, 11, 31, 118, 28, 69, 71, 22], ["+", 0, 1, 0, 11, 31, 118, 28, 69, 71, 22]] | 0 | 434 | 2 |
package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
)
type point struct {
x float64
y float64
}
var th = 3.14 * 60.0 / 180.0
func hoge(l point, r point, x int) {
if x == 0 {
fmt.Printf("%f %f\n", l.x, l.y)
} else {
p1 := point{
x: (2.0*l.x + 1.0*r.x) / 3.0,
y: (2.0*l.y + 1.0*r.y) / 3.0,
}... | package main
import (
"bufio"
"fmt"
"math"
"os"
"strconv"
)
type point struct {
x float64
y float64
}
var th = math.Pi * 60.0 / 180.0
func hoge(l point, r point, x int) {
if x == 0 {
fmt.Printf("%f %f\n", l.x, l.y)
} else {
p1 := point{
x: (2.0*l.x + 1.0*r.x) / 3.0,
y: (2.0*l.y + 1.0*r.y) / 3.0,
... | [["-", 0, 441, 51, 432, 0, 16, 31, 16, 31, 445], ["+", 51, 432, 0, 16, 31, 16, 31, 438, 439, 22], ["+", 51, 432, 0, 16, 31, 16, 31, 438, 0, 131], ["+", 51, 432, 0, 16, 31, 16, 31, 438, 119, 120]] | 7 | 418 | 4 |
package main
import (
"bytes"
"fmt"
"math"
)
const theta = math.Pi * 60.0 / 180.0
var memo bytes.Buffer
type point struct {
x float64
y float64
}
func solve() string {
var depth int
fmt.Scan(&depth)
var left, right point
left.x, left.y = 0, 0
right.x, right.y = 100, 0
memo.WriteString(fmt.Sprintf("%.8f ... | package main
import (
"bytes"
"fmt"
"math"
)
const theta = math.Pi * 60.0 / 180.0
var memo bytes.Buffer
type point struct {
x float64
y float64
}
func solve() string {
var depth int
fmt.Scan(&depth)
var left, right point
left.x, left.y = 0, 0
right.x, right.y = 100, 0
memo.WriteString(fmt.Sprintf("%.8f ... | [["-", 8, 196, 0, 1, 0, 2, 3, 4, 0, 22], ["+", 8, 196, 0, 1, 0, 2, 3, 4, 0, 22]] | 7 | 484 | 4 |
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
class FS {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
retur... | import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
class FS {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return... | [["-", 0, 235, 8, 498, 0, 124, 39, 506, 0, 507], ["+", 0, 235, 8, 498, 0, 124, 39, 506, 0, 96], ["-", 8, 196, 0, 57, 15, 15, 0, 16, 17, 18], ["+", 8, 196, 0, 57, 15, 15, 0, 16, 17, 19]] | 3 | 799 | 4 |
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
// Scanner scan = new Scanner(new
// File("D:\\UserArea\\J0124567\\Downloads\\ALDS1_5_D-in19.txt"));
// w... | import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
// Scanner scan = new Scanner(new
// File("D:\\UserArea\\J0124567\\Downloads\\ALDS1_5_D-in19.txt"));
// w... | [["+", 0, 1, 0, 11, 12, 23, 0, 16, 17, 33], ["+", 0, 1, 0, 11, 12, 23, 0, 16, 12, 22]] | 3 | 421 | 2 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
private int count;
private int[] a;
public static void main(String[] args) { new Main(); }
public Main() {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
... | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
private long count;
private int[] a;
public static void main(String[] args) { new Main(); }
public Main() {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {... | [["-", 0, 235, 8, 498, 0, 124, 39, 506, 0, 507], ["+", 0, 235, 8, 498, 0, 124, 39, 506, 0, 96], ["-", 0, 1, 0, 11, 12, 16, 31, 16, 12, 22], ["+", 0, 1, 0, 11, 12, 16, 31, 16, 12, 22]] | 3 | 480 | 4 |
#include <stdio.h>
#define MAX 200000
#define SE 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
long v1, v2, v3;
long merge(int *A, int n, int left, int right, int mid) {
int i, j, k = 0;
long cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = ... | #include <stdio.h>
#define MAX 200000
#define SE 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
long v1, v2, v3;
long merge(int *A, int n, int left, int right, int mid) {
int i, j, k = 0;
long cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left + i];
for (i = ... | [["-", 0, 14, 49, 53, 54, 55, 0, 56, 49, 22], ["+", 0, 14, 49, 53, 54, 55, 0, 56, 49, 22]] | 0 | 399 | 4 |
#include <stdio.h>
#define MAX 200000
#define SENTINEL 20000000000
long long merge(int, int, int);
long long mergeSort(int, int);
int A[MAX];
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int main() {
int n, i;
long long result;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
result = mergeSort(... | #include <stdio.h>
#define MAX 200000
#define SENTINEL 2000000000
long long merge(int, int, int);
long long mergeSort(int, int);
int A[MAX];
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int main() {
int n, i;
long long result;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
result = mergeSort(0... | [["-", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["+", 36, 36, 36, 36, 0, 30, 0, 58, 51, 59], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 391 | 4 |
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
/*
int bubbleSort(int A[], int n) {
int i, j, t, s;
int cnt = 0; // 反転数
for(i=0;i<n-1;i++) {
for(j=n-1,s=i+1;j>=s;j--) {
if(A[j] < A[j-1]) {
t = A[j];
A[j] = A[j-1];
A[j-1] = A[j];... | #include <memory.h>
#include <stdio.h>
#include <stdlib.h>
/*
int bubbleSort(int A[], int n) {
int i, j, t, s;
int cnt = 0; // 反転数
for(i=0;i<n-1;i++) {
for(j=n-1,s=i+1;j>=s;j--) {
if(A[j] < A[j-1]) {
t = A[j];
A[j] = A[j-1];
A[j-1] = A[j];... | [["+", 36, 36, 0, 30, 0, 43, 39, 86, 0, 96], ["+", 0, 14, 8, 9, 0, 43, 39, 86, 0, 96], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 316 | 6 |
#include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
typedef long long llong;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
llong merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
llong cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L... | #include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
typedef long long llong;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
llong merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
llong cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L... | [["-", 15, 339, 51, 16, 12, 69, 341, 342, 0, 22], ["+", 15, 339, 51, 16, 12, 69, 341, 342, 0, 22]] | 1 | 381 | 2 |
#include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
long long merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
long long cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left +... | #include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
long long merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
long long cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[left +... | [["-", 0, 11, 12, 69, 341, 342, 0, 16, 12, 13], ["+", 0, 11, 12, 69, 341, 342, 0, 16, 12, 22], ["-", 0, 14, 8, 9, 0, 7, 10, 43, 39, 40]] | 1 | 383 | 3 |
#include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
typedef long long llong;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
llong merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
llong cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; ++i... | #include <iostream>
using namespace std;
#define MAX 200000
#define SENTINEL 2000000000
typedef long long llong;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
llong merge(int A[], int n, int left, int mid, int right) {
int i, j, k;
llong cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; ++i... | [["-", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 7, 10, 43, 49, 50, 51, 22]] | 1 | 385 | 2 |
#include <algorithm>
#include <iostream>
using namespace std;
int n, a[200000], b[200000], bit[262145];
void add(int i, int x) {
while (i <= n)
bit[i] += x, i += i & -i;
}
int sum(int i) {
int ret = 0;
while (i > 0)
ret += bit[i], i -= i & -i;
return ret;
}
int main() {
scanf("%d", &n);
for (int i =... | #include <algorithm>
#include <iostream>
using namespace std;
int n, a[200000], b[200000], bit[262145];
void add(int i, int x) {
while (i <= n)
bit[i] += x, i += i & -i;
}
int sum(int i) {
int ret = 0;
while (i > 0)
ret += bit[i], i -= i & -i;
return ret;
}
int main() {
scanf("%d", &n);
for (int i =... | [["+", 0, 1, 0, 2, 3, 4, 0, 16, 17, 72], ["+", 0, 1, 0, 2, 3, 4, 0, 16, 12, 22]] | 1 | 229 | 2 |
#include <stdio.h>
#define NIL -1
typedef struct {
int id;
int l;
int r;
int p;
} Tree;
Tree tree[30];
int max = 0;
int H[30];
void init(int n) {
for (int i = 0; i < n; ++i) {
tree[i].id = NIL;
tree[i].l = NIL;
tree[i].r = NIL;
tree[i].p = NIL;
}
}
void print_sibling(int i) {
printf("sib... | #include <stdio.h>
#define NIL -1
typedef struct {
int id;
int l;
int r;
int p;
} Tree;
Tree tree[30];
int max = 0;
int H[30];
void init(int n) {
for (int i = 0; i < n; ++i) {
tree[i].id = NIL;
tree[i].l = NIL;
tree[i].r = NIL;
tree[i].p = NIL;
}
}
void print_sibling(int i) {
printf("sib... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 0 | 728 | 2 |
#include <stdio.h>
#define MAX 100005
#define NIL -1
int n;
struct Node {
int p; // parent
int l; // left-child
int r; // right sibiling
};
struct Node T[MAX];
int depth(int u) {
int d = 0;
int tmp = T[u].p;
while (tmp != NIL) {
d++;
tmp = T[tmp].p;
}
return d;
}
int height(int u) {
int l = NI... | #include <stdio.h>
#define MAX 100005
#define NIL -1
int n;
struct Node {
int p; // parent
int l; // left-child
int r; // right sibiling
};
struct Node T[MAX];
int depth(int u) {
int d = 0;
int tmp = T[u].p;
while (tmp != NIL) {
d++;
tmp = T[tmp].p;
}
return d;
}
int height(int u) {
int l = NI... | [["-", 0, 14, 8, 9, 0, 57, 64, 9, 0, 45], ["-", 0, 14, 8, 9, 0, 57, 64, 9, 0, 46], ["-", 75, 76, 0, 57, 15, 23, 0, 16, 17, 98], ["+", 75, 76, 0, 57, 15, 23, 0, 16, 17, 106], ["-", 15, 23, 0, 16, 12, 16, 31, 118, 119, 120], ["+", 15, 23, 0, 16, 12, 16, 31, 118, 119, 120]] | 0 | 525 | 6 |
#include <stdio.h>
#define MAX 100000
#define NIL -1
struct Type {
int p, l, r;
};
struct Type A[MAX];
int n, D[MAX];
int getDegree(int u) {
if (A[u].l != NIL && A[u].r != NIL)
return 2;
else if (A[u].l == NIL && A[u].r == NIL)
return 0;
else
return 1;
}
int getDepth(int u) {
int d = 0;
whi... | #include <stdio.h>
#define MAX 100000
#define NIL -1
struct Type {
int p, l, r;
};
struct Type A[MAX];
int n, D[MAX];
int getDegree(int u) {
if (A[u].l != NIL && A[u].r != NIL)
return 2;
else if (A[u].l == NIL && A[u].r == NIL)
return 0;
else
return 1;
}
int getDepth(int u) {
int d = 0;
whi... | [["-", 8, 9, 0, 1, 0, 11, 31, 118, 119, 120], ["+", 8, 9, 0, 1, 0, 11, 31, 118, 119, 120]] | 0 | 633 | 2 |
#include <stdio.h>
#define NIL -1
typedef struct {
int parent, sibling, leftgaki, rightgaki, degree;
} Node;
Node tree[100001];
int count = 0, count3 = 0; //再帰関数、子供表示用
int count2[100001];
int n;
int retdepth(int id) { //再帰で根っこまでの長さを計る
if (tree[id].parent == NIL) {
return count;
} else {
count++;
ret... | #include <stdio.h>
#define NIL -1
typedef struct {
int parent, sibling, leftgaki, rightgaki, degree;
} Node;
Node tree[100001];
int count = 0, count3 = 0; //再帰関数、子供表示用
int count2[100001];
int n;
int retdepth(int id) { //再帰で根っこまでの長さを計る
if (tree[id].parent == NIL) {
return count / 2;
} else {
count++;
... | [["+", 0, 57, 64, 9, 0, 37, 0, 16, 17, 85], ["+", 0, 57, 64, 9, 0, 37, 0, 16, 12, 13]] | 0 | 732 | 2 |
#include <stdio.h>
typedef struct { /*parent,left child ,right sibling*/
int p, l, r;
} node;
int degree(int);
int height(int);
int depth(int);
int sibling(int);
void Print(int);
node T[100000];
int main() {
int n, i, id, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = -1;
}
... | #include <stdio.h>
typedef struct { /*parent,left child ,right sibling*/
int p, l, r;
} node;
int degree(int);
int height(int);
int depth(int);
int sibling(int);
void Print(int);
node T[100000];
int main() {
int n, i, id, l, r;
scanf("%d", &n);
for (i = 0; i < n; i++) {
T[i].p = T[i].l = T[i].r = -1;
}
... | [["-", 0, 14, 8, 9, 0, 57, 75, 76, 0, 95], ["-", 0, 2, 3, 4, 0, 61, 0, 5, 0, 6], ["+", 0, 2, 3, 4, 0, 61, 0, 5, 0, 6]] | 0 | 556 | 3 |
#include <stdio.h>
#define N 100001
typedef struct {
int parent;
int left;
int right;
int sibling;
} Node;
Node T[N];
int depth[N];
int heightcheck(Node T[], int i) {
int height = 0;
int left, right;
if (T[i].left == -1 && T[i].right == -1)
return height;
else if (i == -1)
return height;
... | #include <stdio.h>
#define N 100001
typedef struct {
int parent;
int left;
int right;
int sibling;
} Node;
Node T[N];
int depth[N];
int heightcheck(Node T[], int i) {
int height = 0;
int left, right;
if (T[i].left == -1 && T[i].right == -1)
return height;
else if (i == -1)
return height;
... | [["+", 75, 76, 0, 57, 75, 76, 0, 9, 0, 45], ["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 44], ["+", 75, 76, 0, 57, 75, 76, 0, 9, 0, 46]] | 0 | 634 | 3 |
#include <bits/stdc++.h>
using namespace std;
#define N 10000
#define NIL -1
typedef struct {
int p, r, l;
} Node;
Node T[N];
int n, D[N], H[N];
void scan(void) {
int i, u, right, left;
cin >> n;
for (i = 0; i < n; i++)
T[i].p = T[i].r = T[i].l = NIL;
for (i = 0; i < n; i++) {
cin >> u >> right ... | #include <bits/stdc++.h>
using namespace std;
#define N 10000
#define NIL -1
typedef struct {
int p, r, l;
} Node;
Node T[N];
int n, D[N], H[N];
void scan(void) {
int i, u, right, left;
cin >> n;
for (i = 0; i < n; i++)
T[i].p = T[i].r = T[i].l = NIL;
for (i = 0; i < n; i++) {
cin >> u >> right ... | [["-", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 64, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 1 | 664 | 2 |
#include "bits/stdc++.h"
using namespace std;
struct Node {
int parent, left, right;
};
Node T[100005];
int n, D[1000005], hei[1000005];
void setDepth(int u, int p) {
if (u == -1)
return;
D[u] = p;
setDepth(T[u].left, p + 1);
setDepth(T[u].right, p + 1);
}
int setHeight(int u) {
int h = 0, hh = 0;
i... | #include "bits/stdc++.h"
using namespace std;
struct Node {
int parent, left, right;
};
Node T[100005];
int n, D[1000005], hei[1000005];
void setDepth(int u, int p) {
if (u == -1)
return;
D[u] = p;
setDepth(T[u].left, p + 1);
setDepth(T[u].right, p + 1);
}
int setHeight(int u) {
int h = 0, hh = 0;
i... | [["+", 0, 57, 15, 339, 51, 16, 12, 16, 17, 60], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 12, 13]] | 1 | 656 | 2 |
#include <stdio.h>
#define MAX 10000
#define NIL -1
struct Node {
int p, left, right;
};
Node T[MAX];
int n, dep[MAX], h[MAX];
void Depth(int a, int da) {
if (a == NIL) {
return;
}
dep[a] = da;
Depth(T[a].left, da + 1);
Depth(T[a].right, da + 1);
}
int Height(int a) {
int ha1 = 0, ha2 = 0;
if (T... | #include <stdio.h>
#define MAX 10000
#define NIL -1
struct Node {
int p, left, right;
};
Node T[MAX];
int n, dep[MAX], h[MAX];
void Depth(int a, int da) {
if (a == NIL) {
return;
}
dep[a] = da;
Depth(T[a].left, da + 1);
Depth(T[a].right, da + 1);
}
int Height(int a) {
int ha1 = 0, ha2 = 0;
if (T... | [["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]] | 1 | 679 | 2 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 100000
#define NIL -1
struct Node {
int parent, left, right;
};
struct Node T[MAX];
int n, D[MAX], H[MAX];
void setDepth(int, int);
int setHeight(int);
int getSibling(int);
void print(int);
int main() {
int i, v, l, r, root = 0;
cin >> n;
for (i = 0... | #include <bits/stdc++.h>
using namespace std;
#define MAX 100000
#define NIL -1
struct Node {
int parent, left, right;
};
struct Node T[MAX];
int n, D[MAX], H[MAX];
void setDepth(int, int);
int setHeight(int);
int getSibling(int);
void print(int);
int main() {
int i, v, l, r, root = 0;
cin >> n;
for (i = 0... | [["-", 8, 9, 0, 1, 0, 16, 12, 5, 0, 6], ["+", 8, 9, 0, 1, 0, 16, 12, 5, 0, 6]] | 1 | 681 | 2 |
class Node
def initialize(node)
@node = node
@parent = nil
@children = []
@depth = 0
end
def who_am_i
if @parent == -1
'root'
elsif @children.empty?
'leaf'
else
'internal_node'
end
end
def to_s
"node #{node}: parent = #{parent}, depth = #{depth}, #{who_a... | class Node
def initialize(node)
@node = node
@parent = nil
@children = []
@depth = 0
end
def who_am_i
if @parent == -1
'root'
elsif @children.empty?
'leaf'
else
'internal node'
end
end
def to_s
"node #{node}: parent = #{parent}, depth = #{depth}, #{who_a... | [["-", 0, 121, 75, 759, 75, 95, 0, 557, 0, 6], ["+", 0, 121, 75, 759, 75, 95, 0, 557, 0, 6]] | 4 | 306 | 2 |
n = gets.to_i
# クラスってかこの程度なら構造体で充分なんだがな!!!!!!!!!!!!!!!!!!!!!!!!!!!
class Tree
attr_accessor :id, :parent, :depth, :tree_type, :childs
def initialize
@childs = []
@parent = -1
@depth = 0
end
end
trees = {}
# 数がわかっているので初期化
n.times do |i|
tree = Tree.new()
tree.id = i
trees[i] = tree
end
# 単にdept... | n = gets.to_i
# クラスってかこの程度なら構造体で充分なんだがな!!!!!!!!!!!!!!!!!!!!!!!!!!!
class Tree
attr_accessor :id, :parent, :depth, :tree_type, :childs
def initialize
@childs = []
@parent = -1
@depth = 0
end
end
trees = {}
# 数がわかっているので初期化
n.times do |i|
tree = Tree.new()
tree.id = i
trees[i] = tree
end
# 単にdept... | [["-", 8, 736, 0, 121, 15, 652, 486, 652, 735, 22], ["-", 196, 737, 8, 736, 0, 121, 15, 652, 17, 131], ["-", 196, 737, 8, 736, 0, 121, 15, 652, 735, 22], ["+", 8, 736, 0, 121, 15, 738, 31, 652, 735, 22], ["+", 196, 737, 8, 736, 0, 121, 15, 738, 17, 60], ["+", 8, 736, 0, 121, 15, 738, 12, 748, 17, 33], ["+", 8, 736, 0, ... | 4 | 322 | 7 |
# ALDS1_7_A: Rooted Trees
class Node
attr_accessor :id, :parent, :left_child, :r_sib
def initialize()
@id = -1
end
def depth
@parent.nil? ? 0 : 1 + @parent.depth
end
def parent_id
@parent.nil? ? -1 : @parent.id
end
def child_ids
child_ids = []
child = @left_child
until c... | # ALDS1_7_A: Rooted Trees
class Node
attr_accessor :id, :parent, :left_child, :r_sib
def initialize()
@id = -1
end
def depth
@parent.nil? ? 0 : 1 + @parent.depth
end
def parent_id
@parent.nil? ? -1 : @parent.id
end
def child_ids
child_ids = []
child = @left_child
until c... | [["-", 0, 750, 8, 170, 0, 662, 12, 652, 735, 22], ["+", 0, 750, 8, 170, 0, 662, 12, 652, 735, 22]] | 4 | 254 | 2 |
class Node
attr_accessor:id, :parent, :child_left, :right_sibling, :depth
def initialize(id)
@id = id
@parent = nil
@child_left = nil
@right_sibling = nil
@depth = 0
end
def depth
if @parent.nil?
0
else
@parent.depth + 1
end
end
def type
if @parent == nil
... | class Node
attr_accessor:id, :parent, :child_left, :right_sibling, :depth
def initialize(id)
@id = id
@parent = nil
@child_left = nil
@right_sibling = nil
@depth = 0
end
def depth
if @parent.nil?
0
else
@parent.depth + 1
end
end
def type
if @parent == nil
... | [["-", 0, 89, 8, 170, 0, 662, 12, 652, 486, 777], ["+", 0, 89, 8, 170, 0, 662, 12, 652, 486, 22]] | 4 | 422 | 2 |
lines = $stdin.read
array = lines.split("\n")
N = array[0].to_i
Node = Struct.new(:parent, :left, :right)
nodes = Array.new(N) { Node.new }
def get_depth(id, nodes)
d = 0
while ! nodes[id].parent.nil? do
id = nodes[id].parent
d += 1
end
d
end
def get_children(id, nodes)
children = []
c = nodes[i... | lines = $stdin.read
array = lines.split("\n")
N = array[0].to_i
Node = Struct.new(:parent, :left, :right)
nodes = Array.new(N) { Node.new }
def get_depth(id, nodes)
d = 0
while ! nodes[id].parent.nil? do
id = nodes[id].parent
d += 1
end
d
end
def get_children(id, nodes)
children = []
c = nodes[i... | [["-", 196, 737, 8, 736, 0, 662, 12, 652, 17, 131], ["-", 196, 737, 8, 736, 0, 662, 12, 652, 735, 22]] | 4 | 312 | 2 |
N = int(input())
def get_parent(node):
parent = -1
if "parent" in node:
parent = node["parent"]
return parent
def get_depth(node):
depth = 0
while "parent" not in node:
depth += 1
parent = node["parent"]
node = rooted_tree[parent]
return depth
def get_node_type... | N = int(input())
def get_parent(node):
parent = -1
if "parent" in node:
parent = node["parent"]
return parent
def get_depth(node):
depth = 0
while "parent" in node:
depth += 1
parent = node["parent"]
node = rooted_tree[parent]
return depth
def get_node_type(nod... | [["-", 0, 14, 8, 196, 0, 52, 15, 666, 667, 699], ["+", 0, 14, 8, 196, 0, 57, 15, 666, 667, 699], ["-", 36, 36, 36, 36, 0, 656, 0, 7, 31, 22], ["+", 36, 36, 36, 36, 0, 656, 0, 7, 31, 22], ["-", 8, 196, 0, 1, 0, 662, 31, 684, 0, 22], ["+", 8, 196, 0, 1, 0, 662, 31, 684, 0, 22]] | 5 | 378 | 7 |
# coding=utf-8
class Node():
# About Type
# parent = -1 ==> Root ==> 0
# child = [] ==> Leaf ==> 1
# others ==> Internal ==> 2
def __init__(self, id, parent, child):
self.id = id
self.parent = parent
self.child = child
def update(self):
self.depth = 0
bac... | # coding=utf-8
class Node():
# About Type
# parent = -1 ==> Root ==> 0
# child = [] ==> Leaf ==> 1
# others ==> Internal ==> 2
def __init__(self, id, parent, child):
self.id = id
self.parent = parent
self.child = child
def update(self):
self.depth = 0
bac... | [["-", 0, 652, 3, 4, 0, 657, 31, 557, 0, 6], ["+", 0, 652, 3, 4, 0, 657, 31, 557, 0, 6], ["-", 0, 652, 3, 4, 0, 653, 51, 557, 0, 6], ["+", 0, 652, 3, 4, 0, 653, 51, 557, 0, 6]] | 5 | 494 | 4 |
n = int(input())
child = {}
parent = {}
for i in range(n):
a = list(map(int, input().split()))
child[a[0]] = a[2:]
for i in child[a[0]]:
parent[i] = a[0]
root = (set(child)-set(parent)).pop()
depth = [None]*n
depth[root] = 0
parent[root] = -1
def dfs(s):
for i in child[s]:
d... | n = int(input())
child = {}
parent = {}
for i in range(n):
a = list(map(int, input().split()))
child[a[0]] = a[2:]
for i in child[a[0]]:
parent[i] = a[0]
root = (set(child)-set(parent)).pop()
depth = [None]*n
depth[root] = 0
parent[root] = -1
def dfs(s):
for i in child[s]:
d... | [["-", 0, 1, 0, 652, 3, 4, 0, 557, 0, 6], ["+", 0, 1, 0, 652, 3, 4, 0, 557, 0, 6]] | 5 | 217 | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.