UVALive 6913 I Want That Cake 博弈dp

I Want That Cake

题目连接：

https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4925

Description

There was an interesting game played on a popular Korean reality TV Show. 12 players in 3 teams

— 4 persons in each team — lined up in one row in random order. The game master approaches the

players one by one starting from the most front player, with a tray full of 31 cakes. Each player should

eat at least 1 and at most 5 cakes during his/her turn. The player who eats the last cake will lose

along with his/her group (this is a team game). It was more an entertainment show rather than a real

competition. The players were selected from “chubby” celebrities who like to eat, thus causing them

in dilemma whether they should win the game (which might require them to hold their urge to eat the

cakes), or just enjoy all 5 cakes ignoring their team member.

This problem is related to the game. There are 2 teams (A and B) each with N players lined up

in a row in random order. Initially there are M cakes in the tray, and each player (starting from the

most front) has to eat at least 1 and at most K cakes during his/her turn. The team whose player eat

the last cake win (note that this is different compared to the original game).

Your task is to determine which team will win the game, given both teams play optimally.

Input

The first line of input contains an integer T (T ≤ 100) denoting the number of cases. Each case begins

with three integers N, M, and K (1 ≤ N ≤ 1, 000; 1 ≤ K ≤ M ≤ 2 ∗ N) in a line denoting the number

of players in each team, the initial number of cakes, and the maximum number of cakes can be eaten

by each player in his/her turn respectively. The next line contains a string S representing the players

order from the front most to the last player. S consists of only character ‘A’ or ‘B’ representing which

team does the respective player belongs to. The length of S is exactly 2 ∗ N and the number of ‘A’ and

‘B’ will be equal.

Output

For each case, output ‘Case #X: Y ’, where X is the case number starts from 1 and Y is ‘A’ if the

game will be won by team A, otherwise ‘B’. Assume both teams will play the game optimally to win

the game.

Explanation for 1st sample case:

The first two players of team A each needs to eat 2 cakes, while the third A player eats the last

cake.

Explanation for 2nd sample case:

No matter what team A do, the last cake will be eaten by one of team B’s player.

Explanation for 3rd sample case:

To ensure their win, the first player (B) should eat 2 cakes, leaving only 3 cakes to the next player

(A). This player (A) should eat at least 1 and at most 2 cakes. No matter how many cakes this player

eats, the next player (B) will eat the last cake.

Sample Input

4

3 5 2

AAABBB

4 7 2

AAABBBBA

4 5 2

BABABABA

4 6 3

BAABBABA

Sample Output

Case #1: A

Case #2: B

Case #3: B

Case #4: A

Hint

题意

有两支队，每只队都有n个人，一共有m个蛋糕，每个人至少吃一个，最多吃k个。

都采取最优策略，谁吃到最后一个蛋糕，那么那只队就胜利。

按照给定的顺序去吃蛋糕，问你最后谁胜利。

题解：

先缩点，把相同的点都缩成一个点。

那么就变成了ABABABA这样交替的形式了，然后跑DP就好了。

但是这个DP好像是n^3的，其实你有break，所以跑起来还是蛮快的，当然，你吃蛋糕得倒着枚举。

代码

#include <bits/stdc++.h>
#define rep(a,b,c) for(int (a)=(b);(a)<=(c);++(a))
#define drep(a,b,c) for(int (a)=(b);(a)>=(c);--(a))
#define pb push_back
#define mp make_pair
#define sf scanf
#define pf printf
#define two(x) (1<<(x))
#define clr(x,y) memset((x),(y),sizeof((x)))
#define dbg(x) cout << #x << "=" << x << endl;
#define lowbit(x) ((x)&(-x))
const int mod = 1e9 + 7;
int mul(int x,int y){return 1LL*x*y%mod;}
int qpow(int x , int y){int res=1;while(y){if(y&1) res=mul(res,x) ; y>>=1 ; x=mul(x,x);} return res;}
inline int read(){int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return x*f;}
using namespace std;
const int maxn = 1000 + 15;
int N , M , K , dp[2 * maxn][maxn * 2];
char str[maxn * 2];
vector < int > op;

int dfs( int x , int y ){
if( y <= 0 ) return 0;
if( dp[x][y] != -1 ) return dp[x][y];
int & ans = dp[x][y] = 0;
if( x == op.size() ) return ans = 1;
for(int i = op[x] * K ; i >= op[x] ; -- i){
int rs = dfs( x + 1 , y - i );
if( rs == 0 ) return ans = 1;
}
return ans;
}

int main(int argc,char *argv[]){
int T=read(),cas=0;
while(T--){
N=read(),M=read(),K=read();
sf("%s",str + 1);
op.clear();
for(int i = 1 ; i <= N * 2 ; ){
int j;
for(j = i ; j <= N * 2 && str[i] == str[j] ; ++ j );
op.pb( j - i  );
i = j;
}
for(int i = 0 ; i <= op.size() ; ++ i) for(int j = 0 ; j <= M ; ++ j) dp[i][j] = -1;
pf("Case #%d: ", ++ cas);
if( dfs( 0 , M ) ) pf("%c\n" , str[1]);
else{
if( str[1] == 'A' ) pf("%c\n" , 'B');
else pf("%c\n" , 'A');
}
}
return 0;
}