2021-10-06 组队赛——2019-icpc-Seoul-题解

Problem K Washer

题意：
给你三维平面上的$n<=100$个点，将他们最多分成$k<=2$类。每一类的价值是，
要求使所有类的价值和 最小，输出最小值。任意三点不共线，任意四点不共面。

思路一：
这个价值函数类似于方差，就是要让分出的类，尽可能地聚合。

考虑用K-means算法。
1）考虑先随机k个聚合点，
2) 然后每次把其他点，归属到距离最近的聚合点
3) 把每个聚合点调整到 属于他的那个点集最靠近质心的点
重复 第 2、3 步，最后剩下的聚合点就是使得每个集合 尽可能聚合的中心点。

代码：

#include<bits/stdc++.h>
using namespace std;
const double eps=1e-10;

int n,k;
struct node{
	double x,y,z;
}z[105];
double dis(double x1,double x2,double y1,double y2,double z1,double z2){
	return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2);
}
vector<int>mp[2];
int main(){
	cin>>n>>k;
	cout<<fixed<<setprecision(6); 
	for(int i=1;i<=n;i++){
		cin>>z[i].x>>z[i].y>>z[i].z;
	}
	double ans=0;
	if(n==1){
		cout<<1e-12<<endl;
		return 0;
	}
	if(k==1){
		double a=0,b=0,c=0;
		for(int i=1;i<=n;i++){
			a+=z[i].x;b+=z[i].y;
			c+=z[i].z;
		}
		a/=n;b/=n;c/=n;
		
		for(int i=1;i<=n;i++){
			ans+=dis(z[i].x,a,z[i].y,b,z[i].z,c);
		}
		cout<<ans<<endl;
	}else{
		ans=1e9;
		for(int w=1;w<=1500;w++){
			int n0=rand()%n;
			n0++;
			int n1=rand()%n;
			while(n1+1==n0){
				n1=rand()%n;
			}
			n1++;
			double a1=z[n0].x,a2=z[n1].x;
			double b1=z[n0].y,b2=z[n1].y;
			double c1=z[n0].z,c2=z[n1].z;
			while(1){
				mp[0].clear();mp[1].clear();
				for(int i=1;i<=n;i++){
					if(dis(a1,z[i].x,b1,z[i].y,c1,z[i].z)<
						dis(a2,z[i].x,b2,z[i].y,c2,z[i].z)){
						mp[0].push_back(i);		
					}else mp[1].push_back(i);
				}
				double aver[2][3];
				for(int i=0;i<2;i++){
					aver[i][0]=aver[i][1]=aver[i][2]=0;
					for(int j=0;j<mp[i].size();j++){
						aver[i][0]+=z[mp[i][j]].x;
						aver[i][1]+=z[mp[i][j]].y;
						aver[i][2]+=z[mp[i][j]].z;
					}
					aver[i][0]/=mp[i].size();
					aver[i][1]/=mp[i].size();
					aver[i][2]/=mp[i].size();
				}
				if(aver[0][0]==a1&&a2==aver[1][0]&&b1==aver[0][1]&&b2==aver[1][1]
					&&aver[0][2]==c1&&c2==aver[1][2])break;
				a1=aver[0][0];b1=aver[0][1];c1=aver[0][2];
				a2=aver[1][0];b2=aver[1][1];c2=aver[1][2];
			}
			double t=0;
			for(int i=0;i<2;i++){
				double a=0,b=0,c=0;
				for(int j=0;j<mp[i].size();j++){
					a+=z[mp[i][j]].x;
					b+=z[mp[i][j]].y;
					c+=z[mp[i][j]].z;
				}
				a/=mp[i].size();
				b/=mp[i].size();
				c/=mp[i].size();
				for(int j=0;j<mp[i].size();j++){
					t+=dis(z[mp[i][j]].x,a,z[mp[i][j]].y,b,z[mp[i][j]].z,c);
				}
			}
			ans=min(ans,t);
		}
		cout<<ans<<endl;
	}
	return 0; 
}

思路二：
考虑利用任意四点不共面的性质，我们用$n^3$的复杂度枚举每个面，然后这个面就把点集分成了两个部分，最后我们再二进制枚举面上的三个点所属哪个面就等于枚举了所有情况，然后对答案取min。
时间复杂度是$O(n^4)$，对于常数的要求特别高，我们就把式子拆开来维护，时间复杂度就是严格$O(n^4)$了。

代码：

变量名太多了，看起来复杂，但是还是简单的。

#include<bits/stdc++.h>
using namespace std;
const double eps=1e-10;

int n,k;
struct node{
	double x,y,z;
}z[105];

double dis(double x1,double x2,double y1,double y2,double z1,double z2){
	return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2);
}
vector<int>v1,v0;

int main(){
	cin>>n>>k;
	cout<<fixed<<setprecision(6);
	for(int i=1;i<=n;i++){
		cin>>z[i].x>>z[i].y>>z[i].z;
	}
	if(k==1){
		double a=0,b=0,c=0;
		for(int i=1;i<=n;i++){
			a+=z[i].x;b+=z[i].y;c+=z[i].z;
		}
		a/=n;b/=n;c/=n;
		double ans=0;
		for(int i=1;i<=n;i++){
			ans+=dis(z[i].x,a,z[i].y,b,z[i].z,c);
		}
		cout<<ans<<endl;
		return 0;
	}
	if(n==1||n==2){
		cout<<1e-12<<endl;
		return 0;
	}
	double ans=1e13;
	for(int i=1;i<=n;i++){
		for(int j=i+1;j<=n;j++){
			for(int k=j+1;k<=n;k++){
				double sum1=0,sum2=0,sum3=0;
				double pp1=0,pp2=0,pp3=0;
				double pp4=0,pp5=0,pp6=0;
				double su1=0,su2=0,su3=0;
				int n0=0,n1=0;
				double a1=z[j].x-z[i].x;
				double a2=z[k].x-z[i].x;
				double b1=z[j].y-z[i].y;
				double b2=z[k].y-z[i].y;
				double c1=z[j].z-z[i].z;
				double c2=z[k].z-z[i].z;
				double a=b1*c2-c1*b2;
				double b=c1*a2-a1*c2;
				double c=a1*b2-b1*a1;
				v0.clear();v1.clear();
				for(int w=1;w<=n;w++){
					if(w==i||w==j||w==k)continue;
					double x1=z[w].x-z[i].x;
					double y1=z[w].y-z[i].y;
					double z1=z[w].z-z[i].z;
					if(a*x1+y1*b+z1*c<0){
						sum1+=z[w].x;
						sum2+=z[w].y;
						sum3+=z[w].z;
						pp1+=z[w].x*z[w].x;
						pp2+=z[w].y*z[w].y;
						pp3+=z[w].z*z[w].z;
						n0++;
						v0.push_back(w);
					}else {
						su1+=z[w].x;
						su2+=z[w].y;
						su3+=z[w].z;
						n1++;
						pp4+=z[w].x*z[w].x;
						pp5+=z[w].y*z[w].y;
						pp6+=z[w].z*z[w].z;
						v1.push_back(w);
					}
				}
				for(int w=0;w<(1<<3);w++){
					double t=0;
					double s1=sum1,s2=sum2,s3=sum3;
					double ss1=su1,ss2=su2,ss3=su3;
					int n2=n0,n3=n1;
					double u1=pp1,u2=pp2,u3=pp3;
					double u4=pp4,u5=pp5,u6=pp6;
					if((w>>0)&1){
						s1+=z[i].x;
						s2+=z[i].y;
						s3+=z[i].z;
						u1+=z[i].x*z[i].x;
						u2+=z[i].y*z[i].y;
						u3+=z[i].z*z[i].z;
						n2++;
					}else{
						ss1+=z[i].x;
						ss2+=z[i].y;
						ss3+=z[i].z;
						u4+=z[i].x*z[i].x;
						u5+=z[i].y*z[i].y;
						u6+=z[i].z*z[i].z;
						n3++;
					}
					if((w>>1)&1){
						s1+=z[j].x;
						s2+=z[j].y;
						s3+=z[j].z;
						n2++;
						u1+=z[j].x*z[j].x;
						u2+=z[j].y*z[j].y;
						u3+=z[j].z*z[j].z;
					}else{
						ss1+=z[j].x;
						ss2+=z[j].y;
						ss3+=z[j].z;
						u4+=z[j].x*z[j].x;
						u5+=z[j].y*z[j].y;
						u6+=z[j].z*z[j].z;
						n3++;
					}
					if((w>>2)&1){
						s1+=z[k].x;
						s2+=z[k].y;
						s3+=z[k].z;
						n2++;
						u1+=z[k].x*z[k].x;
						u2+=z[k].y*z[k].y;
						u3+=z[k].z*z[k].z;
					}else{
						ss1+=z[k].x;
						ss2+=z[k].y;
						ss3+=z[k].z;
						n3++;
						u4+=z[k].x*z[k].x;
						u5+=z[k].y*z[k].y;
						u6+=z[k].z*z[k].z;
					}
					double p1,p2,p3,p4,p5,p6;
					p1=p2=p3=p4=p5=p6=0;
					if(n2!=0){
						p1=s1/n2;p2=s2/n2;p3=s3/n2;
						t+=u1-s1*2*p1+n2*p1*p1;
						t+=u2-s2*2*p2+n2*p2*p2;
						t+=u3-s3*2*p3+n2*p3*p3;
					}
					if(n3!=0){
						p4=ss1/n3;p5=ss2/n3;p6=ss3/n3;
						t+=u4-ss1*2*p4+n3*p4*p4;
						t+=u5-ss2*2*p5+n3*p5*p5;
						t+=u6-ss3*2*p6+n3*p6*p6;
					}
					ans=min(ans,t);
				}
			}
		}
	}
	cout<<ans<<endl;
	return 0; 
}

Problem H Strike Zone

题意:
给你二维平面上的两个点集，每个点集的点数 $num<=1000$，一个点集的权值是$c1$，另一个点集的权值是$-c2$，你可以在平面上任意放一个不限大小的矩形，使矩形内部的点权和最大，求最大点权和。

思路:
考虑把所有点离散化，那么点集的大小只有 2000，我们把点集排序之后，从一个 $x$下标到另一个下标，之间的最大点权和其实就是这个区间的最大字段和，那么我们就$n^2$枚举起点和终点，再用线段树维护动态dp即可。

代码：

就挺平凡的。

#include<bits/stdc++.h>
using namespace std;
#define ll long long

int n,m;
struct node{
	int x,y,c;
}z[2040];
int a[2040];
int b[2040];
int c1,c2;
int len1,len2;
bool cmp(node a,node b){
	if(a.x!=b.x)return a.x<b.x;
	return a.y<b.y;
}
ll tr[8040],trl[8040],trr[8040],tt[8040];
void build(int p,int l,int r){
	tr[p]=0;trl[p]=0;trr[p]=0;tt[p]=0;
	if(l==r)return ;
	int mid=l+r>>1;
	build(2*p,l,mid);
	build(2*p+1,mid+1,r);
}
void pushup(int p,int l,int r){
	tt[p]=max(tt[2*p],tt[2*p+1]);
	tt[p]=max(tt[p],trr[2*p]+trl[2*p+1]);
	tr[p]=tr[2*p]+tr[2*p+1];
	trr[p]=max(trr[2*p+1],tr[2*p+1]+trr[2*p]);
	trl[p]=max(trl[2*p],tr[2*p]+trl[2*p+1]);
	tt[p]=max(tt[p],trl[p]);
	tt[p]=max(tt[p],trr[p]);
}
void update(int p,int l,int r,int x,int w){
	if(l==r){
		tr[p]+=w;
		trl[p]+=w;
		trr[p]+=w;
		tt[p]+=w;
		return ;
	}
	int mid=l+r>>1;
	if(x<=mid)update(2*p,l,mid,x,w);
	else update(2*p+1,mid+1,r,x,w);
	pushup(p,l,r);
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d%d",&z[i].x,&z[i].y);
		a[i]=z[i].x;
		b[i]=z[i].y;
		z[i].c=1;
	}
	scanf("%d",&m);
	for(int i=1+n;i<=m+n;i++){
		scanf("%d%d",&z[i].x,&z[i].y);
		a[i]=z[i].x;
		b[i]=z[i].y;
		z[i].c=-1;
	}
	scanf("%d%d",&c1,&c2);
	sort(a+1,a+1+n+m);
	len1=unique(a+1,a+1+n+m)-a;
	sort(b+1,b+1+n+m);
	len2=unique(b+1,b+1+n+m)-b;
	for(int i=1;i<=n+m;i++){
		int pos=lower_bound(a+1,a+1+len1,z[i].x)-a;
		z[i].x=pos;
		pos=lower_bound(b+1,b+1+len2,z[i].y)-b;
		z[i].y=pos;
		if(z[i].c==1)z[i].c=c1;
		else z[i].c=-c2;
	}
	sort(z+1,z+1+n+m,cmp);
	ll ans=0;
	for(int i=1;i<=n+m;i++){
		if(i!=1&&z[i].x==z[i-1].x)continue;
		build(1,1,len2);
		for(int j=i;j<=n+m;j++){
			update(1,1,len2,z[j].y,z[j].c);
			if(j<n+m&&z[j].x==z[j+1].x)continue;
			ll w=tt[1];
			ans=max(ans,w); 
		}
	}
	printf("%lld\n",ans);
	return 0;
}