2018提高组模拟18【优美的序列】【飞越行星带】【距离】

——————————————————————————————————20181102

T1 【4201 优美的序列】
T2 【4202 飞越行星带】
T3 【4203 距离】
【以上题目均出自WOJ】

T1 【4201 优美的序列】

单调栈

4201

就像找一个数左边最近的比自己大的数，右边最近的比自己大的数一样。

只不过这道题是找左边最近的不是自己倍数的数，右边最近的不是自己倍数的数一样。

当然也有像xly一样的神仙用KMP思想来写的。

$单调栈：$

• 如果新来的数不是栈顶的数的倍数就弹出。
• 弹出的时候再更新。

当然也可以模拟单调栈N²模拟。（60%）

100% :

#include<bits/stdc++.h>
using namespace std;
int n,a[500010];
int l[500010],r[500010];//左边是自己倍数的   右边是自己倍数的
stack<int>s;
int num=0,ans[500010],v[500010],mx=0;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=n;i++){//R
		while(!s.empty()&&a[i]%a[s.top()]!=0){
			r[s.top()]=i-1;
			s.pop();
		} 
		s.push(i);
	}
	while(!s.empty()){
		r[s.top()]=n;
		s.pop();
	}
	for(int i=n;i>0;i--){
		while(!s.empty()&&a[i]%a[s.top()]!=0){
			l[s.top()]=i+1;
			s.pop();
		}
		s.push(i);
	}
	while(!s.empty()){
		l[s.top()]=1;
		s.pop();
	}
	for(int i=1;i<=n;i++){
		if(r[i]-l[i]==mx){
			if(v[l[i]]!=mx+1)ans[++num]=l[i];
			v[l[i]]=mx+1;
		}
		if(r[i]-l[i]>mx){
			num=0;
			ans[++num]=l[i];
			mx=r[i]-l[i];
			v[l[i]]=mx+1;
		}
	}
	sort(ans+1,ans+num+1);
	printf("%d %d\n",num,mx);
	for(int i=1;i<=num;i++)
		printf("%d ",ans[i]);
	return 0;
} 

T2 【4202 飞越行星带】

并查集

kruskal

4202

题目只是要求穿过行星带的最大直径，一定是一个最小的横截面瓶颈。

我们把行星之间的距离看着是一道道瓶颈，

对于任意一个行星，它与x轴形成了一个瓶颈长度为yi,

与直线y=L形成一个瓶颈长度为L-yi，

和其他所有的点形成瓶颈长为他们之间的距离。

飞船要飞过这个行星带就必须传过每个行星形成的瓶颈，

我们把每个行星想象成一个点，

他形成的瓶颈表示边，就变成了一个图。

其中x轴与直线y=L，是两个特殊的点。

再分析这个图，我们可以发现，相当于找一个从x轴走到直线，最小的最大。

注意：

• 暴力很难打啊~~~~

• 是横着走的
  

• 我们像kruskal一样将边从小到大排序，依次加入，并用并查集判连通性。如果上顶点和下顶点连通，就说明这个距离我们刚好能过去。（加的是小于等于这个距离的边）

#include<bits/stdc++.h>
using namespace std;
struct edge{
	int u,v,w;
}e[300000];
inline int Sort(edge x,edge y){
	return x.w<y.w;
}
int fa[600],n,l,a[600],b[600],cnt=0;
inline int find(int x){
	return x==fa[x]?x:fa[x]=find(fa[x]);
}
int main(){
	scanf("%d%d",&n,&l);
	for(int i=1;i<=n+2;i++)
		fa[i]=i;//n+1上界    n+2下届 
	for(int i=1;i<=n;i++){
		scanf("%d%d",&a[i],&b[i]);
		e[++cnt].u=i;e[cnt].v=n+1;e[cnt].w=(l-b[i])*(l-b[i]);
		e[++cnt].u=i;e[cnt].v=n+2;e[cnt].w=b[i]*b[i];
		for(int j=1;j<i;j++){
			e[++cnt].u=i;e[cnt].v=j;
			e[cnt].w=(a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j]);
		}
	}
	sort(e+1,e+cnt+1,Sort);
	for(int i=1;i<=cnt;i++){
		int f1=find(e[i].u),f2=find(e[i].v);
		if(f1==f2)continue;
		fa[f1]=f2;
		if(find(n+1)==find(n+2)){
			printf("%.3lf",sqrt((double)e[i].w));
			return 0;
		}
	}
	return 0;
}

T3 【4203 距离】

斜率优化

矩阵DP

BFS

4203

用BFS从每个 $1$开始扫就好。

不过可能有特殊情况，要扫八个方向

不然很多8会被我们看成9！！！

可惜他们长得太像了，我对大样例的时候没发现就暴零了~~~~~

所以对拍很重要啊~~~~~~~~~~~~~~·

#include<iostream>
#include<cstdio>
#include<queue>
#include<cmath>
#include<cstring>
#include<cctype>
using namespace std;
inline int read(){
    int x=0,f=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return f==1?x:-x;
} 
int n,m,a[1005][1005],e[1000005],f[1000005],t=0,ans[1005][1005];
struct node{
    int x,y,r;
};
queue<node>q;
int dx[8]={-1,0,1,0,-1,1,1,-1},dy[8]={0,1,0,-1,1,1,-1,-1};//八个方向！！！！！
void work1(){
    char c;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            c=getchar();
            while(c!='0'&&c!='1')c=getchar();
            if(c^48){
                e[++t]=i;f[t]=j;
                q.push(node{i,j,t});
            }
        }
    while(!q.empty()){
        node u=q.front();q.pop();
        for(int i=0;i<8;i++){
            int xx=u.x+dx[i],yy=u.y+dy[i];
            if(xx<1||xx>n||yy<1||yy>m)continue;
            int x1=(xx-e[u.r])*(xx-e[u.r])+(yy-f[u.r])*(yy-f[u.r])+1;
            if(!ans[xx][yy]||ans[xx][yy]>x1){
                ans[xx][yy]=x1;
                q.push(node{xx,yy,u.r});
            }
        }

    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)
            printf("%d ",ans[i][j]-1);
        printf("\n");
    }
    return;
}
int main(){
    n=read();m=read();
    work1();
    return 0;
}

据说还可以用斜率优化，但是我不会，就以后再说吧~~~~~~~~~~