洛谷P1857 质数取石子（SG函数）

//#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep(i,st,en) for(int i=st;i<=en;i++)
#define REP(i,st,en) for(int i=st;i>=em;i--)
#define el printf("\n");
using namespace std;
typedef double db;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int,int> pa;
typedef unsigned int uint;
typedef unsigned long long ull;

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;
}
void write(int x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+'0');
    return;
}

bool Isntprime[21030];
int prime[20030],cnt,tot,t,n,sg[20030],maxst[20030],minst[20030];
void euler(int n)
{
    Isntprime[0]=Isntprime[1]=1;
    for(int i=2;i<=n;i++)
    {
        if(!Isntprime[i])
        prime[++tot]=i;
        for(int j=1;j<=tot&&i*prime[j]<=n;j++)
        {
            Isntprime[i*prime[j]]=true;
            if(i%prime[j]==0)
            break;
        } 
    }
}
void dfs(int x)
{
	for(int i=1;i<=tot;i++)//枚举素数
	{
		if(x<prime[i])//x比当前素数小
			break;
		if(sg[x-prime[i]]==0)//如果往前一步有必败态，则当前为必胜态，计算minst
		{
			sg[x]=1;//必胜
			minst[x]=min(minst[x],maxst[x-prime[i]]+1);//当前步数和之前最大步数+1比较
		}
	}
	if(sg[x]==0)//x往前一步全是先手必胜，x是先手必败
	{
		for(int i=1;i<=tot;i++)
		{
			if(x<prime[i])
				break;
			maxst[x]=max(minst[x-prime[i]]+1,maxst[x]);//先手必败则尽量拖延
		}
	}
}
void getsg()
{
	sg[0]=sg[1]=0;先手必败
	for(int i=0;i<=20000;i++)
		maxst[i]=0,minst[i]=999999;
	// maxst存如果先手必败，则最大拖延步数，minst存如果先手必胜，则达成胜利最少步数 
	for(int i=2;i<=20000;i++)
		dfs(i);
	//从2开始处理minst和maxst
}
int main()
{
	t=read();
	euler(20030);//筛素数
	getsg();//预处理sg函数
	while(t--)
	{
		n=read();
		if(sg[n]==0)//Ï先手必败
			puts("-1");
		else
			printf("%d\n",minst[n]);//先手必胜，输出最少步数
	}
	return 0;
}

预处理，0和1先手必败，从2开始如果能一步到达一个先手必败的状态则当前为先手必胜态，先手必胜则取最少胜利步数，先手必败则取最多拖延步数，先手必胜取当前和之前所有先手必败情况步数的最大值+1的最小值，先手必败取当前和之前的先手必胜情况的最小值+1的最大值