[AtCoderContest010D]Decrementing

试题描述

There are $N$ integers written on a blackboard. The $i$-th integer is $A_i$, and the greatest common divisor of these integers is $1$.

Takahashi and Aoki will play a game using these integers. In this game, starting from Takahashi the two player alternately perform the following operation:

Select one integer on the blackboard that is not less than $2$, and subtract $1$ from the integer.
Then, divide all the integers on the black board by $g$, where $g$ is the greatest common divisor of the integers written on the blackboard.
The player who is left with only $1$s on the blackboard and thus cannot perform the operation, loses the game. Assuming that both players play optimally, determine the winner of the game.

两个人玩游戏，他们轮流操作一个初始时最大公约数为 $1$ 的序列，一次操作是将一个数减 $1$，然后所有数除以它们的最大公约数，最终无法操作者输，问是否先手必胜。

输入

The input is given from Standard Input in the following format:

N

A_1 A_2 … A_N

输出

If Takahashi will win, print First. If Aoki will win, print Second.

输入示例1

3

3 6 7

输出示例1

First

输入示例2

4

1 2 4 8

输出示例2

First

输入示例3

5

7 8 8 8 8

输出示例3

Second

数据规模及约定

$1 \le N \le 10^5$

$1 \le Ai \le 10^9$

The greatest common divisor of the integers from $A_1$ through $A_N$ is $1$.

题解

可能考虑奇偶性是一类博弈问题的思路吧。

首先，如果开始时全是奇数，注意到每次操作不会改变数的奇偶性，所以先手一定会将一个奇数变成偶数，那么后手就可以将这个偶数变回奇数，直到最终都变成了 $1$（全是奇数），所以后手必胜。

类似地，可以推广出：奇数个偶数，先手必胜；偶数个偶数，后手必胜。

但是有一个小 bug，如果开始时只有一个奇数，那么就不一定了，因为先手可能将那个奇数变成偶数，然后除以一下公约数，变成一个新局面。

当然这种情况很好处理，直接暴力模拟，直到“只有一个奇数”的局面消失，或者变成了全 $1$ 序列，模拟次数不会超过 $log_2max\{A_i\}$。

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cctype>

#include <algorithm>

using namespace std;

int read() {

	int x = 0, f = 1; char c = getchar();

	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }

	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }

	return x * f;

}

#define maxn 100010

int n, ceven, A[maxn];

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

int main() {

	int sum = 0; bool has1 = 0, cur = 0;

	n = read();

	for(int i = 1; i <= n; i++) A[i] = read(), ceven += !(A[i] & 1), has1 |= (A[i] == 1), (sum += A[i] - 1) &= 1;

	if(has1) return puts(sum ? "First" : "Second"), 0;

	if(ceven & 1) return puts("First"), 0;

	if(n - ceven > 1) return puts("Second"), 0;

	for(; ;) {

		cur ^= 1;

		for(int i = 1; i <= n; i++) if(A[i] & 1) A[i]--;

		int g = A[1];

		for(int i = 2; i <= n; i++) g = gcd(g, A[i]);

		ceven = sum = has1 = 0;

		for(int i = 1; i <= n; i++) A[i] /= g, ceven += !(A[i] & 1), has1 |= (A[i] == 1), (sum += A[i] - 1) &= 1;

		if(has1) return puts((sum ^ cur) ? "First" : "Second"), 0;

		if(n - ceven > 1) return puts(((ceven & 1) ^ cur) ? "First" : "Second"), 0;

	}

	return 0;

}