POJ1048 Follow My Logic

题目来源：http://poj.org/problem?id=1048

题目大意：

　　给定一个逻辑电路，求其逻辑输出。电路含一个或多个输入，以及一些双输入的与门/或门组成。电路图以下面形式的ASCII码图给出。 电路中，路径由横线，纵线和折点组成，'-'和'|'表示横线和纵线，'+'表示折点。输入由大写字母A到Z表示，输出由'?'表示。与门和或门的表示方法如图所示，而且它们的朝向时钟与图示一致(不会反向或成竖直方向)。门的输入和输出可以被取“非”，用小写的'o'表示。下图最右为一个简单但完整的电路。

　　　　:\               :\                 -:\                 -o:\                       A-o:\

　　　　: )              : >                 : )-                 : )o-                       : )o-?

　　　　:/               :/                 -:/                 --:/                       B--:/

     AND gate          OR gate       Gate with inputs    An inverted top input          Two logic inputs

	                                                 and an inverted output         and the output

输入：电路遵循以下规则：

　　1. 电路图的最大尺寸为100*100.

　　2. 线路始终沿直线，除非遇到折点。折点处，路径转弯90°，折点不会相邻。

　　3. 所有的线路都不会中途中断。

　　4. 线路不会相交。

　　5. 逻辑门始终如上图所示，输入位于左侧，输出位于右侧。

　　6. “非”只会出现在紧邻逻辑门输入或输出的地方，且前面（紧邻输入时）或后面（紧邻输出时）接有至少一个'-'或'|'.

　　遇到只含一个'*'的一行时，表示电路图结束，后面为电路图输入状态。每个输入由一行组成，为一个由26个0或1组成的串。第一个数为A的值，第二个为B，以此类推。给定的输入值中电路图里没有用到的应被忽略。"*"表示输入状态结束。

　　接下来是另一副电路图和新的输入状态，直到遇到end of file. 文件中至少含有一个电路图和一组输入状态。

输出：程序输出每个电路图对每个输入状态的逻辑输出值。每个输入状态单独一行，每个电路图的输出之间用空格隔开。

---

Sample Input

A---:\
    : )---?
B---:/
*
00000000000000000000000000
10000000000000000000000000
01000000000000000000000000
11000000000000000000000000
*
A---+
    |
    +---:\
        : >o---:\
    +---:/     : )---?
    |      C--o:/
B---+
*
00000000000000000000000000
11100000000000000000000000
*

Sample Output

0
0
0
1

1
0

---

首先读入整幅电路图，找到电路图输出的位置，然后递归分析电路图的逻辑结构，构造一颗逻辑树。然后对于每个输入状态根据逻辑树去递归求值即可。但是要注意电路图中线路方向的处理问题，因为图并非一定是规矩的沿从左至方向，线路可能弯折。比如下面的例子：

A-+
  |
  o:\
   : )-?
B--:/

A---+
    |
    +---:\
        : >o---:\
    +---:/     : )---?
    |      C--o:/
    +---+
        |
B-------+

 //////////////////////////////////////////////////////////////////////////
 //        POJ1048 Follow My Logic
 //        Memory: 180K        Time: 0MS
 //        Language: C++        Result: Accepted
 //////////////////////////////////////////////////////////////////////////

 #include <iostream>
 #include <cstdio>

 using namespace std;

 char circuit[][];
 int h;
 int x, y;

 enum DIR {
     LEFT, UP, RIGHT, DOWN
 };

 struct Node {
     int type;    //0-25表示对应输入状态的序号(A-Z); -2 and; -3 or; -4 not.
     int left_child;
     int right_child;
 };

 Node tree[];
 int tree_len;

 char input[];

 bool ReadCircuit() {
     memset(circuit, , sizeof(circuit));
     if (!gets(circuit[])) return false;
     h = ;
     while (gets(circuit[h++])) {
         if (circuit[h - ][] == '*') {
             --h;
             break;
         }
     }
     return true;
 }

 void FindOutput() {
     for (int i = ; i < h; ++i) {
         for (int j = ; j < ; ++j) {
             if (circuit[i][j] == '\0') break;
             if (circuit[i][j] == '?') {
                 x = i;
                 y = j;
                 return;
             }
         }
     }
 }

 void ConstructTree(int x, int y, int node_id, DIR dir) {
     switch (circuit[x][y]) {
         case '?':
             if (circuit[x][y - ] == '-') ConstructTree(x, y - , node_id, LEFT);
             else if (circuit[x][y + ] == '-') ConstructTree(x, y + , node_id, RIGHT);
             else if (circuit[x - ][y] == '|') ConstructTree(x - , y, node_id, UP);
             else if (circuit[x + ][y] == '|') ConstructTree(x + , y, node_id, DOWN);
             else ConstructTree(x, y - , node_id, LEFT);
             break;
         case ')':
             tree[node_id].type = -;    //and
             tree[node_id].left_child = ++tree_len;
             tree[node_id].right_child = ++tree_len;
             ConstructTree(x - , y - , tree[node_id].left_child, LEFT);
             ConstructTree(x + , y - , tree[node_id].right_child, LEFT);
             break;
         case '>':
             tree[node_id].type = -;    //or
             tree[node_id].left_child = ++tree_len;
             tree[node_id].right_child = ++tree_len;
             ConstructTree(x - , y - , tree[node_id].left_child, LEFT);
             ConstructTree(x + , y - , tree[node_id].right_child, LEFT);
             break;
         case 'o':
             tree[node_id].type = -;    //not
             tree[node_id].left_child = ++tree_len;
             tree[node_id].right_child = -;
             if (circuit[x][y - ] == ')' || circuit[x][y - ] == '>')
                 ConstructTree(x, y - , tree[node_id].left_child, LEFT);
             else if (circuit[x][y - ] == '-' && dir != RIGHT)
                 ConstructTree(x, y - , tree[node_id].left_child, LEFT);
             else if (circuit[x][y + ] == '-' && dir != LEFT)
                 ConstructTree(x, y - , tree[node_id].left_child, RIGHT);
             else if (circuit[x - ][y] == '|' && dir != DOWN)
                 ConstructTree(x - , y, tree[node_id].left_child, UP);
             else ConstructTree(x + , y, tree[node_id].left_child, DOWN);
             break;
         case '+':
             if (dir == UP || dir == DOWN) {
                 if (circuit[x][y - ] == '-') ConstructTree(x, y - , node_id, LEFT);
                 else ConstructTree(x, y + , node_id, RIGHT);
             } else {
                 if (circuit[x - ][y] == '|')ConstructTree(x - , y, node_id, UP);
                 else ConstructTree(x + , y, node_id, DOWN);
             }
             break;
         case '-':
             if (dir == LEFT) ConstructTree(x, y - , node_id, LEFT);
             else ConstructTree(x, y + , node_id, RIGHT);
             break;
         case '|':
             if (dir == UP) ConstructTree(x - , y, node_id, UP);
             else ConstructTree(x + , y, node_id, DOWN);
             break;
         default:
             tree[node_id].left_child = -;
             tree[node_id].right_child = -;
             tree[node_id].type = circuit[x][y] - 'A';
     }
 }

 bool GetInput() {
     scanf("%s", input);
     if (input[] == '*') return false;
     return true;
 }

 int GetOutput(int i) {
     switch (tree[i].type) {
         case -:    //and
             return GetOutput(tree[i].left_child) && GetOutput(tree[i].right_child);
         case -:    //or
             return GetOutput(tree[i].left_child) || GetOutput(tree[i].right_child);
         case -:    //not
             return !GetOutput(tree[i].left_child);
         default:
             return input[tree[i].type] - '';
     }
 }

 int main(){
     while (ReadCircuit()){
         FindOutput();
         tree_len = ;
         ConstructTree(x, y, , LEFT);
         while (GetInput()) {
             printf("%d\n", GetOutput());
         }
         printf("\n");
     }
     return ;
 }