TCPThree_C杯 Day2

Posted 2020-10-07 shixinyi

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]的点就不必要了。

zyh说这道题有nlog算法，%%%，不会。

//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
*/