ALDS1_7_A-RootedTree.
Description:
A graph G = (V, E) is a data structure where V is a finite set of vertices and E is a binary relation on V represented by a set of edges. Fig. 1 illustrates an example of a graph (or graphs).
A free tree is a connnected, acyclic, undirected graph. A rooted tree is a free tree in which one of the vertices is distinguished from the others. A vertex of a rooted tree is called "node."
Your task is to write a program which reports the following information for each node u of a given rooted tree T:
node ID of u
parent of u
depth of u
node type (root, internal node or leaf)
a list of chidlren of u
If the last edge on the path from the root r of a tree T to a node x is (p, x), then p is the parent of x, and x is a child of p. The root is the only node in T with no parent.
A node with no children is an external node or leaf. A nonleaf node is an internal node
The number of children of a node x in a rooted tree T is called the degree of x.
The length of the path from the root r to a node x is the depth of x in T.
Here, the given tree consists of n nodes and evey node has a unique ID from 0 to n-1.
Fig. 2 shows an example of rooted trees where ID of each node is indicated by a number in a circle (node). The example corresponds to the first sample input.
Input:
The first line of the input includes an integer n, the number of nodes of the tree.
In the next n lines, the information of each node u is given in the following format:
id k c1 c2 ... ck
where id is the node ID of u, k is the degree of u, c1 ... ck are node IDs of 1st, ... kth child of u. If the node does not have a child, the k is 0.
Output:
Print the information of each node in the following format ordered by IDs:
node id: parent = p , depth = d, type, [c1...ck]
p is ID of its parent. If the node does not have a parent, print -1.
d is depth of the node.
type is a type of nodes represented by a string (root, internal node or leaf). If the root can be considered as a leaf or an internal node, print root.
c1...ck is the list of children as a ordered tree.
Please follow the format presented in a sample output below.
Constraints:
≤ n ≤ 100000
SampleInput1:
13
0 3 1 4 10
1 2 2 3
2 0
3 0
4 3 5 6 7
5 0
6 0
7 2 8 9
8 0
9 0
10 2 11 12
11 0
12 0
SampleOutput1:
node 0: parent = -1, depth = 0, root, [1, 4, 10]
node 1: parent = 0, depth = 1, internal node, [2, 3]
node 2: parent = 1, depth = 2, leaf, []
node 3: parent = 1, depth = 2, leaf, []
node 4: parent = 0, depth = 1, internal node, [5, 6, 7]
node 5: parent = 4, depth = 2, leaf, []
node 6: parent = 4, depth = 2, leaf, []
node 7: parent = 4, depth = 2, internal node, [8, 9]
node 8: parent = 7, depth = 3, leaf, []
node 9: parent = 7, depth = 3, leaf, []
node 10: parent = 0, depth = 1, internal node, [11, 12]
node 11: parent = 10, depth = 2, leaf, []
node 12: parent = 10, depth = 2, leaf, []
SampleInput2:
4
1 3 3 2 0
0 0
3 0
2 0
SampleOutput2:
node 0: parent = 1, depth = 1, leaf, []
node 1: parent = -1, depth = 0, root, [3, 2, 0]
node 2: parent = 1, depth = 1, leaf, []
node 3: parent = 1, depth = 1, leaf, []
Codes:
//#define LOCAL
#include <cstdio>
#define N -1
#define M 100010
struct Node { int p, l, r; };
Node T[M]; int A[M];
void print(int a) {
int i = 0, b = T[a].l;
printf("node %d: parent = %d, depth = %d, ", a, T[a].p, A[a]);
if(T[a].p == N) printf("root, [");
else if(T[a].l == N) printf("leaf, [");
else printf("internal node, [");
for(; b!=N; ++i, b=T[b].r) {
if(i) printf(", ");
printf("%d", b);
}
printf("]
");
}
void rec(int a, int b) {
A[a] = b;
if(T[a].r != N) rec(T[a].r, b);
if(T[a].l != N) rec(T[a].l, b+1);
}
int main()
{
#ifdef LOCAL
freopen("E:\Temp\input.txt", "r", stdin);
freopen("E:\Temp\output.txt", "w", stdout);
#endif
int a, b, c, d, i, j, n, 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", &a, &b);
for(j=0; j<b; ++j) {
scanf("%d", &c);
if(!j) T[a].l = c;
else T[d].r = c;
d = c; T[c].p = a;
}
}
for(i=0; i<n; ++i) {
if(T[i].p == N) { r = i; break; }
}
rec(r, 0);
for(i=0; i<n; ++i) print(i);
return 0;
}
ALDS1_7_B-BinaryTree.
Description:
A rooted binary tree is a tree with a root node in which every node has at most two children.
Your task is to write a program which reads a rooted binary tree T and prints the following information for each node u of T:
node ID of u
parent of u
sibling of u
the number of children of u
depth of u
height of u
node type (root, internal node or leaf)
If two nodes have the same parent, they are siblings. Here, if u and v have the same parent, we say u is a sibling of v (vice versa).
The height of a node in a tree is the number of edges on the longest simple downward path from the node to a leaf.
Here, the given binary tree consists of n nodes and evey node has a unique ID from 0 to n-1.
Input:
The first line of the input includes an integer n, the number of nodes of the tree.
In the next n lines, the information of each node is given in the following format:
id left right
id is the node ID, left is ID of the left child and right is ID of the right child. If the node does not have the left (right) child, the left(right) is indicated by -1.
Output:
Print the information of each node in the following format:
node id: parent = p , sibling = s , degree = deg, depth = dep, height = h, type
p is ID of its parent. If the node does not have a parent, print -1.
s is ID of its sibling. If the node does not have a sibling, print -1.
deg, dep and h are the number of children, depth and height of the node respectively.
type is a type of nodes represented by a string (root, internal node or leaf. If the root can be considered as a leaf or an internal node, print root.
Please follow the format presented in a sample output below.
Constraints:
1 ≤ n ≤ 25
SampleInput:
9
0 1 4
1 2 3
2 -1 -1
3 -1 -1
4 5 8
5 6 7
6 -1 -1
7 -1 -1
8 -1 -1
SampleOutput:
node 0: parent = -1, sibling = -1, degree = 2, depth = 0, height = 3, root
node 1: parent = 0, sibling = 4, degree = 2, depth = 1, height = 1, internal node
node 2: parent = 1, sibling = 3, degree = 0, depth = 2, height = 0, leaf
node 3: parent = 1, sibling = 2, degree = 0, depth = 2, height = 0, leaf
node 4: parent = 0, sibling = 1, degree = 2, depth = 1, height = 2, internal node
node 5: parent = 4, sibling = 8, degree = 2, depth = 2, height = 1, internal node
node 6: parent = 5, sibling = 7, degree = 0, depth = 3, height = 0, leaf
node 7: parent = 5, sibling = 6, degree = 0, depth = 3, height = 0, leaf
node 8: parent = 4, sibling = 5, degree = 0, depth = 2, height = 0, leaf
Codes:
//#define LOCAL
#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: parent = %d, sibling = %d, ", u, T[u].parent, getSibling(u));
int deg = 0;
if(T[u].left != NIL) ++deg;
if(T[u].right != NIL) ++deg;
printf("degree = %d, depth = %d, height = %d, ", deg, D[u], H[u]);
if(T[u].parent == NIL) printf("root
");
else if(T[u].left==NIL && T[u].right==NIL) printf("leaf
");
else printf("internal node
");
}
int main()
{
#ifdef LOCAL
freopen("E:\Temp\input.txt", "r", stdin);
freopen("E:\Temp\output.txt", "w", stdout);
#endif
int i, v, l, r, root = 0;
scanf("%d", &n);
for(i=0; i<n; ++i) T[i].parent = NIL;
for(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(i=0; i<n; ++i)
if(T[i].parent == NIL) root = i;
setDepth(root, 0); setHeight(root);
for(i=0; i<n; ++i) print(i);
return 0;
}
ALDS1_7_C-TreeWalk.
Description:
Binary trees are defined recursively. A binary tree T is a structure defined on a finite set of nodes that either
contains no nodes, or
is composed of three disjoint sets of nodes:
- a root node.
- a binary tree called its left subtree.
- a binary tree called its right subtree.
Your task is to write a program which perform tree walks (systematically traverse all nodes in a tree) based on the following algorithms:
Print the root, the left subtree and right subtree (preorder).
Print the left subtree, the root and right subtree (inorder).
Print the left subtree, right subtree and the root (postorder).
Here, the given binary tree consists of n nodes and evey node has a unique ID from 0 to n-1.
Input:
The first line of the input includes an integer n, the number of nodes of the tree.
In the next n linen, the information of each node is given in the following format:
id left right
id is the node ID, left is ID of the left child and right is ID of the right child. If the node does not have the left (right) child, the left(right) is indicated by -1
Output:
In the 1st line, print "Preorder", and in the 2nd line print a list of node IDs obtained by the preorder tree walk.
In the 3rd line, print "Inorder", and in the 4th line print a list of node IDs obtained by the inorder tree walk.
In the 5th line, print "Postorder", and in the 6th line print a list of node IDs obtained by the postorder tree walk.
Print a space character before each node ID.
Constraints:
1 ≤ n ≤ 25
SampleInput1:
9
0 1 4
1 2 3
2 -1 -1
3 -1 -1
4 5 8
5 6 7
6 -1 -1
7 -1 -1
8 -1 -1
SampleOutput1:
Preorder
0 1 2 3 4 5 6 7 8
Inorder
2 1 3 0 6 5 7 4 8
Postorder
2 3 1 6 7 5 8 4 0
Codes:
//#define LOCAL
#include <cstdio>
#define MAX 10000
#define NIL -1
struct Node { int p, l, r; };
Node T[MAX];
void preParse(int u) {
if(u == NIL) return;
printf(" %d", u);
preParse(T[u].l);
preParse(T[u].r);
}
void inParese(int u) {
if(u == NIL) return;
inParese(T[u].l);
printf(" %d", u);
inParese(T[u].r);
}
void postParse(int u) {
if(u == NIL) return;
postParse(T[u].l);
postParse(T[u].r);
printf(" %d", u);
}
int main()
{
#ifdef LOCAL
freopen("E:\Temp\input.txt", "r", stdin);
freopen("E:\Temp\output.txt", "w", stdout);
#endif
int n, i, v, l, r, root;
scanf("%d", &n);
for(i=0; i<n; ++i) T[i].p = NIL;
for(i=0; i<n; ++i) {
scanf("%d%d%d", &v, &l, &r);
T[v].l = l, T[v].r = r;
if(l != NIL) T[l].p = v;
if(r != NIL) T[r].p = v;
}
for(i=0; i<n; ++i)
if(T[i].p == NIL) root = i;
printf("Preorder
"); preParse(root);
printf("
Inorder
"); inParese(root);
printf("
Postorder
"); postParse(root);
printf("
");
return 0;
}
ALDS1_7_D-ReconstructionOfTheTree.
Codes:
#include <iostream>
#include <string>
#include <algorithm>
#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(1, 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;
}
ALDS1_8_A-BinarySearchTreeI
Codes:
//#define LOCAL
#include <cstdio>
#include <cstdlib>
struct Node {
int k;
Node *p, *l, *r;
};
Node *N, *R;
void insert(int u) {
Node *a = R, *b = N, *c;
c = (Node *)malloc(sizeof(Node));
c->k = u, c->l = N, c->r = N;
while(a != N) {
b = a;
if(c->k < a->k) a = a->l;
else a = a->r;
}
c->p = b;
if(b == N) {
R = c;
} else {
if(c->k < b->k) b->l = c;
else b->r = c;
}
}
void inOrder(Node *u) {
if(u == N) return;
inOrder(u->l);
printf(" %d", u->k);
inOrder(u->r);
}
void preOrder(Node *u) {
if(u == N) return;
printf(" %d", u->k);
preOrder(u->l);
preOrder(u->r);
}
int main()
{
#ifdef LOCAL
freopen("E:\Temp\input.txt", "r", stdin);
freopen("E:\Temp\output.txt", "w", stdout);
#endif
int a, i, n;
char c[10];
scanf("%d", &n);
for(i=0; i<n; ++i) {
scanf("%s", c);
if(c[0] == 'i') {
scanf("%d", &a);
insert(a);
} else {
inOrder(R); printf("
");
preOrder(R); printf("
");
}
}
return 0;
}
ALDS1_8_B-BinarySearchTreeII
Codes:
//#define LOCAL
#include <cstdio>
#include <cstdlib>
struct Node {
int k;
Node *p, *l, *r;
};
Node *N, *R;
Node* find(Node *u, int a) {
while(u!=N && a!=u->k) {
if(a < u->k) u = u->l;
else u = u->r;
}
}
void insert(int u) {
Node *a = R, *b = N, *c;
c = (Node *)malloc(sizeof(Node));
c->k = u, c->l = N, c->r = N;
while(a != N) {
b = a;
if(c->k < a->k) a = a->l;
else a = a->r;
}
c->p = b;
if(b == N) {
R = c;
} else {
if(c->k < b->k) b->l = c;
else b->r = c;
}
}
void inOrder(Node *u) {
if(u == N) return;
inOrder(u->l);
printf(" %d", u->k);
inOrder(u->r);
}
void preOrder(Node *u) {
if(u == N) return;
printf(" %d", u->k);
preOrder(u->l);
preOrder(u->r);
}
int main()
{
#ifdef LOCAL
freopen("E:\Temp\input.txt", "r", stdin);
freopen("E:\Temp\output.txt", "w", stdout);
#endif
int a, i, n;
char c[10];
scanf("%d", &n);
for(i=0; i<n; ++i) {
scanf("%s", c);
if(c[0] == 'f') {
scanf("%d", &a);
Node *t = find(R, a);
if(t != N) printf("yes
");
else printf("no
");
} else if(c[0] == 'i'){
scanf("%d", &a);
insert(a);
} else {
inOrder(R); printf("
");
preOrder(R); printf("
");
}
}
return 0;
}