Wannafly挑战赛24游记

A - 石子游戏

题目大意：

A和B两人玩游戏，总共有$n(n\le10^4)$堆石子，轮流进行一些操作，不能进行下去的人则输掉这局游戏。操作包含以下两种：

把石子数为奇数的一堆石子分为两堆正整数个石子；
把两堆石子数为偶数的石子合并为一堆。

若两人都按照最优策略进行操作。求若A先手，最后谁能赢得比赛。

思路：

首先最优策略中一定是将奇数拆成$1$和另一个偶数，然后不断将所有偶数进行合并。

因此我们可以统计非$1$奇数的个数$a$和所有非$1$数的个数$b$。由此我们可以求出拆分次数和合并次数，根据操作次数的奇偶性判断即可。

源代码：

#include<cstdio>

#include<cctype>

inline int getint() {

	register char ch;

	while(!isdigit(ch=getchar()));

	register int x=ch^'0';

	while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');

	return x;

}

int main() {

	const int n=getint();

	int cnt=0,tmp=0,tot=0;

	for(register int i=1;i<=n;i++) {

		const int x=getint();

		if(x==1) continue;

		cnt++;

		if(x&1) tot++;

	}

	while(cnt>1) {

		tmp+=cnt/2;

		cnt=cnt/2+cnt%2;

	}

	puts((tmp+tot)%2?"Alice":"Bob");

	return 0;

}

B - 222333

题目大意：

给定质数$p(p\le10^7)$，一定存在$m,n$满足$p|2^m3^n-1$且$m+n\le p$。求数对$(m,n)$。若存在多种，优先输出$m+n$最小的一种。若还有多中，优先输出$m$最小的一种。

思路：

$p|2^m3^n-1$意味着$2^m3^n\equiv1\pmod{p}$，即$3^m$在模$p$意义下是$2^n$的逆元。

而$p\le10^7$，因此我们可以先求出$3^n$的取值在模$p$意义下有多少种可能。然后枚举$m$，判断$2^m$的逆元是否有对应的$3^m$即可。

其中$2^m$的逆元不需要每次重新求，直接根据$2^{-1}$推即可。

小优化：当$n\ge$目前$n+m$的最小值时，直接跳出循环。

时间复杂度$\mathcal O(10p)$。

源代码：

#include<cstdio>

#include<cctype>

#include<climits>

#include<algorithm>

inline int getint() {

	register char ch;

	while(!isdigit(ch=getchar()));

	register int x=ch^'0';

	while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');

	return x;

}

typedef long long int64;

const int N=1e7+1;

int n,b[N];

inline void exgcd(const int &a,const int &b,int &x,int &y) {

	if(!b) {

		x=1,y=0;

		return;

	}

	exgcd(b,a%b,y,x);

	y-=a/b*x;

}

inline int get_inv(const int &x) {

	int ret,tmp;

	exgcd(x,n,ret,tmp);

	return (ret%n+n)%n;

}

int main() {

	while(~scanf("%d",&n)) {

		const int inv=get_inv(2);

		for(register int i=1,p=3;i<=n;i++) {

			if(!b[p]) b[p]=i;

			p=p*3%n;

		}

		int min=INT_MAX,x,y;

		for(register int i=1,q=inv;i<=n;i++) {

			if(i>=min) break;

			if(b[q]) {

				if(i+b[q]<min) {

					min=i+b[q];

					x=i;

					y=b[q];

				}

			}

			q=(int64)q*inv%n;

		}

		printf("%d %d\n",x,y);

		std::fill(&b[1],&b[n]+1,false);

	}

	return 0;

}

C - 失衡天平

题目大意：

有$n(n\le100)$个物品，每个物品有一个价值$v_i(v_i\le100)$。你可以每次选取两堆物品，若这两堆物品价值总和之差$\le m(m\le100)$则可以将这两堆物品全部取出。问最后最多取走多少价值的物品？

思路：

首先可以证明可以将这些取走物品分成两堆，使得价值和之差仍旧小于$m$。

$f[i][j][k]$表示前$i$个物品，一堆价值为$j$，一堆价值为$k$是否可行。使用滚动数组和bitset优化即可。

时间复杂度$\mathcal O(\frac{n^5}{32})$。

源代码：

#include<cstdio>

#include<cctype>

#include<bitset>

#include<algorithm>

inline int getint() {

	register char ch;

	while(!isdigit(ch=getchar()));

	register int x=ch^'0';

	while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');

	return x;

}

const int N=101,M=1e4+1;

int a[N];

std::bitset<M> b[2][M];

int main() {

	const int n=getint(),m=getint();

	for(register int i=1;i<=n;i++) a[i]=getint();

	std::sort(&a[1],&a[n]+1);

	b[0][0]=true;

	int sum=0;

	for(register int i=1;i<=n;i++) {

		const bool cur=i&1;

		sum+=a[i];

		for(register int j=0;j<=sum;j++) {

			b[cur][j]|=b[!cur][j]<<a[i];

			b[cur][j]|=b[!cur][j];

		}

		for(register int j=a[i];j<=sum;j++) {

			b[cur][j]|=b[!cur][j-a[i]];

		}

	}

	int ans=0;

	for(register int i=0;i<=sum;i++) {

		for(register int j=std::max(i-m,0);j<=std::min(i+m,sum);j++) {

			if(b[n&1][i][j]) ans=std::max(ans,i+j);

		}

	}

	printf("%d\n",ans);

	return 0;

}