CF1738C Even Number Addicts 【DP+奇偶博弈、数学推理】

题目链接

Codeforces Global Round 22, Problem C
1738C Even Number Addicts

题目大意

给定长度为 $n$ 的数列 $a_1,a_2,\dots ,a_n$ ，两名玩家 Alice 、 Bob 依次以最优策略从数列中取走一个数，Alice 先取，直至为空博弈结束。若 Alice 取走的所有数之和为偶，Alice 胜利；若 Alice 取走的所有数之和为奇，Bob 胜利。输入给定序列，请输出必胜玩家。

---

解法 1 DP

定义

• 定义两个二维 DP（每个 DP 的第一维代表序列 $a$ 中偶数 $a_i$ 的个数，第二维代表 $a$ 中奇数 $a_i$ 的个数）：
  • dpEven[maxn][maxn] ：代表首名开始的玩家能否以最优策略得到偶数和，简称首名以偶胜；
  • dpOdd[maxn][maxn] ：代表首名开始的玩家能否以最优策略得到奇数和，简称首名以奇胜。

const int maxn = 100 + 10;
// dp[i][j]: odd num == i, even num == j
// Whether the person who starts first can get an EVEN sum. (plays the optimal strategy)
bool dpEven[maxn][maxn];
// Whether the person who starts first can get an ODD sum. (plays the optimal strategy)
bool dpOdd[maxn][maxn]; 

一些实例：

// n == 1
dpEven[1][0] = false;   dpOdd[1][0] = true;
dpEven[0][1] = true;    dpOdd[0][1] = false;
// n == 2
dpEven[2][0] = false;   dpOdd[2][0] = true;
dpEven[1][1] = true;    dpOdd[1][1] = true;
dpEven[0][2] = true;    dpOdd[0][2] = false;
// n == 3
dpEven[3][0] = true;    dpOdd[3][0] = false;
dpEven[2][1] = false;   dpOdd[2][1] = true;
dpEven[1][2] = false;   dpOdd[1][2] = true;
dpEven[0][3] = true;    dpOdd[0][3] = false;

为理解方便，此处采用两个二维 DP 的定义方法，读者也可采用三维 DP 的定义方法。

初始状态

• 不难得到当序列全为偶数时，首名以偶胜 为真，首名以奇胜 为假；
• 当序列全为奇数时：
  • 若首名玩家从序列 $a$ 中最终取走偶数个数，首名以偶胜 为真，首名以奇胜 为假；
  • 若首名玩家从序列 $a$ 中最终取走奇数个数，首名以偶胜 为假，首名以奇胜 为真。

for (int tot = 1; tot < maxn; tot ++){
	dpEven[0][tot] = true;
	dpOdd[0][tot] = false;
	
	int aliceNum = (tot+1) / 2;
	if (aliceNum % 2 == 0){
	    dpEven[tot][0] = true;
	    dpOdd[tot][0] = false;
	}
	else {
	    dpEven[tot][0] = false;
	    dpOdd[tot][0] = true;
	}
}

状态转移

共识：从序列拿走一个偶数，剩余序列和的奇偶性不改变；拿走一个奇数，剩余序列和的奇偶性改变。

我们不妨假设 Alice 已经从 $n$ 个数字中拿走了一个数字，并把 Bob 当成首名玩家来分析在 $n-1$ 个数字的序列中的 首名以偶胜 和 首名以奇胜 状态，Bob 的胜负条件可以决定 Alice 是否胜负。此问题在上一次转移已得到求解。

• 若初始序列和为偶数，Bob 最终需要得到奇数和才能击败 Alice ：
  • 无论 Alice 从序列 $a$ 中拿走一个奇数还是偶数，若 Bob 在剩余数字中的 首名以奇胜 状态全为 假，则 Alice 的 首名以偶胜 为真，反之为假。
  • 同时更新 Alice 的 首名以奇胜，无论 Alice 拿走一个奇数还是偶数，若 Bob 在剩余数字中的 首名以偶胜 状态全为 假，则 Alice 的 首名以奇胜 为真，反之为假。
• 若初始序列和为奇数，Bob 最终需要得到偶数和才能击败 Alice ：
  • 无论 Alice 从序列 $a$ 中拿走一个奇数还是偶数，若 Bob 在剩余数字中的 首名以偶胜 状态全为 假，则 Alice 的 首名以偶胜 为真，反之为假。
  • 同时更新 Alice 的 首名以奇胜，无论 Alice 拿走一个奇数还是偶数，若 Bob 在剩余数字中的 首名以奇胜 状态全为 假，则 Alice 的 首名以奇胜 为真，反之为假。

for (int tot = 1; tot < maxn; tot ++){
    for (int k = 1; k < tot; k ++){
        // totSum == even, Bob need ODD sum to defeat Alice
        if ((tot-k) % 2 == 0){
            dpEven[tot-k][k] = !(dpOdd[tot-k-1][k] && dpOdd[tot-k][k-1]);
            dpOdd[tot-k][k] = !(dpEven[tot-k-1][k] && dpEven[tot-k][k-1]);
        }
        // totSum == odd, Bob need EVEN sum to defeat Alice
        else {
            dpEven[tot-k][k] = !(dpEven[tot-k-1][k] && dpEven[tot-k][k-1]);
            dpOdd[tot-k][k] = !(dpOdd[tot-k-1][k] && dpOdd[tot-k][k-1]);
        }
    }
}

代码

最终统计序列 $a$ 中偶数 $a_i$ 和奇数 $a_i$ 分别出现的次数cntEven、cntOdd，并判断 首名以偶胜 dpEven[cntOdd][cntEven] 的状态即可输出胜利者姓名。
代码如下：

#include <bits/stdc++.h>
using namespace std;
#define YN(x) cout << (x ? "Alice" : "Bob") << endl
#define Yn(x) cout << (x ? "Yes" : "No") << endl
#define yn(x) cout << (x ? "yes" : "no") << endl

const int maxn = 100 + 10;
// dp[i][j]: odd num == i, even num == j
// Whether the person who starts first can get an EVEN sum. (plays the optimal strategy)
bool dpEven[maxn][maxn];
// Whether the person who starts first can get an ODD sum. (plays the optimal strategy)
bool dpOdd[maxn][maxn];

void init()
{
    for (int tot = 1; tot < maxn; tot ++){
        dpEven[0][tot] = true;
        dpOdd[0][tot] = false;

        int aliceNum = (tot+1) / 2;
        if (aliceNum % 2 == 0){
            dpEven[tot][0] = true;
            dpOdd[tot][0] = false;
        }
        else {
            dpEven[tot][0] = false;
            dpOdd[tot][0] = true;
        }

        for (int k = 1; k < tot; k ++){
            // totSum == even, Bob need ODD sum to defeat Alice
            if ((tot-k) % 2 == 0){
                dpEven[tot-k][k] = !(dpOdd[tot-k-1][k] && dpOdd[tot-k][k-1]);
                dpOdd[tot-k][k] = !(dpEven[tot-k-1][k] && dpEven[tot-k][k-1]);
            }
            // totSum == odd, Bob need EVEN sum to defeat Alice
            else {
                dpEven[tot-k][k] = !(dpEven[tot-k-1][k] && dpEven[tot-k][k-1]);
                dpOdd[tot-k][k] = !(dpOdd[tot-k-1][k] && dpOdd[tot-k][k-1]);
            }
        }
    }
}

int main()
{
	init();
    int tt;     cin >> tt;
    while (tt --){
        int n; 		cin >> n;
        int cntOdd = 0, cntEven = 0;
        int x;      
        for (int i = 0; i < n; i ++){
            cin >> x;
            if (x & 1)  cntOdd ++;
            else        cntEven ++;
        }
        YN(dpEven[cntOdd][cntEven]);
    }
    return 0;
}

---

解法 2 数学推理

共识：奇数 + 奇数 = 偶数；奇数 + 偶数 = 奇数；偶数 + 偶数 = 偶数。

统计序列 $a$ 中偶数 $a_i$ 和奇数 $a_i$ 分别出现的次数 $e$、$o$，依次可确定下列几种情况，决定二人胜负态：

1. 当 $o\equiv 2(\mathrm{mod}4)$ 时， Bob 存在必胜态；

Bob 仅需保证每次所取数字与 Alice 所取数字奇偶性相同即可，这样可以使二者取走的奇数个数相同。若在此过程中 Alice 取走了最后一个偶数，奇数必然剩余偶个。随后，Alice 和 Bob 各自将选择剩余奇数的一半。最后，Alice 和 Bob 都拥有 $\frac{o}{2}$ 个奇数，Alice 和为奇数，Alice 败。

2. 当 $o\equiv 3(\mathrm{mod}4)$ 时， Alice 存在必胜态；

Alice 首先选择一个奇数，若 Bob 能从剩下的数字中取走偶个奇数，则 Bob 胜。从情况 1 中可知，Bob 必败。

3. 当 $o\equiv 0(\mathrm{mod}4)$ 时， Alice 存在必胜态；

Alice 首先选择一个偶数，在随后的操作中，Alice 仅需保证每次所取数字与 Bob 所取数字奇偶性相同即可，这样可以使二者取走的奇数个数相同。若在此过程中偶数被取完，奇数必然剩余偶个。随后，Alice 和 Bob 各自将选择剩余奇数的一半。最后，Alice 和 Bob 都拥有 $\frac{o}{2}$ 个奇数，Alice 和为偶数，Alice 胜。

4. 当 $o\equiv 1(\mathrm{mod}4)$ 时，先选择奇数的人败。

先选择奇数的人将会导致对手出现情况 3，对手必胜。博弈开始时，如果 $e$ 为偶即 $e\equiv 0(\mathrm{mod}2)$，则 Bob 将会取走最后一个偶数，Alice 败；$e$ 为奇即 $e\equiv 1(\mathrm{mod}2)$，则 Alice 胜。

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define YN(x) cout << (x ? "Alice" : "Bob") << endl

int main()
{
    int tt;     
    cin >> tt;
    while (tt --){
        int n; 		
        cin >> n;
        int cntOdd = 0, cntEven = 0;
        int x;      
        for (int i = 0; i < n; i ++){
            cin >> x;
            if (x & 1)  cntOdd ++;
            else        cntEven ++;
        }
        
        bool ok = false;
        if (cntOdd % 4 == 2)		ok = false;
        else if (cntOdd % 4 == 3)	ok = true;
    	else if (cntOdd % 4 == 0)	ok = true;
    	else if (cntEven % 2 == 1)	ok = true;
    	
        YN(ok);
    }
    return 0;
}