[蓝桥杯2017初赛]拉马车

 题目描述

小的时候，你玩过纸牌游戏吗？有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。
其规则简述如下：假设参加游戏的小朋友是A和B，游戏开始的时候，他们得到的随机的纸牌序列如下：
A方：[K, 8, X, K, A, 2, A, 9, 5, A]
B方：[2, 7, K, 5, J, 5, Q, 6, K, 4]
其中的X表示“10”，我们忽略了纸牌的花色。
从A方开始，A、B双方轮流出牌。
当轮到某一方出牌时，他从自己的纸牌队列的头部拿走一张，放到桌上，并且压在最上面一张纸牌上（如果有的话）。
此例中，游戏过程：A出K，B出2，A出8，B出7，A出X，此时桌上的序列为：K,2,8,7,X
当轮到B出牌时，他的牌K与桌上的纸牌序列中的K相同，则把包括K在内的以及两个K之间的纸牌都赢回来，放入自己牌的队尾。
注意：为了操作方便，放入牌的顺序是与桌上的顺序相反的。
此时，A、B双方的手里牌为：
A方：[K, A, 2, A, 9, 5, A]
B方：[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K]
赢牌的一方继续出牌。也就是B接着出5，A出K，B出J，A出A，B出5，又赢牌了。
5,K,J,A,5
此时双方手里牌：
A方：[2, A, 9, 5, A]
B方：[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5]
注意：更多的时候赢牌的一方并不能把桌上的牌都赢走，而是拿走相同牌点及其中间的部分。
但无论如何，都是赢牌的一方继续出牌，有的时候刚一出牌又赢了，也是允许的。
当某一方出掉手里最后一张牌，但无法从桌面上赢取牌时，游戏立即结束。
对于本例的初始手牌情况下，最后A会输掉，而B最后的手里牌为：9K2A62KAX58K57KJ5
本题的任务就是已知双方初始牌序，计算游戏结束时，赢的一方手里的牌序。当游戏无法结束时，输出-1。 

输入

输入存在多组数据，对于每组测试数据：
输入为2行，2个串，分别表示A、B双方初始手里的牌序列。输入的串的长度不超过30

输出

对于每组测试数据：输出为1行，1个串，表示A先出牌，最后赢的一方手里的牌序。

样例输入

96J5A898QA
6278A7Q973
25663K6X7448
J88A5KJXX45A

样例输出

2J9A7QA6Q6889977
6KAJ458KXAX885XJ645

 题解：用栈和队列模拟就好了

#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
#include<string.h>
#include<map>
#include<stack>
#include<queue>
#define ll long long
using namespace  std;
char a[100],b[100];
int main()
{
    while(cin>>a>>b)
    {
        int len1=strlen(a);
        int len2=strlen(b);
        queue<char>aa;
        queue<char>bb;
        map<char,int>mp;

        for(int i=0;i<len1;i++)
            aa.push(a[i]);
        for(int i=0;i<len2;i++)
            bb.push(b[i]);

        stack<char>p;
        
        int ans=0,flag=0;
        while(!aa.empty()&&!bb.empty())
        {
            if(flag==0)
            {
                char temp=aa.front();
                aa.pop();
                if(mp[temp]==1)
                {
                    aa.push(temp);
                    mp[temp]=0;
                    while(1)
                    {
                        char x=p.top();
                        p.pop();
                        aa.push(x);
                        mp[x]=0;
                        if(x==temp)
                            break;
                    }
                    flag=!flag;//这里取反一次，后面再取反一次又变回原来的值，就实现了“赢了之后继续出牌的”规则
                }
                else
                {
                    p.push(temp);
                    mp[temp]=1;
                }
                

            }
            else
            {
                char temp=bb.front();
                bb.pop();
                if(mp[temp]==1)//如果栈p里面有相同的字母
                {
                    bb.push(temp);
                    mp[temp]=0;
                    while(1)
                    {
                        char x=p.top();
                        p.pop();
                        bb.push(x);
                        mp[x]=0;
                        if(x==temp)
                            break;
                    }
                    flag=!flag;
                }
                else
                {
                    p.push(temp);
                    mp[temp]=1;
                }
                

            }
            
            flag=!flag;
            ans++;
        }
        if(ans>10000)
            cout<<"-1"<<endl;
        else
        {
            if(aa.empty())  
            {   
                while(!bb.empty())
                {
                    cout<<bb.front();
                    bb.pop();
                }
            }
            else
            {
                while(!aa.empty())
                {
                    cout<<aa.front();
                    aa.pop();
                }

            }
            cout<<endl;
        }
    }
        return 0;
}