ZOJ 2852 Deck of Cards DP

题意:

一一个21点游戏。

1. 有三个牌堆,分别为1X,2X,3X。

2. 纸牌A的值为1,纸牌2-9的值与牌面面相同,10(T)、J、Q、K的值为10,而而joke(F)的值为

任意大大。

3. 一一列牌要按顺序放入入三个牌堆中。当某个牌堆的值超过21点时,不能在放牌;如果某个牌堆的

总值为21点时,这个排队讲会被清空;joke放上后这个牌堆的值立立即变为21点。

4. 成功放上一一张牌得50美元;成功清空一一个牌堆讲得到100*牌堆号美元,即1X得100美元,2X得

200美元,3X得300美元。

5. 当任意一一堆都不能继续放牌,或者已经没牌时,游戏结束。

现在求一一列扑克牌通过某种方方式放最多能得多少美元。

思路:

四维DP,令dp[i][j][k][g]表示示放第i张牌时,1X堆的值为j,2X堆的值为k,3X的值为g时,最

多能拿到的钱。以1x为例,设v为当前牌的值,其转移方方程为 dp[i+1][j+v][k][g] =

max(dp[i+1][j+v][k][g], dp[i][j][k][g]+50),当 j < 21且 j + v != 21且 v !=

21 时。dp[i+1][0][k][g] = max(dp[i+1][0][k][g], dp[i][j][k][g]+50),当 j <

21且 v 为 joke,或者 j + v == 21。

当然可以利用用滚动数组降低空间消耗。

Solution by Sake

　　

Source Code:

//#pragma comment(linker, "/STACK:16777216") //for c++ Compiler

#include <stdio.h>

#include <iostream>

#include <fstream>

#include <cstring>

#include <cmath>

#include <stack>

#include <string>

#include <map>

#include <set>

#include <list>

#include <queue>

#include <vector>

#include <algorithm>

#define Max(a,b) (((a) > (b)) ? (a) : (b))

#define Min(a,b) (((a) < (b)) ? (a) : (b))

#define Abs(x) (((x) > 0) ? (x) : (-(x)))

#define MOD 1000000007

#define pi acos(-1.0)



using namespace std;



typedef long long           ll      ;

typedef unsigned long long  ull     ;

typedef unsigned int        uint    ;

typedef unsigned char       uchar   ;



template<class T> inline void checkmin(T &a,T b){if(a>b) a=b;}

template<class T> inline void checkmax(T &a,T b){if(a<b) a=b;}



const double eps = 1e-7      ;

const int N = 210            ;

const int M = 1100011*2      ;

const ll P = 10000000097ll   ;

const int MAXN = 10900000    ;



int dp[120][40][40][40], n, ans;

char c;



int GetValue (char c) {

    if (c >= '2' && c <= '9') {

        return c - '0';

    } else {

        if (c == 'A')   return 1;

        if (c == 'T')   return 10;

        if (c == 'J')   return 10;

        if (c == 'Q')   return 10;

        if (c == 'K')   return 10;

        if (c == 'F')   return 0;

    }

    return 0;

}



int main(){

    std::ios::sync_with_stdio(false);

    int i, j, t, k, u, v, g, numCase = 0;



    while (cin >> n) {

        if (0 == n) break;

        memset (dp, -1, sizeof (dp));

        dp[0][0][0][0] = 0;

        ans = 0;

        for (i = 0; i <= n; ++i) {

            if (i < n) {

                cin >> c;

            } else {

                c = 0;

            }

            v = GetValue(c);

            for (j = 0; j < 31; ++j) {

                for (k = 0; k < 31; ++k) {

                    for (g = 0; g < 31; ++g) {

                        if (dp[i][j][k][g] == -1)   continue;

                        checkmax(ans, dp[i][j][k][g]);

                        if ((v == 0 && j < 21) || j + v == 21) {

                            checkmax(dp[i + 1][0][k][g], dp[i][j][k][g] + 150);

                        } else if (j < 21) {

                            checkmax(dp[i + 1][j + v][k][g], dp[i][j][k][g] + 50);

                        }



                        if ((v == 0 && k < 21) || k + v == 21) {

                            checkmax(dp[i + 1][j][0][g], dp[i][j][k][g] + 250);

                        } else if (k < 21) {

                            checkmax(dp[i + 1][j][k + v][g], dp[i][j][k][g] + 50);

                        }



                        if ((v == 0 && g < 21) || g + v == 21) {

                            checkmax(dp[i + 1][j][k][0], dp[i][j][k][g] + 350);

                        }  else if (g < 21) {

                            checkmax(dp[i + 1][j][k][g + v], dp[i][j][k][g] + 50);

                        }

                    }

                }

            }

            memset (dp[i], -1, sizeof (dp[i]));

        }

        cout << ans << endl;

    }



    return 0;

}