51Nod-1467-旋转绳

最新推荐文章于 2017-10-18 22:03:00 发布

f_zyj

最新推荐文章于 2017-10-18 22:03:00 发布

阅读量394

点赞数

分类专栏：数据结构 51Nod-题解集锦文章标签：二分

本文链接：https://blog.youkuaiyun.com/f_zyj/article/details/74082262

版权

51Nod-题解集锦同时被 2 个专栏收录

460 篇文章

订阅专栏

数据结构

228 篇文章

订阅专栏

本文介绍了一道ACM竞赛题目，通过巧妙利用二分查找而非预处理或线段树优化来解决大规模数据查询问题。文章分享了一个优化技巧，通过判断变量关系确定位置并进行取模操作，有效提升效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ACM模版

描述

题解

这个题倒是不难，主要就是二分，并不像平时做的那种海量查询的问题那样，需要预处理优化、线段树优化之类的。

一开始看到数据这么大，访问次数这么多，就感觉是需要预处理的，可是想半天也没有想到怎么处理，后来发现是二分，感觉很出乎意料，二分竟然能过，写好后提交了两次超时了，因为这个题卡 I/O 了，加上输入和输出外挂后，顺利 AC，只用了 $300+ms$ 就过了，这个代码在 $122 \sim 128$ 行有一个十分不错的优化，就是判断 $len$ 和 $y$ 之间的关系，来确定 $now$ 的位置，接着，取模一下，优化效果是极其显著的。

这个题远没有我一开始想的那么复杂，但是 AC 人数着实有些少，让我感觉这个题很神秘，所以一开始想岔了。

代码

#include <iostream>
#include <stdio.h>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAXN = 2e5 + 10;

int n, m;
int pos[MAXN];

struct snag
{
    int x, pos;
    bool operator < (const snag &b) const
    {
        return x < b.x;
    }
} sg[MAXN];

int bs(int x)
{
    int l = 1, r = n, res = n + 1;
    while (l <= r)
    {
        int m = (l + r) >> 1;
        if (sg[m].x > x)
        {
            res = m;
            r = m - 1;
        }
        else
        {
            l = m + 1;
        }
    }
    return res;
}

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if (c = getchar(), c == EOF)
    {
        return 0; //EOF
    }
    while (c != '-' && (c < '0' || c > '9'))
    {
        c = getchar();
    }
    sgn = (c == '-') ? -1 : 1;
    ret = (c == '-') ? 0 : (c - '0');
    while (c = getchar(), c >= '0' && c <= '9')
    {
        ret = ret * 10 + (c - '0');
    }
    ret *= sgn;
    return 1;
}

template <class T>
inline void out_d(T a)
{   //  输出外挂
    if (a < 0)
    {
        putchar('-');
        a = -a;
    }
    if (a >= 10)
    {
        out_d(a / 10);
    }
    putchar(a % 10 + '0');
}

int main()
{
    scan_d(n), scan_d(m);
    for (int i = 1; i <= n; i++)
    {
        scan_d(sg[i].x);
        sg[i].pos = i;
    }
    sort(sg + 1, sg + n + 1);
    for (int i = 1; i <= n; i++)
    {
        pos[sg[i].pos] = i;
    }

    int x, flag, now, len;
    for (int i = 1; i <= m; i++)
    {
        scan_d(x), scan_d(len);

        x = pos[x];
        flag = 1;
        now = bs(len + sg[x].x) - 1;
        len -= sg[now].x - sg[x].x;
        flag = -1;
        x = now;
        while (len)
        {
            if (flag == 1)
            {
                now = bs(len + sg[x].x) - 1;
            }
            else
            {
                now = bs(sg[x].x - len);
            }
            if (now && sg[now - 1].x == sg[x].x - len)
            {
                now--;
            }
            if (now == x)
            {
                break;
            }
            int y = abs(sg[now].x - sg[x].x);
            if ((len / y) & 1)
            {
                x = now;
                flag = -flag;
            }
            len %= y;
        }

        out_d(sg[x].pos);
        putchar(10);
    }

    return 0;
}