ceoi2011 切题记

最新推荐文章于 2021-09-03 17:47:25 发布
最新推荐文章于 2021-09-03 17:47:25 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： ceoi 文章标签： 图论 kmp 动态规划 倍增 贪心
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lych_cys/article/details/52104143
版权

18th Central European Olympiad in Informatics

Tasks

Similarity(Day 0)(100/100)
Balloons(Day 1)(100/100)
Matching(Day 1)(100/100)
Treasure Hunt(Day 1)(100/100)
Hotel(Day 2)(100/100)
Teams(Day 2)(100/100)
Traffic(Day 2)(100/100)
        不得不说ceoi的题目还是很不错的。。。然而水平太差了QAQ根本切不动

       但是切完辣~~~~

Similarity

       搞笑来的题。随便怎么搞都行 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int n,m,num[26]; char a[2000005],b[2000005];
int main(){
	scanf("%s%s",a+1,b+1);
	int i; n=strlen(a+1); m=strlen(b+1);
	for (i=1; i<=m-n+1; i++) num[b[i]-'a']++;
	long long ans=num[a[1]-'a'];
	for (i=m-n+2; i<=m; i++){
		num[b[i-m+n-1]-'a']--; num[b[i]-'a']++;
		ans+=num[a[i-m+n]-'a'];
	}
	printf("%lld\n",ans);
	return 0;
}

Balloons

        随便列一个方程就能知道r[i]=min{(a[i]-a[j])^2/4/r[j]}，然后感性理解吹气球的过程，不妨从当前有用的气球一个个尝试，如果比当前有用的气球最右边一个半径大那么那个气球就没用了。这样一直做下去直到比最右边那个要小，这个时候就是膨胀的极限了。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 200005
using namespace std;

int n,q[N]; double a[N],r[N];
int main(){
	scanf("%d",&n);
	int i,j,tail=0;
	for (i=1; i<=n; i++){
		scanf("%lf%lf",&a[i],&r[i]);
		while (tail){
			j=q[tail]; r[i]=min(r[i],(a[i]-a[j])*(a[i]-a[j])/4/r[j]);
			if (r[i]>=r[j]) tail--; else break;
		}
		printf("%.3f\n",r[i]); q[++tail]=i;
	}
	return 0;
}

Matching

       拓展kmp，，根本想不到啊。

       首先预处理出模板中每一位，求出它之前比它小的最大的那个，以及比它大的最小的那个作为前后驱。然后用kmp一样的方法处理即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 1000005
using namespace std;

int n,m,cnt,pre[N],nxt[N],ans[N],lf[N],rg[N],a[N],b[N],c[N],q[N],f[N];
int read(){
	int x=0; char cr=getchar();
	while (cr<'0' || cr>'9') cr=getchar();
	while (cr>='0' && cr<='9'){ x=x*10+cr-'0'; cr=getchar(); }
	return x;
}
bool ok(int *a,int x,int y){
	return (!lf[x] || a[y+lf[x]]<a[y]) && (!rg[x] || a[y+rg[x]]>a[y]);
}
int main(){
	m=read(); n=read();
	int i,j;
	for (i=1; i<=m; i++) b[c[i]=read()]=i;
	for (i=1; i<=n; i++) a[i]=read();
	for (i=1; i<=m; i++){ pre[i]=i-1; nxt[i]=i+1; } 
	for (i=m; i; i--){
		j=b[i];
		if (pre[j]) lf[i]=c[pre[j]]-i; if (nxt[j]<=m) rg[i]=c[nxt[j]]-i;
		pre[nxt[j]]=pre[j]; nxt[pre[j]]=nxt[j];
	}
	for (i=2; i<=m; i++){
		f[i]=f[i-1]; while (f[i] && !ok(b,f[i]+1,i)) f[i]=f[f[i]];
		if (ok(b,f[i]+1,i)) f[i]++;
	}
	for (i=1,j=0; i<=n; i++){
		while (j && !ok(a,j+1,i)) j=f[j];
		if (ok(a,j+1,i)) j++;
		if (j==m){ ans[++cnt]=i-m+1; j=f[j]; }
	}
	printf("%d\n",cnt);
	for (i=1; i<=cnt; i++) printf("%d%c",ans[i],(i<cnt)?' ':'\n');
	return 0;
}

Treasure Hunt

         由于要兹瓷动态加块，而且显然要求lca，那就不能用树剖或者rmq了。。考虑倍增，令fa[x][i]表示x这个块向上走2^i步到达的块，dad[x][i]表示x这个块向上走2^i步走到的点。这样就可以很方便地处理了。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 400005
using namespace std;

int cnt,bin[36],fa[N][19],dad[N][19],d[N],dep[N];
struct node{ int l,r; }a[N];
void init(){
	a[cnt=1].l=a[1].r=1; d[cnt]=dep[cnt]=1;
	int i;
	bin[0]=1; for (i=1; i<=19; i++) bin[i]=bin[i-1]<<1;
}
int find(int x){
	int l=1,r=cnt,mid;
	while (l<r){
		mid=(l+r)>>1;
		if (x<=a[mid].r) r=mid; else l=mid+1;
	}
	return l;
}
void path(int x,int len){
	cnt++;
	a[cnt].l=a[cnt-1].r+1; a[cnt].r=a[cnt-1].r+len;
	fa[cnt][0]=find(x); dad[cnt][0]=x;
	d[cnt]=d[fa[cnt][0]]+x-a[fa[cnt][0]].l+1;
	dep[cnt]=dep[fa[cnt][0]]+1;
	int i;
	for (i=1; i<=18; i++){
		fa[cnt][i]=fa[fa[cnt][i-1]][i-1]; dad[cnt][i]=dad[fa[cnt][i-1]][i-1];
	}
}
int dig(int x,int y){
	int u=find(x),v=find(y),dx=d[u]+x-a[u].l,dy=d[v]+y-a[v].l,p=x,q=y;
	if (dep[u]<dep[v]){ swap(u,v); swap(x,y); }
	int tmp=dep[u]-dep[v],i;
	for (i=0; i<=18; i++) if (tmp&bin[i]){
		x=dad[u][i]; u=fa[u][i];
	}
	for (i=18; i>=0; i--) if (fa[u][i]!=fa[v][i]){
		x=dad[u][i]; y=dad[v][i];
		u=fa[u][i]; v=fa[v][i];
	}
	if (u!=v){
		x=dad[u][0]; y=dad[v][0];
		u=fa[u][0]; v=fa[v][0];
	}
	tmp=dx+dy-(d[u]+min(x,y)-a[u].l<<1);	
	x=p; y=q;
	if (dx<dy){ swap(x,y); swap(dx,dy); tmp=tmp+1>>1; }
	else tmp>>=1;
	tmp=dx-tmp;
	u=find(x);
	for (i=18; i>=0; i--)
		if (d[fa[u][i]]+dad[u][i]-a[fa[u][i]].l>=tmp) u=fa[u][i];
	return a[u].l+tmp-d[u];
}

Hotel

       最朴素的贪心。。然而是对的。

       考虑将订单按价格从高到低排序，然后按顺序安排最便宜房间并求出收益。然后把最大的o个收益加起来就好了。这样显然是对的，因为如果房间有冲突，显然会满足价格最高的；另一方面如果2个订单对2个房间可以任意分配，那么将价格高的订单分配便宜的房间或是贵的并没有影响。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 500005
using namespace std;

int n,m,cnt,ans[N],fa[N];
struct node{ int x,y; }a[N],b[N];
int read(){
	int x=0; char cr=getchar();
	while (cr<'0' || cr>'9') cr=getchar();
	while (cr>='0' && cr<='9'){ x=x*10+cr-'0'; cr=getchar(); }
	return x;
}
bool cmpx(const node &u,const node &v){ return u.x>v.x; }
bool cmpy(const node &u,const node &v){ return u.y<v.y || u.y==v.y && u.x<v.x; }
int getfa(int x){ return (x==fa[x])?x:fa[x]=getfa(fa[x]); }
int find(int x){
	int l=1,r=n+1,mid;
	while (l<r){
		mid=(l+r)>>1;
		if (a[getfa(mid)].y<x) l=mid+1; else r=mid;
	}
	return getfa(l);
}
int main(){
	n=read(); m=read(); cnt=read();
	int i,j;
	for (i=1; i<=n; i++){
		a[i].x=read(); a[i].y=read();
	}
	for (i=1; i<=m; i++){
		b[i].x=read(); b[i].y=read();
	}
	sort(a+1,a+n+1,cmpy); sort(b+1,b+m+1,cmpx);
	for (i=1; i<=n+1; i++) fa[i]=i; a[n+1].y=1000000000;
	for (i=1; i<=m; i++){
		j=find(b[i].y);
		if (j<=n && a[j].x<b[i].x){
			ans[i]=b[i].x-a[j].x; fa[j]=j+1;
		}
	}
	sort(ans+1,ans+m+1);
	long long sum=0;
	for (i=m-cnt+1; i<=m; i++) sum+=ans[i];
	printf("%lld\n",sum);
	return 0;
}

Teams

       O(N)的思路好神啊。。波兰人怎么这么熟练啊根本想不到（只会带log的sb做法）

       首先按照a[i]降序排序，然后令f[i]表示前i个最多分成几组。显然f[i-1]<=f[i]<=f[i-1]+1，考虑f[i]=f[i-1]+1的条件，一定是存在f[j]==f[i-1]且j+a[j+1]==i，这样所有i向i+a[i+1]连边，最多N个转移。

        然后考虑最大组人数最小，不妨设为g[i]。如果f[i]=f[i-1]，显然可以把i塞到前面随便什么地方，如果已经塞满了那么g[i]=g[i-1]+1；否则g[i]=g[i-1]。如果f[i]=f[i-1]+1，那么显然g[i]=max(g[x],i-x)，其中f[x]==f[i-1]且x+a[x+1]==i。

        然后打个表示表示如果f[i]=f[i-1]+1那么i是从那个x转移来的然后把x+1~i的都编成一组。剩下的按照a[i]从大到小塞入从大到小的组中即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 1000005
using namespace std;

int n,cnt,fst[N],nxt[N],a[N],b[N],f[N],g[N],p[N],sz[N],ans[N]; bool bo[N];
int read(){
	int x=0; char cr=getchar();
	while (cr<'0' || cr>'9') cr=getchar();
	while (cr>='0' && cr<='9'){ x=x*10+cr-'0'; cr=getchar(); }
	return x;
}
void add(int x,int y){ nxt[y]=fst[x]; fst[x]=y; }
int main(){
	n=read();
	int i,x;
	for (i=1; i<=n; i++){
		x=read(); add(x,i);
	}
	for (i=n; i; i--)
		for (x=fst[i]; x; x=nxt[x]){ a[++cnt]=i; b[cnt]=x; }
	memset(fst,0,sizeof(fst)); memset(p,-1,sizeof(p));
	f[a[1]]=1; g[a[1]]=a[1]; p[a[1]]=0;
	add(a[1]+a[a[1]+1],a[1]);
	for (i=a[1]+1; i<=n; i++){
		f[i]=f[i-1]; g[i]=((long long)f[i-1]*g[i-1]==i-1)?g[i-1]+1:g[i-1];
		for (x=fst[i]; x; x=nxt[x])
			if (f[x]+1>f[i]){
				f[i]=f[x]+1; g[i]=max(g[x],i-x); p[i]=x;
			} else if (f[x]+1==f[i] && max(g[x],i-x)<g[i]){
				g[i]=max(g[x],i-x); p[i]=x;
			}
		add(i+a[i+1],i);
	}
	printf("%d\n",f[n]);
	memset(fst,0,sizeof(fst)); memset(bo,1,sizeof(bo));
	for (i=n,cnt=0; i>=a[1]; i=(p[i]>=0)?p[i]:i-1)
		if (p[i]>=0){
			cnt++;
			for (x=i; x>p[i]; x--){ add(cnt,b[x]); sz[cnt]++; bo[x]=0; }
		}
	for (i=1,x=cnt; i<=n; i++) if (bo[i]){
		while (sz[x]==g[n]) x--;
		add(x,b[i]); sz[x]++;
	}
	for (i=1; i<=cnt; i++){
		printf("%d",sz[i]);
		for (x=fst[i]; x; x=nxt[x]) printf(" %d",x); puts("");
	}
	return 0;
}

Traffic

       题目中的关键在于任意两条路没有交叉。

       这说明一个点能到达的右侧的点一定是连续的（永远到不了的除外）。

       那么tarjan缩点以后dp出每个点能到达的最小和最大的编号即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 300005
#define M 1800005
using namespace std;

int n,m,ta,tb,cnt,pt,tot,dfsclk,fst[N],pnt[M],nxt[M],tp,stk[N];
int mx[N],mn[N],scc[N],q[N],id[N],pos[N],low[N],a[N],b[N]; bool vis[N];
struct node{ int x,y,z; }e[M>>1];
int read(){
	int x=0; char cr=getchar();
	while (cr<'0' || cr>'9') cr=getchar();
	while (cr>='0' && cr<='9'){ x=x*10+cr-'0'; cr=getchar(); }
	return x;
}
void add(int x,int y){
	pnt[++tot]=y; nxt[tot]=fst[x]; fst[x]=tot;
}
void dfs(int x){
	if (vis[x]) return; vis[x]=1;
	int i;
	for (i=fst[x]; i; i=nxt[i]) dfs(pnt[i]);
}
void tarjan(int x){
	int i,y; pos[x]=low[x]=++dfsclk; stk[++tp]=x;
	for (i=fst[x]; i; i=nxt[i]){
		y=pnt[i];
		if (!pos[y]){
			tarjan(y); low[x]=min(low[x],low[y]);
		} else if (!scc[y]) low[x]=min(low[x],pos[y]);
	}
	if (low[x]==pos[x]){
		cnt++; mx[cnt]=-1000000000; mn[cnt]=1000000000;
		while (1){
			scc[stk[tp]]=cnt;
			if (y=id[stk[tp]]){
				mx[cnt]=max(mx[cnt],y); mn[cnt]=min(mn[cnt],y);
			}
			if (stk[tp--]==x) break;
		}
	}
}
void dp(int x){
	if (vis[x]) return; vis[x]=1;
	int i,y;
	for (i=fst[x]; i; i=nxt[i]){
		y=pnt[i];
		dp(y); mx[x]=max(mx[x],mx[y]); mn[x]=min(mn[x],mn[y]);
	}
}
bool cmp(const int &x,const int &y){ return b[x]>b[y]; }
int main(){
	n=read(); m=read(); ta=read(); tb=read();
	int i,x,y;
	for (i=1; i<=n; i++){
		a[i]=read(); b[i]=read();
	}
	for (i=1; i<=m; i++){
		e[i].x=read(); e[i].y=read(); e[i].z=read();
		add(e[i].x,e[i].y);
		if (e[i].z==2) add(e[i].y,e[i].x);
	}
	for (i=1; i<=n; i++) if (!a[i]) dfs(i);
	for (i=1; i<=n; i++) if (a[i]==ta && vis[i]) q[++pt]=i;
	sort(q+1,q+pt+1,cmp);
	for (i=1; i<=pt; i++) id[q[i]]=i;
	for (i=1; i<=n; i++) if (!pos[i]) tarjan(i);
	tot=0; memset(fst,0,sizeof(fst));
	for (i=1; i<=m; i++){
		x=scc[e[i].x]; y=scc[e[i].y];
		if (x!=y) add(x,y);
	}
	memset(vis,0,sizeof(vis));
	for (i=1; i<=cnt; i++) dp(i);
	pt=0;
	for (i=1; i<=n; i++) if (!a[i]) q[++pt]=i; 
	sort(q+1,q+pt+1,cmp);
	for (i=1; i<=pt; i++) printf("%d\n",max(0,mx[scc[q[i]]]-mn[scc[q[i]]]+1));
	return 0;
}

by lych
2016.8.3

基于贪心算法对整数区间问题(CEOI1997)的深入研究
PerfectPeter的博客
10-28 362
题目 题目描述 请编程完成以下任务： 1.从文件中读取闭区间的个数及它们的描述； 2.找到一个含元素个数最少的集合,使得对于每一个区间,都至少有一个整数属于该集合，输出该集合的元素个数。 输入 首行包括区间的数目n,1≤n≤10000,接下来的n行,每行包括两个整数a,b,被一空格隔开,0≤a≤b≤10000,它们是某一个区间的开始值和结束值。 输出 第一行集合元素的个数,对于每一个区间都至少有一...
CEOI--2008
02-08
【CEOI 2008】是第十三届国际信息学奥林匹克竞赛（International Olympiad in Informatics，简称IOI）的赛事，全称为“国际中学生信息学奥林匹克竞赛”。这一年度的竞赛在中国上海举行，旨在检验世界各国中学生的...
[CEOI2011]Matching
七代目鸽影
09-03 242
究竟该不该算作字符串题呢？分明没有字符，却是字符串匹配算法……
BZOJ2587 : [Ceoi2011]Team
weixin_33997389的博客
03-23 117
将球员按限制从大到小排序，那么最优解中每支球队都是一个连续的区间。 设$f[i]$表示前$i$大的球员成功组队时，最多能组的队伍数，$g[i]$表示此时最大人数的最小值。 那么$f[i]=\max(f[j]+1),a[j]\geq i-j$，即$a[j]+j\geq i$。 注意到$a[j]+j&gt;j$恒成立，所以可以使用链表来维护，当计算$f[a[j]+j]$时，才将$j$加入决策范围...
luogu P4696 [CEOI2011]Matching
lahlah的博客
08-10 288
luogu P4696 [CEOI2011]Matching 题目大意 讲得比较清楚了吧 我就讲怎么把问题转换吧 p[i]p[i]p[i]表示的是排名为iii的在第p[i]p[i]p[i]那个位置 然后我们可以令rk[i]rk[i]rk[i]表示第iii位的排名位rk[i]rk[i]rk[i],很明显rk[p[i]]=irk[p[i]] = irk[p[i]]=i 然后就转换为rkrkrk数组和a...
【BZOJ2384】[Ceoi2011]Match KMP
aodanchui1057的博客
09-24 153
【BZOJ2384】[Ceoi2011]Match Description 作为新一轮广告大战的一部分，格丁尼亚的一家大公司准备在城市的某处设置公司的标志（logo）。公司经理决定用一些整栋的建筑来构成标志的组成部分。v标志由不同高度的竖直条纹组成。这些条纹从左到右依次编号为1…n。标志用数字1,2,…,n的排列(s1,s2,…,sn)来描述。编号s1的条纹高度最低，编号s2的条...
BZOJ 2386: [Ceoi2011]Team
sillyf的博客
07-02 440
手撸了几波小数据 容易发现最优解之一是所有人都按a[i]排序后再一段一段分开 如果不是这样的话，总会可以通过一些交换使之变成有序的 考虑dp，排序后f[i]=max{f[i-k]+1},k #include #include #define N 1000005 using namespace std; int read() { int a=0,f=1;char c=ge
CEOI高中信息学编程竞赛学习资料集测试数据（2001-2016）.rar
最新发布
01-19
《CEOI高中信息学编程竞赛学习资料集测试数据（2001-2016）》是一个专门针对高中学生的信息学编程竞赛的学习资源库，包含了从2001年至2016年间历年的测试数据。这个压缩包是为那些准备参加CEOI（国际中学生奥林匹克...
CEOI1994-2003
02-08
《CEOI 1994-2003：回首早期的编程竞赛之旅》 中国的计算机奥林匹克竞赛（China Girls Mathematical Olympiad，简称CGMO）是中国青少年计算机编程领域的一项重要赛事，自1994年开始举办以来，吸引了众多对编程充满...
CEOI2005解题报告
03-09
### CEOI2005 解题报告：Depot 问题详解 #### 题目概述 在CEOI2005的比赛中，“Depot”是一个经典的算法问题，它要求通过一系列移动操作，重新排列给定的数列，使得每个长度为M的连续子序列都包含1到M的所有数字。...
[bzoj1135][Ceoi2011]Match_线段树
dianan0938的博客
07-23 133
[Ceoi2011]Match 题目大意：初始时滑冰俱乐部有1到n号的溜冰鞋各k双。已知x号脚的人可以穿x到x+d的溜冰鞋。 有m次操作，每次包含两个数ri，xi代表来了xi个ri号脚的人。xi为负，则代表走了这么多人。 对于每次操作，输出溜冰鞋是否足够。 数据范围：n m k d ( 1≤n≤200,000 ， 1≤m≤500,000 ， 1≤k≤10^9 ， 0≤d≤n ) ri...
ceoi 2011 Matching kmp
weixin_30784501的博客
04-07 113
题意：给定一个长度为n的排列，m个数，要求在m个数中选出一段长度为n的数串，使得选出的数串与给定的排列是匹配的。匹配的定义：设给定的排列为A,选出的数串为B,要满足B[A[i]]在数串中排第i小。 思路：扩展KMP O(n) 1 #include<iostream> 2 #include<cstring> 3 #include<cstdio...
BZOJ 2384: [Ceoi2011]Match （KMP，树状数组）
EM LGH
03-26 127
这道题是 KMP 来转移子串中的相对排名. 然后查询排名的话需要用到树状数组. 如果跳 fail 指针的话要把没用元素全部删掉. code: #include <bits/stdc++.h> #define N 1005000 #define setI(s) freopen(s".in","r",stdin) using name...
【KMP】BZOJ2384[Ceoi2011]Match
氧化钠的博客
10-22 622
分析： 首先，可以转化判定条件：如果在一段数中，每一个数左侧，比它小的数和给出的目标序列相同。那么就能认为这段数的大小关系合法。 然后就可以魔改KMP来做了。 所谓魔改，就是之前本来是判定两个字符是否相同，而这里变为判断当前已加入的左侧的数中，比它小的数是否合法。 但是为了高效修改，需要借助树状数组优化修改。 其余部分和KMP较为类似。 #include&lt;cstdio&gt; #includ...
LOJ2507 CEOI2011 Matching
baobi9069的博客
07-08 177
题目链接 参考了 神仙yyb的博客 现在发现kmp不仅能匹配字符串，还可以用于处理任意模式匹配中的状态，如这题中已经匹配的序列中的数的大小关系就是一种状态，使用kmp找到模式序列的每一个前缀的border，即一个最长的前缀和后缀使得它们的数字大小关系相同，即匹配状态相同，然后在失配时跳转到一个前缀的状态继续匹配，就可以解决这个问题啦！ 代码： 1 #include<...
bzoj2386 [CEOI2011] Team
weixin_30914981的博客
06-14 126
题意 给你n个数,每个数的大小在1到n之间,要求把它们分成几组,每个数字的大小要小于等于它所在组中的数字总个数,问最多能分出多少组. 分析 首先把所有数字排序,比较显然的是最后一定存在一个最优解是按这个顺序把所有数字划分为若干个区间,一个区间一组.(如果不是,一定可以进行恰当的交换使得是若干区间) 然后...我写了个错误的贪心...每次从后往前分组,分每一组的时候尽量少选人...然而这样不一定最优...
ceoi2011选做
cjoilmd的专栏
02-20 1521
就做了王宏的ppt上提到的3道题（好吧，其实提到了4道题，但是treasure hunt想法太烦了=。=，还不能测，就算了吧=。=！）               题意就不赘述了。        matching：        这道题主要问题是如何修改kmp的匹配方式使得kmp可以在o（logn）或o（1）的时间判断是否匹配，而且可以使用next数组。        对于模式串预处理，
[Ceoi2011]Traffic
weixin_30546933的博客
07-20 167
#2387. [Ceoi2011]Traffic Online Judge：Bzoj-2387，Luogu-4700 Label：Yy，Tarjan缩点，dfs 题目描述 格丁尼亚的中心位于Kacza河中的一座岛屿。每天清晨，成千上万辆汽车通过岛屿从西岸的住宅区（由桥连接岛的西部）到东岸的工业区（由桥连接岛的东部）。该岛类似于矩形，它的边平行于主方向。故可将它看作是**笛卡尔坐标系中的一个A...
[CEOI2011] balloons 单调栈
Dr_Nobody的博客
08-16 557
靠图分析：对当前圆扩张大小有影响的圆不止一个，是一个序列，而且这个序列满足x递增，r递减。 x的递增是自然的（否则就排序）r用一种数据结构来维护就可以了 但是，难道每次要遍历整个栈？ 不难发现（直觉吧）圆怎么膨胀也不会与比他大的那个圆的后一个圆相切，那么靠这个性质来维护单调栈就可以了，严格证明略过吧，应该都会写。 好像还可以用斜率优化来做，维护一个下凸壳之类的双端队列也可以。#include
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值