uva 508 Morse Mismatches

Samuel F. B. Morse is best known for the coding scheme that carries his name. Morse code is still used in international radio communication. The coding of text using Morse code is straightforward. Each character (case is insignificant) is translated to a predefined sequence of dits and dahs (the elements of Morse code). Dits are represented as periods (``.'') and dahs are represented as hyphens or minus signs (``-''). Each element is transmitted by sending a signal for some period of time. A dit is rather short, and a dah is, in perfectly formed code, three times as long as a dit. A short silent space appears between elements, with a longer space between characters. A still longer space separates words. This dependence on the spacing and timing of elements means that Morse code operators sometimes do not send perfect code. This results in difficulties for the receiving operator, but frequently the message can be decoded depending on context.

In this problem we consider reception of words in Morse code without spacing between letters. Without the spacing, it is possible for multiple words to be coded the same. For example, if the message ``dit dit dit'' were received, it could be interpreted as ``EEE'', ``EI'', ``IE'' or ``S'' based on the coding scheme shown in the sample input. To decide between these multiple interpretations, we assume a particular context by expecting each received word to appear in a dictionary.

For this problem your program will read a table giving the encoding of letters and digits into Morse code, a list of expected words (context), and a sequence of words encoded in Morse code (morse). These morse words may be flawed. For each morse word, your program is to determine the matching word from context, if any. If multiple words from context match morse, or if no word matches perfectly, your program will display the best matching word and a mismatch indicator.

If a single word from context matches morse perfectly, it will be displayed on a single line, by itself. If multiple context words exist for a given morse, the first matching word will be displayed followed by an exclamation point (``!'').

We assume only a simple case of errors in transmission in which elements may be either truncated from the end of a morse word or added to the end of a morse word. When no perfect matches for morse are found, display the word from context that matches the longest prefix of morse, or has the fewest extra elements beyond those in morse. If multiple words in context match using these rules, any of these matches may be displayed. Words that do not match perfectly are displayed with a question mark (``?'') suffixed.

The input data will only contain cases that fall within the preceding rules.

Input

The Morse code table will appear first and consists of lines each containing an uppercase letter or a digit C, zero or more blanks, and a sequence of no more than six periods and hyphens giving the Morse code for C. Blanks may precede or follow the items on the line. A line containing a single asterisk (``*''), possibly preceded or followed by blanks, terminates the Morse code table. You may assume that there will be Morse code given for every character that appears in the context section.

The context section appears next, with one word per line, possibly preceded and followed by blanks. Each word in context will contain no more than ten characters. No characters other than upper case letters and digits will appear. Thered will be at most 100 context words. A line containing only a single asterisk (``*''), possibly preceded or followed by blanks, terminates the context section.

The remainder of the input contains morse words separated by blanks or end-of-line characters. A line containing only a single asterisk (``*''), possibly preceded or followed by blanks, terminates the input. No morse word will have more than eighty (80) elements.

Output

For each input morse word, display the appropriate matching word from context followed by an exclamation mark (``!'') or question mark (``?'') if appropriate. Each word is to appear on a separate line starting in column one.

Sample Input

A       .-
B       -...
C       -.-.
D       -..
E       .
F       ..-.
G       --.
H       ....
I       ..
J       .---
K       -.-
L       .-..
M       --
N       -.
O       ---
P       .--.
Q       --.-
R       .-.
S       ...
T       -
U       ..-
V       ...-
W       .--
X       -..-
Y       -.--
Z       --..
0       ------
1       .-----
2       ..---
3       ...--
4       ....-
5       .....
6       -....
7       --...
8       ---..
9       ----.
*
AN
EARTHQUAKE
EAT
GOD
HATH
IM
READY
TO
WHAT
WROTH
*
.--.....--  
.....--....
--.----..   
.--.-.----..
.--.....--  
.--.
..-.-.-....--.-..-.--.-.
..--  
.-...--..-.--
----     
..--
*
Sample output  
 WHAT 
 HATH
 GOD
 WROTH?
 WHAT
 AN
 EARTHQUAKE
 EAT!
 READY
 TO
 EAT!

给定一些已知字典，给定一些编码，求解这些编码的对应原文，如果可以精确匹配，则直接输出原单词，
如果有多个可精确匹配的结果，则输出匹配结果里字典序最小的单词并在末位加上“!”；
如果无法精确匹配，则可以在编码的末尾增加或删除一些字符后匹配单词（增删量最小），无论增删后匹配一个还是多个，最后都要加上“？”；
如果有多个模糊匹配结果（增删数相等），则输出字典序最小的匹配结果；
如果无精确匹配也无模糊匹配结果，则输出整个给定字典里字典序最小的那个单词。

看清题意就好，用map做，不难！

#include <iostream>
#include <map>
#include <cmath>
#include <string>
#include <algorithm>
using namespace std;

map <char, string>morse;
string words[],codes[];
int n;
map<char,string>::iterator t;

string change(string word)
{
    char code[];
    int wordsize = word.length(),p = ;

    for(int i = ;i < wordsize; i++){

        for(t = morse.begin();t != morse.end();t++){

            if((*t).first == word[i]){
                int morsesize = ((*t).second).length();
                for(int j = ;j < morsesize;j++ )code[p++] = ((*t).second)[j];
                break;
            }
        }
    }
    code[p] = '\0';
    return code;
}

void detail(string co)
{
    int p = co.length(),a,b=,c;
    bool flag;
    for(int i = ;i < n;i++){
        int q = codes[i].length();
        flag = true;
        if(q > p){
            for(int j = ;j < p;j++){
                if(co[j] != codes[i][j]){
                    flag = false;
                    break;
                }
            }
        }
        else{
            for(int j = ;j < q;j++){
                if(co[j] != codes[i][j]){
                    flag = false;
                    break;
                }
            }
        }
        if(flag){
            a = abs(q - p);
            c = i;
        }
        if(flag && a < b){
            b = a;
            c = i;
        }
    }
    cout << words[c] << "?" <<endl;
}

void deal(string co)
{
    int m = ;
    for(int i = ;i < n;i++){
        if(co == codes[i]){
            if(m == )cout << words[i];
            m++;
        }
    }
    if(m == )cout << endl;
    else if(m > ) cout << "!" << endl;
    else if(m == )detail(co);
}

int main()
{
    char ch;

    while(cin >> ch){                   //单词对应的编码
        if(ch == '*')break;
        string mima;
        cin >> mima;
        morse[ch] = mima;
     }

     for(int i = ; ; i++){                //字典中的单词
        cin >> words[i];
        if(words[i][] == '*'){
            n = i;
            break;
        }
     }
    sort(words , words + n);           //字典序从小到大排列
    for(int i = ;i < n;i++){
        //cout<<"-**-"<<words[i]<<endl;
        codes[i] = change( words[i] );
    }

     string co;
     while(cin >> co){
        if(co[] == '*')break;
        deal(co);
     }

    //system("pause");
    return ;
}

提交以上代码....发现 还是结果错误

有两个小错误，通过以下测试得出的

1.

S ...
O ---
T -
*
SO
ST
*
...--

得到的结果是ST 而正确答案是SO     经检查发现detail函数中第一个flag只判断第一次true的情况，所以加上条件cot即可

2.

S ...
O ---
T -
V ...-
I ..
A .-
*
SO
IAT
*
...---.

得到的结果是IAT  而正确答案是SO       经检查发现detail函数中给a赋值不是只在第一次flag判断中赋值，所有情况为都要给a赋值，由于上一部加上cot条件导致这一步出错所以将a的赋值语句移至flag为true情况外即可

AC代码

 #include <iostream>
 #include <map>
 #include <cmath>
 #include <string>
 #include <algorithm>
 using namespace std;

 map <char, string>morse;
 string words[],codes[];
 int n;
 map<char,string>::iterator t;

 string change(string word)
 {
     char code[];
     int wordsize = word.length(),p = ;

     for(int i = ;i < wordsize; i++){

         for(t = morse.begin();t != morse.end();t++){

             if((*t).first == word[i]){
                 int morsesize = ((*t).second).length();
                 for(int j = ;j < morsesize;j++ )code[p++] = ((*t).second)[j];
                 break;
             }
         }
     }
     code[p] = '\0';
     return code;
 }

 void detail(string co)
 {
     int p = co.length(),a,b=,c,cot=;       //q为待检测电码长度
     bool flag;
     for(int i = ;i < n;i++){
         int q = codes[i].length();       //p为原单词电码的长度
         //cout<<words[i]<<" "<<codes[i]<<" "<<q<<endl;
         flag = true;
         if(q > p){
             for(int j = ;j < p;j++){
                 if(co[j] != codes[i][j]){
                     flag = false;
                     break;
                 }
             }
         }
         else{
             for(int j = ;j < q;j++){
                 if(co[j] != codes[i][j]){
                     flag = false;
                     break;
                 }
             }
         }
         a = abs(q - p);
         if(flag && cot){
             c = i;
             cot = ;
             //cout<<"aa "<<a<<" "<<c<<endl;
         }
         if(flag && a < b){
             b = a;
             c = i;
         }
     }
     cout << words[c] << "?" <<endl;
 }

 void deal(string co)
 {
     int m = ;
     for(int i = ;i < n;i++){
         if(co == codes[i]){
             if(m == )cout << words[i];
             m++;
         }
     }
     if(m == )cout << endl;
     else if(m > ) cout << "!" << endl;
     else if(m == )detail(co);
 }

 int main()
 {
     char ch;

     while(cin >> ch){                   //单词对应的编码
         if(ch == '*')break;
         string mima;
         cin >> mima;
         morse[ch] = mima;
      }

      for(int i = ; ; i++){                //字典中的单词
         cin >> words[i];
         if(words[i][] == '*'){
             n = i;
             break;
         }
      }
     sort(words , words + n);           //字典序从小到大排列

     for(int i = ;i < n;i++){
         codes[i] = change( words[i] );
         /*cout<<"words  "<<words[i]<<endl;
         cout<<"codes  "<<codes[i]<<endl;*/
     }

      string co;
      while(cin >> co){
         if(co[] == '*')break;
         deal(co);
      }

     //system("pause");
     return ;
 }