【動態規劃】質數取石子

题目描述

DD 和 MM 正在玩取石子游戏。他们的游戏规则是这样的：桌上有若干石子，DD 先取，轮流取，每次必须取质数个。如果某一时刻某一方无法从桌上的石子中取质数个，比如说剩下 0 个或 1 个石子，那么他/她就输了。

DD 和 MM 都很聪明，不管哪方存在一个可以必胜的最优策略，他/她都会按照最优策略保证胜利。于是，DD 想知道，对于给定的桌面上的石子数，他究竟能不能取得胜利呢？

当 DD 确定会取得胜利时，他会说：“不管 MM 选择怎样的取石子策略，我都能保证至多 X 步以后就能取得胜利。”那么，最小的满足要求的 X 是多少呢？注意，不管是 DD 取一次石子还是 MM 取一次石子都应该被计算为“一步”。
输入格式

第一行有一个整数 N，表示这个输入文件中包含 N 个测试数据。

第二行开始，每行有一个测试数据，其中仅包含一个整数，表示桌面上的石子数。

输出格式

你需要对于每个输入文件中的 N 个测试数据输出相应的 N 行。

如果对于该种情形是 DD 一定取得胜利，那么输出最小的 X。否则该行输出 -1。

样例输入
3 8 9 16
样例输出
1 -1 3

這是一道簡單的動態規劃（對我來說比較困難）。

看到題目，不難想到枚舉最後一次取石子，但是若直接以剩下的石子數作為狀態，就會有後效性，因為最後一次是DD還是MM取石子的轉移條件是不一樣的。
所以考慮將最後一次取石子的人也作為狀態。

定義狀態如下：

用f[i][0]表示剩下i個石子，DD先取，他是否能夠取勝（若能取勝則值為取勝的最小步數，否則為-1。）；用f[i][1]表示剩下i個石子，MM先取，DD是否能夠取勝。

轉移方程：f[i][0] = max(f[i - p][1])（所有的f[i - p][1]都不為-1，否則f[i][0] = -1）；
    f[i][1] = min(f[i - p][0])（有一個f[i - p][0]不為-1，否則f[i][0] = -1）。
其中，p為所枚舉的質數。

提交了4次：

第一次0分；

第二次20分；

第三次20分；之前的錯在在轉移時沒有按先取石子的人進行分類討論。

第四次100分。

ACCode：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <bitset>

const char fi[] = "rqnoj116.in";
const char fo[] = "rqnoj116.out";
const int maxN = 50010;
const int maxP = 5000;
const int MAX = 0x3fffff00;
const int MIN = -MAX;

int prime[maxP];
int f[maxN][2];
int N, n;

  void init_file()
  {
    freopen(fi, "r", stdin);
    freopen(fo, "w", stdout);
  }
  
  void mkprime()
  {
    prime[0] = 2; prime[1] = 3; prime[2] = 5;
    for (int i = 3, tmp = 6; i < maxP; ++i)
    {
      for (bool ok = false; !ok; )
      {
        ++tmp;
        ok = true;
        for (int j = 0; prime[j]
          * prime[j] <= tmp; ++j)
          if (tmp % prime[j] == 0)
            {ok = false; break; }
      }
      prime[i] = tmp;
      f[prime[i]][0] = f[prime[i] + 1][0] = 1;
	//在一步以內肯定能成功。
      f[prime[i]][1] = f[prime[i] + 1][1] = -1;
	//肯定失敗。
    }
  }
  
  void DP(int i, bool odd)
  {
    if (f[i][odd] > -2) return;
    if (odd)
    {
      for (int j = 0; j < maxP
        && prime[j] < i + 1; ++j)
      {
        DP(i - prime[j], !odd);
        if (f[i - prime[j]][!odd] == -1)
          {f[i][odd] = -1; return; }
        f[i][odd] = std::max(f[i][odd],
          f[i - prime[j]][!odd] + 1);
      }
      if (f[i][odd] < -2)
        f[i][odd] = -1;
    }
    else
    {
      f[i][odd] = MAX;
      for (int j = 0; j < maxP
        && prime[j] < i + 1; ++j)
      {
        DP(i - prime[j], !odd);
        if (f[i - prime[j]][!odd] == -1)
          continue;
        f[i][odd] = std::min(f[i][odd],
          f[i - prime[j]][!odd] + 1);
      }
      if (f[i][odd] == MAX)
        f[i][odd] = -1;
    }
  }
  
  void work()
  {
    memset(f, 0xfe, sizeof(f));
    mkprime();
	//建立質數表。
    scanf("%d", &N);
    f[0][1] = 0;
    f[1][1] = 0;
    f[0][0] = -1;
    f[1][0] = -1;
	//對邊界賦初值。
    for (int t = 0; t < N; ++t)
    {
      scanf("%d", &n);
      DP(n, 0);
      printf("%d\n", f[n][0]);
    }
  }
  
int main()
{
  init_file();
  work();
  exit(0);
}