UVa Problem Solution: 843 - Crypt Kicker

This is the hardest problem ever since in this book. After some thinking, I realized that this problem can be solved with backtracking. After some more thinking, I realized that we should backtrack the cipher, i.e., the decrypt table along with the encrypt table. Unfortunately, one day has passed after these thinking.

The search procedure can be accelerated by three means: 
  1) index the dictionary by word length,
  2) associate each word with a signature that specify the word's character pattern, and
  3) sort the words by length in reverse order.

Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 843 C "Crypt Kicker" */
8. #include <stdio.h>
9. #include <stdlib.h>
10. #include <string.h>
11. #include <strings.h>
12.                
13. #define WORDSIZE 17
14. #define LINESIZE 81
15. #define NLINEWORDS (LINESIZE/2)
16. #define NWORDS 1000
17. #define NCHARS 128
19. /*************************************************************************
20.  * Stack (FILO)                                                          *
21.  * Note: No error check is performed.                                    *
22.  *************************************************************************/
23. #define STACKSIZE NWORDS
25. /* a cipher; used for backtracking */
26. typedef struct cipher
27. {
28.   int pos; /* the position of the current text in the line*/
29.   char decrypt[NCHARS]; /* the decrypt table to current*/
30.   char encrypt[NCHARS]; /* the encrypt table to current*/
31. } cipher;
33. typedef cipher valuetype;
35. typedef struct stack
36. {
37.   size_t top;
38.   valuetype values[STACKSIZE];
39. } stack;
41. void initstack(stack *s)
42. {
43.   s->top = 0;
44. }
46. int emptystack(stack *s)
47. {
48.   return s->top == 0;
49. }
51. void pushstack(stack *s, valuetype v)
52. {
53.   s->values[s->top++] = v;
54. }
56. valuetype popstack(stack *s)
57. {
58.   return s->values[--s->top];
59. }
60. /*************************************************************************/
62. typedef int sig_t[WORDSIZE];
64. /* a word in the dictionary */
65. typedef struct dictword 
66. {
67.   char *word; /* the word */
68.   sig_t sig; /* the signature of the word */
69. } dictword;
71. /* a series of words in the dictionary */
72. typedef struct dictwords
73. {
74.   dictword words[NWORDS];
75.   int size;
76. } dictwords;
78. /* a dictionary indexed by the length of the words */
79. typedef dictwords dict_t[WORDSIZE];
81. void read_words(char words[][WORDSIZE], int nwords)
82. {
83.   while (nwords-- > 0) {
84.     gets(words[nwords]);
85.   }
86. }
88. void make_sig(char *s, sig_t sig)
89. {
90.   int trans[NCHARS] = {0};
91.   int i, t;
92.   for (i = 0, t = 1; s[i] != '/0'; ++i) {
93.     if (trans[s[i]]) {
94.       sig[i] = trans[s[i]];
95.     } else {
96.       sig[i] = trans[s[i]] = t++;
97.     }
98.   }
99. }
101. void make_dict(char words[][WORDSIZE], int nwords, dict_t dict)
102. {
103.   int i;
104.   for (i = 0; i < WORDSIZE; ++i) {
105.     dict[i].size = 0;
106.   }
107.   for (i = 0; i < nwords; ++i) {
108.     dictword dw;
109.     dw.word = words[i];
110.     make_sig(dw.word, dw.sig);
111.     int len = strlen(words[i]);
112.     dict[len].words[dict[len].size++] = dw;
113.   }
114. }
116. int split(char line[], int size, char *texts[])
117. {
118.   int i;
119.   int ntexts;
120.   for (i = 0, ntexts = 0; i < size; ++ntexts) {
121.     texts[ntexts] = line + i;
122.     for (; line[i] != ' ' && line[i] != '/0'; ++i);
123.     line[i++] = '/0';
124.   }
125.   return ntexts;
126. }
128. int strlencmp(void const *x, void const *y)
129. {
130.   return strlen(*(char **)y) - strlen(*(char **)x);
131. }
133. char *decrypt(dict_t dict, char line[])
134. {
135.   int i;
136.   int size = strlen(line);
137.   char *texts[LINESIZE];
138.   /* split the line into words */
139.   int ntexts = split(line, size, texts);
140.   /* sort by the word length: longest first */
141.   qsort(texts, ntexts, sizeof(char *), strlencmp);  
142.   /* generate the signatures of the words */
143.   sig_t sigs[NLINEWORDS];
144.   for (i = 0; i < ntexts; ++i) {
145.     make_sig(texts[i], sigs[i]);
146.   }
147.   
148.   stack s;
149.   initstack(&s);
150.   cipher c = {0, {0}, {0}};
151.   pushstack(&s, c);
153.   /* backtracking with the ciphers */
154.   while (!emptystack(&s) && (c = popstack(&s), c.pos < ntexts)) {
155.     char *text = texts[c.pos];
156.     int len = strlen(text);
157.     dictwords *dws = &dict[len];
158.     for (i = 0; i < dws->size; ++i) {
159.       /* check the signature first to avoid unneccesary cipher checking */
160.       if (memcmp(sigs[c.pos], dws->words[i].sig, len*sizeof(int)) == 0) {
161.         cipher cc = c;
162.         char *word = dws->words[i].word;
163.         int j;
164.         for (j = 0; j < len; ++j) {
165.           if (!cc.decrypt[text[j]] && !cc.encrypt[word[j]]) {
166.             cc.decrypt[text[j]] = word[j];
167.             cc.encrypt[word[j]] = text[j];
168.           } else if (cc.decrypt[text[j]] != word[j]) {
169.             break;
170.           }
171.         }
172.         if (j == len) { /* cipher verified, track it */
173.           ++cc.pos;
174.           pushstack(&s, cc);
175.         }
176.       } 
177.     }
178.   }
180.   if (c.pos != ntexts) { /* cannot be decrypted */
181.     memset(c.decrypt, '*', NCHARS);
182.   }
183.   c.decrypt['/0'] = ' ';
184.   
185.   for (i = 0; i < size; ++i) {
186.     line[i] = c.decrypt[line[i]];
187.   }
189.   return line;
190. }
192. int main(int argc, char *argv[])
193. {
194. #ifndef ONLINE_JUDGE
195.   char in[256];
196.   char out[256];
197.   strcpy(in, argv[0]);
198.   strcat(in, ".in");
199.   strcpy(out, argv[0]);
200.   strcat(out, ".out");
201.   if (freopen(in, "r", stdin) == NULL)
202.     fprintf(stderr, "%s: cannot open input file: %s./n", argv[0], in);
203.   if (freopen(out, "w", stdout) == NULL)
204.     fprintf(stderr, "%s: cannot open output file: %s./n", argv[0], out);
205. #endif
207.   int nwords;
208.   scanf("%d/n", &nwords);
210.   char words[NWORDS][WORDSIZE];
211.   read_words(words, nwords);
213.   dict_t dict;
214.   make_dict(words, nwords, dict);
216.   char line[LINESIZE];
217.   while (gets(line) != NULL)
218.     puts(decrypt(dict, line));
220.   return 0;
221. }