S-Trees 

A Strange Tree (S-tree) over the variable set  is a binary tree
representing a Boolean function . Each path of the S-tree begins at the root node and consists
of n+1 nodes. Each of the S-tree's nodes has a depth, which is the amount of nodes between itself and the root (so the root has depth 0). The nodes with depth less than n are called non-terminal nodes. All non-terminal nodes
have two children: the right child and the left child. Each non-terminal node is marked with some variablex_i from the variable set X_n. All non-terminal nodes with the same depth are
marked with the same variable, and non-terminal nodes with different depth are marked with different variables. So, there is a unique variable x_i1 corresponding to the root, a unique variable x_i2 corresponding
to the nodes with depth 1, and so on. The sequence of the variables  is called the variable ordering.
The nodes having depth nare called terminal nodes. They have no children and are marked with either 0 or 1. Note that the variable ordering and the distribution of 0's and 1's on terminal nodes are sufficient to completely describe an S-tree.

As stated earlier, each S-tree represents a Boolean function f. If you have an S-tree and values for the variables ,
then it is quite simple to find out what  is: start with the root. Now repeat the following: if the node you are
at is labelled with a variable x_i, then depending on whether the value of the variable is 1 or 0, you go its right or left child, respectively. Once you reach a terminal node, its label gives the value of the function.

Figure 1: S-trees for the function 

On the picture, two S-trees representing the same Boolean function, ,
are shown. For the left tree, the variable ordering is x₁, x₂, x₃, and for the right tree it is x₃, x₁, x₂.

The values of the variables , are given as a Variable Values Assignment (VVA) 

with .
For instance, ( x₁ = 1, x₂ =
1 x₃ = 0) would be a valid VVA for n =
3, resulting for the sample function above in the value .
The corresponding paths are shown bold in the picture.

Your task is to write a program which takes an S-tree and some VVAs and computes  as
described above.

Input 

The input file contains the description of several S-trees with associated VVAs which you have to process. Each description begins with a line containing a single integer n, ,
the depth of the S-tree. This is followed by a line describing the variable ordering of the S-tree. The format of that line is xi₁ xi₂...xi_n.
(There will be exactly n different space-separated strings). So, for n =
3 and the variable orderingx₃, x₁, x₂,
this line would look as follows:

x3 x1 x2

In the next line the distribution of 0's and 1's over the terminal nodes is given. There will be exactly 2ⁿcharacters (each of which can be 0 or 1), followed by the new-line character. The characters
are given in the order in which they appear in the S-tree, the first character corresponds to the leftmost terminal node of the S-tree, the last one to its rightmost terminal node.

The next line contains a single integer m, the number of VVAs, followed by m lines describing them. Each of the m lines contains exactly n characters (each of which can be 0 or
1), followed by a new-line character. Regardless of the variable ordering of the S-tree, the first character always describes the value of x₁, the second character describes the value of x₂, and so on. So, the line

110

corresponds to the VVA ( x₁ = 1, x₂ = 1, x₃ = 0).

The input is terminated by a test case starting with n = 0. This test case should not be processed.

Output 

For each S-tree, output the line ``S-Tree #j:", where j is
the number of the S-tree. Then print a line that contains the value of  for
each of the given m VVAs, where f is
the function defined by the S-tree.

Output a blank line after each test case.

 Sample Input 

3
x1 x2 x3
00000111
4
000
010
111
110
3
x3 x1 x2
00010011
4
000
010
111
110
0

Sample Output 

S-Tree #1:
0011

S-Tree #2:
0011

忍不住吐槽了。。UVa的题意难懂，自己的英文水平也不够。所以其实这道题只要看懂了题意，就很简单了。。

有一棵完全二叉树，每一层上面的结点值都相同。并且告诉我们最后的叶子的值（按照从左到右的次序排列）

然后从根节点开始，如果为0则走到左子树，为1则走到右子树。问最后到叶子时为多少

接下来有几组数据，每一组告诉你二叉树上每一层的值。

其实都不需要建树，根据二叉树的特性，结点为k，左子树为2*k-1，右子树为2*k。所以就可以直接得到答案。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
int main ()
{
    int n,i,j,t=1;
    char str[1000];
    while(cin>>n)
    {
        int a[1000]={0};
        if (n==0) break;
        getchar();
        gets(str);
        gets(str);
        printf("S-Tree #%d:\n",t++);
        int m,k=1,p=0;
        char num[1000];
        cin>>m;
        getchar();
        char fi[1000];
        while(m--)
        {
            k=1;
            gets(num);
            int len=strlen(num);
            for (i=0; i<len; i++)
                if (num[i]=='0')
                    k=2*k-1;
                else
                    k=2*k;
            fi[p++]=str[k-1];
        }
        fi[p]='\0';
        cout<<fi<<endl;
        cout<<endl;
    }
    return 0;
}