UVA 1262 password (数学编码与解码)*

Shoulder-surfing is the behavior of intentionally and stealthily watching the screen of another person’s electronic device, such as laptop computer or mobile phone. Since mobile devices prevail, it is getting serious to steal personal information by shoulder-surfing. Supposethatwehaveasmartphone. Ifwetouchthescreenkeyboarddirectlytoenterthepassword, this is very vulnerable since a shoulder-surfer easily knows what we have typed. So it is desirable to conceal the input information to discourage shoulder-surfers around us. Let me explain one way to do this. You are given a 6×5 grid. Each column can be considered the visible part of a wheel. So you can easily rotate each column wheel independently to make password characters visible. In this problem, we assume that each wheel contains the 26 upper letters of English alphabet. See the following Figure 1.
Figure 1. 6×5 window clips a valid grid representation for a password. Assumethatwehavealength-5passwordsuchas p1 p2 p3 p4 p5. Inordertopasstheauthentication procedure, we should construct a configuration of grid space where each pi appears in the i-th column of the grid. In that situation we say that the user password is accepted.
Figure 2. A valid grid representation for password ‘COMPU’.
Let me start with one example. Suppose that our password was set ‘COMPU’. If we construct the grid as shown in Figure 2 on next page, then the authentication is successfully processed. In this password system, the position of each password character in each column is meaningless. If each of the 5 characters in p1 p2 p3 p4 p5 appears in the corresponding column, that can be considered the correct password. So there are many grid configurations allowing one password. Note that the sequence of letters on each wheel is randomly determined for each trial and for each column. In practice, the user is able to rotate each column and press “Enter” key, so a should-surfer cannot perceive the password by observing the 6×5 grid since there are too many password candidates. In this 6×5 grid space, maximally 65 = 7,776 cases are possible. This is the basic idea of the proposed password system against shoulder-surfers. Unfortunately there is a problem. If a shoulder-surfer can observe more than two grid plate configurations for a person, then the shoulder-surfer can reduce the searching space and guess the correct password. Even though it is not easy to stealthily observe other’s more than once, this is one weakness of implicit grid passwords. Let me show one example with two observed configurations for a grid password. The user password is ‘COMPU’, but ‘DPMAG’ is also one candidate password derived from the following configuration.
Figure 3. Both of ‘COMPU’ and ‘DPMAG’ are feasible password . You are given two configurations of grid password from a shoulder-surfer. Suppose that you have succeeded to stealthily record snapshots of the target person’s device (e.g. smart phone). Then your next task is to reconstruct all possible passwords from these two snapshots. Since there are lots of password candidates, you are asked for the k-th password among all candidates in lexicographical order. In Figure 3, let us show the first 5 valid password. The first 5 valid passwords are ‘ABGAG’ , ‘ABGAS’, ‘ABGAU’, ‘ABGPG’ and ‘ABGPS’. The number k is given in each test case differently. If there does not exist a k-th password since k is larger than the number of all possible passwords, then you should print ‘NO’ in the output. Input Your program is to read from standard input. The input consists of T test cases. The number of test cases T is given in the first line of the input. The first line of each test case contains one integer, K, the order of the password you should find. Note that 1 ≤ K ≤ 7,777. Next the following 6 lines show the 6 rows of the first grid and another 6 lines represent the 6 rows of the second grid. Output Your program is to write to standard output. Print exactly the k-th password (including ‘NO’) in one line for each test case. The following shows sample input and output for three test cases. Sample Input 3 1 AYGSU DOMRA CPFAS XBODG WDYPK PRXWO CBOPT DOSBG GTRAR APMMS WSXNU EFGHI 5 AYGSU DOMRA CPFAS XBODG WDYPK PRXWO CBOPT DOSBG GTRAR APMMS WSXNU EFGHI 64 FGHIJ EFGHI DEFGH CDEFG BCDEF ABCDE WBXDY UWYXZ XXZFG YYFYH EZWZI ZGHIJ Sample Output ABGAG ABGPS NO

#include<bits/stdc++.h>
#define mod 1e9+7
#define ll long long
#define maxn 205
#define MAX 1000000000
#define ms memset
using namespace std;

char mp1[6][6] , mp2[6][6];
int t,n,flag,cnt[10];
vector<int> st[5];
/*
题目大意：两个表，
一串编码满足每个字母都对应在两个表对应列中出现过，
这个编码串应该是一个集合，所以对于给定的序号，求出对应顺序的串。

典型的编码与解码的过程。
数学解码见代码即可。
就是不断的和后缀乘积比较，
然后更新n大小。
*/
int main()
{
    scanf("%d",&t);
    while(t--)
    {
         scanf("%d",&n); flag=1;

         for(int i=0;i<6;i++)  scanf("%s",mp1[i]);
         for(int i=0;i<6;i++)  scanf("%s",mp2[i]);

         for(int i=0;i<5;i++)
         {
             int tp[30];memset(tp,0,sizeof(tp));
             st[i].clear();

             for(int j=0;j<6;j++)
             {
                 int id1 = mp1[j][i]-'A';
                 tp[id1]=1;
             }

             for(int j=0;j<6;j++)
             {
                 int id2 = mp2[j][i]-'A';
                 if(tp[id2]) st[i].push_back(id2);
             }

             sort( st[i].begin() , st[i].end() );///排序和unique去重的顺序不能错
             int sz=unique(st[i].begin(),st[i].end())-st[i].begin();///unique函数的特性，不是删除重复元素，而是把重复元素全部积累到容器尾部
             cnt[i]=sz;
            /// st[i].resize(cnt[i]);  
            
             if(cnt[i]==0) { flag=0; break; }
         }

         cnt[5]=1;
         for(int i=4;i>=0;i--)
             if(i!=4)  cnt[i]*=cnt[i+1];

        if(n>cnt[0]||flag==0) { puts("NO");continue; }

        for(int i=0;i<5;i++)
        {
             int t=(n%cnt[i+1]==0)?(n/cnt[i+1]-1):(n/cnt[i+1]);
             printf("%c",'A'+st[i][t]);
             n-=(t*cnt[i+1]);
         }
        puts("");
    }
    return 0;
}