void test_tree() {
TreeNode *tree = (TreeNode*)malloc(sizeof(TreeNode));
int key = 0;
init_tree(key++, 0, 0, tree);
add_left(key++, 0, tree);
add_right(key++, 0, tree);
add_left(key++, 0, tree->left);
add_right(key++, 0, tree->left);
add_left(key++, 0, tree->right);
add_right(key++, 0, tree->right);
add_left(key++, 0, tree->left->left);
print_tree(tree);
std::cout << std::endl;
std::cout << "max depth: " << max_depth(tree, 0) << std::endl;
std::cout << "min depth: " << min_depth(tree, 0) << std::endl;
std::cout << "Is tree balanced? " << (is_tree_balanced(tree) == 1 ? "yes" : "no") << std::endl;
free_tree(tree);
}
void Tree<T> :: math_parse(char* exp,Node<T>** node)
{
if('\0' == *exp)
{
//cerr << "Wrong expression: math_parse" << endl;
return;
}else
if('(' == *exp)
{
add_left(*exp,node);
math_parse(exp+1, &(*node)->left);
}else
if('+' == *exp || '-' == *exp || '*' == *exp || '/'== *exp)
{
(*node)->data = *exp;
add_right('n', node);
math_parse(exp+1, &(*node)->right);
}else
if(*exp >= '0' && *exp <= '9')
{
(*node)->data = *exp;
math_parse(exp+1, &(*node)->father);
}else
if(')' == *exp)
math_parse(exp+1, &(*node)->father);
else
math_parse(exp+1, node);
}
struct node* copy_list(struct node* plist)
{
struct node *pcurrent = NULL;
struct node *phead = NULL;
struct node *ptail = NULL;
if (plist == NULL)
return plist;
pcurrent = plist; // head of the input list
add_right(&phead, pcurrent->data); // head of the copy list
ptail = phead;
while (pcurrent->next != NULL) {
add_right(&ptail, pcurrent->next->data);
ptail = ptail->next;
pcurrent = pcurrent->next;
}
return phead; // returns the head of the copy list
}
node *init_or_add_right(node *node_pointer, int value) {
if (node_pointer == NULL) {
node_pointer = create_node(value);
} else {
node_pointer = add_right(node_pointer, value);
}
return node_pointer;
}
void append(struct node** ref_plist, int data)
{
struct node *pcurrent = *ref_plist;
if (pcurrent == NULL) { // empty list, add left to it
add_left(ref_plist, data);
} else { // find the last node, add right to it
while(pcurrent->next != NULL)
pcurrent = pcurrent->next;
add_right(&pcurrent, data);
}
}
struct node* copy_local_ref(struct node* plist)
{
struct node *pcurrent = plist;
struct node *pnew_head = NULL;
struct node **ref_last_ptr = &pnew_head;
while(pcurrent != NULL) {
add_right(ref_last_ptr, pcurrent->data);
ref_last_ptr = &((*ref_last_ptr)->next);
pcurrent = pcurrent->next;
}
return pnew_head;
}
int main(void)
{
char array[10];
int choice, size, i;
printf("enter size:");
scanf("%d", &size);
for(i = 0;i < size;i++)
{
scanf(" %c", &array[i]);
}
do
{
printf("press 1 to add left\n");
printf("press 2 to add right\n");
printf("press 3 to retrieve left\n");
printf("press 4 to retrieve right\n");
printf("press 5 to exit\n");
printf("enter your choice:");
scanf("%d", &choice);
switch(choice)
{
case 1:
size = add_left(array, size);
break;
case 2:
size = add_right(array, size);
break;
case 3:
size = retrieve_left(array, size);
break;
case 4:
retrieve_right(array, size);
break;
case 5:
printf("Exiting...\n");
return 0;
}
}while(choice != 5);
}
int main()
{
std::ifstream fin("castle.in", std::ios::in);
fin>>M>>N;
for( int i = 0; i < M * N; ++i ) fin >> room[i];
for( int i = 0; i < M * N; ++i ) room_state[i] = 0;
#if 0
for( int i = 0; i < M * N; ++i ) {
std::cout << room[i];
if( i % M == M-1 ) std::cout << std::endl;
else std::cout << " ";
}
std::cout << M << " " << N << " "
<< M * N << std::endl;
#endif
for( int i = 0; i < M * N; ++i ){
if( room_state[i] == 0 ){
int temp_max_count = 0;
q.push( i );
while( !q.empty() ){
int index = q.front();
temp_max_count++;
room_state[index] = count;
q.pop();
#if 0
std::cout << count << ":" << index/M + 1 << " " << index % M + 1 << std::endl;
#endif
switch( room[index] ){
case 0:
add_left( index );
add_up( index );
add_right( index );
add_down( index );
break;
case 1:
{
add_left_edge( index );
add_up( index );
add_right( index );
add_down( index );
}
break;
case 2:
{
add_left( index );
add_up_edge( index );
add_right( index );
add_down( index );
}
break;
case 3:
{
add_left_edge( index );
add_up_edge( index );
add_right( index );
add_down( index );
}
break;
case 4:
{
add_left( index );
add_up( index );
add_right_edge( index );
add_down( index );
}
break;
case 5:
{
add_left_edge( index );
add_up( index );
add_right_edge( index );
add_down( index );
}
break;
case 6:
{
add_left( index );
add_up_edge( index );
add_right_edge( index );
add_down( index );
}
break;
case 7:
{
add_left_edge( index );
add_up_edge( index );
add_right_edge( index );
add_down( index );
}
break;
case 8:
{
add_left( index );
add_up( index );
add_right( index );
add_down_edge( index );
}
break;
case 9:
{
add_left_edge( index );
add_up( index );
add_right( index );
add_down_edge( index );
}
break;
case 10:
{
add_left( index );
add_up_edge( index );
add_right( index );
add_down_edge( index );
}
break;
case 11:
{
add_left_edge( index );
add_up_edge( index );
add_right( index );
add_down_edge( index );
}
break;
case 12:
{
add_left( index );
add_up( index );
add_right_edge( index );
add_down_edge( index );
}
break;
case 13:
{
add_left_edge( index );
add_up( index );
add_right_edge( index );
add_down_edge( index );
}
break;
case 14:
{
add_left( index );
add_up_edge( index );
add_right_edge( index );
add_down_edge( index );
}
break;
case 15:
{
add_left_edge( index );
add_up_edge( index );
add_right_edge( index );
add_down_edge( index );
}
break;
default:
break;
}
}
room_num[count] = temp_max_count;
max_count = std::max( max_count, temp_max_count );
count++;
}
}
std::ofstream fout("castle.out", std::ios::out );
#if 0
std::cout << count - 1 << std::endl;
std::cout << max_count << std::endl;
#endif
fout << count - 1 << std::endl;
fout << max_count << std::endl;
int a, b, c;
a = N;
b = M;
c = 4;
for( int i = 0; i < edge_count; ++i ){
#if 0
std::cout << edge1[i] / M + 1 << ":" << edge1[i] % M + 1 << " "
<< edge2[i] / M + 1 << ":" << edge2[i] %M + 1 << std::endl;
#endif
if( room_state[edge1[i]] != room_state[edge2[i]] ){
if( new_max_count < room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] ){
new_max_count = room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]];
if( abs( edge2[i] - edge1[i] ) == 1 ) {
int temp = std::min( edge1[i], edge2[i] );
a = temp / M + 1;
b = temp % M + 1;
c = 4;
}else{
int temp = std::max( edge1[i], edge2[i] );
a = temp / M + 1;
b = temp % M + 1;
c = 2;
}
}else if( new_max_count == room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] ) {
if( abs( edge1[i] - edge2[i] ) == 1 ){
int temp = std::min( edge1[i], edge2[i] );
if( temp % M + 1< b || (temp % M + 1 == b && temp / M + 1 > a)){
a = temp / M + 1;
b = temp % M + 1;
c = 4;
}
}else {
int temp = std::max( edge1[i], edge2[i] );
if( temp % M + 1 < b || ( temp % M + 1 == b && temp / M + 1 > a ) ){
a = temp / M + 1;
b = temp % M + 1;
c = 2;
}
}
}
// new_max_count = std::max( new_max_count,
// room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] );
#if 0
std::cout << room_num[room_state[edge1[i]]] << ":" << room_num[room_state[edge2[i]]] << " " << new_max_count << std::endl;
std::cout << a << " " << b << " " << c << std::endl;
#endif
}
}
fout << new_max_count << std::endl;
fout << a << " "<< b << " "<< (c == 2? 'N' : 'E') << std::endl;
return 0;
}
node* node::operator+=(node* list) { $1 add_right(list); return this; };
static int
process_filter(struct event_format *event, struct filter_arg **parg,
char **error_str, int not)
{
enum event_type type;
char *token = NULL;
struct filter_arg *current_op = NULL;
struct filter_arg *current_exp = NULL;
struct filter_arg *left_item = NULL;
struct filter_arg *arg = NULL;
enum op_type op_type;
enum filter_op_type btype;
enum filter_exp_type etype;
enum filter_cmp_type ctype;
int ret;
*parg = NULL;
do {
free(token);
type = read_token(&token);
switch (type) {
case EVENT_SQUOTE:
case EVENT_DQUOTE:
case EVENT_ITEM:
arg = create_arg_item(event, token, type, error_str);
if (!arg)
goto fail;
if (!left_item)
left_item = arg;
else if (current_exp) {
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
left_item = NULL;
/* Not's only one one expression */
if (not) {
arg = NULL;
if (current_op)
goto fail_print;
free(token);
*parg = current_exp;
return 0;
}
} else
goto fail_print;
arg = NULL;
break;
case EVENT_DELIM:
if (*token == ',') {
show_error(error_str,
"Illegal token ','");
goto fail;
}
if (*token == '(') {
if (left_item) {
show_error(error_str,
"Open paren can not come after item");
goto fail;
}
if (current_exp) {
show_error(error_str,
"Open paren can not come after expression");
goto fail;
}
ret = process_filter(event, &arg, error_str, 0);
if (ret != 1) {
if (ret == 0)
show_error(error_str,
"Unbalanced number of '('");
goto fail;
}
ret = 0;
/* A not wants just one expression */
if (not) {
if (current_op)
goto fail_print;
*parg = arg;
return 0;
}
if (current_op)
ret = add_right(current_op, arg, error_str);
else
current_exp = arg;
if (ret < 0)
goto fail;
} else { /* ')' */
if (!current_op && !current_exp)
goto fail_print;
/* Make sure everything is finished at this level */
if (current_exp && !check_op_done(current_exp))
goto fail_print;
if (current_op && !check_op_done(current_op))
goto fail_print;
if (current_op)
*parg = current_op;
else
*parg = current_exp;
return 1;
}
break;
case EVENT_OP:
op_type = process_op(token, &btype, &ctype, &etype);
/* All expect a left arg except for NOT */
switch (op_type) {
case OP_BOOL:
/* Logic ops need a left expression */
if (!current_exp && !current_op)
goto fail_print;
/* fall through */
case OP_NOT:
/* logic only processes ops and exp */
if (left_item)
goto fail_print;
break;
case OP_EXP:
case OP_CMP:
if (!left_item)
goto fail_print;
break;
case OP_NONE:
show_error(error_str,
"Unknown op token %s", token);
goto fail;
}
ret = 0;
switch (op_type) {
case OP_BOOL:
arg = create_arg_op(btype);
if (current_op)
ret = add_left(arg, current_op);
else
ret = add_left(arg, current_exp);
current_op = arg;
current_exp = NULL;
break;
case OP_NOT:
arg = create_arg_op(btype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
current_exp = arg;
ret = process_filter(event, &arg, error_str, 1);
if (ret < 0)
goto fail;
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
break;
case OP_EXP:
case OP_CMP:
if (op_type == OP_EXP)
arg = create_arg_exp(etype);
else
arg = create_arg_cmp(ctype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
ret = add_left(arg, left_item);
if (ret < 0) {
arg = NULL;
goto fail_print;
}
current_exp = arg;
break;
default:
break;
}
arg = NULL;
if (ret < 0)
goto fail_print;
break;
case EVENT_NONE:
break;
default:
goto fail_print;
}
} while (type != EVENT_NONE);
if (!current_op && !current_exp)
goto fail_print;
if (!current_op)
current_op = current_exp;
current_op = collapse_tree(current_op);
*parg = current_op;
return 0;
fail_print:
show_error(error_str, "Syntax error");
fail:
free_arg(current_op);
free_arg(current_exp);
free_arg(arg);
free(token);
return -1;
}
