UVA127- "Accordian" Patience(模拟链表）

                                                                                      "Accordian" Patience

You are to simulate the playing of games of ``Accordian'' patience, the rules for which are as follows:

Deal cards one by one in a row from left to right, not overlapping. Whenever the card matches its immediate neighbour on the left, or matches the third card to the left, it may be moved onto that card. Cards match if they are of the same suit or same rank. After making a move, look to see if it has made additional moves possible. Only the top card of each pile may be moved at any given time. Gaps between piles should be closed up as soon as they appear by moving all piles on the right of the gap one position to the left. Deal out the whole pack, combining cards towards the left whenever possible. The game is won if the pack is reduced to a single pile.

Situations can arise where more than one play is possible. Where two cards may be moved, you should adopt the strategy of always moving the leftmost card possible. Where a card may be moved either one position to the left or three positions to the left, move it three positions.

Input

Input data to the program specifies the order in which cards are dealt from the pack. The input contains pairs of lines, each line containing 26 cards separated by single space characters. The final line of the input file contains a # as its first character. Cards are represented as a two character code. The first character is the face-value (A=Ace, 2-9, T=10, J=Jack, Q=Queen, K=King) and the second character is the suit (C=Clubs, D=Diamonds, H=Hearts, S=Spades).

Output

One line of output must be produced for each pair of lines (that between them describe a pack of 52 cards) in the input. Each line of output shows the number of cards in each of the piles remaining after playing ``Accordian patience'' with the pack of cards as described by the corresponding pairs of input lines.

Sample Input

QD AD 8H 5S 3H 5H TC 4D JH KS 6H 8S JS AC AS 8D 2H QS TS 3S AH 4H TH TD 3C 6S
8C 7D 4C 4S 7S 9H 7C 5D 2S KD 2D QH JD 6D 9D JC 2C KH 3D QC 6C 9S KC 7H 9C 5C
AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC AD 2D 3D 4D 5D 6D 7D 8D TD 9D JD QD KD
AH 2H 3H 4H 5H 6H 7H 8H 9H KH 6S QH TH AS 2S 3S 4S 5S JH 7S 8S 9S TS JS QS KS
#

Sample Output

6 piles remaining: 40 8 1 1 1 1
1 pile remaining: 52

题意：给你一副牌，共有52张，摆成一行，每张牌由两个字符组成，第一个代表大小，第二个代表花色，每次操作是找到一堆牌最顶上的那张牌，如果他左边或者左边第3堆的最顶上的牌跟他一样
（大小或是花色一样），就把这张牌移过去（如果左边第3堆符合，则优先考虑，否则左边那堆），如果某一堆牌空了，则它后面的所有牌堆都往左移。如果某次操作有多组牌堆都符合，则优先考虑
最左边的，直到某次操作不能实现为止，最后打印有多少组牌堆剩余，注意这里有一个坑，如果只剩下一堆牌，pile后面没有s(QAQ),再按照从左到右的顺序剩余每组牌堆的牌数。

解析：很容易想到用链表去模拟，就按照他说的步骤一步步来，在查找左边或是左边第3堆时还要判断一下是否不存在，所以我把第一堆的le指向0,0的le再指向0，那么如果左边第3堆不存在时，你
查找的下标一定是0.还有52的ri指向一个越界的数，如53。

代码如下：

#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<vector>
#include<iterator>
#include<utility>
#include<sstream>
#include<iostream>
#include<cmath>
#include<stack>
using namespace std;
const int INF=1000000007;
const double eps=0.00000001;
vector<string> card[55];
struct node
{
    int le,ri;
}nod[55];
void init()                          // 建立链表
{
    for(int i=1;i<=52;i++)
    {
        nod[i].le=i-1;
        nod[i].ri=i+1;
    }
    nod[0].le=0;
    nod[0].ri=1;
    nod[53].le=52;
    nod[53].ri=53;
}
int ans[55];
bool Same(int a,int b)                  // 判断两张牌是否相同
{
     string s1=card[a].back();
     string s2=card[b].back();
     if(s1[0]==s2[0]||s1[1]==s2[1])  return true;
     return false;
}
void Link(int le,int ri)
{
    nod[le].ri=ri;
    nod[ri].le=le;
}
bool Match(int where)
{
    int a=nod[where].le;      // a是左边的
    if(a==0)  return false;   //左边都不存在，直接false
    int b1=nod[a].le;
    int b=nod[b1].le;        // b是左边第三个
    if(b!=0&&Same(where,b))  //先考虑左边第三个
    {
        card[b].push_back(card[where].back());   // 添加到牌堆上
        card[where].pop_back();                     
        if(card[where].empty())
        {
            int L=nod[where].le,R=nod[where].ri;  // 并判断该牌堆是否为空
            Link(L,R);                            // 将左右连接起来
        }
        return true;
    }
    else if(Same(where,a))                         // 再考虑左边的，跟上面操作一样
    {
        card[a].push_back(card[where].back());
        card[where].pop_back();
        if(card[where].empty())
        {
            int L=nod[where].le,R=nod[where].ri;
            Link(L,R);
        }
        return true;
    }
    return false;
}
bool Find()
{
    for(int st=nod[0].ri;st<53;)           // 从剩余牌堆中找是否存在一个可行的牌堆
    {
        if(Match(st))
        {
            return true;
        }
        st=nod[st].ri;
    }
    return false;
}
void solve()
{
    while(true)
    {
        if(!Find())  break;               // 找可操作的牌堆，找不到就退出了
    }
    int go=0;
    for(int i=nod[0].ri;i<53;)           // 从0指向的数开始保存
    {
        ans[go++]=card[i].size();
        i=nod[i].ri;
    }
    if(go>1)                               // 大于1输出时pile加s
    {
        printf("%d piles remaining:",go);
        for(int i=0;i<go;i++)  printf(" %d",ans[i]);
        printf("
");
    }
    else  printf("%d pile remaining: %d
",1,ans[0]);
}
int main()
{
    while(true)
    {
        string S;
        cin>>S;
        if(S=="#")  break;
        for(int i=1;i<=52;i++)  card[i].clear();  // 清空动态数组
        init();
        card[1].push_back(S);       
        for(int i=2;i<=52;i++)                    // 每堆添加一个数
        {
            cin>>S;
            card[i].push_back(S);
        }
        solve();
    }
    return 0;
}