Question

给出包含N个整数的数组A.您需要在阵列上运行Q查询。查询有两种类型。

1 U P：您需要将A _u的值更新为P。

2 L R P：您需要找到A _k，使得A _k - P最小，A _k＆gt; P和L＆lt; = k＆lt; = R

输入格式：

第一行输入包含一个整数N.下一行包含N个以空格分隔的整数，即数组A的元素。

下一行输入包含一个内部Q.

Q行跟随每个包含查询的语句。

输出格式：

对于类型2的查询，您需要打印A _k的值。如果没有这样的K打印-1。在新行中为每个查询打印答案。

Example Input:                               Example Output:
5                                            2
3 2 1 1 5                                    -1
3
2 1 5 1
1 4 4
2 1 4 5

说明：对于[1,5]和P = 1范围内的第一个查询，所需的A _k为2。

我正在考虑一个带有O（log（N））的分段树解决方案，用于查询类型2.但是无法弄清楚如何做。

Answer 1

让我们考虑上面的例子并在其上构建我们的算法。

所以我们的输入看起来像这样： -

Example Input:                               Example Output:
5                                            2
3 2 1 1 5                                    -1
3
2 1 5 1
1 4 4
2 1 4 5

现在我正在构建一个Segment树，它在(min, max)的每个节点上保留两个值，min对应于该范围内的最小值，max值对应于最大值在那个范围内。

现在，在运行上面示例的构建方法之后，我们的分段树将如下所示： -

                [0:4] (1,5)
              /             \
             /               \
        [0:2] (1,3)           [3:4] (1,5)
       /         \            /         \
      /           \          /           \
   [0:1] (2,3)   [2:2](1,1) [3:3](1,1)  [4:4](5,5)
  /       \
 /         \
[0:0](3,3)  [1:1](2,2)

因此，您可以在上面的细分树中看到，每个级别的每个节点如何在该区间内由(min, max)对组成。

现在让我们根据伪代码查看我们的更新查询。这很简单。

void update(int node, int start, int end, int idx, int val)
{
if(start == end)
{
    // Leaf node
    A[idx] = val;
    tree[node] = val;
}
else
{
    int mid = (start + end) / 2;
    if(start <= idx and idx <= mid)
    {
        // If idx is in the left child, recurse on the left child
        update(2*node, start, mid, idx, val);
    }
    else
    {
        // if idx is in the right child, recurse on the right child
        update(2*node+1, mid+1, end, idx, val);
    }
    // Internal node will have the min and max of both of its children
    tree[node] = pair(min(tree[2*node].min, tree[2*node+1].min), max(tree[2*node].max, tree[2*node+1].max);
}

}

更新非常清楚，我们只需要达到叶值并更新该索引处的值然后递归到顶部，我们将继续使用最小值和最大值更新其他节点。

更新查询的时间复杂度为O(logn)。

现在让我们来看看问题的主要组成部分，即查询问题的一部分。

因此我们的查询部分代码如下所示： -

// P here is the value for which our Ak > P and Ak - P shoudl be minimum
// l and r is our range provided in the input for each query
int query(int node, int start, int end, int l, int r, int P)
{
    // If the maximum element at this particular node of the tree is less than P,
    // then there is no point in going down as we need to find the element which is greater than P.
    if(tree[node].max < P) 
    {
      return -1;
    }
    if(r < start or end < l)
    {
        // range represented by a node is completely outside the given range
        return -1;
    }
    if(l<=start and end <= r and start==end) {
      return tree[node] - P;
    }
    // range represented by a node is partially inside and partially outside the given range
    int mid = (start + end) / 2;
    int p1 = query(2*node, start, mid, l, r);
    int p2 = query(2*node+1, mid+1, end, l, r);
    return min(p1 + p2);
}

我添加了尽可能多的评论，我可以在伪代码中，如果我犯了任何错误，请查看并告诉我。

希望这有帮助！

在给定的数组范围内找到最接近P的数字

1 个答案: