F - Shuffle‘m Up(set+map+BFS)

The actual shuffle operation is performed by interleaving a chip from S1 with a chip from S2 as shown below for C = 5:

The single resultant stack, S12, contains 2 * C chips. The bottommost chip of S12 is the bottommost chip from S2. On top of that chip, is the bottommost chip from S1. The interleaving process continues taking the 2nd chip from the bottom of S2 and placing that on S12, followed by the 2nd chip from the bottom of S1 and so on until the topmost chip from S1 is placed on top of S12.

After the shuffle operation, S12 is split into 2 new stacks by taking the bottommost C chips from S12 to form a new S1 and the topmost C chips from S12 to form a new S2. The shuffle operation may then be repeated to form a new S12.

For this problem, you will write a program to determine if a particular resultant stack S12 can be formed by shuffling two stacks some number of times.
输入

The first line of input contains a single integer N, (1 ≤ N ≤ 1000) which is the number of datasets that follow.
Each dataset consists of four lines of input. 
The first line of a dataset specifies an integer C, (1 ≤ C ≤ 100) which is the number of chips in each initial stack (S1 and S2). 
The second line of each dataset specifies the colors of each of the C chips in stack S1, starting with the bottommost chip. 
The third line of each dataset specifies the colors of each of the C chips in stack S2 starting with the bottommost chip. 
Colors are expressed as a single uppercase letter (A through H).
There are no blanks or separators between the chip colors. 
The fourth line of each dataset contains 2 * C uppercase letters (A through H), representing the colors of the desired result of the shuffling of S1 and S2 zero or more times. 
The bottommost chip’s color is specified first.

输出

Output for each dataset consists of a single line that displays the dataset number (1 though N), a space, and an integer value which is the minimum number of shuffle operations required to get the desired resultant stack.

If the desired result can not be reached using the input for the dataset, display the value negative 1 (−1) for the number of shuffle operations.

样例输入

2
4
AHAH
HAHA
HHAAAAHH
3
CDE
CDE
EEDDCC

样例输出

1 2
2 -1

题意
给出两个长度为len的字符串s1,s2,然后给出一个长度为2×len的字符串ss。

你可以对字符串s1,s2进行题目中所描述的整合方式整合出一个长度为2×len的str。

若str与ss相同则输出操作次数，否则将str的前len个字符作为s1，后面的字符作为s2重复操作。
如果无法将s1,s2整合为ss，输出-1。

整合方式：先取s2的第一个字符，然后取s1的第一个字符，然后是s2的第二个字符，反复操作。

思路
既然是搜索题，我们的思路就向BFS/DFS靠拢。
这里是用BFS解决的。

既然是BFS就要搞清BFS所需的几个点在此题中分别对应什么：

第一，我们要想一想标记数组怎么搞？
如何确定当前的字符串我之前没整合出来过？
(开数组的就不用多想了，200长度的字符串全排列，恐怖如斯。)
(想要打表的我膝盖给你了)

看标记需求：可以存储字符串，并且还能查看当前字符串是否已存在。
我的脑海里出现了两个东西：set与map(不了解set与map的小伙伴可以先去了解一下)

这里我们用map实现标记：

    map<string,int>p;          
    //字符串作为key，第一次出现的字符串其对应的value我们初始化为1，代表其出现过
    //搜索时我们只需用p.count(s)，若s字符串未出现会返回0
    //这样就可以标记已经整合好的字符串了

第二，也就是所谓的"移动"。

我们先来看一下用来存储的结构体定义：

struct node
{
    int step;   //当前操作次数
    string s;   //当前字符串
};

在读完整合方式后我相信有人想过用substr将两个字符串取出来操作(不会只有我这样想过吧，呜呜呜/(ㄒoㄒ)/~~)

其实我们可以直接对原字符串操作：

//n为长度len
for(int i=0; i<n; i++)           
//取字符的次数为n次，每次从两个字符串各取一个，所以得到的s的长度是2×n长度
{
      tail.s+=tmp.s[n+i]; 
      tail.s+=tmp.s[i];
}

那么接下来就是正常的BFS了，直接上代码。

「伊丽莎白」！

代码

map实现标记

#define _CRT_SBCURE_NO_DEPRECATE
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;

struct node
{
    int step;   //当前操作次数
    string s;   //当前字符串
};

string ss,s1,s2;
int t,n;

int BFS()
{
    node tmp;
    tmp.s=s1+s2,tmp.step=0;  //我们直接把两个字符串相接存进去，步数标为0
    queue<node>q;
    q.push(tmp);
    map<string,int>p;
    //字符串作为key，对应的value我们初始化为1，代表其出现过
    //搜索时我们只需用p.count(s)，若s字符串未出现会返回0
    //这样就可以标记已经整合好的字符串了
    p.clear();
    while(!q.empty())
    {
        node tail;
        tmp=q.front();
        q.pop();
        if(tmp.s==ss&&tmp.step)  
        //如果当前样例中恰巧s1+s2==ss，这时注意这不是我们经过正规整合得来的，所以不能输出0
            return tmp.step;
        //n为长度len
        for(int i=0; i<n; i++)
        //取字符的次数为n次，每次从两个字符串各取一个，所以得到的s的长度是2×n长度
        {
            tail.s+=tmp.s[n+i];
            tail.s+=tmp.s[i];
        }
        if(!p.count(tail.s))
        {
            p[tail.s]=1;    //存入该字符串，并把值设为1
            tail.step=tmp.step+1;
            q.push(tail);
        }
    }
    return -1;   //没能整合出，返回-1
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    cin>>t;
    for(int i=1; i<=t; i++)
    {
        cin>>n;
        cin>>s1>>s2>>ss;
        cout<<i<<' '<<BFS()<<endl;
    }
}

set实现标记

#define _CRT_SBCURE_NO_DEPRECATE
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
struct node
{
    int step;   //当前操作次数
    string s;   //当前字符串
};
string ss,s1,s2;
int t,n;
int BFS()
{
    node tmp;
    tmp.s=s1+s2,tmp.step=0;  //我们直接把两个字符串相接存进去，步数标为0
    queue<node>q;
    q.push(tmp);
    set<string>p;
    //内部元素为string的集合
    p.clear();

    while(!q.empty())
    {
        node tail;
        tmp=q.front();
        q.pop();
        if(tmp.s==ss&&tmp.step)
        //如果当前样例中恰巧s1+s2==ss，这时注意这不是我们经过正规整合得来的，所以不能输出0
            return tmp.step;
        //n为长度len
        for(int i=0; i<n; i++)
        //取字符的次数为n次，每次从两个字符串各取一个，所以得到的s的长度是2×n长度
        {
            tail.s+=tmp.s[n+i];
            tail.s+=tmp.s[i];
        }
        if(!p.count(tail.s))
        {
            p.insert(tail.s);   //插入该字符串
            tail.step=tmp.step+1;
            q.push(tail);
        }
    }
    return -1;   //没能整合出，返回-1

}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    cin>>t;
    for(int i=1; i<=t; i++)
    {
        cin>>n;
        cin>>s1>>s2>>ss;
        cout<<i<<' '<<BFS()<<endl;
    }

}

又是AC的一天呢~

溜了溜了~