2017 多校4 Security Check

2017 多校4 Security Check

题意：

有(A_i)和(B_i)两个长度为(n)的队列过安检,当(|A_i-B_j|>K)的时候， (A_i和B_j)是可以同时过安检的，过安检必须按照队列的顺序，问你两个队列过完安检最少花费的时间
(1<=n<=6e4)，
(1<=A_i,B_i<=n)

题解：

设(f_{i,j})
表示仅考虑(a[1..i])与(b[1..j])时，最少需要多少时间。

若(|a_i-b_j|>k)
​，则(f_{i,j}=f_{i-1,j-1}+1)否则(f_{i,j}=min(f_{i-1,j},f_{i,j-1})+1)

注意到后者只有(O(nk))个，可以暴力DP，前者可以通过二分找到最大的(t)，满足(i,j)往前(t)个均不冲突，然后再从某个后者状态转移过来。

时间复杂度(O(nklog n))。

这个(dp)就跟求最长公共子序列的dp一样，很容易想到(O(n^{2}))的做法，优化就不容易想到了，想到了也不知道如何实现

对于(|A_i-B_j|<=K)的时候 可以暴力(dp)，
否则在(i)的左边找一个最接近(i)的(t) 满足(|A_t-B_{j-i+t}|<=K)
那么在(t<p<=i) 这一段 都是满足(|A_p-B_{j-i+p}|>K)他们同时过安检显然是最优的，直接算即可,这样下次有跳跃到了(<=K)的情况,所以只需要(做dp) 计算(<=K)的情况

如何找到这个(t)呢，开始我直接写了一发二分下标，WA，没仔细思考，这样二分下标不具有单调性。去网上看了看别人的写法，是把所有(i-j)差值为(x)而且(|A_i-B_j|<=K)的(i)存起来，然后去二分这个(i),好巧的做法，因为(i,j)一直往左走，走到(t)，差值都是相同的，这样是可行的。

#include<bits/stdc++.h>
#define LL long long
#define P pair<int,int>
using namespace std;
const int N = 6e4 + 10;
int read(){
    int x = 0;
    char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
    return x;
}
int n,k;
int a[N],b[N],pos[N];
vector<int> v[2 * N];///下标差值为x且绝对值小于等于k的 a_i的位置
int dp[N][22];
int Find(int i,int j){///i左边找到第一个x 使得abs(a[x] - b[j - i + x])<=k
   int x = upper_bound(v[i - j + n].begin(),v[i - j + n].end(),i) - v[i - j + n].begin() - 1;
   if(x < 0) return 0;
   return v[i-j+n][x];
}
int dfs(int i,int j){
    if(!i || !j) return i + j;
    if(abs(a[i] - b[j]) <= k){
        int &res = dp[i][a[i] - b[j] + k];
        if(res != -1) return res;
        return res = min(dfs(i-1,j),dfs(i,j-1)) + 1;
    }
    int x = Find(i,j);
    return dfs(x,max(0,j - i + x)) + i - x;
}
int main(){

    int T;
    T = read();
    while(T--){
        n = read(),k = read();
        for(int i = 1;i <= n;i++) a[i] = read();
        for(int i = 1;i <= n;i++) b[i] = read(),pos[b[i]] = i;
        for(int i = 0;i <= 2 * n;i++) v[i].clear();
        for(int i = 1;i <= n;i++){
            for(int j = max(1,a[i] - k);j <= min(a[i] + k,n);j++){
                v[i - pos[j] + n].push_back(i);
            }
        }
        memset(dp, -1, sizeof(dp));
        printf("%d
",dfs(n,n));
    }
    return 0;
}