uoj #190. 【集训队互测2016】消失的源代码 提交答案题

Test 1:

发现是一个字母表的映射

把 \('a' \to 'z'\) 打进去找出映射就好了QAQ .

Test 2:

求助 \(dalao\) 得知的点。。

答案是 : \(2016x^2 + 4x + 10 (\bmod 233333)\)

Test 3:

把给的数列输进 \(OEIS\) 里。

发现是 : \(\lfloor\sqrt{\frac{n}{\pi}}\rfloor\)

Test 4:

发现给的是个图?

随便输几个数据进去发现只与连通性有关。

再进一步分析，发现是连通块大小的平方之和。

... ...

Test 5:

带权的树 ?

下面给的 \(m\) 个点对是啥？

询问？输出怎么只有一个数？

把询问数改成 \(1\)...还是输出一个数。。

好像是路径长度？

询问两次相同的？

输出变成零了！！！！

询问三次？

又变回来了。。。

把所有询问得到的结果 \(xor\) 输出。。。

Test 6:

怎么跟上一个点这么像。。。

询问改成了路径上最小边权？

其他的一点都没变？

。。。 。。。

Test 7:

输入两个数。。输出一个数？

对于所有的 \((i,1) , (1,i)\) 类型的询问的输出都是 \(i\) ?

把这个 \(n\times m\) 的表打出来。。

好像似曾相识。。。

怎么好象是 : \(\sum_{i=1}^n\sum_{j=1}^mgcd(i,j)\) 啊。。。

打了一下发现还真是。。。

反演一波.

Test8:

这个序列好神奇啊 QAQ ...

怎么我连续输出两个相同的序列得到的答案不一样啊。。。

。。。 。。。

只有数据组数不超过一组时，保证lost的输出正确。

。。。 。。。

\(*&@)#(*!(\)^)(!@#(&!@#!(@&#(!@&(#)(!@)#!)@(\((*&!@^#*(!@()!@&*(#^!@(*\)

然后搞了一波发现是本质不同的子串数目。。。

Test9:

随便扔几个点进去发现是平面最近点对。。

写了一个都说是 \(O(n\log n)\) 实际上跑的死慢死慢的东西跑了十几分钟跑出来了。

Test10:

输出 "invalid input!"

#include <map>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline void read(int &x){
	x=0;static char ch;static bool flag;flag = false;
	while(ch=getchar(),ch<'!');if(ch == '-') ch=getchar(),flag = true;
	while(x=10*x+ch-'0',ch=getchar(),ch>'!');if(flag) x=-x;
}
#define rg register int
#define rep(i,a,b) for(rg i=(a);i<=(b);++i)
#define per(i,a,b) for(rg i=(a);i>=(b);--i)
namespace work1{
	char mp[] = {'y','f','r','b','k','g','i','m','u','j','v','p','h','a','t','d','s','n','e','l','o','z','c','x','w','q'};
	char s[100010];
	int main(){
		int n;read(n);
		while(n--){
			scanf("%s",s);
			int m = strlen(s);
			rep(i,0,m-1){
				s[i] = mp[s[i] - 'a'];
			}
			printf("%s\n",s);
		}
		return 0;
	}
}
namespace work2{
	inline void work(){
		int n;read(n);
		printf("%lld\n",(2016LL*n%233333*n%233333+4LL*n+10) % (233333));
	}
	int main(){
		int T;read(T);
		while(T--) work();
		return 0;
	}
}
namespace work3{
	const double pi = acos(-1);
	inline void work(){
		int n;read(n);
		printf("%lld\n",(ll)sqrt((double)n/pi));
	}
	int main(){
		int T;read(T);
		while(T--) work();
	}
}
namespace work4{
	const int maxn = 100010;
	int fa[maxn],siz[maxn];
	int find(int x){return fa[x] == x ? x : fa[x] = find(fa[x]);}
	inline void Union(int u,int v){
		int x = find(u),y = find(v);
		if(x == y) return ;
		fa[x] = y;siz[y] += siz[x];
	}
	int main(){
		int T;read(T);
		while(T--){
			int n,m;read(n);read(m);
			rep(i,1,n) fa[i] = i,siz[i] = 1;
			int u,v;
			while(m--){
				read(u);read(v);
				Union(u,v);
			}
			ll ans = 0;
			rep(i,1,n){
				int x = find(i);
				ans += 1LL*siz[x]*siz[x];
				siz[x] = 0;
			}printf("%lld\n",ans);
		}
	}
}
namespace work5{
	const int maxn = 100010;
	struct Edge{
		int to,next,dis;
	}G[maxn<<1];
	int head[maxn],cnt;
	void add(int u,int v,int d){
		G[++cnt].to = v;
		G[cnt].next = head[u];
		head[u] = cnt;
		G[cnt].dis = d;
	}
#define v G[i].to
	int fa[maxn],son[maxn],siz[maxn],dep[maxn];
	int top[maxn],n;ll dis[maxn];
	void dfs(int u){
		siz[u] = 1;
		for(rg i = head[u];i;i=G[i].next){
			if(v == fa[u]) continue;
			fa[v] = u;dep[v] = dep[u] + 1;
			dis[v] = dis[u] + G[i].dis;
			dfs(v);siz[u] += siz[v];
			if(siz[son[u]] < siz[v]) son[u] = v;
		}return ;
	}
	void dfs(int u,int tp){
		top[u] = tp;
		if(son[u]) dfs(son[u],tp);
		for(rg i = head[u];i;i=G[i].next){
			if(v == fa[u] || v == son[u]) continue;
			dfs(v,v);
		}return ;
	}
#undef v
	inline int lca(int u,int v){
		while(top[u] != top[v]){
			if(dep[top[u]] < dep[top[v]]) swap(u,v);
			u = fa[top[u]];
		}return dep[u] < dep[v] ? u : v;
	}
	inline ll query(int u,int v){
		return dis[u] + dis[v] - 2*dis[lca(u,v)];
	}
	inline void init(){
		memset(head,0,sizeof head);
		memset(son,0,sizeof son);
		memset(top,0,sizeof top);
		cnt = 0;
	}
	inline void work(){
		init();
		int m;read(n);read(m);
		int u,v,d;
		rep(i,2,n){
			read(u);read(v);read(d);
			add(u,v,d);add(v,u,d);
		}dfs(1);dfs(1,1);
		ll ans = 0;
		rep(i,1,m){
			read(u);read(v);
			ans ^= query(u,v);
		}printf("%lld\n",ans);
	}
	int main(){
		int T;read(T);
		while(T--) work();
		return 0;
	}
}
namespace work6{
	const int maxn = 100010;
	struct Edge{
		int to,next,dis;
	}G[maxn<<1];
	int head[maxn],cnt;
	void add(int u,int v,int d){
		G[++cnt].to = v;
		G[cnt].next = head[u];
		head[u] = cnt;
		G[cnt].dis = d;
	}
#define v G[i].to
	int fa[maxn],son[maxn],siz[maxn],dep[maxn];
	int top[maxn],dfn[maxn],dfs_clock,w[maxn];
	int seq[maxn],n;
	void dfs(int u){
		siz[u] = 1;
		for(rg i = head[u];i;i=G[i].next){
			if(v == fa[u]) continue;
			fa[v] = u;dep[v] = dep[u] + 1;
			w[v] = G[i].dis;
			dfs(v);siz[u] += siz[v];
			if(siz[son[u]] < siz[v]) son[u] = v;
		}return ;
	}
	void dfs(int u,int tp){
		top[u] = tp;dfn[u] = ++ dfs_clock;
		seq[dfs_clock] = u;
		if(son[u]) dfs(son[u],tp);
		for(rg i = head[u];i;i=G[i].next){
			if(v == fa[u] || v == son[u]) continue;
			dfs(v,v);
		}return ;
	}
#undef v
	int T[maxn<<2];
	void build(int rt,int l,int r){
		if(l == r){
			T[rt] = w[seq[l]];
			return ;
		}
		int mid = l+r >> 1;
		build(rt<<1,l,mid);
		build(rt<<1|1,mid+1,r);
		T[rt] = min(T[rt<<1],T[rt<<1|1]);
	}
	int query(int rt,int l,int r,int L,int R){
		if(L <= l && r <= R) return T[rt];
		int mid = l+r >> 1;
		if(R <= mid) return query(rt<<1,l,mid,L,R);
		if(L >  mid) return query(rt<<1|1,mid+1,r,L,R);
		return min(query(rt<<1,l,mid,L,R),query(rt<<1|1,mid+1,r,L,R));
	}
	inline void init(){
		memset(head,0,sizeof head);
		memset(w,0,sizeof w);
		memset(son,0,sizeof son);
		memset(top,0,sizeof top);
		memset(dfn,0,sizeof dfn);
		memset(seq,0,sizeof seq);
		cnt = 0;dfs_clock = 0;
	}
	inline int query(int u,int v){
		int res = 1987654321;
		while(top[u] != top[v]){
			if(dep[top[u]] < dep[top[v]]) swap(u,v);
			res = min(res,query(1,1,n,dfn[top[u]],dfn[u]));
			u = fa[top[u]];
		}
		if(dep[u] > dep[v]) swap(u,v);
		if(u != v) res = min(res,query(1,1,n,dfn[u]+1,dfn[v]));
		return res;
	}
	void work(){
		init();
		int m;read(n);read(m);
		int u,v,d;
		rep(i,2,n){
			read(u);read(v);read(d);
			add(u,v,d);add(v,u,d);
		}dfs(1);dfs(1,1);w[1] = 1987654321;
		build(1,1,n);
		ll ans = 0,x;
		rep(i,1,m){
			read(u);read(v);
			ans ^= (x = query(u,v));
		}printf("%lld\n",ans);
		return ;
	}
	int main(){
		int T;read(T);
		while(T--) work();
		return 0;
	}
}
namespace work7{
	const int maxn = 1000010;
	bool vis[maxn];int pri[maxn],cnt;
	ll f[maxn];
	inline void liner(int n){
		f[1] = 1;
		rep(i,2,n){
			if(!vis[i]) pri[++cnt] = i,f[i] = i - 1;
			rep(j,1,cnt){
				ll x = 1LL*i*pri[j];
				if(x > n) break;
				vis[x] = true;
				if(i % pri[j] == 0){
					f[x] = f[i]*pri[j];
					break;
				}f[x] = f[i]*f[pri[j]];
			}
		}
		rep(i,1,n) f[i] += f[i-1];
	}
	inline void work(){
		int n,m;read(n);read(m);
		if(n > m) swap(n,m);
		ll ans = 0;
		for(rg i = 1,j;i <= n;i = j+1){
			j = min(n/(n/i),m/(m/i));
			ans += (f[j] - f[i-1])*(n/i)*(m/i);
		}
		printf("%lld\n",ans);
	}
	int main(){
		liner(1000000);
		int T;read(T);
		while(T--) work();
		return 0;
	}
}
namespace work8{
	const int maxn = 1000010;
	struct Node{
		int nx[21];
		int len,fa;
	}T[maxn<<1];
	int last,nodecnt,num[maxn<<1];
	inline void init(){
		last = nodecnt = 0;
		T[0].fa = -1;T[0].len = 0;
		rep(i,1,20) T[0].nx[i] = 0;
	}
	inline void insert(int c){
		int cur = ++ nodecnt,p;
		rep(i,1,20) T[cur].nx[i] = 0;
		T[cur].len = T[last].len + 1;
		for(p = last;p != -1 && !T[p].nx[c];p = T[p].fa) T[p].nx[c] = cur;
		if(p == -1) T[cur].fa = 0;
		else{
			int q = T[p].nx[c];
			if(T[q].len == T[p].len + 1) T[cur].fa = q;
			else{
				int co = ++ nodecnt;
				T[co] = T[q];T[co].len = T[p].len + 1;
				for(;p != -1 && T[p].nx[c] == q;p=T[p].fa) T[p].nx[c] = co;
				T[cur].fa = T[q].fa = co;
			}
		}last = cur;++ num[last];
	}
	int c[maxn],a[maxn],cnt;
	void work(){
		init();int n;read(n);
		rep(i,1,n) read(a[i]),c[i] = a[i];
		sort(c+1,c+n+1);cnt = unique(c+1,c+n+1) - c - 1;
		rep(i,1,n) a[i] = lower_bound(c+1,c+cnt+1,a[i]) - c;
		rep(i,1,n) insert(a[i]);
		ll ans = 0;
		rep(i,1,nodecnt) ans += T[i].len - T[T[i].fa].len;
		printf("%lld\n",ans);
		return ;
	}
	int main(){
		int T;read(T);
		while(T--) work();
		return 0;
	}
}
namespace work9{
	const int maxn = 1000010;
	struct Point{
		int x,y;
		Point(){}
		Point(const int &a,const int &b){
			x = a;y = b;
		}
	}p[maxn];
	inline double dis(const Point &a,const Point &b){
		return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
	}
	inline bool cmpx(const Point &a,const Point &b){
		return a.x == b.x ? a.y < b.y : a.x < b.x;
	}
	inline bool cmpy(const Point &a,const Point &b){
		return a.y < b.y;
	}
	Point tmp[maxn];int n;
	double solve(int l,int r){
		if(l == r) return 1e10;
		if(l == r-1) return dis(p[l],p[r]);
		int mid = l+r >> 1;double d = 1e10;
		d = min(solve(l,mid),solve(mid+1,r));
		int cnt = 0;
		rep(i,1,n) if(abs(p[i].x - p[mid].x) < d) tmp[++cnt] = p[i];
		sort(tmp+1,tmp+cnt+1,cmpy);
		rep(i,1,cnt){
			rep(j,i+1,cnt){
				if(abs(tmp[i].y - tmp[j].y) >= d) break;
				d = min(d,dis(tmp[i],tmp[j]));
			}
		}return d;
	}
	inline void work(){
		read(n);
		rep(i,1,n){
			read(p[i].x);read(p[i].y);
		}sort(p+1,p+n+1,cmpx);
		printf("%.3lf\n",solve(1,n));
	}
	int main(){
		int T;read(T);
		while(T--) work();
	}
}
namespace work10{
	inline void work(){
		puts("invalid input!");
	}
	int main(){
		int T;read(T);
		while(T--) work();
	}
}
int main(){
	int n;read(n);
	if(n == 1) work1::main();
	if(n == 2) work2::main();
	if(n == 3) work3::main();
	if(n == 4) work4::main();
	if(n == 5) work5::main();
	if(n == 6) work6::main();
	if(n == 7) work7::main();
	if(n == 8) work8::main();
	if(n == 9) work9::main();
	if(n == 10) work10::main();
	return 0;
}