ZOJ(3455)

Shizuka's Letter

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

Nobita receives a letter from Shizuka. For the sake of security, the letter's content T is produced as follows, first the message is written, then the substitution cipher and transposition cipher is applied to the message. Finally, the encrypted message is inserted into another text.

Substitution cipher changes all occurrences of each letter to some other letter. Substitutes for all letters must be different. For example, after substitution cipher, the message "BBA" can become "AAC".

Transposition cipher applies some permutation to the letters of the message. For example, after applying the permutation (1, 3, 2), the second letter moves to the third place, the third letter moves to the second place, so the message "AAC" turns to "ACA".

For example, suppose the original message is "BBA", after substitution, it becomes "AAC", then after transposition, it becomes "ACA". Finally the encrypted message "ACA" is inserted into another text "CBC", after letter 'B', so the content of the letter is "CBACAC".

Nobita don't know what the original message is, but he guesses the message should be P. Now given the letter's content T and Nobita's guess P, you should determine if Nobita's guess is possible to be right.

Input

There are multiple cases.

For each case, the first line is letter's content T, the second line is Nobita's guess P. P and T are strings consist of characters whose ASCII code is between 33 ('!') and 126 ('~'). The length of P and T is no more than 500000. P is guaranteed to be shorter than T.

Output

For each case, if Nobita's guess is possible to be right, output "Yes", otherwise output "No". If the answer is "Yes", it should be followed by another line of integers which denote all the positions (0-based) of the message in the content.

Sample Input

CBACAC
BBA
ABCDE
BBA

Sample Output

Yes
2 3
No
转：http://blog.watashi.ws/1760/zojmonthly1012/
题意：有一种加密方法，对于字符串P，首先将字符串中的字符进行替换，然后可以对位置进行交换，最后将它插入另一个字符串中间获得加密串T。然后对于一对T与P，求T是否可以为P的一个加密结果，若是则求所有的加密位置。
思路：首先只考虑替换和交换这两步，那么会知道，这样变化后会满足出现i次的字母的个数l[i]是不变的，反之，如果满足这个条件，则一定可以通过替换加交换得到。而从位置j到位置j+1，多了一个字符T[j+n]，少了T[j]，所以最多有两个l[i]发生了变化。如果我们用一个变量k，记录有多少l[i]与P的一致，那么k==SIGMA的时候，就是一个合法的位置。每一步，这些变量都可以在O(1)的时间内得到维护，所以总的复杂度是O(n)的。
难点：维护k。

 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define  maxn 500500
 #define ASCII 256
 int c[ASCII];
 int l[maxn];
 char T[maxn];
 char P[maxn];
 int main()
 {
     int n,m,k;
     vector<int>ans;
     while(~scanf("%s%s",T,P))
     {
         n=strlen(T);
         m=strlen(P);
         fill(c,c+ASCII,);
         for(int i=;i<m;i++)//字符作下标对应的是是ASCII码。
             c[P[i]]++;
         fill(l+,l++m,);
         for(int i=;i<ASCII;i++)
             l[c[i]]--;
         k=count(l+,l++m,);

         ans.clear();
         fill(c,c+ASCII,);
         for(int i=;i<n;i++)
         {
             if(i>=m)
             {
                 int &temp1=c[T[i-m]];//不能掉了引用符号
                 if(l[temp1]==)
                     k--;
                 if(l[temp1]==)
                     k++;
                 l[temp1]--;
                 temp1--;
                 if(temp1!=)
                 {
                     if(l[temp1]==-)
                         k++;
                      if(l[temp1]==)
                         k--;
                     l[temp1]++;
                 }
             }
             int &temp2=c[T[i]];
             if(temp2!=)
             {
                 if(l[temp2]==)
                     k--;
                 if(l[temp2]==)
                     k++;
                 l[temp2]--;
             }
             temp2++;
             if(l[temp2]==-)
             k++;
             if(l[temp2]==)
             k--;
             l[temp2]++;
             if(k==m)
             {
                 ans.push_back(i-m+);
             }
         }
         if(ans.empty())
             puts("No");
         else
         {
             puts("Yes");
             for(int i=;i<ans.size();i++)
                 printf(i==ans.size()-?"%d\n":"%d ",ans[i]);
         }
     }
     return ;
 }