其实是队友写的

题目链接：http://codeforces.com/contest/903

题意：给出K个串， 每个串长度为N， 问是否可以找到一个模式串， 使得对于任意Si(1<= i < = N),都可以通过交换2个字符(2个字符下标不同，并且必须交换)使其与找到的模式串相同。

题解：很奇妙的解法。

  1：很显然， 一定是这N个串里， 任意S[i]交换(S[i][pos1], S[i][pos2])得到模式串。但是这样从一个串里选2个是C（2，N），然后需要对K个串进行匹配，每次匹配的复杂度是O(N)， 所以总体复杂第是N^3*K的， 显然会被数据卡掉。

  2：现在进行优化， 我们可以任找2个不同的串，用数组记录下来这2个串字符不同的位置，不同的数目为tot。 接下来一点很重要如果tot = 1, 则一定无解， 很显然， 如果

tot > 4, 也一定无解很显然，tot = 4的时候比如(caab, acba)4个位置都不同， 但可以找到模式串acab。 接下来就对其中一个串不同的位置与这个串其他位置进行交换这里复杂度就优化成了O(tot*N)，然后在O(K*N)进行匹配, 总体复杂度为tot*N^2*K。

[cpp] view plain copy

1. #include <bits/stdc++.h>  
2.   
3. using namespace std;  
4. const int N = 2507;  
5. string s[N], res;  
6. bool vis[26];  
7. int h[27], n, k, dif[N], tot;  
8. bool solve(int p1, int p2)  
9. {  
10.     tot = 0;  
11.     for(int i = 0;i < n;i ++)  if(s[p1][i] != s[p2][i]) {  
12.         dif[tot++] = i;  
13.     }  
14.     //cout << tot <<endl;  
15.     if(tot == 1 || tot > 4) {  
16.         return false;  
17.     }  
18.     int ok = 0;  
19.     memset(vis, 0, sizeof(vis));  
20.     for(int i = 0;i < tot;i ++) {  
21.         for(int j = 0;j < n;j ++) {  
22.             if(j == dif[i]) continue;  
23.             res = s[p1];  
24.             int fg = 1, t1 = dif[i], t2 = j;  
25.             swap(res[t1], res[t2]);  
26.             //cout << t1 << " " << t2 << res <<endl;  
27.             for(int now = 0;now < k;now ++) {  
28.                 if(now != p1) {  
29.                     vector<int> vec;  
30.                     for(int p = 0;p < n;p ++) {  
31.                         if(res[p] != s[now][p]) vec.push_back(p);  
32.                     }  
33.                     if(vec.size() == 1 || vec.size() > 2) {  
34.                         fg = 0; break;  
35.                     } else if(vec.size() == 0) {  
36.                         memset(h, 0, sizeof(h));  
37.                         int kk = 0;  
38.                         for(int z = 0;z < n;z ++) {  
39.                             int idx = s[now][z] - 'a';  
40.                             if(h[idx]) {  
41.                                 kk = 1;  
42.                             }  
43.                             h[idx] = 1;  
44.                         }  
45.                         if(!kk) {  
46.                             fg = 0; break;  
47.                         }  
48.                     } else {  
49.                         fg &= (res[vec[0]] == s[now][vec[1]] && res[vec[1]] == s[now][vec[0]]);  
50.                         if(!fg) break;  
51.                     }  
52.                 }  
53.             }  
54.             if(fg) {  
55.                 return 1;  
56.             }  
57.         }  
58.     }  
59.     if(!ok) {  
60.         return false;  
61.     }  
62. }  
63.   
64. int main()  
65. {  
66.     std::ios::sync_with_stdio(false), cin.tie(0);  
67.     cin >> k >> n;  
68.     for(int i = 0;i < k;i ++) cin >> s[i];  
69.     for(int i = 0;i < k;i ++) {  
70.         for(int j = i + 1;j < k;j ++) {  
71.             if(s[i] != s[j]) {  
72.                 int fg1 = solve(i, j);  
73.                 if(fg1) {  
74.                     return cout << res << endl, 0;  
75.                 }  
76.                 return cout << -1 << endl, 0;  
77.             }  
78.         }  
79.     }  
80.     swap(s[0][0], s[0][1]);  
81.     cout << s[0] << endl;  
82.     return 0;  
83. }