LOJ6435【PKUSC2018】星际穿越题解（贪心+倍增）

题目：LOJ6435.
题目大意：给定一张无向图$n$个点，表示现在又知道了一些信息为每个点$i$与编号为$[l_i,i-1]$的点有连边，边权均为$1$.现在给定$q$组询问$l_i,r_i,x_i(l_i<r_i<x_i)$，表示在$[l_i,r_i]$中等概率随机选择一个点$y_i$，求$x_i$到$y_i$最短路长度的期望.设$dis(x,y)$表示点$x$到点$y$的最短路长度，答案为：
$$\frac{1}{r_i-l_i+1}\sum _{j=l_i}^{r_i}dis(x_i,j)$$

$1\le n,q\le 3\ast 10^5$.

显然这个期望中的$\frac{1}{r_i-l_i+1}$可以算出$x_i$到$[l_i,r_i]$所有点的距离和之后再乘上去，现在问题变为求$x_i$到$[l_i,r_i]$所有点的距离和.

首先一个贪心，每一次的询问$x_i$一定是第一步向前或向后，之后全部向前走.

为什么呢？显然的.因为如果第一步向后走，那么选择一个可以走到的点中，下一步可以走到最前面
点显然是可行的.如果第二步还要往后走的话，由于我们第一步选的点已经是可以走到最前面的了，所以第二步可定选的是第一步走不到的点，而由于这是张无向图，它显然不可能走到比起点$x_i$更前面的点的…

然后又有一个贪心，每一次必然走下一次可以走到最前面的点选择.

显然，这样选择包含其他任何其他选择可以到达的点，肯定是没问题的.

有了这两个性质后，就可以了开始做这道题了.

很自然地设$f[i][j]$表示点$i$往前走$j$步可以到达的最前面的点，预处理出来之后，考虑如何回答询问.

直接统计$x_i$走到$[l_i,r_i]$有些麻烦，我们可以利用前缀和的思想，把问题拆为$x_i$走到$[l_i,x_i)$和$(r_i,x_i)$两部分.

之后询问时，第一步的时候分成两种情况，一种是直接从起点开始往前走，一种是先从起点往后走再往前走，最后答案在两种情况中取最小即可.

第一种大概流程如下：
1.设当前走到的最前面的点为$p$，上一次为$p^{\prime }$，当前走的步数为$now$.
2.从$[p,p^{\prime })$中找到一个可以走得最前面的点$bp$，设$bp$可以走到的最前面的点为$np$.
3.走到$[np,p)$的步数必然都为$now+1$，贡献计入答案后，令$p^{\prime }=p,p=np,now=now+1$.
4.重复执行上述过程直到$np\le l$（这里的边界要处理一下）.

第二种其实只需要求一下$(x_i,n]$中$x_i$可以到达的点中下一步走最前面的点就是第一种情况了，就不再重复了.

我们会发现这个过程有些难搞，一次询问复杂度达到了$O(n)$，怎么办呢？

由于每一次走的时候取区间$[p,p^{\prime })$中最优的决策时，区间的两个端点都不固定并不好搞，但容易发现$[p^{\prime },n]$中的点肯定不会走得比$[p,p^{\prime })$中的点优，是不是可以操作一下呢？

改变状态$f[i][j]$的意义，现在改为区间$[i,n]$中的点每个点往前走$j$步可以到达的最前面的点中最小的，也就是说取了一下后缀最小值.

这个时候我们就可以省去每一个区间中最优决策的时间了.然而，这个做法最坏情况下仍然是$O(n)$一次询问.

但是，$f[i][j]$显然是可以倍增预处理的，而且，设$sum[i][j]$表示$i$走到$[f[i][j],i)$的最短距离和，$sum$也是可以倍增预处理的.

具体是这样的：
$$\begin{gathered} f[i][j]=f[f[i][j-1]][j-1] \\ sum[i][j]=sum[i][j-1]+sum[f[i][j-1]][j-1]+2^{j-1}\ast (f[i][j-1]-f[i][j]) \end{gathered}$$

然后，这个问题就解决了？

不，我们解决的只是第一种，还有第二种.

幸运的是，第二种看起来有些难搞，但其实我们只需要在第一步的时候，强制往前走就可以了.

为什么呢？因为第一步强制往前走了，如果往后走更优，这个决策也被包含在了$(i,n]$里面，走第二步的时候已经被顺便统计进去了…

需要注意的是，这个时候我们还要打个特判，如果终点位置只需要从起点开始走一步就直接返回区间长度.

然后这个问题就真的解决了.

惊不惊喜？意不意外？

时间复杂度$O((n+q)\log n)$.

代码如下：

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

#define Abigail inline void
typedef long long LL;

const int N=300000,C=20;

LL gcd(LL a,LL b){return b?gcd(b,a%b):a;}

int n,l[N+9],cq;
int go[N+9][C];
LL sum[N+9][C];

void Pre_doubly(){
  go[n][0]=l[n];
  for (int i=n-1;i>=1;--i)
    go[i][0]=min(l[i],go[i+1][0]),sum[i][0]=(LL)i-go[i][0];
  for (int i=1;i<=n;++i)
    for (int j=1;j<C;++j){
      go[i][j]=go[go[i][j-1]][j-1];
      sum[i][j]=sum[i][j-1]+sum[go[i][j-1]][j-1]+((LL)go[i][j-1]-go[i][j]<<j-1);
    }
}

LL Query(int tdp,int stp){
  if (l[stp]<=tdp) return (LL)stp-tdp;
  LL res=stp-l[stp];
  int now=1;
  stp=l[stp];
  for (int i=C-1;i>=0;--i)
    if (go[stp][i]>tdp){
      res+=sum[stp][i]+(LL)now*(stp-go[stp][i]);
      stp=go[stp][i];
      now+=1<<i;
    }
  return res+(stp-tdp)*(now+1);
}

Abigail into(){
  scanf("%d",&n);
  for (int i=2;i<=n;++i)
    scanf("%d",&l[i]);
}

Abigail work(){
  l[1]=1;
  Pre_doubly();
}

Abigail getans(){
  scanf("%d",&cq);
  for (int i=1;i<=cq;++i){
    int l,r,x;
    scanf("%d%d%d",&l,&r,&x);
    LL ans=Query(l,x)-Query(r+1,x),len=(LL)r-l+1,g=gcd(ans,len);
    printf("%lld/%lld\n",ans/g,len/g);
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}