UVa Problem Solution: 10150 - Doublets

This problem can be solved by a BFS on a graph that modeling the doublet relationships. If the pair of a and b forms a doublet, then there is a edge between a and b in the graph.

You can divide the dictionary into portions by word size, then handle each portion separately. To get a better RT, build each graph lazily only when needed.

Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 10150 C++ "Doublets" */
8. #include <cstring>
9. #include <iostream>
10. #include <fstream>
11. #include <string>
12. #include <map>
13. #include <queue>
14. #include <list>
15. #include <vector>
16. #include <map>
18. using namespace std;
19.      
20. int const wordcount = 25200;
21. int const wordsize = 20;
22.        
23. typedef vector<char *> wordtable;
25. struct strcomp 
26. { bool operator()(char *s1, char *s2) { return strcmp(s1, s2) < 0; } };
27. typedef map<char *, int, strcomp> wordmap;
29. typedef vector<vector<int> > wordgraph;
31. bool adjacent(char const *s1, char const* s2)
32. {
33.   bool adj = false;
34.   for (int i = 0; s1[i] != '/0'; ++i) {
35.     if (s1[i] != s2[i]) {
36.       adj = !adj;
37.       if (!adj) break;
38.     }
39.   }
40.   return adj;
41. }
43. void build_wordgraph(wordtable const& wt, wordgraph& wg)
44. {
45.   wg.resize(wt.size());
46.   for (int i = 0; i < wt.size() - 1; ++i) {
47.     for (int j = i + 1; j < wt.size(); ++j) {
48.       if (adjacent(wt[i], wt[j])) {
49.         wg[i].push_back(j);
50.         wg[j].push_back(i);
51.       }
52.     }
53.   }
54. }
56. bool get_doublets(wordgraph const& wg, int s, int t, list<int>& doublets)
57. {
58.   queue<int> q;
59.   vector<bool> visited(wg.size(), false);
60.   vector<int> previous(wg.size());
61.   q.push(s);
62.   visited[s] = true;
63.   bool found = false;
64.   while (!q.empty()) {
65.     int v = q.front();
66.     q.pop();
67.     if (v == t) {
68.       found = true;
69.       break;
70.     }
71.     for (int i = 0, size = wg[v].size(); i < size; ++i) {
72.       int a = wg[v][i];
73.       if (!visited[a]) {
74.         q.push(a);
75.         visited[a] = true;
76.         previous[a] = v;
77.       }
78.     }
79.   }
80.   
81.   if (found) {
82.     for (; t != s; t = previous[t]) doublets.push_front(t);
83.     doublets.push_front(t);
84.   }
86.   return found;
87. }
89. int main(int argc, char *argv[])
90. {
91. #ifndef ONLINE_JUDGE
92.   filebuf in, out;
93.   cin.rdbuf(in.open((string(argv[0]) + ".in").c_str(), ios_base::in));
94.   cout.rdbuf(out.open((string(argv[0]) + ".out").c_str(), ios_base::out));
95. #endif
97.   char words[wordcount][wordsize];
98.   int nwords = 0;
99.   for (; cin.getline(words[nwords], wordsize) && words[nwords][0] != '/0'; 
100.        ++nwords) {}
102.   /* index words by size */
103.   vector<wordtable> wts(wordsize);
104.   vector<wordmap> wms(wordsize);
105.   for (int i = 0; i < nwords; ++i) {
106.     int size = strlen(words[i]);
107.     wts[size].push_back(words[i]);            
108.     wms[size].insert(make_pair(words[i], wts[size].size() - 1));
109.   }
110.   
111.   /* we will build wordgraph lazily */
112.   vector<wordgraph> wgs(wordsize);
114.   char source[wordsize], target[wordsize];
115.   int ncases = 0;
116.   while (cin >> source >> target) {
117.     if (ncases++ != 0) cout << '/n';
118.     list<int> doublets;
119.     bool found = false;
120.     int size = strlen(source);
121.     wordtable& wt = wts[size];
122.     wordmap& wm = wms[size];
123.     wordgraph& wg = wgs[size];
124.     if (size == strlen(target)) {
125.       if (wg.empty()) build_wordgraph(wt, wg);
126.       found = get_doublets(wg, wm[source], wm[target], doublets);
127.     }
128.     if (found) {
129.       list<int>::iterator first = doublets.begin(), last = doublets.end();
130.       for (; first != last; ++first) cout << wt[*first] << '/n';
131.     } else {
132.       cout << "No solution./n";
133.     }
134.   }
136.   return 0;
137. }