AtCoder Regular Contest 095 题解

BG

---

atcoder上的题都好奇妙哇
说是题解实际上只会做前三题QUQ

C - Many Medians

---

给定n个数字a[]，分别求出当i=1…n时，除去i后剩余数字的中位数

没啥好说的，权值线段树然后二分就可以了，这种东西写多了30行都可以搞定。。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

const int N=400005;

int a[N],b[N],s[N<<2];

int read() {
	int x=0,v=1; char ch=getchar();
	for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
	for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
	return x*v;
}

void modify(int now,int tl,int tr,int x,int v) {
	s[now]+=v; if (tl==tr) return ;
	int mid=(tl+tr)>>1;
	if (x<=mid) modify(now<<1,tl,mid,x,v);
	else modify(now<<1|1,mid+1,tr,x,v);
}

int ask(int now,int tl,int tr,int k) {
	if (tl==tr) return tl;
	int w=s[now<<1],mid=tl+tr>>1;
	if (w>=k) return ask(now<<1,tl,mid,k);
	else return ask(now<<1|1,mid+1,tr,k-w);
}

int main(void) {
	int n=read();
	rep(i,1,n) b[i]=a[i]=read();
	std:: sort(b+1,b+n+1);
	int size=std:: unique(b+1,b+n+1)-b-1;
	rep(i,1,n) a[i]=std:: lower_bound(b+1,b+size+1,a[i])-b;
	rep(i,1,n) modify(1,1,size,a[i],1);
	rep(i,1,n) {
		modify(1,1,size,a[i],-1);
		printf("%d\n", b[ask(1,1,size,n/2)]);
		modify(1,1,size,a[i],1);
	}
	return 0;
}

D - Binomical Coefficients

---

给定一个长度为n的非负整数序列a[]，选出两个数字a,b使得$a\le b$且最大化$\left(\genfrac{}{}{0ex}{}{a}{b}\right)$

最开始的响法是枚举a，然后查询离$\frac{a}{2}$最近的数字，大小的比较就两边取ln用double。就是不知道为什么re了
然后找了一波规律发现a一定是最大的数字，然后b选最接近a/2的就行了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <set>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

typedef long double db;
const int N=200005;

std:: set <db> set;

int a[N],prt1,prt2;
db fac[N],ans=-1;

int read() {
	int x=0,v=1; char ch=getchar();
	for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
	for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
	return x*v;
}

void upd(int n,int m) {
	if (n<m) return ;
	if (m==0) {
		if (fac[1]>ans) {
			ans=fac[1];
			prt1=n,prt2=m;
		}
		return ;
	}
	if (fac[n]-fac[m]-fac[n-m]>ans) {
		ans=fac[n]-fac[m]-fac[n-m];
		prt1=n,prt2=m;
	}
}

void solve(int x) {
	db tmp=0.5*x;
	int wjp=-1,lxf=-1;
	set.insert(tmp);
	std:: set <db>:: iterator pos=set.find(tmp);
	if (pos!=set.begin()) {
		pos--; wjp=*pos; pos++;
	}
	pos++;
	if (pos!=set.end()) lxf=*pos;
	pos--;
	if (wjp>=0) upd(x,wjp);
	if (lxf>=0) upd(x,lxf);
	set.erase(pos);
}

int main(void) {
	// rep(i,1,N-1) fac[i]=fac[i-1]+log(i);
	int n=read();
	db mn=1000000000;
	rep(i,1,n) a[i]=read();
	std:: sort(a+1,a+n+1);
	rep(i,1,n-1) {
		if (fabs(a[i]-0.5*a[n])<mn) {
			mn=fabs(a[i]-0.5*a[n]);
			prt1=i;
		}
	}
/*	rep(i,1,n) {
		solve(a[i]);
		set.insert(a[i]);
	}
	printf("%d %d\n", prt1,prt2);*/
	printf("%d %d\n", a[n],a[prt1]);
	return 0;
}

E - Symmetric Grid

---

给定一个n*m的矩阵，可以交换任意行任意列，问是否存在一种方案使得新的矩阵中心对称

眼熟的题目，看起来就像爆搜。交换等价于一种对应关系，我们枚举行与行之间的配对，然后暴力判断列之间能否恰好匹配完就可以了。注意奇数的情况有一列有一行是自己配对的

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (register int i=st;i<=ed;++i)

const int N=25;

char s[N][N];

int match[N],n,m,flag;

bool used[N],lxf;

bool check() {
	int cnt=m;
	rep(i,1,m) used[i]=0;
	rep(i,1,m) if (!used[i]) {
		rep(j,i+1,m) if (!used[j]) {
			bool wjp=true;
			rep(k,1,n) if (s[k][i]!=s[match[k]][j]) {
				wjp=false; break;
			}
			if (wjp) {
				used[i]=used[j]=true;
				cnt-=2;
				break;
			}
		}
	}
	if (cnt==0) return true;
	if (cnt==1&&m%2==1) {
		rep(i,1,m) if (!used[i]) {
			rep(j,1,n) if (s[j][i]!=s[match[j]][i]) return false;
			break;
		}
		return true;
	}
	return false;
}

void dfs(int dep) {
	if (flag) return ;
	if (dep==(n+1)/2+1) return (void) (flag|=check());
	rep(i,1,n) if (!match[i]) {
		rep(j,i+1,n) if (!match[j]) {
			match[i]=j; match[j]=i;
			dfs(dep+1);
			match[i]=match[j]=0;
		}
		if ((n&1)&&!lxf) {
			match[i]=i; lxf=true;
			dfs(dep+1);
			match[i]=0; lxf=false;
		}
	}
}

int main(void) {
	freopen("data.in","r",stdin);
	scanf("%d%d",&n,&m);
	rep(i,1,n) scanf("%s",s[i]+1);
	dfs(1);
	puts(flag?"YES":"NO");
	return 0;
}

F - Permutation Tree

---

留坑 填坑，这里只说说怎么判断
注意到给定的连边限制是二维偏序，不妨把每个节点看成二维坐标上的一个点(pi,i)，我们按照pi递增依次插入这些节点，那么i最大的节点就是单调的。

考虑这里单调的含义，也就是我们每次记下当前i最大的节点并染黑，其余节点染白。那么黑点一定连成了一条树上的直径，并且只存在黑-黑、白-黑这样的边。

代码就不写了吧。。