NOIP2017提高组模拟赛13（总结）

第一题函数

【题目描述】

【输入格式】

　　三个整数。

　　1≤t＜10^{9+7,2≤l≤r≤5*10}6

【输出格式】

　　一个整数。

【输出样例】

2 2 4

【输出样例】

19

【解题思路】

　　证明：对于n个人，分解成质因数，按质数个人分为一组（从小到大）。

　　例如：30可以分成2 * 3 * 5，那么一开始2人为一组，共有15组。再分成3人为一组，然后有5组。再分成5人一组，有1组。

　　为什么这是最优的？

　　ａ,ｂ是n的质因数

　　设$\frac{n}{ab}=x$

　　$bx\frac{a(a-1)}{2}+x\frac{b(b-1)}{2}=\frac{bx}{2}(a²-a+b-1)$

　　$x\frac{ab(ab-1)}{2}=\frac{bx}{2}(a²b-a)$

　　∵a,b>=2

　　∴(a²b-a)>(a²-a+b-1)

　　由(a²-a+b-1)可得，a＜b会比a>b优。

　　证毕。

【代码】

#include<cstdio>

#include<algorithm>

using namespace std;

typedef long long ll;

const ll mods=1e9+7;

const int N=7000000;

int pr[N],lp,n,L,R,t;

bool inp[N],re[N];

ll F[N],ans,tl;

void getpr()

{

	inp[1]=1;

	for(int i=2;i<=n;i++)

	{

		if(!inp[i]) { pr[++lp]=i; F[i]=(((ll)i*(i-1))>>1)%mods; re[i]=1; }

		for(int j=1;(ll)i*pr[j]<=n && j<=lp;j++)

		{

			F[pr[j]*i]=(F[pr[j]]*i%mods+F[i])%mods;

			inp[pr[j]*i]=1;

			if(!(i%pr[j])) break;

		}

	}

}

int main()

{

	freopen("2233.in","r",stdin);

	freopen("2233.out","w",stdout);

	scanf("%d%d%d",&t,&L,&R);

	n=R; getpr(); tl=1ll; ans=0ll;

	for(int i=L;i<=R;i++)

	{

		ll k=F[i];

		ans=(ans+tl*k%mods)%mods;

		tl=tl*t%mods;

	}

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

	return 0;

}

第二题部落

【题目描述】

　　部落的基地里已经有N个建筑设施受到了严重的损伤，如果不尽快修复的话，这些建筑设施将会完全毁坏。

　　现在的情况是：T部落基地里只有一个修理工人，虽然他能瞬间到达任何一个建筑，但是修复每个建筑都需要一定的时间。

同时，修理工人修理完一个建筑才能修理下一个建筑，不能同时修理多个建筑。

　　如果某个建筑在一段时间之内没有完全修理完毕，这个建筑就报废了。

你的任务是帮小刚合理的制订一个修理顺序，以抢修尽可能多的建筑。

【输入格式】

　　第一行一个整数N

　　接下来N行每行两个整数T1，T2，表示修该建筑需要T1秒，要在T2秒之前修完。

【输出格式】

　　一个整数表示最多能抢救的建筑数量。

【输入样例】

4

100 200

200 1300

1000 1250

2000 3200

【输出样例】

3

【数据规模】

　　对于40%的数据，T2<=1000000

　　对于100%的数据，N <= 150,000; T1 < T2 < maxlongint

【解题思路】

　　一个简单的推论：假若建筑i的T2＜建筑j的T2，而且建筑i的T1≥建筑j的T1，总时间+T1＜建筑j的T2，那么将i替换成j，答案会更优。（贪心）

　　所以，用大根堆维护最大值，每次将最大值判断一下，是否需要替换掉即可。

【代码】

#include<cstdio>

#include<algorithm>

using namespace std;

typedef long long ll;

const ll mods=1e9+7;

const int N=150500;

struct data { int a,b,id; } d[N];

int n,ans,h[N],cnt;

bool cmp(data A,data B) { return (A.b<B.b); }

void add(int x)

{

	cnt++; h[cnt]=x;

	int now=cnt;

	while((now>1) && (d[h[now>>1]].a<d[h[now]].a))

	{

		swap(h[now>>1],h[now]);

		now>>=1;

	}

}

void down()

{

	h[1]=h[cnt]; cnt--;

	int now=1;

	while((now<<1)<=cnt)

	{

		int uw;

		if((now<<1|1)>cnt) uw=now<<1; else uw=(d[h[now<<1]].a>d[h[now<<1|1]].a)?(now<<1):(now<<1|1);

		if(d[h[now]].a<d[h[uw]].a) swap(h[now],h[uw]); else break;

		now=uw;

	}

}

int main()

{

	freopen("2234.in","r",stdin);

	freopen("2234.out","w",stdout);

	scanf("%d",&n);

	for(int i=1;i<=n;i++) scanf("%d%d",&d[i].a,&d[i].b),d[i].id=i;

	sort(d+1,d+1+n,cmp);

	int tim=0;

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

	{

		if(tim+d[i].a<=d[i].b)

		{

			tim+=d[i].a;

			ans++; add(i);

		} else

		{

			int yu=h[1];

			if(d[yu].a>d[i].a)

			{

				tim+=d[i].a-d[yu].a;

				down(); add(i);

			}

		}

	}

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

	return 0;

}

第三题 sunny图（原题 codeforces 603E）

【题目描述】

【输入格式】

　　第一行两个整数n和m。

　　接下来m行每行三个整数。ai,bi,li。

【输出格式】

　　共m行，每行一个整数表示每次操作的答案。

【输入样例】

4 4

1 3 4

2 4 8

1 2 2

3 4 3

【输出样例】

-1

8

8

3

【数据规模】

　　１≤ai,bi≤n，1≤li≤10^9

　　对于20%的数据，2≤n小于等于15，1≤m≤15。

　　对于40%的数据，2≤n小于等于100，1≤m≤100。

　　对于60%的数据，2≤n小于等于500，1≤m≤2000。

　　对于100%的数据，2≤n小于等于100000，1≤m≤300000。

【解题思路】

　　一个重要的推论（然而并没有推出来）：

　　将图分成若干个联通块，每个联通块的点数均为偶数，那么就是sunny图。

　　为什么？（分类讨论）

　　假如有一个偶数点的图，一定可以划分成一棵树。

　　那么设根节点为father，father的点数为奇数的儿子sonY一定为奇数个，奇 * 奇+偶 * （偶或奇）+1=偶。那么将sonX与father的边cut掉，就满足了father的度数为奇数（奇数条与儿子的边）的情况。

　　那么点数为奇数的儿子sonY，仍保留与father的边。那么sonY的点数为奇数的儿子Y一定有偶数个，奇 * 偶+偶 * （偶或奇）+1=奇。那么将X与sonY的边cut掉，就满足了sonY的度数为奇数（偶数条与儿子的边+与父亲的边）的情况。

　　点数为偶数的儿子sonX的情况与第一种类似（是完全一样好吧）。

　　那么，树是自己造的，边随便搞，加入一条x->y的边，若x，y之前已经连通，就把路径上的最大边删了，加入新边（在新边小于最大边的情况下）

　　至于联通块分成两个偶数块，判断删除最大边L后，剩下的两个联通块点数是否为偶数就行了。

　　需要用LCT维护子树大小。

　　具体应该是这样：

　　多个splay树通过parent边相连。

　　在每个splay树记录一个sub，表示整棵splay树的奇偶（仅仅是splay树）

　　再记一个all，表示整个子树i包括相连的splay树的奇偶（在splay树合并或断开的时候更新）

【代码】

//codeforce 603E

#include<cstdio>

#include<algorithm>

#include<set>

#define imax(a,b) ((a>b)?(a):(b))

#define imin(a,b) ((a<b)?(a):(b))

using namespace std;

const int N=400010;

struct tree { int mx,val,sub,all,zi; } s[N];

int c[N][2],fa[N],rev[N];

int H[N],ht,W[N];

int n,m,odd,cnt;

int stack[N];

//int F[N];

struct godD { int a,b,l; } d[N];

//set <pair<int,int> > hp;

bool gd(int x) { return (c[fa[x]][1]==x); }

bool isroot(int x) { return (c[fa[x]][0]!=x && c[fa[x]][1]!=x); }

int MAX(int x,int y)

{

	if(!x || !y) return x+y;

	return ((s[x].val>s[y].val)?(x):(y));

}

void up(int x)

{

	s[x].all=s[x].sub^s[x].zi;

	s[x].mx=x;

	if(c[x][0]) s[x].all^=s[c[x][0]].all;

	if(c[x][1]) s[x].all^=s[c[x][1]].all;

	s[x].mx=MAX(s[x].mx,s[c[x][0]].mx);

	s[x].mx=MAX(s[x].mx,s[c[x][1]].mx);

}

void down(int x)

{

	if(rev[x])

	{

		rev[x]^=1;

		rev[c[x][0]]^=1; rev[c[x][1]]^=1;

		swap(c[x][0],c[x][1]);

	}

}

void rotate(int x)

{

	int y=fa[x],z=fa[y];

	int l=gd(x),r=!l;

	if(!isroot(y)) c[z][gd(y)]=x;

	fa[x]=z; fa[y]=x; fa[c[x][r]]=y;

	c[y][l]=c[x][r]; c[x][r]=y;

	up(y); up(x);

}

void splay(int x)

{

	int hy=0; stack[++hy]=x;

	for(int i=x;!isroot(i);i=fa[i]) stack[++hy]=fa[i];

	for(int i=hy;i;i--) down(stack[i]);

	for(;!isroot(x);)

	{

		int y=fa[x];

		if(!isroot(y)) (gd(x)^gd(y))?rotate(x):rotate(y);

		rotate(x);

	}

}

void access(int x)

{

	int y=0;

	while(x)

	{

		splay(x);

		down(x);

		if(y) s[x].sub^=s[y].all;

		if(c[x][1]) s[x].sub^=s[c[x][1]].all;

		c[x][1]=y;

		up(x);

		y=x;

		x=fa[x];

	}

}

void evert(int x)

{

	access(x); splay(x); rev[x]^=1;

}

int findroot(int x)

{

	access(x); splay(x);

	while(c[x][0]) x=c[x][0];

	return x;

}

void link(int x,int y)

{

	evert(x); evert(y);

	fa[x]=y; s[y].sub^=s[x].all;

	up(y);

}

void cut(int x,int y)

{

	evert(x); access(y); splay(y);

	fa[x]=0; c[y][0]=0;

	up(y);

}

void Cut(int u)

{

	int x=d[u].a,y=d[u].b;

	cut(x,u+n); cut(y,u+n);

}

bool cle(int u)

{

	int x=d[u].a,y=d[u].b;

	cut(x,u+n); cut(y,u+n);

	if(!s[x].all && !s[y].all) return 1;

	link(x,u+n); link(y,u+n);

	return 0;

}

void add(int x)

{

	H[++ht]=x; int now=ht;

	while((now>1) && d[H[now>>1]].l<d[H[now]].l)

	{

		swap(H[now>>1],H[now]);

		now>>=1;

	}

}

void hdown()

{

	H[1]=H[ht--]; int now=1;

	while((now<<1)<=ht)

	{

		int uw;

		if(((now<<1)|1)>ht) uw=(now<<1); else uw=(d[H[now<<1]].l>d[H[now<<1|1]].l)?(now<<1):(now<<1|1);

		if(d[H[now]].l<d[H[uw]].l)

		{

			swap(H[now],H[uw]);

		} else break;

		now=uw;

	}

}

//int findroot(int x) { return ((F[x]<0)?(x):(F[x]=findroot(F[x]))); }

/*void uni(int x,int y)

{

	int ix=findroot(x),iy=findroot(y);

	if(F[ix]>F[iy]) swap(ix,iy);

	F[ix]+=F[iy]; F[iy]=ix;

}*/

int main()

{

	freopen("2235.in","r",stdin);

	freopen("2235.out","w",stdout);

	scanf("%d%d",&n,&m);

	odd=n; ht=0;

	for(int i=1;i<=n;i++) s[i].all=s[i].zi=1;

	for(int i=1;i<=m;i++)

	{

		int lx,ly,cost;

		scanf("%d%d%d",&lx,&ly,&cost);

		d[i].a=lx; d[i].b=ly; d[i].l=cost;

		s[i+n].val=cost; s[i+n].mx=i+n;

		if(findroot(lx)!=findroot(ly))

		{

			evert(lx); evert(ly);

			if(s[lx].all && s[ly].all) odd-=2;

			link(lx,i+n); link(ly,i+n);

			W[i]=1; add(i); //uni(lx,ly);

			//hp.insert(make_pair(-cost,i));

		} else

		{

			evert(ly); access(lx); splay(lx);

			int yu=s[lx].mx;

			if(s[yu].val>cost)

			{

				Cut(yu-n);

				link(lx,i+n); link(ly,i+n);

				W[i]=1; W[yu-n]=0; add(i);

				//hp.erase(make_pair(-s[yu].val,yu-n));

				//hp.insert(make_pair(-cost,i));

			}

		}

		if(odd==0)

		{

			for(;;)

			{

				int yu=H[1];

				if(!W[yu] || cle(yu)) hdown(); else break;

			}

			printf("%d\n",d[H[1]].l);

		} else printf("-1\n");

		/*if(odd==0)

		{

			for(;;)

			{

				int e=(*hp.begin()).second;

				if(cle(e)) hp.erase(hp.begin()); else break;

			}

			printf("%d\n",-(*hp.begin()).first);

		} else printf("-1\n");*/

	}

	return 0;

}