POJ 1026 Cipher(置换)

                                                               Cipher

Time Limit: 1000MS   Memory Limit: 10000K
Total Submissions: 19502   Accepted: 5239

Description

Bob and Alice started to use a brand-new encoding scheme. Surprisingly it is not a Public Key Cryptosystem, but their encoding and decoding is based on secret keys. They chose the secret key at their last meeting in Philadelphia on February 16th, 1996. They
chose as a secret key a sequence of n distinct integers, a1 ; . . .; an, greater than zero and less or equal to n. The encoding is based on the following principle. The message is written down below the key, so that characters in the message and numbers in
the key are correspondingly aligned. Character in the message at the position i is written in the encoded message at the position ai, where ai is the corresponding number in the key. And then the encoded message is encoded in the same way. This process is
repeated k times. After kth encoding they exchange their message.

The length of the message is always less or equal than n. If the message is shorter than n, then spaces are added to the end of the message to get the message with the length n.

Help Alice and Bob and write program which reads the key and then a sequence of pairs consisting of k and message to be encoded k times and produces a list of encoded messages.

Input

The input file consists of several blocks. Each block has a number 0 < n <= 200 in the first line. The next line contains a sequence of n numbers pairwise distinct and each greater than zero and less or equal than n. Next lines contain integer number k and
one message of ascii characters separated by one space. The lines are ended with eol, this eol does not belong to the message. The block ends with the separate line with the number 0. After the last block there is in separate line the number 0.

Output

Output is divided into blocks corresponding to the input blocks. Each block contains the encoded input messages in the same order as in input file. Each encoded message in the output file has the lenght n. After each block there is one empty line.

Sample Input

10
4 5 3 7 2 8 1 6 10 9
1 Hello Bob
1995 CERC
0
0

Sample Output

BolHeol  b
C RCE

第一次做这种多个循环节,对每个循环节中的元素分开求解的题目,记录一下。

题意:给出一个n个数的置换,按照置换规则把一个字符串置换k次,如果字符串的长度不足n,则在字符串末尾补空格,直到长度为n。求置换k次之后的字符串是什么。

分析:如果直接按照题目描述的模拟,肯定会超时。

对整个字符串置换,可以转换为对每个循环节进行置换。因为一个循环节里面的元素,对其他元素没有影响,这样我们就可以先求出所有的循环节和每个循环节中的元素及循环节的长度,然后对每个循环节中的元素进行置换。一个循环节中的元素置换k次,等价于每个元素置换k%(这个元素所在循环节的长度)次,这样模拟次数变得很小,就可以模拟了。

#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;

const int N = 215;
char str[N];  //原始字符串
char ans[N]; //置换后的字符串
int key[N];  //置换规则
int cnt; //循环节数量
int num[N]; //每个循环节的长度
int cir[N][N]; //cir[i][j]表示第i个循环节中的第j个元素对应的位置
int vis[N]; //记录每个数是否访问过

int n;

void get_circle() {
    memset(vis, 0, sizeof(vis));
    memset(num, 0, sizeof(num));
    cnt = 0;
    for(int i = 1; i <= n; i++) {
        if(!vis[i]) {
            vis[i] = 1;
            num[cnt] = 0;
            int tmp = key[i];
            cir[cnt][num[cnt]++] = tmp;
            while(!vis[tmp]) {
                vis[tmp] = 1;
                tmp = key[tmp];
                cir[cnt][num[cnt]++] = tmp;
            }
            cnt++;
        }
    }
}

int main() {
    int k;
    while(~scanf("%d",&n) && n) {
        for(int i = 1; i <= n; i++)
            scanf("%d", &key[i]);
        get_circle();
        while(~scanf("%d", &k) && k) {
            gets(str);
            int len = strlen(str);
            for(int i = len; i <= n; i++)
                str[i] = ' ';
            for(int i = 0; i < cnt; i++) {
                for(int j = 0; j < num[i]; j++) {
                    ans[cir[i][(j+k)%num[i]]] = str[cir[i][j]];
                } //第i个循环节中的第j个元素置换k次之后的位置为第(j+k)% num[i]
            }
            ans[n+1] = '\0';
            printf("%s\n", ans+1);
        }
        printf("\n");
    }
    return 0;
}
时间: 2024-11-09 02:11:40

POJ 1026 Cipher(置换)的相关文章

POJ 1026 Cipher[置换]

Cipher 时限:1000MS Description Bob and Alice started to use a brand-new encoding scheme. Surprisingly it is not a Public Key Cryptosystem, but their encoding and decoding is based on secret keys. They chose the secret key at their last meeting in Phila

[ACM] POJ 1026 Cipher (组合数学,置换)

Cipher Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 19228   Accepted: 5148 Description Bob and Alice started to use a brand-new encoding scheme. Surprisingly it is not a Public Key Cryptosystem, but their encoding and decoding is base

poj 1026 Cipher

http://poj.org/problem?id=1026 这道题题意是给你一个置换群,再给你一个字符串,输出经过k次置换的字符串. 就是找循环节. 1 #include <cstdio> 2 #include <cstring> 3 #include <algorithm> 4 #define maxn 3000 5 using namespace std; 6 7 int a[maxn],key[maxn]; 8 int n,k; 9 char str[maxn]

POJ 1026 Cipher 题解

看似简单的字符串处理,不过直接暴力法是会超时的. 故此需要优化,这里使用周期优化. 研究过数列序列的都知道,其实序列反复调用另外一个序列得到一个新的序列,都会出现周期的,问题是周期何时出现,如果利用这个周期. 这就需要分开每个数,使用一个新的数列记录每个数的周期,利用这个周期截去一大段数据,那么剩下的数据就很好处理了. 因为所有的周期数总和都不会超过n,数列的长度的,所以时间效率可以达到O(n),常数项为2. 其他难度,我觉得相对新手来说,就是执行的细节最困难了,比如下标的准确性,如何移动数据等

poj 1026 Cipher (置换群)

链接:poj 1026 题意:给定n个大小1-n的不同的整数作为密钥,给定一个字符串, 求将该字符串经过k次编码后的字符串 分析:暴力求解会超时,可以利用置换群的知识解题 置换群:一个有限集合的一一变换叫做置换,一对对置换组成了置换群. 对于一个集合a(a[1],a[2],a[3]...a[n]) 通过置换可以变成 (b[a[1]],b[a[2]],b[a[3]]...b[a[n]]) b的作用就是置换(可以理解为某种函数的作用),将原来的集合映射成具有 相应次序的集合a',a'可以看做是a的相

POJ 1026 Cipher(置换群)

题目链接 题意 :由n个数字组成的密钥,每个数字都不相同,都在1-n之间,有一份长度小于等于n的信息,要求将信息放到密钥下边,一一对应,信息不足n的时候补空格,然后将位置重新排列,将此过程重复k次,求最后的字符串序列,最后的空格不用输出. 思路 :如果按照最原始的求循环结的话会超时,因为k值范围很大.所以要用置换群,把每个的元素的循环求出来,直接对其取余即可.会3270的话,这个题理解起来挺容易的. 1 //1126 2 #include <stdio.h> 3 #include <st

poj 2369 Permutations 置换水题

找循环节求lcm就够了,若答案是12345应该输出1,被坑了下. #include<iostream> #include<cstdio> #include<cstring> #include<string> #include<algorithm> #include<cmath> using namespace std; #define INF 0x3FFFFFF #define MAXN 2222 #define eps 1e-6 i

poj 1721 CARDS(置换)

http://poj.org/problem?id=1721 大致题意:原始序列通过洗牌机洗牌s次后变为当前序列,已知当前序列,求原始序列. 在置换群快速幂运算 研究与探讨中最后有详解,有两种解法,一种是求出置换的长度a(即一副牌洗a次后变回原来的位置),现已知原始序列置换s次变为当前序列,那么当前序列再置换a-s次就是原始序列了.求a就是直接模拟每个置换的过程,直到某序列与当前序列相等.另一种是置换的开方,相当于原始序列的2^s幂是当前序列,将当前序列开2^s次方便是原始序列. 第二种方法暂时

【POJ】1026.Cipher

题解 置换群的快速幂,然而我姿势水平不高,样例过不去,然后才明白这个置换的意思是这个位置上的数代表要把原位置的某个数换过来 需要新开一个数组存结果 代码 #include <iostream> #include <cstdio> #include <vector> #include <set> #include <cstring> #include <ctime> #include <map> #include <a