CF1045G AI robots题解

合集 - codeforces题解集1(37)
1.CF1916E Happy Life in University 题解2.CF763E Timofey and our friends animals题解3.CF1270G Subset with Zero Sum
4.CF1045G AI robots题解
5.CF940F Machine Learning题解6.CF678F Lena and Queries题解7.CF1921F Sum of Progression 题解8.CF526F Pudding Monsters 题解9.CF455D Serega and Fun 题解10.CF351D Jeff and Removing Periods 题解11.CF452F Permutation 与 P2757 [国家集训队] 等差子序列 题解12.CF911G Mass Change Queries 题解13.CF145E Lucky Queries 题解14.CF1515F Phoenix and Earthquake 题解15.CF765F Souvenirs 题解16.CF1764H Doremy's Paint 2 题解17.CF1000F One Occurrence题解18.CF813E Army Creation 题解19.CF1706E Qpwoeirut and Vertices 题解20.CF620E New Year Tree 题解21.CF1454F Array Partition 题解22.CF1771F Hossam and Range Minimum Query 题解23.CF1931F Chat Screenshots 另一种题解24.CF896C Willem, Chtholly and Seniorious 题解25.CF55D Beautiful numbers 题解26.CF916E Jamie and Tree 题解27.CF696B Puzzles 题解28.CF383C Propagating tree 题解29.CF1436E Complicated Computations 题解30.CF817F MEX Queries 题解31.CF1638E Colorful Operations 题解32.CF1618G Trader Problem 题解33.CF794F Leha and security system 题解34.CF371E Subway Innovation 题解35.CF1200E Compress Words 题解36.CF1884D Counting Rhyme 题解37.CF1982F Sorting Problem Again 题解
收起

题目链接：洛谷 或者 CF

本题考虑转化为 cdq 分治模型

对于 cdq 分治来说，只需要考虑左边对右边的影响，那我们要考虑该怎样设置第一维度的左右对象。很显而易见的是抛开 q 限制而言，我们着眼于，如何让双方互相看到的严格条件转化为只需要关注单体看见。考虑什么情况下只需要一方看到对方，对方就能看到自身。首先考虑双方互相看到的充要条件：

1. pos1−R1≤pos2≤pos1+R1

2. pos2−R2≤pos1≤pos2+R2

考虑上述两个条件如何转化为一个条件，我们注意到如果有 R1≤R2 那么，很容易得知，当 pos1 位置的机器人能看到 pos2 位置的机器人时，它俩就互相能看到了，换句话来说，此时此刻 1 成立，即可。

简单证明就是有两个机器人，它们都处在各自圆心处在数轴上，各自有个探测半径，现在要求它们的圆心都处于对方的园内。很显而易见的有：

圆心距=|pos1−pos2|≤min(R1,R2)，证毕。

那么我们就能把双方影响，变为只有一方影响另一方了，符合 cdq 模型。考虑哪个放左哪个放右？右边是受左边影响计算的。考虑计算某个 pos 的答案时，我们显然根据刚刚所说，如果它能看到其他机器人，那么其他机器人就能看到它，所以它的探测范围是用于最终查询的对象，它应该作为右边，其他机器人放在左边。通过上述，我们能知道它具备的条件为它的探测范围比其他机器人小，这样一来，它找自己探测范围内比它探测范围大的机器人时，对方一定能同时看到它。外层框架搭建完毕。

现在考虑 K 限制，很显而易见的是，题目条件所表达的意思为：

|qcurr−qother|≤K⇔qcurr−K≤qother≤qcurr+K

当前查询点和其他点的 q 的绝对值之差不超过 K,很显然，qcurr 和 K 是定值，我们如何找到 qother 在左区间 [L,mid] 上。根据 cdq 分治的套路，我们只需要让 q 有序就行了，这个有序依托于归并排序的排序。这样一来双指针类似莫队应用的插入和删除在一种支持单点修改，区间查询的数据结构上就行了。最后查询对应的搜索范围就行了。

cdq 分治的题型常常有这么几步，考虑外层如何转化为单个对象对单个对象有影响，从而确定左右之分，受影响和影对象。内存因为基于归并排序的结构，所以常常可以让其中一维有序，有序就具备了单调性，常常可以考虑构建双指针或者其他单调算法。最后再配上一个查询类的数据结构就行了，常常是计数类问题，所以可以考虑树状数组。

算法框架

首先我们最终使用树状数组查询探测范围，所以需要考虑离散化，我用的哈希表进行离散化，结果发现 gp_hash_table 被卡哈希了，试了下 unordered_map 或者 cc_hash_table 没问题，当然cf 上非必要还是考虑使用 map 代替哈希表功能。当然也可以用二分离散化。

其次，外层需要对探测范围排序，由于小的探测范围作为被查询对象，需要放右边，所以逆序排序就好了。最后在每次 merge 时将 q 变为有序，双指针时像类似莫队一样的 add 和 del 即可，树状数组维护 pos 用于探测范围内圆心计数。

参照代码 
#include <bits/stdc++.h>
 
//#pragma GCC optimize("Ofast,unroll-loops")
 
// #define isPbdsFile
 
#ifdef isPbdsFile
 
#include <bits/extc++.h>
 
#else
 
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
 
#endif
 
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
 
template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}
 
template <typename T>
T lowBit(T x)
{
    return x & -x;
}
 
template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}
 
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}
 
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c)if (b & 1)(ans *= a) %= c;
    return modt(ans, c);
}
 
template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}
 
template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}
 
template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char))return;
    if (x < 0)x = -x, putchar('-');
    if (x > 9)write(x / 10);
    putchar(x % 10 ^ 48);
}
 
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}
 
 
template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;
 
    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow)return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }
 
    T3() { one = tow = three = 0; }
 
    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};
 
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y)x = y;
}
 
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y)x = y;
}
 
constexpr int N = 1e5 + 10;
set<int> t;
hash3<int, int> mp;
int n, K;
ll ans;
int mx;
int bit[N << 2];
 
struct Query
{
    int pos, R, l, r;
    int q;
} node[N];
 
inline void add(int x, const int val)
{
    for (; x <= mx; x += lowBit(x))bit[x] += val;
}
 
inline int query(int x)
{
    int ans = 0;
    for (; x; x -= lowBit(x))ans += bit[x];
    return ans;
}
 
inline int queryLR(const int L, const int R)
{
    return query(R) - query(L - 1);
}
//按探测范围降序排序
inline bool cmpLen(const Query& x, const Query& y)
{
    return x.R > y.R;
}
 
Query tmp[N];
//q有序数组合并
inline void merge(const int L, const int mid, const int R)
{
    int cnt = L;
    int i = L, j = mid + 1;
    while (i <= mid and j <= R)tmp[cnt++] = node[i].q <= node[j].q ? node[i++] : node[j++];
    while (i <= mid)tmp[cnt++] = node[i++];
    while (j <= R)tmp[cnt++] = node[j++];
    forn(i, L, R)node[i] = tmp[i];
}
 
inline void cdq(const int L, const int R)
{
    const int mid = L + R >> 1;
    if (L == R)return;
    cdq(L, mid);
    cdq(mid + 1, R);
    int l = L, r = L - 1;
    //双指针找[q-K,q+K]范围内的所有圆心,加入树状数组
    forn(curr, mid+1, R)
    {
        auto [pos,R,queryL,queryR,q] = node[curr];
        while (l <= mid and q - K > node[l].q)add(node[l++].pos, -1);
        while (r < mid and node[r + 1].q <= q + K)add(node[++r].pos, 1);
        ans += queryLR(queryL, queryR);
    }
    forn(i, l, r)add(node[i].pos, -1);
    merge(L, mid, R); //使q有序
}
 
inline void solve()
{
    cin >> n >> K;
    forn(i, 1, n)
    {
        auto& [pos,R,_1,_2,q] = node[i];
        cin >> pos >> R >> q;
        t.insert(pos);
        t.insert(pos + R);
        t.insert(pos - R);
    }
    for (auto v : t)mp[v] = ++mx;
    //离散化
    forn(i, 1, n)node[i].l = mp[node[i].pos - node[i].R], node[i].r = mp[node[i].pos + node[i].R], node[i].pos = mp[node[i].pos];
    sort(node + 1, node + n + 1, cmpLen);
    cdq(1, n);
    cout << ans;
}
 
signed int main()
{
    Spider
    //------------------------------------------------------
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test)solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
}
优化常数代码 
#include <bits/stdc++.h>
 
//#pragma GCC optimize("Ofast,unroll-loops")
 
// #define isPbdsFile
 
#ifdef isPbdsFile
 
#include <bits/extc++.h>
 
#else
 
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>
 
#endif
 
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
 
template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}
 
template <typename T>
T lowBit(T x)
{
    return x & -x;
}
 
template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}
 
template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}
 
template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c) if (b & 1) (ans *= a) %= c;
    return modt(ans, c);
}
 
template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-') sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}
 
template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}
 
template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char)) return;
    if (x < 0) x = -x, putchar('-');
    if (x > 9) write(x / 10);
    putchar(x % 10 ^ 48);
}
 
template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}
 
 
template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;
 
    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow) return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }
 
    T3()
    {
        one = tow = three = 0;
    }
 
    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};
 
template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y) x = y;
}
 
template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y) x = y;
}
 
struct Hash
{
    static uint64_t splitmix64(uint64_t x)
    {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ x >> 30) * 0xbf58476d1ce4e5b9;
        x = (x ^ x >> 27) * 0x94d049bb133111eb;
        return x ^ x >> 31;
    }
 
    static size_t get(const uint64_t x)
    {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
 
    template <typename T>
    size_t operator()(T x) const
    {
        return get(std::hash<T>()(x));
    }
 
    template <typename F, typename S>
    size_t operator()(pair<F, S> p) const
    {
        return get(std::hash<F>()(p.first)) ^ std::hash<S>()(p.second);
    }
};
 
constexpr int N = 1e5 + 10;
int tot, t[N << 2];
hash2<int, int, Hash> mp;
int n, K;
ll ans;
 
int bit[N << 2];
 
struct Query
{
    int pos, R, l, r;
    int q;
 
    bool operator<(const Query other) const
    {
        return q < other.q;
    }
} node[N];
 
inline void add(int x, const int val)
{
    for (; x <= tot; x += lowBit(x)) bit[x] += val;
}
 
inline int query(int x)
{
    int ans = 0;
    for (; x; x -= lowBit(x)) ans += bit[x];
    return ans;
}
 
inline int queryLR(const int L, const int R)
{
    return query(R) - query(L - 1);
}
 
namespace fasI
{
    constexpr int BF_SIZE = 1 << 12;
    bool IOerr = false;
 
    inline char nc()
    {
        static char buf[BF_SIZE], *p1 = buf + BF_SIZE, *pend = buf + BF_SIZE;
        if (p1 == pend)
        {
            p1 = buf;
            pend = buf + fread(buf, 1, BF_SIZE,stdin);
            if (pend == p1)
            {
                IOerr = true;
                return -1;
            }
        }
        return *p1++;
    }
 
    inline bool bla(const char ch)
    {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
 
    template <typename T>
    void Rd(T& x)
    {
        char ch;
        while (bla(ch = nc()));
        T sign = 1;
        if (ch == '-') sign = -1, ch = nc();
        for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
        x *= sign;
    }
 
    template <typename T, typename... U>
    void Rd(T& x, U&... y)
    {
        Rd(x);
        Rd(y...);
    }
#undef BF_SIZE
}
 
using namespace fasI;
//按探测范围降序排序
inline bool cmpLen(const Query& x, const Query& y)
{
    return x.R > y.R;
}
 
Query tmp[N];
//q有序数组合并
inline void cdq(const int L, const int R)
{
    const int mid = L + R >> 1;
    if (L == R) return;
    cdq(L, mid), cdq(mid + 1, R);
    int l = L, r = L - 1;
    //双指针找[q-K,q+K]范围内的所有圆心,加入树状数组
    forn(curr, mid+1, R)
    {
        const auto& [pos,R,queryL,queryR,q] = node[curr];
        while (l <= mid and q - K > node[l].q) add(node[l++].pos, -1);
        while (r < mid and node[r + 1].q <= q + K) add(node[++r].pos, 1);
        ans += queryLR(queryL, queryR);
    }
    forn(i, l, r) add(node[i].pos, -1);
    merge(node + L, node + mid + 1, node + mid + 1, node + R + 1, tmp + L); //使q有序
    forn(i, L, R) node[i] = tmp[i];
}
 
inline void solve()
{
    Rd(n, K);
    forn(i, 1, n)
    {
        auto& [pos,R,_1,_2,q] = node[i];
        Rd(pos, R, q);
        t[++tot] = pos, t[++tot] = pos + R, t[++tot] = pos - R;
    }
    sortArr(t, tot), tot = disc(t, tot);
    forn(i, 1, tot) mp[t[i]] = i;
    //离散化
    forn(i, 1, n)
    {
        auto& [pos,R,l,r,q] = node[i];
        l = mp[node[i].pos - node[i].R];
        r = mp[node[i].pos + node[i].R];
        pos = mp[node[i].pos];
    }
    stable_sort(node + 1, node + n + 1, cmpLen);
    cdq(1, n);
    cout << ans;
}
 
signed int main()
{
    Spider
    //------------------------------------------------------
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test) solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
}
最终时间复杂度显然为 O(nlog2⁡n)，第二支 log 准确一点应该为log⁡3n
posted @   Athanasy  阅读(55)  评论(0)  编辑  收藏  举报
相关博文：
·  CF455D Serega and Fun 题解
·  CF911G Mass Change Queries 题解
·  CF1045G 题解
·  【做题记录】CF1045G AI robots
·  零些做过的题
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
· 如何调用 DeepSeek 的自然语言处理 API 接口并集成到在线客服系统
点击右上角即可分享
微信分享提示
SQL AI 助手