Description

Some message encoding schemes require that an encoded message be sent in two parts. The first part, called the header, contains the characters of the message. The second part contains a pattern that represents the message. You must write a program that can decode messages under such a scheme.
The heart of the encoding scheme for your program is a sequence of “key” strings of 0’s and 1’s as follows:
0, 00, 01, 10, 000, 001, 010, 011, 100, 101, 110, 0000, 0001, . . . , 1011, 1110, 00000, . . .
The first key in the sequence is of length 1, the next 3 are of length 2, the next 7 of length 3, the next 15 of length 4, etc. If two adjacent keys have the same length, the second can be obtained from the first by adding 1 (base 2). Notice that there are no keys in the sequence that consist only of 1’s.
The keys are mapped to the characters in the header in order. That is, the first key (0) is mapped to the first character in the header, the second key (00) to the second character in the header, the kth key is mapped to the kth character in the header. For example, suppose the header is:
AB#TANCnrtXc
Then 0 is mapped to A, 00 to B, 01 to #, 10 to T, 000 to A, ..., 110 to X, and 0000 to c.
The encoded message contains only 0’s and 1’s and possibly carriage returns, which are to be ignored. The message is divided into segments. The first 3 digits of a segment give the binary representation of the length of the keys in the segment. For example, if the first 3 digits are 010, then the remainder of the segment consists of keys of length 2 (00, 01, or 10). The end of the segment is a string of 1’s which is the same length as the length of the keys in the segment. So a segment of keys of length 2 is terminated by 11. The entire encoded message is terminated by 000 (which would signify a segment in which the keys have length 0). The message is decoded by translating the keys in the segments one-at-a-time into the header characters to which they have been mapped.

Input

The input file contains several data sets. Each data set consists of a header, which is on a single line by itself, and a message, which may extend over several lines. The length of the header is limited only by the fact that key strings have a maximum length of 7 (111 in binary). If there are multiple copies of a character in a header, then several keys will map to that character. The encoded message contains only 0’s and 1’s, and it is a legitimate encoding according to the described scheme. That is, the message segments begin with the 3-digit length sequence and end with the appropriate sequence of 1’s. The keys in any given segment are all of the same length, and they all correspond to characters in the header. The message is terminated by 000.
Carriage returns may appear anywhere within the message part. They are not to be considered as part of the message.

Output

For each data set, your program must write its decoded message on a separate line. There should not be blank lines between messages.

Sample input

TNM AEIOU
0010101100011
1010001001110110011
11000
$# 0100000101101100011100101000

Sample output

TAN ME ##*$

Analyze

看紫書的時候卡在這題老久了，題目倒是看懂了，但是劉老師的代碼前幾眼實在是有點抽象，不過懂了之後確實感覺很巧妙。
題目會給你二進制遞增(在各自的位數裏遞增)序列，然後先輸入一串你自定義的編碼頭，將這個串的每個字符和二進制序列的每個數建立映射，再根據後面輸入的編碼按要求一一對應輸出。

什麽是各自的位數呢，比如：
1位： 0
2位： 00 01
3位： 000 001 010 011 100 101 110 111
...
將它們寫在一行就是:

0,00,01,10,000,001,010,011,100,101,110,111,0000, . . . (無限長)

假設編碼頭是AB#TANC，那麽映射是這樣的：

0???00???01???10???000???001???010
A????B???? #?????T????A????N????C

編碼的讀入要求就不用我多說了吧。

解讀一下核心readCodes函數：

readCodes()函數,作用是讀取每組數據首行的編碼頭

int readCodes() {
    memset(code, 0, sizeof(code));
    code[1][0] = readChar();        // 先把編碼頭的第一個字母讀進來
    for(int len = 2; len <= 7; len++) { 
        for(int i = 0; i < (1 << len) - 1; i++) {
            int ch = getchar();
            // 文件結束，終止程序
            if(ch == EOF) {
                return 0;
            }
            // 讀一行
            if(ch == ‘\n‘ || ch == ‘\r‘) {
                return 1;
            }
            code[len][i] = ch;
        }
    }
    return 1;
}

怎麽理解readCodes()呢?之前列舉的編碼頭AB#TANC對應的映射二進制數是

0 00 01 10 000 001 010
位數： 1 2 2 2 3 3 3

可以看到1位二進制的只有0一種情況，不用循環處理，所以直接由code[1][0] = readChar();讀金第一個字符。

你會問為什麽不從code[0][0]開始呢？因為僅從自然語義來說更容易操作，假設1位就寫code[1][xxx]而不是code[0][xxx]。

從二位的二進制數開始，每種位(n)二進制數的組合就有2^n-1種(為什麽不是2^n種呢，因為題目要求後面輸入的編碼全為1的代表結束，所以和編碼頭映射時全為1的編碼無任何意義，直接舍棄)。

所以我們會發現函數中的第二層循環for(int i = 0; i < (1 << len) - 1; i++)算的正是每種位二進制數所有的取值對應的10進制數，並將算出的i映射到code數組的第二個維度下標上。

而第一層循環負責控制二進制位數的範圍。

就之前的例子來說，AB#TANC映射到數組裏是這樣的：

位數為2的映射： code[2][0(00)] = B的asc2值 code[2][1(01)] = # 的asc2值 code[2][2(10)] = T的asc值
位數為3的映射： code[3][0(000)] = A的asc2值 code[3][1(001)] = N的asc2值 code[3][2(010)] = C的asc值

我覺得我解釋得夠詳細了吧？難點幾乎就是在這了

Code

#include <stdio.h>
#include <string.h>
int code[8][1<<8];
int readChar() {
    while(true) {
        int ch = getchar();
        // 讀到非換行符為止
        if(ch != ‘\n‘ && ch != ‘\r‘) {
            return ch;
        }
    }
}
int readInt(int c) {    //將指定的下c位二進制轉換為10進制
    int v = 0;
    while(c--) {
        v = v * 2 + readChar() - ‘0‘;
    }
    return v;
}

int readCodes() {
    memset(code, 0, sizeof(code));
    // 讀取編碼頭的第一個字符
    code[1][0] = readChar();
    for(int len = 2; len <= 7; len++) {
        for(int i = 0; i < (1 << len) - 1; i++) {
            int ch = getchar();
            if(ch == EOF) {
                return 0;
            }
            if(ch == ‘\n‘ || ch == ‘\r‘) {
                return 1;
            }
            code[len][i] = ch;
        }
    }
    return 1;
}

int main() {
    while(readCodes()) {    //讀編碼頭
        while(true) {
            int len = readInt(3);
            if(!len) {
                break;
            }
            while(true) {           //讀編碼
                int v = readInt(len);
                if(v == (1 << len) - 1) {
                    break;
                }
                putchar(code[len][v]);
            }
        }
        putchar(‘\n‘);
    }
    return 0;
}

[算法競賽入門經典]Message Decoding,ACM/ICPC World Finals 1991,UVa213