If you are not using PBDS, then I think you have to use Coordinate Compression in order to use values as indexes as Array elements can go upto `1e9`. At least this is how I did it. Also I think deciding which values to compress is something to think about here. I will explain a bit.

  (A[i] − A[j] + c) <= (B[i] − B[j] + d)
=> (A[i] - B[i]) + c <= (A[j] - B[j]) + d
=> A[i] + c <= A[j] + d         // A[i] := A[i] - B[i]
=> A[i] + (c - d) <= A[j];

So the values we are going to compress should be all the `A[i]` values and `A[i] + (c - d)` values, because these are the only values which will be compared against one another. So basically 2*N number of values. It's reasonable and works.

Since the official solution only has pseudo code, I will leave my solution with (Fenwick Tree + Coordinate Compression)
 

#include <bits/stdc++.h>
using namespace std;

template <class T>
struct CoordinateCompression {
public:
    int n;
    vector<T> helper, compressed;

    CoordinateCompression(vector<T>& v) : helper(v), compressed(v) {
        n = static_cast<int>(v.size());
        sort(helper.begin(), helper.end());
        helper.resize(unique(helper.begin(), helper.end()) - helper.begin());
        for (int i = 0; i < n; ++i) {
            compressed[i] = lower_bound(helper.begin(), helper.end(), compressed[i]) - helper.begin();
        }
    }

    T& operator[](int index) {  // returns compressed value
        assert(index >= 0 and index < n);
        return compressed[index];
    }

    T& at(int index) {  // returns original value before compression
        assert(index >= 0 and index < n);
        return helper[compressed[index]];
    }
};

template <typename T, class F = function<T(const T&, const T&)>>
struct FenwickTree {
public:
    int n;
    F merge;
    vector<T> bit;

    FenwickTree() {}

    FenwickTree(int n, const F& f) : n(n), merge(f), bit(n, T(0)) {}

    void init(vector<T>& array, const F& f) {
        this->n = static_cast<int>(array.size());
        this->merge = f;
        bit.resize(n, T(0));
        for (int i = 0; i < n; ++i) {
            add(i, array[i]);
        }
    }

    FenwickTree(vector<T>& array, const F& f) {
        this->n = static_cast<int>(array.size());
        this->merge = f;
        bit.resize(n, T(0));
        for (int i = 0; i < n; ++i) {
            add(i, array[i]);
        }
    }

    void add(int index, T delta) {
        while (index < n) {
            bit[index] = merge(bit[index], delta);
            index = index | (index + 1);
        }
    }

    T get(int index) {
        T sum = 0;
        while (index >= 0) {
            sum = merge(sum, bit[index]);
            index = (index & (index + 1)) - 1;
        }
        return sum;
    }

    T get(int l, int r) {
        T ans = get(r);
        if (l >= 1) ans -= get(l - 1);
        return ans;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t;
    cin >> t;
    while (t--) {
        int n, c, d;
        cin >> n >> c >> d;
        vector<int> A(n);
        for (auto& e : A) cin >> e;
        for (int i = 0; i < n; ++i) {
            int B;
            cin >> B;
            A[i] -= B;
        }
        long long ans = 0;
        c = c - d;
        vector<int> nums = A;
        for (int i = 0; i < n; ++i) {
            nums.push_back(A[i] + c);
        }
        unordered_map<int, int> mp;
        for (int i = 0; i < ((int) nums.size()); ++i) {
            mp[nums[i]] = i;
        }
        CoordinateCompression<int> ccp(nums);
        int z = mp.size() + 2;
        FenwickTree<int> ft(z, [&](int x, int y) { return x + y; });
        for (int i = n - 1; i >= 0; --i) {
            int num = A[i] + c;
            int comp = ccp[mp[num]];
            ans += ft.get(comp, z - 1);
            int comp2 = ccp[mp[A[i]]];
            ft.add(comp2, 1);
        }
        cout << ans << '\n';
    }
}