CSUOJ 2128: Wells's Travel Plan 倍增ST表 dp递推

Description

Wells来到了一个未知的梦幻国度，这个国度有 2N 个城市，分布为一个 2*N 的矩阵。有些城市是无法到达的。一个城市可以到达与之曼哈顿距离为 1 的城市。

大家都知道打acm没有太多的自由时间出去玩，但Wells仍然想知道，如果在从第 l 个城市出发到第 r 个城市的最少需要经过多少城市。

城市的分布如下图:

1, 2, 3, ….N

N+1,N+2,N+3….N*2

Input

第一行两个正整数 n，m，m 为询问数 接下来两行，每行是一个长度为 N 的字符串，表示城市能否经过。 若为 X，表示不能经过，若为 P，表示可以经过。 接下来 m 行，每行两个整数 l,r，描述一个询问。

Output

对于每个询问输出一行，l 到 r 的需要经过的最少城市个数(不包括起点，但包括终点)，若无法到达输出-1。

Sample Input

3 4 
XPX
PPP
1 4
4 2
6 5 
6 4

Sample Output

-1
2
1
2

Hint

对于所有数据,n, m < =2 * 10⁵.

Source

Author

Wells

其实是一道比较水的题 首先 对于每次询问 其实可以想到一个O(l-r)的递推 dp[ i ] [0/1] [0/1] 横坐标为i纵坐标为0，1的点到(i+1,0/1) 的花费 这个状态转移方程很好像 。 那么 对于每次询问 都要进行一次递推 那么总复杂度为O(nm) 这显然是不能接受的。 显然是需要降低复杂度的。 设想 可否使在线查询复杂度从O(n) 变成O(logn) 或者离线莫队搞一下 logn 的复杂度 一般有二分和倍增两种方式 这里 明显可以想到倍增。 增加一维 dp[i] [k] [0/1] [0/1] 横坐标为i的点 向前移动2^k 单位距离 所有情况所用的最小花费 然后 我们就可以在O(nlogn) 的时间内预处理出一个ST表 然后 对于每次询问 遍历次数就可以控制在logn次 总复杂度就降下来了 写得很复杂 ， 其实思想很简单。。。。。。。

#include <iostream>
#include <string>
#include <cstdio>
#include <math.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef long long LL;
const int MAX=2e5+10;
int dis[MAX][20][2][2];
int base[20];
int n,m;
char a[MAX];
char b[MAX];
void init() {
    memset(dis,0x3f,sizeof dis);
    base[0]=1;
    for(int i=1; i<20; i++) {
        base[i]=base[i-1]*2;
    }
    for(int i=0; i<n; i++) {
        /// 上到上
        if(a[i+1]=='P' && a[i]=='P') {
            dis[i][0][0][0]=1;
        }
        /// 上到下
        if(a[i]=='P'&&b[i+1]=='P' &&(b[i]=='P'||a[i+1]=='P')) {
            dis[i][0][0][1]=2;
        }
        /// 下到上
        if(b[i]=='P' &&a[i+1]=='P' &&(a[i]=='P' ||b[i+1]=='P')) {
            dis[i][0][1][0]=2;
        }
        /// 下到下
        if(b[i+1]=='P'&& b[i]=='P') {
            dis[i][0][1][1]=1;
        }
    }
    for(int k=1; k<20; k++) {
        for(int i=0; i<n; i++) {
            if(i+base[k]>=n) break;
            int cnt=1e9;
            /// 上到上
            if(dis[i][k-1][0][0]<2*MAX && dis[i+base[k-1]][k-1][0][0]<2*MAX && a[i+base[k-1]]=='P' && a[i]=='P') {
                cnt=min(cnt,dis[i][k-1][0][0]+dis[i+base[k-1]][k-1][0][0]);
            }
            if(dis[i][k-1][0][1]<2*MAX && dis[i+base[k-1]][k-1][1][0]<2*MAX && b[i+base[k-1]]=='P' && a[i]=='P') {
                cnt=min(cnt,dis[i][k-1][0][1]+dis[i+base[k-1]][k-1][1][0]);
            }
            dis[i][k][0][0]=cnt;
            /// 上到下
            cnt=1e9;
            if(dis[i][k-1][0][1]<2*MAX && dis[i+base[k-1]][k-1][1][1]<2*MAX && b[i+base[k-1]]=='P'&& a[i]=='P') {
                cnt=min(cnt,dis[i][k-1][0][1]+dis[i+base[k-1]][k-1][1][1]);
            }
            if(dis[i][k-1][0][0]<2*MAX && dis[i+base[k-1]][k-1][0][1]<2*MAX && a[i+base[k-1]]=='P'&& a[i]=='P') {
                cnt=min(cnt,dis[i][k-1][0][0]+dis[i+base[k-1]][k-1][0][1]);
            }
            dis[i][k][0][1]=cnt;
            /// 下到上
            cnt=1e9;
            if(dis[i][k-1][1][0]<2*MAX && dis[i+base[k-1]][k-1][0][0]<2*MAX && a[i+base[k-1]]=='P' && b[i]=='P') {
                cnt=min(cnt,dis[i][k-1][1][0]+dis[i+base[k-1]][k-1][0][0]);
            }
            if(dis[i][k-1][1][1]<2*MAX && dis[i+base[k-1]][k-1][1][0]<2*MAX && b[i+base[k-1]]=='P' && b[i]=='P') {
                cnt=min(cnt,dis[i][k-1][1][1]+dis[i+base[k-1]][k-1][1][0]);
            }
            dis[i][k][1][0]=cnt;
            /// 下到下
            cnt=1e9;
            if(dis[i][k-1][1][1]<2*MAX && dis[i+base[k-1]][k-1][1][1]<2*MAX && b[i+base[k-1]]=='P' && b[i]=='P') {
                cnt=min(cnt,dis[i][k-1][1][1]+dis[i+base[k-1]][k-1][1][1]);
            }
            if(dis[i][k-1][1][0]<2*MAX && dis[i+base[k-1]][k-1][0][1]<2*MAX && a[i+base[k-1]]=='P' && b[i]=='P') {
                cnt=min(cnt,dis[i][k-1][1][0]+dis[i+base[k-1]][k-1][0][1]);
            }
            dis[i][k][1][1]=cnt;
        }
    }
}
int dp[20][2];
int main() {
    while(cin>>n>>m){
        scanf("%s",a);
        scanf("%s",b);
        init();
        for(int i=0; i<m; i++) {
            memset(dp,0x3f,sizeof dp);
            int l,r;
            scanf("%d %d",&l,&r);
            int cntl=l,cntr=r;
            if(cntl>n) cntl-=n;
            if(cntr>n) cntr-=n;
            cntl--,cntr--;
            if(cntl>cntr){
                swap(cntl,cntr);
                swap(l,r);
            }
            if(cntl==cntr){
                int flag=1;
                if(l>n) flag&= (b[cntl]=='P');
                else flag &= (a[cntl]=='P');
                if(r>n) flag &= (b[cntl]=='P');
                else flag &= (a[cntl]=='P');
                if(!flag){
                    puts("-1");
                }else{
                    if(l==r)
                        puts("0");
                    else{
                        puts("1");
                    }
                }
            }else{
                cntr-=cntl;
                int tot=0;
                int flagl=l>n,flagr=r>n;
                if(flagl) {
                    dp[0][1]=0;
                } else {
                    dp[0][0]=0;
                }
                for(int i=19; i>=0; i--) {
                    if(cntr>=base[i]) {
                        tot++;
                        dp[tot][0]=min(dp[tot-1][0]+dis[cntl][i][0][0],dp[tot-1][1]+dis[cntl][i][1][0]);
                        dp[tot][1]=min(dp[tot-1][0]+dis[cntl][i][0][1],dp[tot-1][1]+dis[cntl][i][1][1]);
                        cntr-=base[i],cntl+=base[i];
                    }
                }
                printf("%d\n",((dp[tot][flagr]>3*MAX||dp[tot][flagr]<0)?-1:dp[tot][flagr]));
            }
        }
    }
    return 0;
}