TCPThree_C杯 Day2

T1

我已经被拉格朗日插值蒙蔽了双眼，变得智障无比。

第一反应就是拉格朗日插值，然后就先放下了它。

模数那么小，指数那么大，这是一套noip模拟题，拉格朗日，你脑袋秀逗了？

无脑暴力20分贼开心。

正解：

因为模数很小，所有大于模数的数可以先mod再算，就相当于多次用了从0到mod-1的答案。

对于0到mod-1（相当于1到mod）可以只算素数，由于这个函数是积性函数，所以可以在 线性筛素数 的时候顺便求i的k次方

//Serene
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=3e6+10;
long long n,m,mod,ans;
long long f[maxn];

long long rs;
long long qp(long long x,long long k) {
	if(x<=1) return x;
	rs=1;
	while(k&&rs) {
		if(k&1) rs=rs*x%mod;
		x=x*x%mod;k>>=1;
	}
	return rs;
}

bool ok[maxn];
int prime[maxn/5],tot_p;
void get_p() {
	f[1]=1;
	for(int i=2;i<=mod;++i) {
		if(!ok[i]) prime[++tot_p]=i,f[i]=qp(i,m);
		for(int j=1;j<=tot_p&&prime[j]<=mod/i;++j) {
			ok[i*prime[j]]=1;f[i*prime[j]]=f[i]*f[prime[j]]%mod;
			if(i%prime[j]==0) break;
		}
	}
}

int main() {
	freopen("sum.in","r",stdin);
	freopen("sum.out","w",stdout);
	cin>>mod>>m>>n;
	get_p();
	for(int i=1;i<=mod;++i) f[i]=(f[i-1]+f[i])%mod;
	ans=(f[mod]*(n/mod)+f[n%mod])%mod;
	cout<<ans;
	fclose(stdin);fclose(stdout);
	return 0;
}

　　

T2

二分，线段覆盖，很裸，具体见代码：

//Serene
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=1e5+10;
const double pi=acos(-1);
int n;double L,R,maxh=0;
double dn[maxn][4];

struct Node{
	double x,y;
}node[maxn];

bool cmp(const Node& a,const Node& b) {
	return a.y<b.y;
}

bool check(double h) {
	int tot=0;double x,minl=1e4,maxr=-1e4;
	for(int i=1;i<=n;++i) {
		if(dn[i][2]<h) continue;
		x=tan(pi*dn[i][3]/180.0)*(dn[i][2]-h);
		if(dn[i][1]-x>R||dn[i][1]+x<L) continue;
		node[++tot].x=dn[i][1]-x;
		node[tot].y=dn[i][1]+x;
		minl=min(minl,node[tot].x);
		maxr=max(maxr,node[tot].y);
	}
	if(minl>L||maxr<R) return 0;
	sort(node+1,node+tot+1,cmp);
	minl=1e4;
	for(int i=tot;i>1;--i) {
		minl=min(minl,node[i].x);
		if(node[i-1].y<minl&&(node[i-1].y<R&&minl>L)) return 0;
	}
	return 1;
}

int main() {
	freopen("light.in","r",stdin);
	freopen("light.out","w",stdout);
	cin>>n>>L>>R;
	for(int i=1;i<=n;++i)
	{
		scanf("%lf%lf%lf",&dn[i][1],&dn[i][2],&dn[i][3]);
		maxh=max(maxh,dn[i][2]);
	}
	double l=0,r=maxh,mid;
	while(r-l>=1e-7) {
		mid=(l+r)/2.0;
		if(check(mid)) l=mid;
		else r=mid;
	}
	printf("%.7lf",l);
	fclose(stdin);fclose(stdout);
	return 0;
}

　　

T3：

我写的线段树你不会杀了我吧（所以竟然比pyh跑得快？！）。

我建了n颗线段树（不要问我为什么建这么多），但是并不用把所有节点开完，每次修改的时候再新建节点。

对于第i颗线段树的第j个位置表示把前i个数合并，且合并后最大数为j，需要的最小合并次数。

我们知道，如果最后合并出来的东西是确定的，无论合并顺序是否相同，合并次数是确定的。

具体地说：如果我把第 x 到第 y 共（ y - x +1）个数合并需要合并（ y - x ）次。

那么我们每次从前到后扫一遍，扫到一个 i ，我们从 i - 1 到 0逆序枚举 j ，我们把从第 j+1到i的所有数合并，（在第j颗线段树里面查询<=合并后的值的最小合并次数）并计算答案（插入第i颗线段树）。

关于优化：就是为什么从 i - 1 到 0逆序枚举 j ，我们知道如果存在一个 k （ k > j ）所以sum[i]-sum[k]<sum[i]-sum[j]，那么如果第i颗线段树中 最大数为sum[i]-sum[k]的点的需要的最小合并次数比 最大数为sum[i]-sum[j]的点的需要的最小合并次数 要小，那么再更新最大数为sum[i]-sum[j]的点就不必要了。

//Serene
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=1500+10,INF=1e6;
int n,a[maxn],sum[maxn],maxnum=0,ans,tot;

int aa;char cc;
int read() {
	aa=0;cc=getchar();
	while(cc<'0'||cc>'9') cc=getchar();
	while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();
	return aa;
}

struct Node{
	int l,r,minnum,son[2];
}node[maxn*4000];

void chge(int pos,int t,int x) {
	node[pos].minnum=min(node[pos].minnum,x);
	if(node[pos].l==node[pos].r) return;
	int mid=(node[pos].l+node[pos].r)>>1;
	if(t<=mid) {
		if(!node[pos].son[0]) {
			node[pos].son[0]=++tot;
			node[tot].l=node[pos].l;
			node[tot].r=mid;
			node[tot].minnum=INF;
		}
		chge(node[pos].son[0],t,x);
	}
	else {
		if(!node[pos].son[1]) {
			node[pos].son[1]=++tot;
			node[tot].l=mid+1;
			node[tot].r=node[pos].r;
			node[tot].minnum=INF;
		}
		chge(node[pos].son[1],t,x);
	}
}

int q(int pos,int r) {
	if(!pos) return INF;
	if(node[pos].r<=r) return node[pos].minnum;
	int mid=(node[pos].l+node[pos].r)>>1;
	if(r<=mid) return q(node[pos].son[0],r);
	else return min(q(node[pos].son[0],mid),q(node[pos].son[1],r));
}

int main() {
	freopen("sequence.in","r",stdin);
	freopen("sequence.out","w",stdout);
	n=read();int x,y; ans=n-1;
	for(int i=1;i<=n;++i) a[i]=read(),sum[i]=a[i]+sum[i-1];
	for(int i=1;i<=n;++i) node[i].l=1,node[i].r=sum[i],node[i].minnum=INF;
	tot=n;int ff;
	for(int i=1;i<=n;++i) {
		ff=ans;
		for(int j=i-1;j>=0;--j) {
			x=sum[i]-sum[j];
			if(j) y=q(j,x)+i-j-1; else y=i-j-1;
			if(y>=ff) continue;//优化
			chge(i,x,y);ff=y;
		}
	}
	ans=min(ans,q(n,sum[n]));
	cout<<ans;
	fclose(stdin);fclose(stdout);
	return 0;
}
/*
7
3 4 8 2 3 4 7
*/

　　

其实那个线段树并不必要，直接用n平方算法过，证明在代码下面。

//Serene
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=1500+10,INF=1e6;
int n,sum[maxn],ans[maxn],g[maxn];

int aa;char cc;
int read() {
	aa=0;cc=getchar();
	while(cc<'0'||cc>'9') cc=getchar();
	while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();
	return aa;
}

int main() {
	freopen("sequence.in","r",stdin);
	freopen("sequence.out","w",stdout);
	n=read();int x,y;
	for(int i=1;i<=n;++i) sum[i]=read()+sum[i-1];
	for(int i=1;i<=n;++i) {
		for(int j=i-1;j>=0;--j) {
			g[i]=x=sum[i]-sum[j];
			if(x>=g[j]) {
				ans[i]=ans[j]+i-j-1;
				break;
			}
		}
	}
	cout<<ans[n];
	return 0;
}

　　

zyh说这道题可以加一个单调队列变成nlogn，但是实际运行比n²慢。%%%

题解（来源：https://wenku.baidu.com/view/d6726d0552ea551810a68772.html）：

形成非降序列的最少合并次数

给定一个序列，你每次可以合并相邻两个元素，新的元素为这两个元素的和。你需要使得若干次合并之后的序列非降，求最小合并次数。

[LYP的并，tyvj2008tower，QW的CCL]

解析：设f[i]表示以i结尾的所有数分成的组数,g[i]存第i个数结尾的数它这组的数的值,那么转移为:

f[i]=max{f[j]+1}(j<i,s[i]-s[j]>=g[j]),转移f[i]的同时转移g[i]为s[i]-s[j],

初始f[i]=1,g[i]=s[i].

通过观察我们发现,设当前分了k组,第i个数,最坏分到第k组,所以,f数组一定是不减的,所以j只要倒着循环,找到第一个满足s[i]-s[j]>=g[j]的j,转移f[i].

开始认为此方程有问题 {存在p，使得f[p]在所有已得到的f值中最大；若存在q满足f[q]<f[p]且q>p，则此方程有bug。但是这种情况不存在！f值单调非降！}，

另外有单调队列做法。