NOIP2017模拟赛总结（2017.10.30-2017.11.1）

第三篇博客，放上2017.10.30-2017.11.1的题。

2017.10.30 Problem A
题目大意： 有一排$n$棵果树和一个容量为$s$的果篮，从前往后摘果，如果当前果树的果子数量不超过果篮的剩余容量，就将果子全部装进果篮，否则取一个新的果篮，然后将这棵果树上的果子全部装进果篮。求使用果篮数不超过$k$的情况下最小的$s$。
做法： 显然二分$s$，然后从左往右扫一遍判定即可。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n,k;
ll l=0,r=0,a[100010];

bool check(ll mid)
{
	ll s=mid;
	int tot=1;
	for(int i=1;i<=n;i++)
	{
		if (s<a[i])
		{
			s=mid-a[i];
			tot++;
		}
		else s-=a[i];
	}
	if (tot>k) return 0;
	else return 1;
}

int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld",&a[i]);
		l=max(l,a[i]);
		r=r+a[i];
	}
	
	while(l<r)
	{
		ll mid=(l+r)>>1;
		if (check(mid)) r=mid;
		else l=mid+1;
	}
	printf("%lld",l);
	
	return 0;
}

2017.10.30 Problem B
题目大意： 一个带边权的无向图，有$n(\le 100000)$个点和$m(\le n+20)$条无向边，求长度最小的从点$1$开始经过每个点一次且仅一次的环路（点$1$两次）。题目保证有解。
做法： 本题需要用到搜索。
注意到$m\le n+20$，又因为题目保证有解，也就是说每个点的度数都$\ge 2$，而度数$>2$的点不超过$40$个，于是我们把连通在一起的度数为$2$的点缩成一个点，那么最后的点数肯定只有几十个，然后爆搜即可，时间复杂度为$O(跑得过)$。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define inf 2000000000
#define ll long long
using namespace std;
int n,m,tot=0,first[200010]={0},deg[100010]={0},belong[100010]={0},tots=0;
ll ans=inf;
struct edge {int v,next;ll d;} e[500010];
bool vis[200010]={0};

void insert(int a,int b,ll d)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	e[tot].d=d;
	first[a]=tot;
}

void suo(int v,int s)
{
	vis[v]=1;
	belong[v]=s;
	for(int i=first[v];i;i=e[i].next)
		if (deg[e[i].v]==2&&!vis[e[i].v]) suo(e[i].v,s);
}

void link(int v,ll s)
{
	vis[v]=1;
	for(int i=first[v];i;i=e[i].next)
	{
		if (deg[e[i].v]!=2) insert(belong[v],belong[e[i].v],s+e[i].d),insert(belong[e[i].v],belong[v],s+e[i].d);
		else if (!vis[e[i].v]) link(e[i].v,s+e[i].d);
	}
}

void dfs(int v,ll s,int step)
{
	if (s>ans) return;
	if (step<tots-n&&v==belong[1]) return;
	if (step==tots-n&&v==belong[1])
	{
		ans=min(ans,s);
		return;
	}
	for(int i=first[v];i;i=e[i].next)
		if (!vis[e[i].v])
		{
			vis[e[i].v]=1;
			dfs(e[i].v,s+e[i].d,step+1);
			vis[e[i].v]=0;
		}
}

int main()
{
	scanf("%d%d",&n,&m); 
	for(int i=1;i<=m;i++)
	{
		int a,b;ll d;
		scanf("%d%d%lld",&a,&b,&d);
		insert(a,b,d),insert(b,a,d);
		deg[a]++,deg[b]++;
	}
	
	if (m==n)
	{
		ans=0;
		for(int i=1;i<=m;i++)
			ans+=e[2*i].d;
		printf("%lld",ans);
		return 0;
	}
	
	tots=n;
	for(int i=1;i<=n;i++)
	{
		if (deg[i]==2&&!vis[i]) suo(i,++tots);
		else if (deg[i]!=2) belong[i]=++tots;
	}
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++)
	{
		if (deg[i]==2&&!vis[i]) link(i,0);
		else if (deg[i]!=2)
		{
			for(int j=first[i];j;j=e[j].next)
				if (deg[e[j].v]!=2) insert(belong[i],belong[e[j].v],e[j].d); 
		}
	}
	
	for(int i=first[belong[1]];i;i=e[i].next)
	{
		vis[e[i].v]=1;
		dfs(e[i].v,e[i].d,1);
		vis[e[i].v]=0;
	}
	printf("%lld",ans);
	
	return 0;
}

2017.10.30 Problem C
题目大意： 给定一个等差数列 { a i } \{a_i\} {ai​}和正整数$n$，令$a_0=s,a_n=a_{n-1}+d$，求${\sum }_{i=0}^n{a}_i{C}_n^i$对大素数取模的值。
做法： 本题需要用到组合数学推导式子。
因为$a_i=s+id$，所以$原式={\sum }_{i=0}^n(s+id)C_n^i=s{\sum }_{i=0}^n{C}_n^i+d{\sum }_{i=0}^{n}i{C}_n^i$。
我们知道${\sum }_{i=0}^n{C}_n^i=2^n$，所以关键是求${\sum }_{i=0}^{n}i{C}_n^i$，接下来用公式$C_n^m=\frac{n!}{m!(n-m)!}$尝试化一下式子。
$i{C}_n^i=\frac{n!i}{i!(n-i)!}=\frac{n!}{(i-1)!(n-i)!}=\frac{(n-1)!n}{(i-1)!(n-i)!}=n{C}_{n-1}^{i-1}$
所以${\sum }_{i=0}^{n}i{C}_n^i=n{\sum }_{i=0}^{n-1}{C}_{n-1}^i=n{2}^{n-1}$，代入原式中，运用快速幂求出结果即可，时间复杂度为$O(\log n)$。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
#define mod 998244353
using namespace std;
ll n,s,d,ans;

ll power(ll a,ll b)
{
	ll s=1,ss=a;
	while(b)
	{
		if (b&1) s=(s*ss)%mod;
		b>>=1,ss=(ss*ss)%mod;
	}
	return s;
}

int main()
{
	scanf("%lld%lld%lld",&n,&s,&d);
	ans=s%mod*power(2,n)%mod;
	ans=(ans+(d%mod*(n%mod)%mod*power(2,n-1)%mod))%mod;
	printf("%lld",ans);
	
	return 0;
}

2017.10.31 Problem A
做法： 这题太暴力了，不想贴了…

2017.10.31 Problem B
题目大意： 给定两个长不超过$5000$的字符串$A,B$，求它们LCS的长度并计算LCS的数量（这里的LCS是一种对应关系，位置不同也算不同）。
做法： 本题需要用到DP。
LCS的做法大家应该都知道吧，令$f(i,j)$为$A$的前$i$个字符和$B$的前$j$个字符中LCS的长度，那么有状态转移方程：
$if$ $(A[i]=B[j])$ $f(i,j)=f(i-1,j-1)+1$
$else$ $f(i,j)=\max (f(i,j-1),f(i-1,j))$
这是个$O(n^2)$的方程，用滚动数组可以把空间优化到$O(n)$。
那么LCS怎么计数呢？令$g(i,j)$为$A$的前$i$个字符和$B$的前$j$个字符中LCS的个数，主要分析几种情况：
1.$A[i]=B[j]$时
这时$f(i,j)$必定可以从$f(i-1,j-1)$继承$g(i-1,j-1)$的个数，而且，如果$f(i,j)=f(i,j-1)$或者$f(i,j)=f(i-1,j)$，那么个数就累加上$g(i,j-1)$或$g(i-1,j)$即可。
2.$A[i]\ne B[j]$时
这时$f(i,j)$会从$f(i-1,j)$和$f(i,j-1)$中较大的那一个继承一个个数，那么有4种情况：
若$f(i-1,j-1)<f(i,j)$而且$f(i-1,j)>f(i,j-1)$，那么$g(i,j)=g(i-1,j)$；
若$f(i-1,j-1)<f(i,j)$而且$f(i,j-1)>f(i-1,j)$，那么$g(i,j)=g(i,j-1)$；
若$f(i-1,j-1)<f(i,j)$而且$f(i,j-1)=f(i-1,j)$，那么$g(i,j)=g(i,j-1)+g(i-1,j)$；
上面三种情况都好理解，主要是最后一种：
若$f(i-1,j-1)=f(i,j)$，那么$g(i,j)=g(i,j-1)+g(i-1,j)-g(i-1,j-1)$。
这种情况要怎么解释呢？其实非常容易，因为当$f(i-1,j-1)=f(i,j)$时，$f(i,j-1)$和$f(i-1,j)$也必定等于$f(i,j)$，这时$g(i-1,j-1)$对$g(i,j)$也有贡献，只不过体现在$g(i,j-1)$和$g(i-1,j)$中，而因为这个贡献被算了两次，所以要减去一次，其实就是一个容斥的思想。
上面方程的边界条件为$g(0,i)=g(i,0)=1$，时间复杂度$O(n^2)$，可以通过该题。
（下面这个代码是HAOI2010-最长公共子序列）
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define mod 100000000
using namespace std;
char a[5010],b[5010];
int n,m,f[2][5010],g[2][5010],mx=0,tot=0;

int main()
{
	a[0]=b[0]='#';
	scanf("%s",a+1);
	scanf("%s",b+1);
	
	n=strlen(a)-2;
	m=strlen(b)-2;
	memset(f,0,sizeof(f));
	memset(g,0,sizeof(g));
	
	int now=0,past=1;
	for(int i=0;i<=m;i++) g[past][i]=1;
	for(int i=1;i<=n;i++)
	{
		g[now][0]=1;
		for(int j=1;j<=m;j++)
		{
			if (a[i]==b[j])
			{
				f[now][j]=f[past][j-1]+1;
				g[now][j]=g[past][j-1];
				if (f[now][j]==f[now][j-1]) g[now][j]=(g[now][j]+g[now][j-1])%mod;
				if (f[now][j]==f[past][j]) g[now][j]=(g[now][j]+g[past][j])%mod;
			}
			else
			{
				f[now][j]=max(f[now][j-1],f[past][j]);
				g[now][j]=0;
				if (f[now][j]==f[now][j-1]) g[now][j]=(g[now][j]+g[now][j-1])%mod;
				if (f[now][j]==f[past][j]) g[now][j]=(g[now][j]+g[past][j])%mod;
				if (f[now][j]==f[past][j-1]) g[now][j]=(g[now][j]-g[past][j-1]+mod)%mod;
			}
		}
		swap(now,past);
	}
	
	printf("%d\n%d",f[past][m],g[past][m]);
	
	return 0;
}

2017.10.31 Problem C
题目大意： APIO2009-抢掠计划。
做法： 我写过的题解在此：APIO2009-抢掠计划，以前我是用递归Tarjan+SPFA的做法写的，这里贴一个非递归Tarjan+拓扑排序的解法吧。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n,m,s,p,tot=0,first[1000010]={0},belong[500010]={0},tots;
int dfn[500010]={0},low[500010]={0},st[500010]={0},tim=0,top=0;
int in[1000010]={0},h,t,q[1000010],runtime[1000010],now[1000010];
ll val[1000010]={0},f[1000010]={0};
bool bar[1000010]={0},vis[500010]={0},del[500010]={0};
struct edge {int v,next;} e[1000010];

void insert(int a,int b)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	first[a]=tot;
}

void tarjan()
{
	int tp=0;
	runtime[++tp]=s;
	dfn[s]=low[s]=++tim;
	st[++top]=s;now[s]=top;
	vis[s]=1;
	while(tp)
	{
		int v=runtime[tp];
		for(int i=first[v];i;i=e[i].next)
			if (!vis[e[i].v])
			{
				runtime[++tp]=e[i].v;
				dfn[e[i].v]=low[e[i].v]=++tim;
				st[++top]=e[i].v,now[e[i].v]=top;
				vis[e[i].v]=1;
				break;
			}
		if (v==runtime[tp])
		{
			for(int i=first[v];i;i=e[i].next)
				if (!del[e[i].v]) low[v]=min(low[v],low[e[i].v]);
			if (dfn[v]==low[v])
			{
				++tots;
				for(int i=now[v];i<=top;i++)
				{	 
					belong[st[i]]=tots;
					del[st[i]]=1; 
				} 
				top=now[v]-1;
			}
			tp--;
		}
	}
}

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		insert(a,b);
	}
	for(int i=1;i<=n;i++)
		scanf("%lld",&val[i]);
	scanf("%d%d",&s,&p);
	for(int i=1;i<=p;i++)
	{
		int x;
		scanf("%d",&x);
		bar[x]=1;
	}
	
	tots=n;
	tarjan();
	for(int i=1;i<=n;i++)
	{
		val[belong[i]]+=val[i];
		bar[belong[i]]=bar[belong[i]]||bar[i];
	}
	for(int i=1;i<=n;i++)
		for(int j=first[i];j;j=e[j].next)
			if (vis[i]&&vis[e[j].v]&&belong[i]!=belong[e[j].v])
			{
				insert(belong[i],belong[e[j].v]);
				in[belong[e[j].v]]++;
			}
	
	h=t=1,q[1]=belong[s];f[belong[s]]=val[belong[s]];
	ll ans=0;
	while(h<=t)
	{
		int v=q[h++];
		if (bar[v]) ans=max(ans,f[v]);
		for(int i=first[v];i;i=e[i].next)
		{
			in[e[i].v]--;
			f[e[i].v]=max(f[e[i].v],f[v]+val[e[i].v]);
			if (!in[e[i].v]) q[++t]=e[i].v;
		}
	}
	
	printf("%lld",ans);
	
	return 0;
}

2017.11.1 Problem A
题目大意： 找到在$[a,b](1\le a\le b\le 10^9)$中，因子个数最大的数，如果有多个输出最小的数。当$a>100000$时，$b-a=3\times 10^7$。
做法： 本题需要用到搜索。
首先当$b\le 100000$时，$O(n\sqrt{n})$暴力即可。
当$a>100000$时，保证因数个数最大的最小数字一定在区间中，直接枚举质因数的指数爆搜即可。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
ll a,b,mx=0,mxi,prime[15]={0,2,3,5,7,11,13,17,19,23,29,31};

void dfs(ll s,ll step,ll last,ll tot)
{
	if (tot>mx) mx=tot,mxi=s;
	if (tot==mx&&s<mxi) mxi=s;
	ll f=1;
	for(ll i=1;i<=last;i++)
	{
		f*=prime[step];
		if (s*f>b) break;
		dfs(s*f,step+1,i,tot*(i+1));
	}
}

int main()
{
	scanf("%lld%lld",&a,&b);
	if (b<=100000)
	{
		for(ll i=a;i<=b;i++)
		{
			ll f=0;
			for(ll j=1;j*j<=i;j++)
				if (i%j==0)
				{
					if (j*j==i) f++;
					else f+=2;
				}
			if (f>mx) mx=f,mxi=i;
		}
	}
	else dfs(1,1,30,1);
	
	printf("%lld",mxi);
	
	return 0;
}

2017.11.1 Problem B
题目大意： 平面上有若干个卫星，每个卫星有一个坐标，现在要调整卫星坐标，每个卫星的$y$坐标可以增加或减少一定长度，不同卫星的这个长度可能不同，求调整后两个卫星间最小距离的最大值的平方。
做法： 本题需要用到二分答案+2-SAT判定。
首先看到最小值最大，显然二分最小距离，问题变成能不能使所有卫星之间距离都大于等于$mid$。观察发现每个卫星只能选两个位置，考虑2-SAT判定，如果一个卫星的一个位置和另一个卫星的一个位置之间距离小于二分到的$mid$，就要加一个限制，然后就可以判定有没有解了，时间复杂度为$O(n^2\log w)$，其中$w$为最大距离。
（话说NOIP模拟赛考2-SAT真的没有问题吗…）
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n,tot=0,first[2010],dfn[2010],low[2010],st[2010],belong[2010],tim,tots,top;
ll x[1010],y[1010],d[1010];
bool vis[2010],del[2010];
struct edge {int v,next;} e[8000010];

void dfs(int v)
{
	vis[v]=1;
	dfn[v]=low[v]=++tim;
	int now=++top;st[top]=v;
	for(int i=first[v];i;i=e[i].next)
	{
		if (!vis[e[i].v])
		{
			dfs(e[i].v);
			low[v]=min(low[v],low[e[i].v]);
		}
		else if (!del[e[i].v]) low[v]=min(low[v],dfn[e[i].v]);
	}
	if (dfn[v]==low[v])
	{
		++tots;
		for(int i=now;i<=top;i++)
			belong[st[i]]=tots,del[st[i]]=1;
		top=now-1;
	}
}

void tarjan()
{
	tim=0,tots=2*n;
	memset(vis,0,sizeof(vis));
	memset(del,0,sizeof(del));
	for(int i=1;i<=2*n;i++)
		 if (!vis[i]) dfs(i);
}

ll dis(int i,int j,ll f1,ll f2)
{
	ll X=x[i]-x[j],Y=(y[i]+f1*d[i])-(y[j]+f2*d[j]);
	return X*X+Y*Y;
}

void insert(int a,int b)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	first[a]=tot;
}

bool check(ll mid)
{
	tot=0;
	memset(first,0,sizeof(first));
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
		{
			int a=2*i-1,b=2*i,c=2*j-1,d=2*j;
			if (dis(i,j,1,1)<mid) insert(a,d),insert(c,b);
			if (dis(i,j,1,-1)<mid) insert(a,c),insert(d,b);
			if (dis(i,j,-1,1)<mid) insert(b,d),insert(c,a); 
			if (dis(i,j,-1,-1)<mid) insert(b,c),insert(d,a);
		}
	tarjan();
	for(int i=1;i<=n;i++)
		if (belong[2*i-1]==belong[2*i]) return 0;
	return 1;
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%lld%lld%lld",&x[i],&y[i],&d[i]);
	
	ll l=0,r=1;
	r<<=62;
	r=r-1+r;
	while(l<r)
	{
		ll mid=l/2+r/2;
		if (l%2==1&&r%2==1) mid++;
		if (check(mid+1)) l=mid+1;
		else r=mid;
	}
	printf("%lld",l);
	
	return 0;
}

2017.11.1 Problem C
题目大意： 给定一棵边权均为$1$的有$n$个点的树，$m$个询问，每次询问跟两个点$a,b$距离相同的点的数量。
做法： 本题需要用到倍增LCA。
分析此题，我们可以发现，如果$a$和$b$之间路径经过的点数为偶数，那么不存在跟$a$和$b$距离相同的点。如果存在跟$a$和$b$的距离相同的点，那么从$a$到$b$的路径上必然存在一个且仅一个关节点，该关节点跟$a$和$b$的距离相同，且其他跟$a$和$b$距离相同的点都和该关节点连通。那么我们可以得到一个性质：一切不经过$a$和$b$之间路径，能和关节点连通的点，都是跟$a$和$b$距离相同的点。那么问题就是找关节点了。首先倍增求出$a$和$b$的LCA：$LCA(a,b)$，然后分情况讨论：如果$a$和$b$到$LCA(a,b)$距离相同，那么$LCA(a,b)$为关节点，那么令$siz(i)$为点$i$子树中的点数，再令$p,q$分别为$LCA(a,b)$的儿子的子树中，包含点$a$或者$b$的那个子树对应的儿子编号，那么答案为$n-siz(p)-siz(q)$。如果$a$和$b$到$LCA(a,b)$的距离不同，那么关节点在$LCA(a,b)$到深度较深的那个点的路径上，不妨令深度较深的点为$a$，倍增求出关节点$p$，然后求出$p$的儿子的子树中包含$a$的那个子树对应的儿子的编号$q$，那么最后的答案为$siz(p)-siz(q)$。这样我们就解决了这一问题，时间复杂度为$O(m\log n)$。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n,m,tot=0,first[100010]={0};
int dep[100010]={0},fa[100010][21],siz[100010];
struct edge {int v,next;} e[200010];

void insert(int a,int b)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	first[a]=tot;
}

void dfs(int v,int f)
{
	siz[v]=1;
	for(int i=first[v];i;i=e[i].next)
		if (e[i].v!=f)
		{
			dep[e[i].v]=dep[v]+1;
			fa[e[i].v][0]=v;
			dfs(e[i].v,v);
			siz[v]+=siz[e[i].v];
		}
}

int lca(int a,int b)
{
	if (dep[a]<dep[b]) swap(a,b);
	for(int i=20;i>=0;i--)
		if (dep[fa[a][i]]>=dep[b]) a=fa[a][i];
	if (a==b) return a;
	for(int i=20;i>=0;i--)
		if (fa[a][i]!=fa[b][i]) a=fa[a][i],b=fa[b][i];
	return fa[a][0];
}

int find(int a,int b)
{
	int i=0;
	while(b)
	{
		if (b&1) a=fa[a][i];
		i++;b>>=1;
	}
	return a;
}

int solve(int a,int b)
{
	if (a==b) return n;
	int g=lca(a,b),k,p,q;
	if ((dep[a]+dep[b]-2*dep[g])%2!=0) return 0;
	k=(dep[a]+dep[b]-2*dep[g])/2;
	if (dep[a]==dep[b])
	{
		p=find(a,k-1),q=find(b,k-1);
		return siz[1]-siz[p]-siz[q];
	}
	else
	{
		if (dep[a]<dep[b]) swap(a,b);
		p=find(a,k),q=find(a,k-1);
		return siz[p]-siz[q];
	}
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<n;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		insert(a,b),insert(b,a);
	}
	
	dep[0]=-1;dep[1]=0;
	memset(fa,0,sizeof(fa));
	dfs(1,0);
	
	for(int i=1;i<=20;i++)
		for(int j=1;j<=n;j++)
			fa[j][i]=fa[fa[j][i-1]][i-1];
	
	scanf("%d",&m);
	for(int i=1;i<=m;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		printf("%d\n",solve(a,b));
	}
	
	return 0;
}