给定两个无序列表，查询 A[i] > a 和 B[i] > b 的元素个数

Posted 2023-02-19

【中文标题】给定两个无序列表，查询 A[i] > a 和 B[i] > b 的元素个数

【英文标题】：Query the count of elements for which A[i] > a and B[i] > b given two unordered lists

【发布时间】：2021-11-02 09:46:57

【问题描述】：

考虑两个数组 A 和 B。数组 A 中索引 i 处的元素与数组 B 中索引 i 处的元素相关联。我们可以将它们视为一对。我们有一些（a，b）形式的查询q。我们需要找到 A[i] > a 和 B[i] > b 的所有此类元素的计数。

Constraints - 
n (size of array) <= 10^5
q (count of queries) <= 10^5
 

Example - 
A = [1,  3, 6, 7, 2]
B = [10, 7, 2, 6, 4]
q = [(2, 6), (3, 9), (0, 1)]

Output - 
[1, 0, 5]

说明-

对于查询 (2, 6)，只有一个实体满足 A[i] > 2 和 B[i] > 6。对于第一个条件 A[i] > 2，我们有三个候选者 - 3, 6, 7 但基于第二个条件 B[i] > 6 对于这些候选者，只有一个答案是第一个数组 (3, 7) 中值为 3 的候选者。

我尝试过线性搜索的蛮力方法，但这会导致 TLE。

【问题讨论】：

A和B的最大值是多少？

在我的答案中添加了 Python 代码。

见range counting

【参考方案1】：

如果查询是离线提供的，则不需要四叉树，我们可以在O(n log n) 中解决这个问题。将所有查询对和数组对插入一个列表，按a 或A[i] 排序（如果a 等于A[i]，则将查询对放在数组对之后）。按降序处理列表中的对（A[i] 或 a）。如果是数组对，则将其插入到由B[i] 排序的排序统计树中。如果是查询，则在树中查找具有B[i] > b 的树节点（这些是数组对）的计数（我们已经知道树中的所有对都有A[i] > a）。

Python 代码：

# Order statistic treap

import random

class Treap:
  def __init__(self, val=None):
    self.val = val
    self.size = 1
    self.key = random.random()
    self.left = None
    self.right = None

  def __repr__(self):
    return str("val": self.val, "size": self.size, "key": self.key, "left": self.left, "right": self.right)

def size(t):
  return t.size if t else 0

def update(t):
  if t:
    t.size = 1 + size(t.left) + size(t.right)
  return t

def insert(t, node):
  if not t:
    return node

  # t above
  if node.key > t.key:
    if node.val > t.val:
      t.right = insert(t.right, node)
      return update(t)
    else:
      t.left = insert(t.left, node)
      return update(t)
  # node above
  else:
    if node.val > t.val:
      node.left = insert(node.left, t)
      return update(node)
    else:
      node.right = insert(node.right, t)
      return update(node)

def query(t, val):
  if not t:
    return 0

  if val < t.val:
    return 1 + size(t.right) + query(t.left, val)
  else:
    return query(t.right, val)


def merge_queries(lst, Q):
  result = [None] * (len(lst) + len(Q))

  i = 0
  j = 0

  for k in range(len(result)):
    if i < len(lst) and (j == len(Q) or lst[i][0] <= Q[j][0]):
      result[k] = lst[i]
      i += 1
    else:
      result[k] = Q[j]
      j += 1

  return result


def f(A, B, Q):
  sorted_zip = sorted(zip(A, B))
  sorted_queries = sorted([(a, b, i) for i, (a, b) in enumerate(Q)])
  merged = merge_queries(sorted_zip, sorted_queries)

  result = [None] * len(Q)
  tree = None

  for tpl in reversed(merged):
    if len(tpl) == 3:
      result[tpl[2]] = query(tree, tpl[1])
    else:
      tree = insert(tree, Treap(tpl[1]))

  return result


A = [1,  3, 6, 7, 2]
B = [10, 7, 2, 6, 4]
Q = [(2, 6), (3, 9), (0, 1)]

print(f(A, B, Q))

【参考方案2】：

使用四叉树 (https://en.m.wikipedia.org/wiki/Quadtree)，它可以在 log(len(q)) 时间内为您提供值 x 满足的 q 条件数 然后你可以在 len(A)*log(len(q)) 时间内解决你的问题

【讨论】：

您能详细说明一下吗？

从一个更简单的问题开始：L=(x0,x1,...xn] 是一个数字列表 E=((a0,b0),(a1,b1),...; (an,bn)] 是一组区间 使用en.wikipedia.org/wiki/Interval_tree 查找与 Ei 的 xi 交集的数量然后你的问题是这个问题的二维版本。