Codeforces 725C Hidden Word【思维+构造】

最新推荐文章于 2021-09-12 20:20:30 发布

原创最新推荐文章于 2021-09-12 20:20:30 发布 · 644 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Codeforces 725C

思维专栏收录该内容

692 篇文章

订阅专栏

探讨构建特定路径的算法挑战，需在2*13的网格中形成由27个唯一及重复英文大写字母组成的路径。文章提供了解题思路与AC代码示例。

Let’s define a grid to be a set of tiles with 2 rows and 13 columns. Each tile has an English letter written in it. The letters don't have to be unique: there might be two or more tiles with the same letter written on them. Here is an example of a grid:

ABCDEFGHIJKLM
NOPQRSTUVWXYZ

We say that two tiles are adjacent if they share a side or a corner. In the example grid above, the tile with the letter 'A' is adjacent only to the tiles with letters 'B', 'N', and 'O'. A tile is not adjacent to itself.

A sequence of tiles is called a path if each tile in the sequence is adjacent to the tile which follows it (except for the last tile in the sequence, which of course has no successor). In this example, "ABC" is a path, and so is "KXWIHIJK". "MAB" is not a path because 'M' is not adjacent to 'A'. A single tile can be used more than once by a path (though the tile cannot occupy two consecutive places in the path because no tile is adjacent to itself).

You’re given a string s which consists of 27 upper-case English letters. Each English letter occurs at least once in s. Find a grid that contains a path whose tiles, viewed in the order that the path visits them, form the string s. If there’s no solution, print "Impossible" (without the quotes).

Input

The only line of the input contains the string s, consisting of 27 upper-case English letters. Each English letter occurs at least once in s.

Output

Output two lines, each consisting of 13 upper-case English characters, representing the rows of the grid. If there are multiple solutions, print any of them. If there is no solution print "Impossible".

Examples

Input

ABCDEFGHIJKLMNOPQRSGTUVWXYZ

Output

YXWVUTGHIJKLM
ZABCDEFSRQPON

Input

BUVTYZFQSNRIWOXXGJLKACPEMDH

Output

Impossible

题目大意：

给你一个字符串（长度固定为27），然后让你将这个字符串变成两行2*13的字符串，使得其有一条路能够走出原字符串的路径来(向相邻的格子走，斜着也可以)。题目保证每个字母都至少出现一次。

样例分析：

ABCDEFGHIJKLMNOPQRSGTUVWXYZ就可以转变为：

ABCDEFGHIJKLM

ZYXWVUTSRQPON

我们直接从A向右走走到M然后向下走到N然后向左走到S，然后斜左上走到G之后，再走下来，然后走到最左端。

思路：

1、首先我们知道，题目保证每个字母都至少出现一次，而且字符串长度为27，那么一定有一个字母出现两次。那么我们首先可以考虑Impossible的情况，不难想到，如果当两个相同字母连在了一起的时候，无论当前怎么走，都一定走出来的是27个字符的路，明显大于2*13，明显就是无解的情况。

2、那么接下来考虑如何摆放能够构成这样的一个可行解：

①我们可以枚举一个格点作为起点，然后再枚举一个字符作为这个格点的起点字符，然后按照如图顺序走一圈，当我们走到第二次出现tmp这个字符的时候，判断一下当前位子是否能够走到上一次出现tmp的位子，如果可以，继续走，否则当前枚举的情况就是一个不可行解：

②对应如果枚举出了一个可行解，那么对应输出即可。

Ac代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
char a[1500];
char ans[2][30];
int vis[30];
int tmp;
int Slove(int r,int c)
{
    for(int s=0;s<27;s++)
    {
        memset(ans,' ',sizeof(ans));
        int x=r,y=c;
        int flag=0;
        int i=s;
        int cont=0;
        while(1)
        {
            if(cont>=27)return 1;
            if(a[i]-'A'==tmp&&flag==1)
            {
                flag++;
                if(x==1)
                {
                    if(ans[x-1][y]-'A'==tmp||ans[x-1][y+1]-'A'==tmp)
                    {
                        cont++;
                        i++;
                        i%=27;
                        continue;
                    }
                    else break;
                }
                else break;
            }
            if(a[i]-'A'==tmp&&flag==0)flag++;
            ans[x][y]=a[i];
            cont++;
            i++;
            i%=27;
            if(x==0)
            {
                y++;
                if(y==13)y=12,x++;
            }
            else
            {
                y--;
                if(y<0)y=0,x--;
            }
        }
    }
    return 0;
}
int main()
{
    while(~scanf("%s",a))
    {
        memset(vis,0,sizeof(vis));
        int n=strlen(a);
        for(int i=0;i<n;i++)
        {
            vis[a[i]-'A']++;
        }
        for(int i=0;i<26;i++)
        {
            if(vis[i]==2)tmp=i;
        }
        int flag=0;
        int flag2=0;
        for(int i=0;i<n-1;i++)
        {
            if(a[i]==a[i+1])
            {
                flag2=1;
                printf("Impossible\n");
                break;
            }
        }
        if(flag2==1)continue;
        for(int c=0;c<13;c++)
        {
            int tt=Slove(0,c);
            if(tt==1)
            {
                flag=1;
                for(int i=0;i<2;i++)
                {
                    for(int j=0;j<13;j++)
                    {
                        printf("%c",ans[i][j]);
                    }
                    printf("\n");
                }
                break;
            }
        }
        if(flag==0)
        {
            printf("Impossible\n");
        }
    }
}