ACM解题总结——HihoCoder1155

题目来源：
    HihoCoder1155

题目要求：
    题目要求给定一个Lisp语句，求解表达式的值。
    Lisp语句的表达式格式有如下几种：
    (1) 单独的一个非负整数是一个合法的表达式，如：2。
    (2) 单独的一个布尔值是一个合法的表达式，其值只有2种：true 和 false。
    (3) 定义变量。变量的名称由不超过10个的小写英文字母组成，true，false，let，if为保留字，不能作为变量名,该表达式的值为变量的绑定值，如果变量没有绑定，则表达式非法，程序输出：Unbound Identifer。
    (4) 算术运算。包括加减乘除，格式为：( + x y )、( - x y )、( * x y )、( / x y )。其中 x y 均为合法的表达式，并且只有 x y 的值的结果均为数字时，该表达式才合法，否则，表达式非法，程序输出：Type Mismatch。另外，如果除法表达式中的除数是0，则该表达式非法，程序输出：Division By Zero。
    (5) 分支表达式：if。格式为：( if a b c )。其中：a b c 均为合法的表达式。a的表达式的值必须为布尔值，否则，该表达式非法，程序输出：Type Mismatch。如果表达式a的值为true，则该表达式的值为表达式b的计算值，否则，该表达式的值为表达式c的计算值。
    (6) let表达式。let表达式的作用是对变量绑定一个值。格式为：( let ( x a ) b )，其中 x 一定为变量， a 是合法的表达式，该表达式的值是把 x = a 代入到b中后，表达式b的计算值。例如：表达式：( let ( x 2 ) ( + x 1 ) ）的值是3；另外在包含let表达式嵌套的表达式中，如果对相同的变量绑定多次，则最层的绑定有效，如：表达式 ( let ( x
1 ) ( let (x 2) ( + x 1 ) ) ) 的计算值是3而不是2。
    （7）比较运算。格式为 ( < x y )、 ( > x y )、( = x y )。其中 x y 都是合法的表达式，并且计算值必须为数字，否则，该表达式非法，程序输出：Type
Mismatch。根据x y的值的大小关系确定该表达式的值为true或false。
    以上是题目中用到的Lisp表达式的语法。
    给定的输入数据保证语法正确，仅存在逻辑错误。

解答：
    本题的要求其实是要编写一个简单的编译器。代码量比较大，但难度不算太难。基本的解答思路是根据输入的表达式构建语法树。然后遍历语法树后，整个表达式的值就存储在语法树的根节点中。比较好的一点是：题目中所有的语法都是“前缀语法”，即操作符在操作数的前面。这样程序处理数据的顺序就是表达式的读取顺序——从左到右。首先说明语法树的构建方式。
    根据题目中的语法的描述，需要用到的语法树的节点有如下的几种：
    (1) 数值： 这是最简单的节点，没有子节点，在语法树中是叶子节点。节点的值就是数值本身，存储在节点内。如下：
    


     (2)布尔值：这也是最简单的节点，在语法树中也是叶子节点。节点的值就是布尔值本身，存储在节点内。如下：
    

 
    (3)变量：变量有变量名和变量值两个属性，但表达式的值仅和变量的值有关，因此变量也是一个叶子节点，节点中存储变量的名称和变量值：
    

 
    (4)算术计算。算术运算表达式的值需要先计算两个子表达式 x y 的值，再计算整个表达式的值，因此它有两个子节点，分别代表子表达式 x 和 y。如下：
     


    (4)分支表达式：表达式( if a b c ) 的值由表达式 a b c 的值决定，因此if节点具有3个子节点，分别代表表达式a b c，如下：
    

 
    (6)let 表达式：let表达式有三个字表达式：变量x，赋值表达式a，以及求值表达式b，因此它也有3个子节点，分别代表变量、赋值表达式a、求值表达式b：
    

  
    (7) 比较运算：比较运算的处理方式和算术运算类似，它也有两个子节点，分别代表子表达式：x 和 y：
    

 
 

     通过上面的方法，就可以把一个表达式转化为一棵语法树。例如，表达式:
 ( let ( x 4 ) ( if true x y ) )
可以转化为如下的语法树：    



    树中的每个节点存储该节点代表的表达式的值，因此求解整个表达式的值就是对语法树由上到下、从左到右进行深度优先搜索的过程，上面的语法树的求解过程如下：
    (i) 首先访问let节点，计算let表达式的值需要首先计算赋值表达式的值，即let节点的第二个子节点。
    (ii) let节点的第二个节点是一个数字，其值可以直接读出。该节点求解完成。回溯到根节点let。
    (iii) 接下来，求解let表达式中的求值表达式，即let节点的第3个子节点。
    (iv) 求解let节点的第三个子节点的值，该节点是if节点，需要先求解它的第1个子节点的值。
    (v) if节点的第一个子节点为布尔值，节点的值可以直接读出，该节点求解完毕。回溯到if节点。
    (vi) 由于第一个节点的结果是true，因此此时需要求解if节点的第二个子节点的值。
    (vii) if节点的第二个节点是变量，此时x已经被绑定为4，因此该节点的值是4，求解完毕，回溯到if节点。
    (viii) 此时if节点可以求解，它的值就是第2个节点的值，if节点求解完毕回溯到let节点。
    (ix) 此时let节点也可以求值了，它的值就是它第三个节点的值，结果是4。整个表达式的值求解完毕。
    因此，利用语法树求解表达式的值的基本过程就是：从根节点采用深度优先搜索的方式对树进行遍历，如果某个节点有子节点则递归求解子节点的值，然后求解本节点的值后返回。这样遍历完成后就可以从树的根节点中找到整个表达式的值。如果在求解过程中发现题目中说明的非法情况，则输出相关信息，求解结束。
    在每一轮递归过程中，在完成子节点的求解后，在求解本节点的值的过程根据语法的定义求解即可。这里需要说明的是let表达式的求解过程，由于求解let节点的第3个子节点的值的过程中会遇到变量，而变量的值则由let节点的第1、2个子节点决定。因此在求解let节点的第3个子节点的值时会用到这些信息。这里可以定义一个“变量表”来存储每一个变量的值，在求解过程中，如果遇到了变量，就查找这个变量表找到对应变量的值即可，如果找不到对应的表项，则说明该变量没有绑定值，求解非法。
    例如：表达式：（ let （ x 1 ) ( let ( x 2 ) ( + x 1 ) ) ) 的语法树和变量表如下：



 
    由于内层变量的绑定会覆盖掉外层，因此在查找变量的值时，要从下向上查找，第一个符合的表项就是要找的变量的值。

输入输出格式：
    输入：第一行为一个整数T，表示有T组测试数据；
            接下来的T行，每一行为一个字符串，表示一个Lisp表达式。
    输出：对于每一个表达式，输出一行，显示表达式的值，如果表达式非法，则输出出错信息。

程序代码：

/****************************************************/
/* File        : hiho_week_87.cpp                   */
/* Author      : Zhang Yufei                        */
/* Date        : 2016-03-01                         */
/* Description : HihoCoder ACM program. (submit:g++)*/
/****************************************************/

/*
* Update log:
*		Create by Zhang Yufei in 2016-03-01 ~ 2016-03-02.
*		Submit result: CE->PE->AC.
* End.
*/

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<stdlib.h>

/*
* Define the closure to record variant in the situation of program
*/
typedef struct node {
int value;
int value_type;
char name[25];
struct node *pre;
} Closure;

/*
* Define the super class of s_expression.
* Parameters:
*		@type: The type of this expression. The value is as follow:
*		+-------+------------------------------------------------+
*		| value | 		type                             |
*              +-------+------------------------------------------------+
*              |   0   |	nonnegtive integer                       |
*              +-------+------------------------------------------------+
*		|   1   |	boolean value: true, false               |
*              +-------+------------------------------------------------+
*		|   2   |  <span style="white-space:pre">	</span>variant                                  |
*		+-------+------------------------------------------------+
*		|   3   |	add: + x y                               |
*		+-------+------------------------------------------------+
*		|   4   |	substract: - x y                         |
*		+-------+------------------------------------------------+
*		|   5   |	multiply: * x y                          |
*		+-------+------------------------------------------------+
*		|   6   |	devide: / x y                            |
*		+-------+------------------------------------------------+
*		|   7   |	if expression: if a b c                  |
*		+-------+------------------------------------------------+
*		|   8   |	let expression: let ( x a ) b            |
*		+-------+------------------------------------------------+
*		|   9   |	greater comparision: > x y               |
*		+-------+------------------------------------------------+
*		|   10  |	equal comparision: = x y                 |
*		+-------+------------------------------------------------+
*		|   11  |	less comparision: < x y                  |
*		+-------+------------------------------------------------+
*		@value: The value of this s_expression.
*		@value_type: The type of value.
*/
typedef struct node1 {
int type;
int value;
int value_type;
} s_expression;

/*
* The sub-classes of s_expression:
*/

// nonnegtive integer
typedef struct node2 {
int type;
int value;
int value_type;
} Integer;

// boolean
typedef struct node3 {
int type;
int value;
int value_type;
} Boolean;

typedef struct node4 {
int type;
int value;
int value_type;
char name[20];
} Variant;

// + x y
typedef struct node5 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Add;

// - x y
typedef struct node6 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Substract;

// * x y
typedef struct node7 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Multiply;

// / x y
typedef struct node8 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Devide;

// if a b c
typedef struct node9 {
int type;
int value;
int value_type;
s_expression *a, *b, *c;
} If;

// let (x a) b
typedef struct node10 {
int type;
int value;
int value_type;
s_expression *x, *a, *b;
} Let;

// < x y
typedef struct node11 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Greater;

// = x y
typedef struct node12 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Equal;

// < x y
typedef struct node13 {
int type;
int value;
int value_type;
s_expression *x, *y;
} Less;

// The input data.
char input[250];
// The length of input.
int length;
// The curren index in the process of interpreting.
int start;

/*
* This function deals with one test case.
* Parameters:
*		None.
* Returns:
*		None.
*/
void function(void);

/*
* This function sets a synax tree using given input s_expression.
* Parameters:
*		None.
* Return:
*		The root node of the synax tree.
*/
s_expression* set_tree(void);

/*
* This function transfers the string into nodes in synax tree
* Parameters:
*		None.
* Returns:
*		The node created by this function.
*/
s_expression* make_node(void);

/*
* This function calculates the value of the input s_expression.
* Parameter:
*		@expression: The root of synax tree generated by input s_expression.
*		@closure: The current closure node of the situation.
* Return:
*		If computing process is correct and the result has been worked out,
*		returns 1, or returns 0.
*/
int calculate(s_expression *expression, Closure *closure);

/*
* The main progarm.
*/
int main(void) {
int T;
scanf("%d", &T);
getchar();
for(int i = 0; i < T; i++) {
function();
}

return 0;
}

/*
* This function deals with one test case.
* Parameters:
*		None.
* Returns:
*		None.
*/
void function(void) {
gets(input);
length = strlen(input);
start = 0;
s_expression *s = set_tree();
if(calculate(s, NULL) == 1) {
if(s->value_type == 0) {
printf("%d\n", s->value);
} else if(s->value_type == 1) {
if(s->value == 1) {
printf("true\n");
} else {
printf("false\n");
}
}
}
}

/*
* This function sets a synax tree using given input s_expression.
* Parameters:
*		None
* Return:
*		The root node of the synax tree.
*/
s_expression* set_tree(void) {
s_expression *s = make_node();
switch (s->type) {
case 0: break;
case 1: break;
case 2: break;
case 3: { Add *add = (Add*)s;
add->x = set_tree();
add->y = set_tree();
break; }
case 4: { Substract *substract = (Substract*)s;
substract->x = set_tree();
substract->y = set_tree();
break; }
case 5: { Multiply *multiply = (Multiply*)s;
multiply->x = set_tree();
multiply->y = set_tree();
break; }
case 6: { Devide *devide = (Devide*)s;
devide->x = set_tree();
devide->y = set_tree();
break; }
case 7:	{ If *iF = (If*)s;
iF->a = set_tree();
iF->b = set_tree();
iF->c = set_tree();
break; }
case 8: { Let *let = (Let*)s;
let->x = set_tree();
let->a = set_tree();
let->b = set_tree();
break; }
case 9: { Greater *greater = (Greater*)s;
greater->x = set_tree();
greater->y = set_tree();
break; }
case 10: { Equal *equal = (Equal*)s;
equal->x = set_tree();
equal->y = set_tree();
break; }
case 11: { Less *less = (Less*)s;
less->x = set_tree();
less->y = set_tree();
break; }
default: break;
}

return s;
}

/*
* This function transfers the string into nodes in synax tree
* Parameters:
*		None
* Returns:
*		The node created by this function.
*/
s_expression* make_node(void) {
s_expression *node;

while(start < length && (isblank(input[start]) ||
input[start] == ')' || input[start] == '('))
start++;

if(isdigit(input[start])) {
Integer *integer = (Integer*) malloc(sizeof(Integer));
int num = 0;
while(isdigit(input[start])) {
num *= 10;
num += input[start] - 48;
start++;
}
integer->type = 0;
integer->value = num;
node = (s_expression*) integer;
} else if(input[start] == '+') {
Add *add = (Add*) malloc(sizeof(Add));
add->type = 3;
node = (s_expression*) add;
start++;
} else if(input[start] == '-') {
Substract *substract = (Substract*) malloc(sizeof(Substract));
substract->type = 4;
node = (s_expression*) substract;
start++;
} else if(input[start] == '*') {
Multiply *multiply = (Multiply*) malloc(sizeof(Multiply));
multiply->type = 5;
node = (s_expression*) multiply;
start++;
} else if(input[start] == '/') {
Devide *devide = (Devide*) malloc(sizeof(Devide));
devide->type = 6;
node = (s_expression*) devide;
start++;
} else if(input[start] == '>') {
Greater *greater = (Greater*) malloc(sizeof(Greater));
greater->type = 9;
node = (s_expression*) greater;
start++;
} else if(input[start] == '=') {
Equal *equal = (Equal*) malloc(sizeof(Equal));
equal->type = 10;
node = (s_expression*) equal;
start++;
} else if(input[start] == '<') {
Less *less = (Less*) malloc(sizeof(Less));
less->type = 11;
node = (s_expression*) less;
start++;
} else if(isalpha(input[start])) {
char ch[15];
int index = 0;
while(isalpha(input[start])) {
ch[index++] = input[start++];
}
ch[index] = '\0';

if(strcmp("if", ch) == 0) {
If *iF = (If*) malloc(sizeof(If));
iF->type = 7;
node = (s_expression*) iF;
} else if(strcmp("let", ch) == 0) {
Let *let = (Let*) malloc(sizeof(Let));
let->type = 8;
node = (s_expression*) let;
} else if(strcmp("true", ch) == 0 || strcmp("false", ch) == 0) {
Boolean *boolean = (Boolean*) malloc(sizeof(Boolean));
boolean->type = 1;
if(strcmp("true", ch) == 0) {
boolean->value = 1;
} else {
boolean->value = 0;
}
node = (s_expression*) boolean;
} else {
Variant *variant = (Variant*) malloc(sizeof(Variant));
variant->type = 2;
strcpy(variant->name, ch);
node = (s_expression*) variant;
}
}

return node;
}

/*
* This function calculates the value of the input s_expression.
* Parameter:
*		@expression: The root of synax tree generated by input s_expression.
*		@closure: The current closure node of the situation.
* Return:
*		If computing process is correct and the result has been worked out,
*		returns 1, or returns 0.
*/
int calculate(s_expression *expression, Closure *closure) {
int type = expression->type;

switch (type) {
case 0: expression->value_type = 0; return 1;         // Integer.
case 1: expression->value_type = 1; return 1;         // Boolean.
case 2: {Closure *c = closure;                         // variant.
Variant *v = (Variant*) expression;
while(c != NULL) {
if(strcmp(v->name, c->name) == 0) {
v->value = c->value;
v->value_type = c->value_type;
return 1;
}
c = c->pre;
}
printf("Unbound Identifier\n");
return 0; }
case 3: { Add *add = (Add*) expression;                 // + x y
if(calculate(add->x, closure) == 0) {
return 0;
}
if(calculate(add->y, closure) == 0) {
return 0;
}
if(add->x->value_type != 0
|| add->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}
add->value = add->x->value + add->y->value;
add->value_type = 0;
return 1; }
case 4: { Substract *substract = (Substract*) expression;// - x y
if(calculate(substract->x, closure) == 0) {
return 0;
}
if(calculate(substract->y, closure) == 0) {
return 0;
}
if(substract->x->value_type != 0 || substract->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}

substract->value = substract->x->value - substract->y->value;
substract->value_type = 0;
return 1; }
case 5: { Multiply *multiply = (Multiply*) expression;   // * x y
if(calculate(multiply->x, closure) == 0) {
return 0;
}
if(calculate(multiply->y, closure) == 0) {
return 0;
}
if(multiply->x->value_type != 0 || multiply->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}

multiply->value = multiply->x->value * multiply->y->value;
multiply->value_type = 0;
return 1; }
case 6: { Devide *devide = (Devide*) expression;         // / x y
if(calculate(devide->x, closure) == 0) {
return 0;
}
if(calculate(devide->y, closure) == 0) {
return 0;
}
if(devide->x->value_type != 0 || devide->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}
if(devide->y->value == 0) {
printf("Division By Zero\n");
return 0;
}
devide->value = devide->x->value / devide->y->value;
devide->value_type = 0;
return 1; }
case 7: { If *iF = (If*) expression;                    // if a b c
if(calculate(iF->a, closure) == 0) {
return 0;
}
if(iF->a->value_type != 1) {
printf("Type Mismatch\n");
return 0;
}
if(iF->a->value == 1) {
if(calculate(iF->b, closure) == 0) {
return 0;
}
iF->value = iF->b->value;
iF->value_type = iF->b->value_type;
return 1;
} else {
if(calculate(iF->c, closure) == 0) {
return 0;
}
iF->value = iF->c->value;
iF->value_type = iF->c->value_type;
return 1;
} }
case 8: { Let *let = (Let*) expression;               // let ( x a ) b
if(calculate(let->a, closure) == 0) {
return 0;
}
Closure *new_c = (Closure*) malloc(sizeof(Closure));
new_c->value = let->a->value;
new_c->value_type = let->a->value_type;
strcpy(new_c->name, ((Variant*) (let->x))->name);
new_c->pre = closure;

if(calculate(let->b, new_c) == 0) {
free(new_c);
return 0;
}
free(new_c);
let->value = let->b->value;
let->value_type = let->b->value_type;
return 1; }
case 9: { Greater *greater = (Greater*) expression;   // > x y
if(calculate(greater->x, closure) == 0) {
return 0;
}
if(calculate(greater->y, closure) == 0) {
return 0;
}
if(greater->x->value_type != 0 ||
greater->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}
if(greater->x->value > greater->y->value) {
greater->value = 1;
greater->value_type = 1;
return 1;
} else {
greater->value = 0;
greater->value_type = 1;
return 1;
} }
case 10: { Equal *equal = (Equal*) expression;   // = x y
if(calculate(equal->x, closure) == 0) {
return 0;
}
if(calculate(equal->y, closure) == 0) {
return 0;
}
if(equal->x->value_type != 0 ||
equal->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}
if(equal->x->value == equal->y->value) {
equal->value = 1;
equal->value_type = 1;
return 1;
} else {
equal->value = 0;
equal->value_type = 1;
return 1;
} }
case 11: { Less *less = (Less*) expression;   // < x y
if(calculate(less->x, closure) == 0) {
return 0;
}
if(calculate(less->y, closure) == 0) {
return 0;
}
if(less->x->value_type != 0 ||
less->y->value_type != 0) {
printf("Type Mismatch\n");
return 0;
}
if(less->x->value < less->y->value) {
less->value = 1;
less->value_type = 1;
return 1;
} else {
less->value = 0;
less->value_type = 1;
return 1;
} }
default: return 0;
}
return 0;
}