[HNOI&AHOI2017] NOIP考挂蒟蒻的一篇游记 && 部分题解

最新推荐文章于 2021-01-05 09:14:37 发布

whzzt

最新推荐文章于 2021-01-05 09:14:37 发布

阅读量4.5k

点赞数 1

本文链接：https://blog.csdn.net/whzzt/article/details/70184330

版权

Day0

犹记得上次NOIP329却切了Day1T2…这次似乎翻盘很困难……？

咸鱼选手试机写了个Pollard-rho 震惊地发现srand(19260817)之后随机的long long数竟然是2*大素数形式还以为我写错了。

隔了一个座位的wyx敲了一个SA和FFT，期间稳爷爷约5-10分钟来奶wyx霸霸一次，然后开始互奶。

后来wlp和zzy来了，场面一度失控（捂脸）

（可能是因为太久没上语文了已经不会写文章了）

Day1

拿到题看了看T1的spaly，画了画图就扔了，感觉不是很可做。

看了看T2 似乎是道计数题怕是还是可以做的先扔了看T3去

然后看了下T3发现是傻逼题直接敲了个NTT就过了样例拍了拍暴力数据感觉没啥错就去看前面的题了(全世界都A了T3)

于是又看了看T2 没看出第一个情况只有O(n)种感觉暴力还是很好写的先丢一边了

研究T1的性质发现单旋最小值就是只有最小值的右子树深度不变其他都+1 单旋最大值也差不多感觉还是不太可做

yy了一个splay维护整棵树的dfs序的写法开始大力码码码码好之后开始调调调前后大概花了3h+ 总算是和暴力拍上了感觉很兴奋(然而只有本傻逼选手写的是splay维护dfs序 wlp是LCT wyx直接一棵线段树就艹过去了为什么不强制在线呜呜呜全世界都A了T1)

然后就玩了玩T2的暴力30分写了一个可持久化线段树的60 不想拍了（其实来不及了有点慌）就直接交了

T2 第一个情况竟然那么少？？？？？？？？？？？？？

(全世界都A了T2)

出来没有fst T1和T3我是很开心的 T2的暴力30也在预想之中似乎把NOIP考挂的差距填回来了

Day2

这个T1数据范围这么小…全场都会做？

然后我就发现自己并不会什么多项式做法先去看T2

woc计算几何？

滚去看T3

诶我好像不会敲个70暴力吧。。

然后滚回去看T2 还是不会跑去写T1暴力

嗯这个T1暴力很靠谱……？于是码了一个dp贪心了一下然后dfs暴力一下瞎jb剪剪枝

竟然A了？

然后又敲了个T2暴力想了想加了一句

if (n >= 100000) {puts("nan");return 0;}

居然给我续了20pts……感觉会被ban掉……

于是day2就220……？懵--

wyx霸霸还是好稳啊怒艹稳爷爷可怕

wlp day2怎么翻车了啊不懂

-------------------------------------------分割线-------------------------------------------

放一下其中几道题的题解吧。。

Day1T1 单旋 spaly

题意：给一棵spaly 要求支持插入单旋最小值单旋最大值单旋删除最小值单旋删除最大值每次输出上次操作节点深度数据范围1E5

听说可以splay直接暴力维护这棵spaly 反正我是维护了整棵spaly的dfs序然后我们来看每个操作

我们考虑我们将每个点拆成了入(深度+1) 出(深度-1) 因此求一个点的深度其实就是求这个点的入/出在整个dfs序上的前缀和，可以均摊O(log n)统计答案。

我们考虑dfs序怎么维护，首先考虑操作1：加入一个节点

显然加入的这个节点要么被挂在前继的右边要么被挂在后继的左边而这取决于前继和后继谁的深度更小

因此我们只要查询一下哪个是父亲如果是这个数的前继其右子树一定为空直接在它的出点前面插入即可

如果是这个数的后继左子树一定为空只要在入点后面插入

操作2：将最小值旋转到根

我们发现最小值旋转到根后它只有右子树并且整个森林中其他值的dfs序位置不变

所以我们将这个最小值提出来分开放到整个dfs序列的最前面和最后面就可以了

操作3：将最大值旋转到根

和操作2相似

操作4和操作5：先做一次对应操作再删去两个节点即可

时间复杂度O(nlogn)

#include"algorithm"
#include"iostream"
#include"stdlib.h"
#include"stdio.h"
#include"math.h"
#include"vector"
#include"queue"
#include"map"
#include"set"

using namespace std;

const int N=100005;

struct node{
	node*c[2],*fa;
	int flag,sum,sz;
	node();
	void pushup();
}Tnull,*null=&Tnull,a[2][N];

node::node(){
	c[0]=c[1]=fa=null;
	flag=0,sum=0,sz=0;
}

void node::pushup(){
	sz=c[0]->sz+c[1]->sz+1;
	sum=c[0]->sum+flag+c[1]->sum;
}

void rotate(node*x,node*&f){
	node*y=x->fa,*z=y->fa;
	if(y==f)f=x;else if(z!=null)z->c[z->c[1]==y]=x;
	int l=y->c[1]==x,r=l^1;
	if(x->c[r]!=null)x->c[r]->fa=y;
	y->fa=x,x->fa=z,y->c[l]=x->c[r],x->c[r]=y,y->pushup();
}

void splay(node*x,node*&f){
	while(x!=f){
		node*y=x->fa,*z=y->fa;
		if(y!=f){
			if((z->c[0]==y)^(y->c[0]==x))rotate(x,f);
			else rotate(y,f);
		}
		rotate(x,f);
	}
	x->pushup();
}

map <int,int> dat;
node*rt=null;

int query_deep(int x){
	node*y=&a[0][x];
	splay(y,rt);
	return y->c[0]->sum+y->flag;
}

void insert_back(node*x,node*i){
	splay(x,rt);
	i->c[1]=x->c[1];
	if(x->c[1]!=null)x->c[1]->fa=i;
	x->c[1]=i,i->fa=x;
	i->pushup(),x->pushup();
}

void insert_front(node*x,node*i){
	splay(x,rt);
	i->c[0]=x->c[0];
	if(x->c[0]!=null)x->c[0]->fa=i;
	x->c[0]=i,i->fa=x;
	i->pushup(),x->pushup();
}

int getsiz(int x){
	node*l=&a[0][x],*r=&a[1][x];
	splay(l,rt),splay(r,rt->c[1]);
	return rt->c[1]->c[0]->sz;
}

node*findfr(node*x){
	if(x->c[0]!=null)return findfr(x->c[0]);
	return x;
}

node*finded(node*x){
	if(x->c[1]!=null)return finded(x->c[1]);
	return x;
}

void insert(int x,int key){
	a[0][x].flag=1,a[0][x].pushup();
	a[1][x].flag=-1,a[1][x].pushup();
	if(rt==null){
		rt=&a[0][x],insert_back(rt,&a[1][x]);
		dat[key]=x;
		printf("%d\n",query_deep(x));
		return;
	}
	map<int,int>::iterator i=dat.lower_bound(key);
	if(i==dat.begin()){
		int d=i->second;
		insert_back(&a[0][d],&a[0][x]);
		insert_back(&a[0][x],&a[1][x]);
	}else if(i==dat.end()){
		--i;
		int d=i->second;
		insert_front(&a[1][d],&a[0][x]);
		insert_back(&a[0][x],&a[1][x]);
	}else{
		map<int,int>::iterator j=i;
		--i;
		if(getsiz(i->second)>getsiz(j->second)){
			int d=j->second;
			insert_back(&a[0][d],&a[0][x]);
			insert_back(&a[0][x],&a[1][x]);
		}else{
			int d=i->second;
			insert_front(&a[1][d],&a[0][x]);
			insert_back(&a[0][x],&a[1][x]);
		}
	}
	dat[key]=x;
	printf("%d\n",query_deep(x));
}

void erase(node*x){
	splay(x,rt);
	if(x->c[1]==null){
		rt=x->c[0];
		x->c[0]=null;
		return;
	}
	node*y=findfr(x->c[1]);
	splay(y,x->c[1]);
	rt=x->c[1];
	if(x->c[0]!=null)x->c[0]->fa=rt;
	rt->c[0]=x->c[0];
	x->c[1]=null,x->c[0]=null;
	rt->pushup();
}

void outtree(node*x){
	if(x->c[0]!=null)outtree(x->c[0]);
	if(x->flag==-1)printf("%d ",x-&a[1][0]);
	else printf("%d ",x-&a[0][0]);
	if(x->c[1]!=null)outtree(x->c[1]);
}

void makeroot(int id){
	int ans=query_deep(id);
	printf("%d\n",ans);
	erase(&a[0][id]);
	node*x=findfr(rt);
	insert_front(x,&a[0][id]);
	erase(&a[1][id]);
	node*y=finded(rt);
	insert_back(y,&a[1][id]);
}

void splay_mn(bool del){
	map<int,int>::iterator i=dat.begin();
	makeroot(i->second);
	if(del)dat.erase(i);
}

void splay_mx(bool del){
	map<int,int>::iterator i=dat.end();
	--i;
	makeroot(i->second);
	if(del)dat.erase(i);
}

void del_mn(){
	splay_mn(1);
	node*x=findfr(rt);
	node*y=finded(rt);
	erase(x),erase(y);
}

void del_mx(){
	splay_mx(1);
	node*x=findfr(rt);
	node*y=finded(rt);
	erase(x),erase(y);
}

int n,m;

int main(){
	freopen("splay.in","r",stdin);
	freopen("splay.out","w",stdout);
	null->c[0]=null->c[1]=null->fa=null;
	scanf("%d",&n);
	for(int i=1,opt,key;i<=n;i++){
		scanf("%d",&opt);
		switch(opt){
			case 1:scanf("%d",&key);insert(++m,key);break;
			case 2:splay_mn(0);break;
			case 3:splay_mx(0);break;
			case 4:del_mn();break;
			case 5:del_mx();break;
		}
	}
	return 0;
}

Day1T2 影魔 sf

题意给定排列a 长度2E5 设L[i]为i左边第一个大于a[i]的值 R[i]为i右边第一个大于a[i]的值

2E5组l,r,求∑[l<=i<j<=r] [L[j]<=i && R[i]>=j] (p1-2p2) + ∑[l<=i<j<=r] [L[j]<=i || R[i]>=j] p2

这是我的做法……可能比较繁琐但是起码……是可以过的吧

时间复杂度O((6n+12m)logn)=O((n+m)logn)

#include"algorithm"
#include"iostream"
#include"stdlib.h"
#include"stdio.h"
#include"math.h"
#include"vector"
#include"queue"
#include"map"
#include"set"

#define last last_

using namespace std;
typedef long long LL;

const int N=200005;
int n,m,p1,p2,a[N],st[N],tp,L[N],R[N];
LL ans;

const int M=24000005;
LL sum[M];
int ls[M],rs[M],ndc;

void add(int&x,int last,int l,int r,int p,int u){
	x=++ndc,sum[x]=sum[last]+u,ls[x]=ls[last],rs[x]=rs[last];
	if(l==r)return;
	int mid=(l+r)>>1;
	if(p<=mid)add(ls[x],ls[last],l,mid,p,u);
	else add(rs[x],rs[last],mid+1,r,p,u);
}

LL qry(int x,int l,int r,int s,int t){
	if(sum[x]==0)return 0;
	if(l==s&&r==t)return sum[x];
	int mid=(l+r)>>1;
	if(t<=mid)return qry(ls[x],l,mid,s,t);
	if(s>mid)return qry(rs[x],mid+1,r,s,t);
	return qry(ls[x],l,mid,s,mid)+qry(rs[x],mid+1,r,mid+1,t);
}

LL ask(int*rt,int l,int r,int L,int R,int S,int T){
	return qry(rt[r],L,R,S,T)-qry(rt[l-1],L,R,S,T);
}

int rt[6][N];

int main(){
	freopen("sf.in","r",stdin);
	freopen("sf.out","w",stdout);
	scanf("%d%d%d%d",&n,&m,&p1,&p2);
	int w1=p1-2*p2,w2=p2;
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	for(int i=1;i<=n;i++){
		while(tp&&a[st[tp]]<a[i])st[tp--]=0;
		L[i]=st[tp];
		st[++tp]=i;
	}
	while(tp)st[tp--]=0;
	st[0]=n+1;
	for(int i=n;i>=1;i--){
		while(tp&&a[st[tp]]<a[i])st[tp--]=0;
		R[i]=st[tp];
		st[++tp]=i;
	}
	int d=n+1;
	for(int i=1;i<=n;i++){
		add(rt[0][i],rt[0][i-1],0,d,R[i],1);
		add(rt[1][i],rt[1][i-1],0,d,R[i],R[i]);
		add(rt[2][i],rt[2][i-1],0,d,L[i],1);
		add(rt[3][i],rt[3][i-1],0,d,L[i],L[i]);
		add(rt[4][i],rt[4][i-1],0,d,R[i],L[R[i]]<i);
		add(rt[5][i],rt[5][i-1],0,d,L[i],R[L[i]]>i);
	}
	for(int i=1,l,r;i<=m;i++,ans=0){
		scanf("%d%d",&l,&r);
		ans+=(ask(rt[1],l,r,0,d,0,r-1)+ask(rt[0],l,r,0,d,r,d)*r)*w2;
		ans-=(ask(rt[3],l,r,0,d,l+1,d)+ask(rt[2],l,r,0,d,0,l)*l)*w2;
		ans+=(ask(rt[4],l,r,0,d,0,r)+ask(rt[5],l,r,0,d,l,d))*w1;
		printf("%lld\n",ans);
	}
	return 0;
}

Day1T3 礼物 gift

题意给两个序列x和y 长度5E4 数字范围1-100 求的最小值

然后就做完了 k可以暴力枚举发现旋转次数和k独立因为这个值很小所以用NTT求一下那个和旋转次数有关的值的最大值即可

时间复杂度O(nlogn+m)

#include"algorithm"
#include"iostream"
#include"stdlib.h"
#include"stdio.h"
#include"math.h"
#include"vector"
#include"queue"
#include"map"
#include"set"

using namespace std;

typedef long long LL;

const int N=50005,M=266666;
const int P=998244353,g=3;

int power(int a,int t,int P){
	int r=1;
	while(t){
		if(t&1)r=(LL)r*a%P;
		a=(LL)a*a%P;t>>=1;
	}
	return r;
}

int wn_[25];

void pre(){for(int i=0;i<22;i++)wn_[i]=power(g,(P-1)>>i,P);}

void transform(int A[],int len,int dft){
	int i,j=len>>1,k,l,c=0;
	for(i=1;i<len-1;i++){
		if(i<j)swap(A[i],A[j]);
		for(k=len>>1;j>=k;j-=k,k>>=1);
		j+=k;
	}
	for(l=2;l<=len;l<<=1){
		i=l>>1;
		int wn=wn_[++c];
		for(j=0;j<len;j+=l){
			int w=1;
			for(k=j;k<j+i;k++){
				LL u=A[k],v=(LL)A[k+i]*w%P;
				A[k]=(u+v)%P,A[k+i]=(u-v+P)%P;
				w=(LL)w*wn%P;
			}
		}
	}
	if(dft==-1){
		int inv_len=power(len,P-2,P);
		for(int i=0;i<len;i++)A[i]=(LL)A[i]*inv_len%P;
		for(int i=1;i<len/2;i++)swap(A[i],A[len-i]);
	}
}

int n,m,a[N],b[N],L,x[M],y[M],z[M],mx=0;

LL w0,w1,w2,ans;

LL calc(){
	ans=(LL)1e10;
	for(int k=-233;k<=233;k++)
		ans=min(ans,w0+w1*k+w2*k*k);
	return ans;
}

int main(){
	freopen("gift.in","r",stdin);
	freopen("gift.out","w",stdout);
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)scanf("%d",&a[i]);
	for(int i=0;i<n;i++)scanf("%d",&b[i]);
	for(int i=0;i<n;i++)x[n-i-1]=a[i];
	for(int i=0;i<n;i++)y[i]=y[i+n]=b[i];
	for(L=1;L<=n*4;L<<=1);
	pre();
	transform(x,L,1);
	transform(y,L,1);
	for(int i=0;i<L;i++)z[i]=(LL)x[i]*y[i]%P;
	transform(z,L,-1);
	for(int i=n-1;i<=2*n-2;i++)mx=max(mx,z[i]);
	w0=-2*mx;
	for(int i=0;i<n;i++){
		w0+=a[i]*a[i];
		w0+=b[i]*b[i];
		w1+=2*b[i];
		w1-=2*a[i];
		w2++;
	}
	printf("%lld\n",calc());
	return 0;
}

Day2T1 大佬 dalao

题意略

我们发现怼dalao的次数和dalao的血量无关所以我们可以先做一个dp 得到怼dalao的最多天数

然后我们就可以大力搜搜搜了

我们发现这个怼dalao的天数也很少所以可以暴力枚举

首先考虑假如一次要怼一个dalao k点自信的最少步数

我们可以枚举最高到达的等级这个等级一定大于等于k的最大质因子一定是k的约数又不会超过步数上限

所以这里可以剪很多 check一次虽然还是O(n^2) 但是会快很多

然后我们就可以暴力处理怼dalao一次的情况

对于怼两次的情况我们暴力步数较少的那一边就是我们搜索这个怼掉的自信值k 然后大力剪剪枝就可以过了

我也不知道时间复杂度是什么。

#include"algorithm"
#include"iostream"
#include"stdlib.h"
#include"string.h"
#include"stdio.h"
#include"math.h"
#include"vector"
#include"queue"
#include"map"
#include"set"

using namespace std;

const int jp[]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
const int N=105,INF=(int)1e9;

int n,m,mc,a[N],w[N],C[N],dp[N][N],k,fl[N],maxc,tmp;

map<int,int> s;
int dat[1000005];

int find(int x){
	if(x<=1000000)return dat[x];
	return s[x];
}

void insert(int x,int ans){
	if(x<=1000000)dat[x]=ans;
	else s[x]=ans;
}

int calc(int n){
	if(n<0)return INF;
	if(n==0)return 0;
	if(n==1)return 1;
	int l=n,ed=1;
	for(int i=0;i<25;i++)while(l%jp[i]==0)ed=jp[i],l/=jp[i];
	if(l>1)return INF;
	if(find(n))return find(n);
	int lim=k+1;
	for(int i=ed;i<lim-1;i++)if(n%i==0){
		int t=i+1;
		l=n;
		for(int j=i;j>=2&&t<=lim&&l>1;j--)while(l%j==0){l/=j;++t;}
		if(l==1)lim=min(lim,t);
	}
	insert(n,lim);
	return lim;
}

void dfs(int x,int pos){
	if(tmp==m)return;
	int t=calc(x);
	if(t>k/2)return;
	for(int i=pos;i>=0;i--)if((long long)x*jp[i]<=maxc)dfs(x*jp[i],i);
	for(int i=0;i<=k-2*t;i++){
		for(int j=1;j<=m;j++)if(!fl[j]){
			int l=calc(C[j]-x-i);
			if(l+t+i<=k)fl[j]=1,++tmp;
		}
	}
}

int main(){
	freopen("dalao.in","r",stdin);
	freopen("dalao.out","w",stdout);
	scanf("%d%d%d",&n,&m,&mc);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)scanf("%d",&w[i]);
	for(int i=1;i<=m;i++)scanf("%d",&C[i]),maxc=max(maxc,C[i]);
	memset(dp,-1,sizeof(dp));
	dp[0][0]=mc;
	for(int i=0;i<n;i++){
		for(int j=0;j<=i;j++)if(dp[i][j]!=-1){
			if(dp[i][j]-a[i+1]<0)continue;
			dp[i+1][j]=min(mc,max(dp[i+1][j],dp[i][j]-a[i+1]+w[i+1]));
			dp[i+1][j+1]=min(mc,max(dp[i+1][j+1],dp[i][j]-a[i+1]));
		}
		for(int j=0;j<=n;j++)if(dp[i+1][j]!=-1)k=max(k,j);
	}
	for(int i=1;i<=m;i++){
		for(int j=0;j<k&&j<C[i];j++)fl[i]|=calc(C[i]-j)+j<=k;
		tmp+=fl[i];
	}
	dfs(1,14);
	for(int i=1;i<=m;i++)printf("%d\n",fl[i]);
	return 0;
}

Day2T2 队长快跑 captain

计算几何题不会 ~~会了再填坑~~

Day2T3 抛硬币 coin

题意：问n次抛硬币正面的数量比m次抛硬币正面的数量多的方案数mod 10^k的值 n,m是1E18级别 k<=9 n>=m n-m<=10000

这个题好棒啊。。反正我是智商不太够。。

首先我们考虑在n个里面选i个在m个中选j个的方案数

就变成了 ∑[i>j]C(n,i)*C(m,j)

真是遗憾反正我是不会继续推式子了

但是我们可以将问题进行一次转化

i>j可以转化为i-j>0

你可能会问这有什么重要的意义吗但是我们再将这个式子变一下就变成了

i+m-j>m

问题就转化为在n+m个物品里面选择超过m个物品的方案数显然我们把这些物品排好每个左边的n个和右边的m个与上面的方案是一一对应的

所以式子就变成了∑[i=m+1...n+m] C(n+m,i)

但是还是有一个问题这个组合数如何计算

我们很想暴力使用扩展Lucas定理但是这样就变成了O(Tk(n-m)logn)会TLE

可能会有一些卡常的技巧但是这里完全可以求出第一个组合数 mod 2^k 用 2^p*c 表示的结果和 mod 5^k 用 5^p * c表示的结果

而我们做CRT时的exgcd值是固定的可以一直使用

这样的时间复杂度就是O(Tk(n-m+logn))的

其实这里可以将k去掉只要预处理出2和5的9次以下幂就可以了但是似乎并没有什么必要

#include"bits/stdc++.h"

using namespace std;

typedef long long LL;

const int Mod=1000000000;
const int Mod1=1<<9,Mod2=Mod>>9;
const int ex1=1537323,ex2=-403;

void exgcd(int a,int b,int&x,int&y){
	if(b==0){x=1,y=0;return;}
	exgcd(b,a%b,y,x);y-=a/b*x;
}

int inv(int a,int mod){
	int x,y;exgcd(a,mod,x,y);
	return (x%mod+mod)%mod;
}

int CRT(int r2,int r5){return ((((LL)(r5-r2)*ex1%Mod<<9)+r2)%Mod+Mod)%Mod;}

int power(int a,LL t,int P){
	int r=1;
	while(t){
		if(t&1)r=(LL)r*a%P;
		a=(LL)a*a%P;t>>=1;
	}
	return r;
}

LL n,m;
int k;

char ot[23];
void output(int n){
	for(int i=1;i<=k;i++)ot[i]=n%10+'0',n/=10;
	for(int i=k;i>=1;i--)putchar(ot[i]);
	putchar('\n');
}

const int N=2000005;

int fac[2][N];

LL gd(LL n,int d){
	if(n<d)return 0;
	return gd(n/d,d)+n/d;
}

int getfac(LL n,int p,int mo){
	if(n<p)return fac[p==5][n];
	return (LL)fac[p==5][n%mo]*power(fac[p==5][mo-1],n/mo,mo)%mo*getfac(n/p,p,mo)%mo;
}

int F,G,FT,GT;

int C(LL n,LL m,bool fl=false){
	if(n<m)return 0;
	int ft=gd(n,2)-gd(m,2)-gd(n-m,2);
	int gt=gd(n,5)-gd(m,5)-gd(n-m,5);
	int fn=(LL)getfac(n,2,Mod1)*inv((LL)getfac(m,2,Mod1)*getfac(n-m,2,Mod1)%Mod1,Mod1)%Mod1;
	int gn=(LL)getfac(n,5,Mod2)*inv((LL)getfac(m,5,Mod2)*getfac(n-m,5,Mod2)%Mod2,Mod2)%Mod2;
	if(fl)F=fn,G=gn,FT=ft,GT=gt;
	fn=(LL)fn*power(2,ft,Mod1)%Mod1;
	gn=(LL)gn*power(5,gt,Mod2)%Mod2;
	return CRT(fn,gn);
}

int calc(LL n,LL m){
	int ans=power(2,n+m-1,Mod);
	if(m+1<=(n+m)/2){
		ans=(ans+C(n+m,m+1,1))%Mod;
		for(LL i=m+2,j,_F,_G;i<=(n+m)/2;i++){
			j=i;
			while(j%2==0)FT--,j/=2;
			F=(LL)F*inv(j%Mod1,Mod1)%Mod1;
			j=i;
			while(j%5==0)GT--,j/=5;
			G=(LL)G*inv(j%Mod2,Mod2)%Mod2;
			j=n+m-i+1;
			while(j%2==0)FT++,j/=2;
			F=(LL)F*(j%Mod1)%Mod1;
			j=n+m-i+1;
			while(j%5==0)GT++,j/=5;
			G=(LL)G*(j%Mod2)%Mod2;
			_F=(LL)F*power(2,FT,Mod1)%Mod1;
			_G=(LL)G*power(5,GT,Mod2)%Mod2;
			ans=(ans+CRT(_F,_G))%Mod;
		}
	}
	if(n+m&1^1)ans=(ans-C(n+m-1,(n+m)/2)+Mod)%Mod;
	return ans;
}

int main(){
	freopen("coin.in","r",stdin);
	freopen("coin.out","w",stdout);
	fac[0][0]=1;
	for(int i=1;i<=2*Mod1;i++){
		if(i%2==0)fac[0][i]=fac[0][i-1];
		else fac[0][i]=(LL)fac[0][i-1]*i%Mod1;
	}
	fac[1][0]=1;
	for(int i=1;i<=Mod2;i++){
		if(i%5==0)fac[1][i]=fac[1][i-1];
		else fac[1][i]=(LL)fac[1][i-1]*i%Mod2;
	}
	while(~scanf("%lld%lld%d",&n,&m,&k))output(calc(n,m));
	return 0;
}