开车旅行NOIP2012（倍增优化）

题目描述
小 A 和小 B 决定利用假期外出旅行，他们将想去的城市从 1 到 N 编号，且编号较小的城市在编号较大的城市的西边，已知各个城市的海拔高度互不相同，记城市 i 的海拔高度为Hi，城市 i 和城市 j 之间的距离 d[i,j]恰好是这两个城市海拔高度之差的绝对值，即d[i,j] = |Hi− Hj|。
旅行过程中，小 A 和小 B 轮流开车，第一天小 A 开车，之后每天轮换一次。他们计划选择一个城市 S 作为起点，一直向东行驶，并且最多行驶 X 公里就结束旅行。小 A 和小 B的驾驶风格不同，小 B 总是沿着前进方向选择一个最近的城市作为目的地，而小 A 总是沿着前进方向选择第二近的城市作为目的地（注意：本题中如果当前城市到两个城市的距离相同，则认为离海拔低的那个城市更近）。如果其中任何一人无法按照自己的原则选择目的城市，或者到达目的地会使行驶的总距离超出 X 公里，他们就会结束旅行。
在启程之前，小 A 想知道两个问题：
1．对于一个给定的 X=X0，从哪一个城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值最小（如果小 B 的行驶路程为 0，此时的比值可视为无穷大，且两个无穷大视为相等）。如果从多个城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值都最小，则输出海拔最高的那个城市。
2.对任意给定的 X=Xi和出发城市 Si，小 A 开车行驶的路程总数以及小 B 行驶的路程总数。
（这个两个问简化为： 
  1.给出x0，求从哪一个城市出发，使得A走的路程/B走的路程最小。如果B走的路程=0，则比值视为无穷大。如果有多个城市满足要求，则输出海拔最高的那个城市。  
   2.给出x和s（出发城市），求旅行终止是A的路程和B的路程。
   )

输入输出格式
输入格式：
第一行包含一个整数 N，表示城市的数目。
第二行有 N 个整数，每两个整数之间用一个空格隔开，依次表示城市 1 到城市 N 的海拔高度，即 H1，H2，……，Hn，且每个 Hi都是不同的。
第三行包含一个整数 X0。
第四行为一个整数 M，表示给定 M 组 Si和 Xi。
接下来的 M 行，每行包含 2 个整数 Si和 Xi，表示从城市 Si出发，最多行驶 Xi公里。
输出格式：
输出共 M+1 行。
第一行包含一个整数 S0，表示对于给定的 X0，从编号为 S0的城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值最小。
接下来的 M 行，每行包含 2 个整数，之间用一个空格隔开，依次表示在给定的 Si和
Xi下小 A 行驶的里程总数和小 B 行驶的里程总数。

【数据范围】  
对于30%的数据，有1≤N≤20，1≤M≤20；  对于40%的数据，有1≤N≤100，1≤M≤100；  对于50%的数据，有1≤N≤100，1≤M≤1,000；  对于70%的数据，有1≤N≤1,000，1≤M≤10,000；  
对于100%的数据，有1≤N≤100,000，1≤M≤10,000，-1,000,000,000≤Hi≤1,000,000,000， 0≤X0≤1,000,000,000，1≤S 
i≤N，0≤Xi≤1,000,000,000，数据保证Hi 互不相同

输入输出样例
输入样例#1：
drive1
4
2 3 1 4
3
4
1 3
2 3
3 3
4 3

drive2
10
4 5 6 1 2 3 7 8 9 10
7
10
1 7
2 7
3 7
4 7
5 7
6 7
7 7
8 7
9 7
10 7

输出样例#1：
drive1
1
1 1
2 0
0 0
0 0

drive2
2
3 2
2 4
2 1
2 4
5 1
5 1
2 1
2 0
0 0
0 0
题解：
这题的题意比较简单，主要难点是询问个数很多、数据规模特别大。
一、每次旅行都直接模拟行走,每次找一个最近或次近,时间O(N * N)。 对于第一问直接枚举起点。时间复杂度为O(N * N * M + N * N * N) （当然新手可以用模拟的方法练手）

二、再考虑预处理询问（合并处理相似询问），这需要看询问间有无共性或关联。但这些询问可能会以每一个城市作为起点，比如第一个询问给定(S=1, x=50)，第二个询问给定(S=12, x=100)，可能第一个询问场景下AB旅行都结束了，还没到走第二个询问场景的起点12。可见，询问之间的关联比较难找到，这条路也不可行。

三、为了不超时，我们需要找到能够快速解答每个询问的算法，一般来说需要O（logN）级别的算法。这时很容易联想到RMQ问题，采用动态规划空间换时间的策略，预先计算好每个起点S、每个x的结果，然后各个询问都可以秒解答。

空间换时间的思路虽然不错，然而数据中的x达到了10⁹，要预计算所有起点(1到10⁹)、所有x的结果是不实际的。不过可以思考下降维：起点这个维度简化不了，只能想办法简化x这个维度了。这时容易想到将x转化为二进制，我们只需要预处理当x为2^k（如2⁰，2¹，2²，…，2¹⁶）时的结果，最后将实际的x值拆成这些幂值的组合，再对相应的结果进行合并即可。

这时就会出现一些问题：
假设我们用f[i][j]表示从城市i出发、最多行驶2^j公里时小A、小B分别行驶的里程数，怎么写状态转移方程呢？我们设想的动态规划是，把整个旅行的过程拆成多段路程，每段路程可用不同的f[s][x]来表示，最后f[s][x]=f[s1][x1]+f[s2][x2]+f[s3][x3]…（其中x=x1+x2+x3+…），因此必须把这些s衔接上。

因为我们X预处理的是2^j,也就是x1,x2,x3,…不是一个城市到另一个城市的距离，而是以2的整数次幂，这样就不知道2的整数次幂停在什么位置，是谁在开车。

但现在f[i][j]这种状态没有表示出这一小段路程的终点在哪，实际上极有可能停在某城到某城的半路上，还没到下一城，因此不能跟另一个f[i][j]衔接。而就算我们把停在半路上的位置也记在f[i][j]里（包括下一站t、距离下一站的距离next_distance），还会遇到另两个问题：

f[i][j]的终点处是小A在开还是小B在开呢？如果是小B在开那还好。如果是小A在开，开到t城时该换小B上了，而下一个状态f[t][j-next_distance]表示的是小A从城市t出发，搞错了人，所以f[i]和f[t]又出现了衔接问题。
不知道next_distance这段路程将来该算小A开的还是小B开的。
要修补以上两个问题即便可行，也相当麻烦。造成这种情况的根本原因是是状态设的不够完美。

因此最好是把小A、小B绑在一起看，把小A、小B各开一次当作一轮，以轮为阶段，这样状态衔接就很自然了。

较佳的动规做法是，用f[i][k]表示从城市i出发、行驶2^k轮后小A、小B各自行驶的里程数A、B以及最后到达的城市T（状态中存3个值）。

容易写出动态转移方程：

在这里插入代码片

理解为，比如8（k=3）轮到达的城市就是，以4（k=2）轮后到达的城市为起点，再经过4轮到达的城市。

边界条件是k=0时，需模拟一轮A、B的行程。其中尤其要判断A是否有下一站以及B是否有下一站，若两者之一没有下一站，该状态的A距离、B距离就是0，T设为i。

注：状态的计算先后次序是：k从小到大，i从大到小。

算出所有状态后，回答询问（S，x）的算法是：

若x大于0，表示还可以继续前进，查找f[S][k]中A+B距离最接近x但不超过x（<=x）的状态，累积A、B的路程，并从x中减去A、B路程，再将S改为此状态中的T，重复此步。
若步骤1中找不到A+B距离不超过x的状态（即f[S][0]也不满足），检查x的距离内小A能否再开一次，如果小A能再开一次，再最后累积一次A的路程。这一步非常重要，因为现在的动规状态没有考虑小A单独走一次（半轮）的情况。
若步骤1中发现T与当前S相同（或者判断状态中的A、B皆为0），表示小A或小B已没有下一个目的地，执行步骤2然后结束。（如果这个判断不加，可能造成死循环）
至此，我们已经分析了这题最难的部分

还有一个最难的问题：快速查找距离最近的2个城市
这题还有一个难点：快速找到小A、小B下一个目的地的算法。也就是查找数组中和某元素值最近的两个元素，而且要在数组元素不断增多时做到即时动态查询。

肯定不能每插入一个元素排一次序（再检查指定元素前后的值），这种在n>103时是无法接受的。

要求是查找这个元素最近两个元素，也就是要取小于这个元素的最大２个元素、大于这个元素的最小２个元素（属于朴素的区间最值问题），共4个元素（答案一定在这4个元素中），再在这４个元素中选２个。 优化下的话，先取最接近的2个，判断后，再取另1个次接近的，共取3个也ok。

容易想到的是用查找树（最好是平衡树） 来解决：这是100%正确可行的，只是考场上如果不可以用STL的话，手写平衡树会很浪费时间还容易错。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<cmath>
#include<cstdlib>
using namespace std;
const int u=100010;
long long a[u][18][2],b[u][18][2],ansA,ansB,A,B;
int f[u][18][2],ans,n,m,t,i,j,k,h[u],g[u],go[u][2],x0,l,x,y;
struct rec{int x,y;};//存放城市编号和城市海拔高度
set<rec> s;//定义平衡树set
set<rec>::iterator it,lt,rt;//定义平衡树使用指针

bool operator <(rec a,rec b)//重定义<运算符，定义rec类型<运算
{
	return a.y<b.y;
}
bool cmp(int a,int b)//定义快排函数cmp，指明快排方式
{
	return abs(h[a]-h[i])<abs(h[b]-h[i])||abs(h[a]-h[i])==abs(h[b]-h[i])&&h[a]<h[b];
}

void solve(int s,int x0,long long &A,long long &B)
{
	A=B=k=0;
	for(int i=t;i>=0;i--)
	  if(f[s][i][k]&&a[s][i][k]+b[s][i][k]<=x0)
	  {
			x0-=a[s][i][k]+b[s][i][k];
			A+=a[s][i][k],B+=b[s][i][k];
			if(i==0) k^=1;
			s=f[s][i][k];
		}
}

int main()
{
	cin>>n;
	for(i=1;i<=n;i++) scanf("%d",&h[i]);//输入n个城市的海拔高度
	for(i=n;i;i--)
	{
		rec New; New.x=i,New.y=h[i];//把每个城市打包到rec类型中
		s.insert(New);//插入到平衡树中
		it=s.find(New);//在平衡树中找到刚插入城市信息的位置，插入到平衡树中的数据就自动排好序了，不知道它在什么位置，只能用find函数找到
		lt=it,rt=it,m=0;
		if(lt!=s.begin()) lt--,g[++m]=lt->x;
		if(lt!=s.begin()) lt--,g[++m]=lt->x;//找到两个前驱节点
		if(rt++,rt!=s.end())//找两个后驱节点
		{
			g[++m]=rt->x;
			if(rt++,rt!=s.end()) g[++m]=rt->x;
		}
		sort(g+1,g+m+1,cmp);//把两个前驱节点和两个后驱节点快排后找出两个最小的，就是当前城市的最近和次近
		if(m) go[i][0]=g[1];//最近城市
		if(m>1) go[i][1]=g[2];//次近城市
	}
	for(i=1;i<=n;i++)
	{
		if(go[i][1]) f[i][0][0]=go[i][1],a[i][0][0]=abs(h[go[i][1]]-h[i]),b[i][0][0]=0;
		/* f[i][0][0]表示小A从i城市出发，下一站要到达的城市
		a[i][0][0]表示小A从i城市出发到次近城市所走的距离
		这两个数据也是动归的边界数据
		*/
		if(go[i][0]) f[i][0][1]=go[i][0],a[i][0][1]=0,b[i][0][1]=abs(h[go[i][0]]-h[i]);
		/*
		f[i][0][1]表示小B从i城市出发，下一站要到达的城市
		b[i][0][1]表示小B从i城市出发到最近城市所走的距离
		*/
	}
	t=(int)(log(n*1.0)/log(2.0)+0.001);//求以2为底n的对数，求n个城市小A、小B交替开车，开几轮
	for(i=1;i<=t;i++)
	  for(j=1;j<=n;j++)
	    for(k=0;k<=1;k++)//k=0、1表示小A小B交替开车
			{
				if(i==1) l=k^1; else l=k;
				if(f[j][i-1][k]) f[j][i][k]=f[f[j][i-1][k]][i-1][l];//f[i][j][k]：从城市 j 出发，k 先走，走 2^i 步后到达的城市编号
				/*
				f[j][i-1][k]表示小A上一轮次走到城市
				f[f[j][i-1][k]][i-1][l]表示上一轮小B接着A走到城市出发，走到下一城市
				*/
				if(f[j][i][k])
				{
					a[j][i][k]=a[j][i-1][k]+a[f[j][i-1][k]][i-1][l];//从城市 j 出发，k 先走，走 2^i 步后，小 A 走过的距离
					b[j][i][k]=b[j][i-1][k]+b[f[j][i-1][k]][i-1][l];//从城市 j 出发，k 先走，走 2^i 步后，小 B 走过的距离
				}
			}
	cin>>x0;
	ansA=1,ansB=0;
	for(i=1;i<=n;i++)
	{
		solve(i,x0,A,B);
		if(!B) A=1;
		if(A*ansB<ansA*B||A*ansB==ansA*B&&h[i]>h[ans]) ansA=A,ansB=B,ans=i;
	}
	cout<<ans<<endl;
	cin>>m;
	for(i=1;i<=m;i++)
	{
		scanf("%d%d",&x,&y);
		solve(x,y,A,B);
		printf("%lld %lld\n",A,B);
	}
	return 0;
}