[51nod] 1467 旋转绳

1467 旋转绳

题目来源： CodeForces 基准时间限制：1.5 秒 空间限制：131072 KB 分值: 80 难度：5级算法题

平面上有n个钉子，他们从１到n编号，第i个钉子的坐标是 (xi, 0)。然后我们我们把一个长度为Ｌ，带重物的绳子系到第i个钉子上（那么重物所在的坐标是(xi, -L)）。然后用力将重物向右推，开始逆时针旋转。同时，如果旋转的过程中碰到其它的钉子，就会绕着那个钉子旋转。假设每个钉子都很细，重物绕着它旋转时，不影响到绳子的长度。

更一般的，如果绳子碰到多个钉子，那么它会绕着最远的那个钉子转。特殊的，如果绳子的末端碰到了一个钉子，那么也会绕着那个钉子以长度为０的绳子在转。

经过一段时间之后，重物就会一直绕着某个钉子转。

现在有m个查询，每个查询给出初始的绳子长度以及挂在哪个钉子下旋转，请找出重物最终会绕哪个钉子旋转。

样例解释：

Input

单组测试数据。
第一行包含两个整数n 和 m (1 ≤ n, m ≤ 2*10^5)，表示钉子的数目以及查询的数目。
接下来一行包含n个整数 x1, x2, ..., xn ( -10^9 ≤ xi ≤ 10^9)，表示每个钉子的坐标。保证输入的钉子的坐标两两不相同。
接下来m行给出查询。每行给出ai (1 ≤ ai ≤ n) 和 li(1 ≤ li ≤ 10^9)，表示该查询的重物挂在第ai个钉子上，绳子长度是li。

Output

输出m行，第i行输出第i个查询的重物最终绕着哪个钉子转。

Input示例

3 2
0 3 5
2 3
1 8

Output示例

3
2

System Message (题目提供者)

 

C++的运行时限为：1500 ms ，空间限制为：131072 KB 示例及语言说明请按这里

 

Analysis分析

模拟+二分优化

显然，如果绳端在这个时候没法接触到某一个钉子，当它绕回去再绕回来以后，仍然没法接触到那根钉子

二分的范围是前缀和，两个方向要分开计算

既然是前缀和，那么在计算的时候需要将绳子也模拟成前缀和的形式，即剩余绳长 + 钉子所对应前缀和

然后看是不是可以在两个钉子上多绕几圈（即取模）

第一个坑点：钉子编号不按坐标增序（然而对钉子坐标是要排序的）

第二个坑点：当两边边界的钉子都是近乎无限远的时候，需要判断是否可以在非边界钉子上快速绕圈（比如第七个点）

（当然这可能只卡我的写法）

第三个...坑点：记得 stdio.h

 

Code代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;

long long trans[1000000],LtoR[1000000],RtoL[1000000];
int n,m;
int Time = 0;

struct data{
    long long val,ord;
}arr[1000000];

bool cmp(const data &a,const data &b){
    return a.val < b.val;
}

int L_find(long long x){
    int L = 1,R = n,mid;
    while(L < R){
        mid = (L+R+1)/2;
        if(LtoR[mid] <= x) L = mid;
        else R = mid-1;
    }return L;
}

int R_find(long long x){
    int L = 1,R = n,mid;
    while(L < R){
        mid = (L+R)/2;
        if(RtoL[mid] <= x) R = mid;
        else L = mid+1;    
    }return L;
}

int rotate_toR(int &pos,long long &L){
    L += LtoR[pos];
    int tar = L_find(L);
    if(pos != 1 && arr[tar].val-arr[pos-1].val > L-LtoR[tar] && arr[tar].val-arr[pos].val)
        L = (L-LtoR[tar])%(2*(arr[tar].val-arr[pos].val))+LtoR[tar];
    L -= LtoR[tar];
//    printf("CheckPoint A: tar%d L%d
",tar,L);
    if(LtoR[tar] && L > LtoR[tar]*2) L %= LtoR[tar]*2;
//    printf("CheckPoint AA: tar%d L%d
",tar,L);
//    if(!L){ pos = tar; return 1; }
    pos = tar;
    return 1; // Then keep dir
}

int rotate_toL(int &pos,long long &L){
    L += RtoL[pos];
    int tar = R_find(L);
    if(pos != n && arr[pos+1].val-arr[tar].val > L-RtoL[tar] && arr[pos].val-arr[tar].val)
        L = (L-RtoL[tar])%(2*(arr[pos].val-arr[tar].val))+RtoL[tar];
    L -= RtoL[tar];
    if(RtoL[tar] && L > RtoL[tar]*2) L %= RtoL[tar]*2;
//    printf("CheckPoint B: tar%d L%d
",tar,L);
//    if(!L){ pos = tar; return 1; }
    pos = tar;
    return 0; // Then keep dir
}

long long readll(){
    long long ret = 0; char ctr = getchar();
    while(ctr < '0' || ctr > '9') ctr = getchar();
    while(ctr >= '0' && ctr <= '9') ret = ret*10+ctr-'0',ctr = getchar();
    return ret;
}

int read(){
    int ret = 0; char ctr = getchar();
    while(ctr < '0' || ctr > '9') ctr = getchar();
    while(ctr >= '0' && ctr <= '9') ret = ret*10+ctr-'0',ctr = getchar();
    return ret;
}

int main(){
    scanf("%d%d",&n,&m);
//    n = read(),m = read();
        
    for(int i = 1;i <= n;i++){
        scanf("%lld",&arr[i].val);
//        arr[i].val = readll();
        arr[i].ord = i;
    }

    sort(arr+1,arr+1+n,cmp);
    
    for(int i = 1;i <= n;i++)
        trans[arr[i].ord] = i;
    
    LtoR[1] = 0;
    for(int i = 2;i <= n;i++)
        LtoR[i] = LtoR[i-1]+arr[i].val-arr[i-1].val;
    RtoL[n] = 0;
    for(int i = n-1;i >= 1;i--)
        RtoL[i] = RtoL[i+1]+arr[i+1].val-arr[i].val;
    
//    for(int i = 1;i <= n;i++) printf("%d ",LtoR[i]); cout << endl;
    
    while(m--){
        int pos = 0; long long L = 0;
        scanf("%d%lld",&pos,&L);
//        pos = read(), L = readll();
        
        pos = trans[pos];
        
        int times = 0,dir = 0;
        while(times < 2){
            int last = pos;
//            cout << "CTime: " << Time++ << " Pos " << pos << " L " << L << endl;
            if(!dir) dir = rotate_toR(pos,L);
            else dir = rotate_toL(pos,L);
            
            if((pos+1 > n || L < arr[pos+1].val-arr[pos].val) && (pos-1 < 1 || L < arr[pos].val-arr[pos-1].val)) times = 2; 
            
//            if(pos == last) times++;
//            else times = 0;
//            cout << "Time: " << Time++ << endl;
        }printf("%d
",arr[pos].ord);
    }
    
    return 0;
}