sicily 1003. Hit or Miss

Description

One very simple type of solitaire game known as "Hit or Miss" (also known as "Frustration," "Harvest," "Roll-Call," "Talkative", and "Treize") is played as follows: take a standard deck of 52 playing cards four sets of cards numbered 1 through 13 (suits do not matter in this game) which have been shuffled and start counting through the deck 1, 2, 3, . . . , and so on. When your count reaches 13, start over at 1. Each time you count, look at the top card of the deck and do one of two things: if the number you count matches the value of the top card, discard it from the deck; if it does not match it, move that card to the bottom of the deck. You win the game if you are able to remove all cards from the deck (which may take a very long time). A version of this game can be devised for two or more players. The first player starts as before with a 52 card deck, while the other players have no cards initially. As the first player removes cards from her deck, she gives them to the second player, who then starts playing the same game, starting at count 1. When that player gets a match, he passes his card to the third player, and so on. The last player discards matches rather than passing them to player 1. All players who have cards to play with perform the following 2-step cycle of moves in lockstep: 1. Each player says his or her current count value and checks for a match. If there is no match, the top card is moved to the bottom of the deck; otherwise it is passed to the next player (or discarded if this is the last player). 2. Each player except the first takes a passed card (if there is one) and places it at the bottom of his or her deck. These rules are repeated over and over until either the game is won (all the cards are discarded by the last player) or an unwinnable position is reached. If any player ever runs out of cards, he waits until he is passed a card and resumes his count from where he left off. (e.g., if player 3 passes his last card on a count of 7, he waits until he receives a card from player 2 and resumes his count with 8 at the beginning of the next 2-step cycle).

Input

Input will consist of multiple input sets. The first line of the file will contain a single positive integer nindicating the number of input sets in the file. Each input set will be a single line containing 53 integers: the first integer will indicate the number of players in the game and the remaining 52 values will be the initial layout of the cards in the deck, topmost card first. These values will all lie in the range 1 . . . 13, and the number of players will lie in the range 1. . . 10.

Output

For each input set, output the input set number (as shown below, starting with 1) and either the phrase "unwinnable" or a list showing the last card discarded by each player. Use a single blank to separate all outputs.

Sample Input

aaarticlea/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAARABIDASIAAhEBAxEB/8QAGAABAAMBAAAAAAAAAAAAAAAAAAMFBwT/xAAlEAACAQQCAQMFAAAAAAAAAAABAgMABAURBiESIjFBMjZxdbP/xAAYAQACAwAAAAAAAAAAAAAAAAAAAwEEBf/EABsRAQEAAgMBAAAAAAAAAAAAAAEAAgMEEyFh/9oADAMBAAIRAxEAPwDQeRW+SyVnctBIkiiScOk87qm0ciP0aZWA8dkEDZA2fcGPCWPI+PXkUt3GIcQjkyQxTGdtMrAhUVQO5CraVd/UB1pa7cnHmbaW5hjxEktoZJJGulnjChWYsT4lvLoHvr3B1vommvuQYaSe/jGSxrW9yXEiCWIiTe9eWohvs/LH8n5ocDh9jlnsER+zt+9wDE9G0uKWO4hSaGRJIpFDI6MCrKewQR7ilVfFPs7B/r4P5rStB8ZJW9KUqIlKUoi//9k=" alt="" /> Copy sample input to clipboard 

2
4 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13
4 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1 2 3 4 5 6 7 8 9 10 11 12 13 1

Sample Output

Case 1: 13 13 13 13
Case 2: unwinnable

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main(int argc, char const *argv[])
{
    int testCase;
    cin >> testCase;
    int personNum, cardValue;
    int t = ;
    int personCountValue[];
    int lastCard[];
    while (t <= testCase) {
        vector<queue<int> > personCard;
        cin >> personNum;
        personCard.resize(personNum);

        for (int i = ; i != personNum; ++i) // 初始化
            personCountValue[i] = ;
        for (int i = ; i != ; ++i) {  // 输入牌的顺序
            cin >> cardValue;
            personCard[].push(cardValue);
        }

        int repeatNum = ;
        int succeedNum = ;
        bool isSucceed = false;
        // 最大循环次数，其实就是考虑一个极限，如果一个人当前拥有全部的卡，然后跑了 52 遍，把全部卡都遍历了也没用给一张给后面的，那么就是循环了
        int maxRepeatNum =  * ;
        while (repeatNum <= maxRepeatNum) {
            repeatNum++;
            for (int i = ; i != personNum; ++i) {
                if (personCard[i].empty()) {  // 计算成功的人的个数，全部成功则跳出，因为后面的人的牌不能给前面的人，所以前面的人为空了name它以后都为空
                    succeedNum++;
                    if (succeedNum == personNum) {
                        isSucceed = true;
                        break;
                    }
                    continue;
                } else {
                    succeedNum = ;
                }

                int frontN = personCard[i].front();
                personCard[i].pop();
                if (frontN == personCountValue[i]) {  // 当前计数和最上方的卡号相同
                    lastCard[i] = frontN;
                    repeatNum = ;
                    if (i < personNum - ) {
                        personCard[i + ].push(frontN);
                    }
                } else {
                    personCard[i].push(frontN);
                }
                personCountValue[i]++;
                if (personCountValue[i] == )
                    personCountValue[i] = ;
            }
            if (isSucceed) {
                break;
            }
        }
        cout << "Case " << t++ << ": ";
        if (isSucceed) {
            for (int i = ; i < personNum - ; ++i)
                cout << lastCard[i] << " ";
            cout << lastCard[personNum - ] << endl;
        } else {
            cout << "unwinnable" << endl;
        }
    }
    return ;
}