UVA 1085 House of Cards（对抗搜索）

Description

 

Axel and Birgit like to play a card game in which they build a house of cards, gaining (or losing) credits as they add cards to the house. Since they both have very steady hands, the house of cards never collapses. They use half a deck of standard playing cards. A standard deck has four suits, two are red and two are black. Axel and Birgit use only two suits, one red, one black. Each suit has 13 ranks. We use the notation 1R, 2R, ..., 13R, 1B, 2B, ..., 13B to denote ranks and colors.

The players begin by selecting a subset of the cards, usually all cards of rank up to some maximum value M. After shuffling the modified deck, they take eight cards from the top of the deck and place them consecutively from left to right to form four ``peaks." For instance, if M = 13 and if the first ten cards (from 26) are:

6B 3R 5B 2B 1B 5R 13R 7B 11R 1R ...

then the game starts off with four peaks and three valleys as shown in Figure 7.

Figure 7: Peaks and valleys formed by the top 8 cards in the deck.

The remaining cards are placed face up, in a single row.

Each player is identified with a color, red or black. Birgit is always black and Axel is always red. The color of the first card used for the peaks and valleys determines which player has the first turn. For the example in Figure 7, Birgit has the first turn since the first card is 6B.

Players alternate taking turns. A turn consists of removing the card from the front of the row of cards and then doing one of the following:

1. Holding the card until the next turn (this is a ``held card").
2. Covering the valley between two peaks with the drawn card or the held card, forming a ``floor". The remaining card, if any, is held.
3. Placing two cards over a floor, forming a peak (one of the cards must be a ``held'' card).

Not all options are always available. At most one card may be held at any time, so the first option is possible only if the player is not already holding a card.

Since the cards in the row are face up, both players know beforehand the order in which the cards are drawn.

If the player forms a downward-pointing triangle by adding a floor, or an upward-pointing triangle by adding a peak, then the scores are updated as follows. The sum of the ranks of the three cards in the triangle is added to the score of the player whose color is the same as the majority of cards in the triangle. If no triangle is formed during a play, both scores remain unchanged.

In the example from Figure 7, if Birgit places her card (11R) on the middle valley, she gains 14 points. If she places her card on the left valley, Axel gains 19 points. If she places her card on the right valley, Axel gains 29 points.

If no more cards remain to be drawn at the end of a turn, the game is over. If either player holds a card at this time, the rank of that card is added to (subtracted from) that player's score if the color of the card is the same as (different from) that player's color.

When the game is over, the player with the lower score pays a number of Swedish Kronor (Kronor is the plural of Krona) equal to the difference between the two scores to the other player. In case of a tie there is no pay out.

You must write a program that takes a description of a shuffled deck and one of the players' names and find the highest amount that player can win (or the player's minimum loss), assuming that the other player always makes the best possible moves.

Input

The input file contains multiple test cases representing different games. Each test case consists of a name (either `Axel' or `Birgit'), followed by a maximum rank M ( 5M13), followed by the rank and color of the 2M cards in the deck in their shuffled order. Every combination of rank (from 1 through M) and color will appear once in this list. The first eight cards form the initial row of peaks from left to right in the order drawn, and the remaining items show the order of the rest of the cards.

The final test case is followed by a line containing the word `End'.

Output

For each test case, print the test case number (starting with 1), the name of the player for the test case, and the amount that the player wins or loses. If there is a tie, indicate this instead of giving an amount. Follow the sample output format.

题目大意：略。

思路：剪枝搜索。

代码（1895MS）：

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 using namespace std;

 const int UP = ;
 const int FLOOR = ;
 const int DOWN = ;
 const int INF = 0x7fffffff;

 int deck[];
 char s[], c;
 int n;

 inline int abs(int x) {int y = x >> ; return (x + y) ^ y;}

 inline int getScore(int a, int b, int c) {
     int ret = abs(a) + abs(b) + abs(c);
     int sgn = (a > ) + (b > ) + (c > );
     if(sgn > ) return ret;
     else return -ret;
 }

 struct State {
     int card[], type[];
     int hold[];
     int pos, score;

     State() {
         for(int i = ; i < ; ++i) {
             card[i] = deck[i];
             type[i] = (i %  == ) ? UP : DOWN;
         }
         hold[] = hold[] = score = ;
         pos = ;
     }

     bool isFinal() {
         if(pos ==  * n) {
             score += hold[] + hold[];
             hold[] = hold[] = ;
             return true;
         }
         return false;
     }

     State child() const {
         State s;
         memcpy(&s, this, sizeof(s));
         s.pos = pos + ;
         return s;
     }

     void expand(int player, vector<State> &ret) const {
         int &cur = deck[pos];
         if(hold[player] == ) {
             State s = child();
             s.hold[player] = cur;
             ret.push_back(s);
         }
         for(int i = ; i < ; ++i) if(type[i] == DOWN && type[i + ] == UP) {
             State s = child();
             s.score += getScore(card[i], card[i + ], cur);
             s.type[i] = s.type[i + ] = FLOOR;
             s.card[i] = s.card[i + ] = cur;
             ret.push_back(s);
             if(hold[player] != ) {
                 State s = child();
                 s.score += getScore(card[i], card[i + ], hold[player]);
                 s.type[i] = s.type[i + ] = FLOOR;
                 s.card[i] = s.card[i + ] = hold[player];
                 s.hold[player] = cur;
                 ret.push_back(s);
             }
         }
         if(hold[player] != ) {
             for(int i = ; i < ; ++i) if(type[i] == FLOOR && type[i + ] == FLOOR && card[i] == card[i + ]) {
                 State s = child();
                 s.score += getScore(card[i], hold[player], cur);
                 s.type[i] = UP; s.type[i + ] = DOWN;
                 s.card[i] = cur; s.card[i + ] = hold[player]; s.hold[player] = ;
                 ret.push_back(s);
                 swap(s.card[i], s.card[i + ]);
                 ret.push_back(s);
             }
         }
     }
 };

 int alphabeta(State &s, int player, int alpha, int beta) {
     if(s.isFinal()) return s.score;
     vector<State> children;
     s.expand(player, children);
     int n = children.size();
     for(int i = ; i < n; ++i) {
         int v = alphabeta(children[i], player ^ , alpha, beta);
         if(!player) alpha = max(alpha, v);
         else beta = min(beta, v);
         if(beta <= alpha) break;
     }
     return !player ? alpha : beta;
 }

 int main() {
     int t = ;
     while(scanf("%s", s) != EOF && *s != 'E') {
         scanf("%d", &n);
         for(int i = ; i <  * n; ++i) {
             scanf("%d%c", &deck[i], &c);
             if(c == 'B') deck[i] = -deck[i];
         }
         int start = !(deck[] > );
         State beg;
         int ans = alphabeta(beg, start, -INF, INF);
         printf("Case %d: ", ++t);
         if(s[] == 'B') ans = -ans;
         if(ans == ) puts("Axel and Birgit tie");
         else if(ans > ) printf("%s wins %d\n", s, ans);
         else printf("%s loses %d\n", s, -ans);
     }
 }