APIO2015简要题解

这场比赛当初是67（？）反正就是Cu滚粗了……

先给个题目的传送门：http://wenku.baidu.com/link?url=mUxdsYomenU-e9SFVPacVtXysemiQA4KnP1EldVuYaB8ECiaLQN4VIAEc19MmHQWyopKLxhzWjWdIE_QrxDWi6PVQt4YuI8IYqPRBN8HUbu

T1

题目大意：给你一个序列，让你分成x段，x∈[A,B]，要求每段之和的or和最小，输出最小的or和。A=1时序列长度n<=2000，A>=1时序列长度n<=100

和位运算相关的这类题大多都是按位DP

从高位做到低位，如果该位可以是0，那么就设为0，否则就置1然后随它去

具体实现用dp

如果A=1，直接用dp[i]记录[1,i]区间内，最少分几个块，随便搞搞O(n^2)转移就出来了，如果dp[n]<=B，这位就可以是0，复杂度O(n^2logn)

如果A>1，不能直接记录最少分几个区间，要把切所有刀的可行性都记下来（原谅我的语言表达……），用dp[i][j]表示[1,i]区间能否内分j块，如果有x∈[A,B]使dp[n][x]=1，这位就可以是0，复杂度O(n^3logn)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#define ll long long
#define N 2003
#define INF 2003

using namespace std;
inline int read(){
	int ret=0;char ch=getchar();
	while (ch<'0' || ch>'9') ch=getchar();
	while ('0'<=ch && ch<='9'){
		ret=ret*10-48+ch;
		ch=getchar();
	}
	return ret;
}

ll bin[60];int K;

int n,L,R;
ll s[N];

bool f[105][105];
int dp[N];

int main(){
	n=read();L=read();R=read();s[0]=0;
	for (int i=1;i<=n;++i) s[i]=s[i-1]+read();
	for (bin[K=0]=1;bin[K]<=s[n];++K) bin[K+1]=bin[K]<<1;
	--K;
	ll ans=0;
	if (L==1) for (;K>=0;--K){
		memset(dp,127,sizeof(dp));dp[0]=0;
		ans=ans<<1;
		for (int i=1;i<=n;++i){
			for (int pre=0;pre<i;++pre)
				if ((((s[i]-s[pre])>>K)|ans)==ans)
					dp[i]=min(dp[i],dp[pre]+1);
		}
		ans^=(ll)(dp[n]>R);
	}
	else for (;K>=0;--K){
		memset(f,0,sizeof(f));f[0][0]=1;
		ans=ans<<1;
		for (int i=1;i<=n;++i)
			for (int j=1;j<=R;++j)
				for (int pre=0;pre<i;++pre)
					if (f[pre][j-1]&&(((s[i]-s[pre])>>K)|ans)==ans){
						f[i][j]=1;break;
					}
		for (int i=L;i<=R;++i) ans|=(ll)f[n][i];
		ans^=1LL;
	}
	printf("%lld\n",ans);
	return 0;
}

　

T2

题目大意：给你一条链，每个点上有狗，每条狗都有一个跳跃力，表示它跳一步能跳过几个节点。现在一条狗要传递消息给另一条狗，只有持有消息的狗才能跳，问所有狗总共最少跳几步。链长狗数均为3*10^4

据说现场暴力出奇迹…………excited

以下是正解

对于跳跃力小于sqrt(n)的狗（我把它叫做小狗），按照跳跃力建立sqrt(n)个类似【轨道】（？）（原谅我形象的比喻……）的东西。每个轨道包含n个点，对应原链的每个节点。对应跳跃力为j的轨道上的点向同轨道左&右边第j个点分别连边，权为1。然后每个轨道上的点都向原链上它对应的点连边，权为0。

对于跳跃力大于sqrt(n)的狗（我把它叫做大狗），暴力简图就行，向所有它跳的到的原链上的点连边，边权为跳的步数。

对于原链上的每个点，向每个初始位置在它上面的狗对应的节点连边，权都为0，如果是大狗，就连到这条狗对应的点，如果是小狗，就连到它跳跃力的轨道上当前点对应的点。总结来说，原链的点，就是用来换狗的。

然后跑dijkstra，边和点都是nlogn的。有个细节就是，边我没有预处理建，我直接在dijkstra里找了，感觉这样会好写一点？

说的有点乱……详见代码吧

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#define N 5000006

using namespace std;
inline int read(){
	int ret=0;char ch=getchar();
	while (ch<'0' || ch>'9') ch=getchar();
	while ('0'<=ch && ch<='9'){
		ret=ret*10-48+ch;
		ch=getchar();
	}
	return ret;
}
const int K=150;

struct edge{
	int adj,next;
	edge(){}
	edge(int _adj,int _next):adj(_adj),next(_next){}
} e[30004];
int n,g[30004],m;
void AddEdge(int u,int v){
	e[++m]=edge(v,g[u]);g[u]=m;
}

int l,doge;
int id[30004],cnt;
int pos[30004],jump[30004];
int code[30004];

struct HeapNode{
	int pos,value;
	HeapNode(){}
	HeapNode(int _pos,int _value):pos(_pos),value(_value){}
};
inline bool operator >(const HeapNode &x,const HeapNode &y){
	return x.value>y.value;
}

priority_queue<HeapNode,vector<HeapNode> ,greater<HeapNode> > h;
bool flag[N];
int mind[N];
void dijkstra(int _s,int _t){
	memset(mind,127,sizeof(mind));
	memset(flag,0,sizeof(flag));
	while (!h.empty()) h.pop();
	flag[_s]=1;mind[_s]=0;
	h.push(HeapNode(_s,0));
	while (!flag[_t]&&!h.empty()){
		int u=h.top().pos;
		h.pop();
		flag[u]=1;int nowd=mind[u];
		if (u<=l) for (int i=g[u];i;i=e[i].next){
			int v=e[i].adj;
			if (mind[v]>nowd){
				mind[v]=nowd;
				h.push(HeapNode(v,mind[v]));
			}
		}
		else if (u>cnt){
			u=code[u-cnt];
			for (int v=(pos[u]-1)%jump[u]+1;v<=l;v+=jump[u])
				if (mind[v]>abs(pos[u]-v)/jump[u]+nowd){
					mind[v]=abs(pos[u]-v)/jump[u]+nowd;
					h.push(HeapNode(v,mind[v]));
				}
		}
		else{
			const int to[3]={(u-1)%l+1,u-(u-1)/l,u+(u-1)/l};
			for (int i=0;i<3;++i){
				int v=to[i];
				if (i&&(u-1)/l!=(v-1)/l) continue;
				if (mind[v]>nowd+(i>0)){
					mind[v]=nowd+(i>0);
					h.push(HeapNode(v,mind[v]));
				}
			}
		}

		while (!h.empty()&&flag[h.top().pos]) h.pop();
	}
	if (!flag[_t]) mind[_t]=-1;
}

int main(){
	l=read();doge=read();
	n=cnt=l*(K+1);
	memset(g,0,sizeof(g));m=1;
	for (int i=1;i<=doge;++i){
		pos[i]=read()+1;
		if ((jump[i]=read())>K) code[(id[i]=++n)-cnt]=i;
		else id[i]=jump[i]*l+pos[i];
		AddEdge(pos[i],id[i]);
	}
	dijkstra(pos[1],pos[2]);
	printf("%d\n",mind[pos[2]]);
	return 0;
}

　　

T3

题目大意：有n个人，每个人有2个房子，有一条河，每个房子都有可能在河任何一边的一个位置。要你建1或2座桥，使得每个人从一个房子到另一个房子（显然不能游泳）的最短距离之和最小，输出最小的和。n<=10^5

当时考场上乱搞一通，连22分算法都想了好久（而且想出来了还无比复杂）……现在看来真是太傻比了。据说此题用各种乱搞的方法也能搞……

首先，对于房子在河的一侧的，读入的时候就能处理掉。所以只需要处理在河2侧的就行了。

对于建1座桥的数据，也就是22分，把所有数丢进去，求个中位数就完了

对于建2座桥的数据，首先我们可以证明，把每个人按2个点的中点从左到右排序，最优解一定是一个前缀走左边的桥，一个后缀走右边的桥。至于具体证明，貌似随便画画图脑补脑补就行了？（虽然想不到TAT）

接下来，问题就变成了，我们需要一个支持插入、删除、求中位数的数据结构，这样什么权值线段树、树状数组上二分、各种STL都能乱搞了

这边顺便安利一下窝的【中根堆】，用4个priority_queue做的（如果不需要删除就只用2个），虽然不开O2很慢，但开了O2速度还是非常可观的。

然后从左往右扫一遍就行了

详见代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#define ll long long
#define N 2000006

using namespace std;
inline int read(){
	int ret=0;char ch=getchar();
	while (ch<'0' || ch>'9') ch=getchar();
	while ('0'<=ch && ch<='9'){
		ret=ret*10-48+ch;
		ch=getchar();
	}
	return ret;
}

int n,op;
int a[N],cnt;
int x[N],y[N];
ll ans;

struct MidHeap{
	priority_queue<int> l,ld;
	priority_queue<int,vector<int> ,greater<int> > r,rd;
	int lsize,rsize;ll lsum,rsum;
	void clear(){
		lsize=rsize=lsum=rsum=0;
		while (!l.empty()) l.pop();
		while (!r.empty()) r.pop();
		while (!ld.empty()) ld.pop();
		while (!rd.empty()) rd.pop();
	}
	void refresh(){
		while (l.size() && ld.size() && l.top()==ld.top()){
			l.pop();ld.pop();
		}
		while (r.size() && rd.size() && r.top()==rd.top()){
			r.pop();rd.pop();
		}
	}
	void LtoR(){
		int tmp=l.top();
		--lsize;lsum-=(ll)tmp;l.pop();
		++rsize;rsum+=(ll)tmp;r.push(tmp);
	}
	void RtoL(){
		int tmp=r.top();
		--rsize;rsum-=(ll)tmp;r.pop();
		++lsize;lsum+=(ll)tmp;l.push(tmp);
	}
	void push(int value){
		if (!lsize){
			++lsize;lsum+=(ll)value;l.push(value);
			return;
		}
		if (value<=l.top()){
			++lsize;lsum+=(ll)value;l.push(value);
			if (lsize>rsize+1) LtoR();
			refresh();
		}
		else{
			++rsize;rsum+=(ll)value;r.push(value);
			if (rsize>lsize) RtoL();
			refresh();
		}
	}
	void erase(int value){
		if (value<=l.top()){
			--lsize;lsum-=(ll)value;ld.push(value);
			refresh();
			if (lsize<rsize) RtoL();
			refresh();
		}
		else{
			--rsize;rsum-=(ll)value;rd.push(value);
			refresh();
			if (rsize+1<lsize) LtoR();
			refresh();
		}
	}
	ll query(){
		if (l.empty()) return 0;
		ll mid=l.top();
		return rsum-lsum+mid*(lsize-rsize);
	}
} h0,h1;

inline bool cmp(const int &a,const int &b){
	return x[a]+y[a]<x[b]+y[b];
}

int main(){
	op=read();n=read();
	cnt=0;ans=0;
	if (op==1){
		for (int i=1;i<=n;++i){
			char c0=getchar();
			while (!isalpha(c0)) c0=getchar();
			int p0=read();
			char c1=getchar();
			while (!isalpha(c1)) c1=getchar();
			int p1=read();
			if (c0!=c1){
				a[++cnt]=p0;
				a[++cnt]=p1;
				++ans;
			}
			else ans+=(ll)abs(p0-p1);
		}
		sort(a+1,a+cnt+1);
		for (int i=1;i<=cnt;++i) ans+=(ll)abs(a[cnt/2]-a[i]);
	}
	else{
		h0.clear();h1.clear();
		for (int i=1;i<=n;++i){
			char c0=getchar();
			while (!isalpha(c0)) c0=getchar();
			int p0=read();
			char c1=getchar();
			while (!isalpha(c1)) c1=getchar();
			int p1=read();
			if (c0!=c1){
				h1.push(x[++cnt]=p0);
				h1.push(y[cnt]=p1);
				a[cnt]=cnt;
				++ans;
			}
			else ans+=(ll)abs(p0-p1);
		}
		sort(a+1,a+cnt+1,cmp);
		ll ans0=h1.query();
		for (int i=1;i<cnt;++i){
			h0.push(x[a[i]]);
			h0.push(y[a[i]]);
			h1.erase(x[a[i]]);
			h1.erase(y[a[i]]);
			ll now=h0.query()+h1.query();
			if (now<ans0) ans0=now;
		}
		ans+=ans0;
	}
	printf("%lld\n",ans);
	return 0;
}