📌  相关文章
📜  二进制数组范围查询以找到两个零之间的最小距离

📅  最后修改于: 2021-05-17 23:18:32             🧑  作者: Mango

先决条件:段树
给定一个仅由0和1组成的二进制数组arr []和由K个查询组成的2D数组Q [] [] ,任务是在以下范围内找到两个0之间的最小距离:每个查询{L,R}。

例子:

方法:想法是使用段树来解决此问题:

  1. 段树中的每个节点将具有最左0和最右0的索引,以及一个整数,其中包含子数组{L,R}中0之间的最小距离。
  2. 令min为两个零之间的最小距离。然后,在形成分段树之后,可以找到min的值,如下所示:
    min =最小值(左侧节点中的min值,右侧节点中的min值,以及右侧节点中最左边的索引0和左侧节点中最右边的索引0之间的差)。
  3. 在计算并存储了每个节点的最小距离之后,所有查询都可以以对数时间回答。

下面是上述方法的实现:

C++
// C++ program to find the minimum
// distance between two elements
// with value 0 within a subarray (l, r)
 
#include 
using namespace std;
 
// Structure for each node
// in the segment tree
struct node {
    int l0, r0;
    int min0;
} seg[100001];
 
// A utility function for
// merging two nodes
node task(node l, node r)
{
    node x;
 
    x.l0 = (l.l0 != -1) ? l.l0 : r.l0;
 
    x.r0 = (r.r0 != -1) ? r.r0 : l.r0;
 
    x.min0 = min(l.min0, r.min0);
 
    // If both the nodes are valid
    if (l.r0 != -1 && r.l0 != -1)
 
        // Computing the minimum distance to store
        // in the segment tree
        x.min0 = min(x.min0, r.l0 - l.r0);
 
    return x;
}
 
// A recursive function that constructs
// Segment Tree for given string
void build(int qs, int qe, int ind, int arr[])
{
    // If start is equal to end then
    // insert the array element
    if (qs == qe) {
 
        if (arr[qs] == 0) {
            seg[ind].l0 = seg[ind].r0 = qs;
            seg[ind].min0 = INT_MAX;
        }
 
        else {
            seg[ind].l0 = seg[ind].r0 = -1;
            seg[ind].min0 = INT_MAX;
        }
 
        return;
    }
 
    int mid = (qs + qe) >> 1;
 
    // Build the segment tree
    // for range qs to mid
    build(qs, mid, ind << 1, arr);
 
    // Build the segment tree
    // for range mid+1 to qe
    build(mid + 1, qe, ind << 1 | 1, arr);
 
    // Merge the two child nodes
    // to obtain the parent node
    seg[ind] = task(seg[ind << 1],
                    seg[ind << 1 | 1]);
}
 
// Query in a range qs to qe
node query(int qs, int qe, int ns, int ne, int ind)
{
    node x;
    x.l0 = x.r0 = -1;
    x.min0 = INT_MAX;
 
    // If the range lies in this segment
    if (qs <= ns && qe >= ne)
        return seg[ind];
 
    // If the range is out of the bounds
    // of this segment
    if (ne < qs || ns > qe || ns > ne)
        return x;
 
    // Else query for the right and left
    // child node of this subtree
    // and merge them
    int mid = (ns + ne) >> 1;
 
    node l = query(qs, qe, ns, mid, ind << 1);
    node r = query(qs, qe, mid + 1, ne, ind << 1 | 1);
 
    x = task(l, r);
    return x;
}
 
// Driver code
int main()
{
 
    int arr[] = { 1, 1, 0, 1, 0, 1,
                0, 1, 0, 1, 0, 1, 1, 0 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Build the segment tree
    build(0, n - 1, 1, arr);
 
    // Queries
    int Q[][2] = { { 3, 9 }, { 10, 13 } };
 
    for (int i = 0; i < 2; i++) {
 
// Finding the answer for every query
// and printing it
        node ans = query(Q[i][0], Q[i][1],
                        0, n - 1, 1);
 
        cout << ans.min0 << endl;
    }
 
    return 0;
}


Java
// Java program to find the minimum
// distance between two elements
// with value 0 within a subarray (l, r)
class GFG{
 
// Structure for each Node
// in the segment tree
static class Node
{
    int l0, r0;
    int min0;
};
 
static Node[] seg = new Node[100001];
 
// A utility function for
// merging two Nodes
static Node task(Node l, Node r)
{
    Node x = new Node();
 
    x.l0 = (l.l0 != -1) ? l.l0 : r.l0;
 
    x.r0 = (r.r0 != -1) ? r.r0 : l.r0;
 
    x.min0 = Math.min(l.min0, r.min0);
 
    // If both the Nodes are valid
    if (l.r0 != -1 && r.l0 != -1)
 
        // Computing the minimum distance to store
        // in the segment tree
        x.min0 = Math.min(x.min0, r.l0 - l.r0);
 
    return x;
}
 
// A recursive function that constructs
// Segment Tree for given string
static void build(int qs, int qe,
                  int ind, int arr[])
{
     
    // If start is equal to end then
    // insert the array element
    if (qs == qe)
    {
        if (arr[qs] == 0)
        {
            seg[ind].l0 = seg[ind].r0 = qs;
            seg[ind].min0 = Integer.MAX_VALUE;
        }
 
        else
        {
            seg[ind].l0 = seg[ind].r0 = -1;
            seg[ind].min0 = Integer.MAX_VALUE;
        }
        return;
    }
 
    int mid = (qs + qe) >> 1;
 
    // Build the segment tree
    // for range qs to mid
    build(qs, mid, ind << 1, arr);
 
    // Build the segment tree
    // for range mid+1 to qe
    build(mid + 1, qe, ind << 1 | 1, arr);
 
    // Merge the two child Nodes
    // to obtain the parent Node
    seg[ind] = task(seg[ind << 1],
                    seg[ind << 1 | 1]);
}
 
// Query in a range qs to qe
static Node query(int qs, int qe, int ns,
                  int ne, int ind)
{
    Node x = new Node();
    x.l0 = x.r0 = -1;
    x.min0 = Integer.MAX_VALUE;
 
    // If the range lies in this segment
    if (qs <= ns && qe >= ne)
        return seg[ind];
 
    // If the range is out of the bounds
    // of this segment
    if (ne < qs || ns > qe || ns > ne)
        return x;
 
    // Else query for the right and left
    // child Node of this subtree
    // and merge them
    int mid = (ns + ne) >> 1;
 
    Node l = query(qs, qe, ns, mid,
                          ind << 1);
    Node r = query(qs, qe, mid + 1,
                  ne, ind << 1 | 1);
 
    x = task(l, r);
    return x;
}
 
// Driver code
public static void main(String[] args)
{
    for(int i = 0; i < 100001; i++)
    {
        seg[i] = new Node();
    }
 
    int arr[] = { 1, 1, 0, 1, 0, 1, 0,
                  1, 0, 1, 0, 1, 1, 0 };
 
    int n = arr.length;
 
    // Build the segment tree
    build(0, n - 1, 1, arr);
 
    // Queries
    int[][] Q = { { 3, 9 }, { 10, 13 } };
 
    for(int i = 0; i < 2; i++)
    {
         
        // Finding the answer for every query
        // and printing it
        Node ans = query(Q[i][0], Q[i][1],
                         0, n - 1, 1);
 
        System.out.println(ans.min0);
    }
}
}
 
// This code is contributed by sanjeev2552


Python3
# Python3 program to find the minimum
# distance between two elements with
# value 0 within a subarray (l, r)
import sys
  
# Structure for each node
# in the segment tree
class node():
     
    def __init__(self):
         
        self.l0 = 0
        self.r0 = 0
        min0 = 0
         
seg = [node() for i in range(100001)]
  
# A utility function for
# merging two nodes
def task(l, r):
     
    x = node()
       
    x.l0 = l.l0 if (l.l0 != -1) else r.l0
    x.r0 = r.r0 if (r.r0 != -1)  else l.r0
  
    x.min0 = min(l.min0, r.min0)
  
    # If both the nodes are valid
    if (l.r0 != -1 and r.l0 != -1):
  
        # Computing the minimum distance to
        # store in the segment tree
        x.min0 = min(x.min0, r.l0 - l.r0)
  
    return x
  
# A recursive function that constructs
# Segment Tree for given string
def build(qs, qe, ind, arr):
  
    # If start is equal to end then
    # insert the array element
    if (qs == qe):
  
        if (arr[qs] == 0):
            seg[ind].l0 = seg[ind].r0 = qs
            seg[ind].min0 = sys.maxsize
             
        else:
            seg[ind].l0 = seg[ind].r0 = -1
            seg[ind].min0 = sys.maxsize
  
        return
  
    mid = (qs + qe) >> 1
     
    # Build the segment tree
    # for range qs to mid
    build(qs, mid, ind << 1, arr)
  
    # Build the segment tree
    # for range mid+1 to qe
    build(mid + 1, qe, ind << 1 | 1, arr)
  
    # Merge the two child nodes
    # to obtain the parent node
    seg[ind] = task(seg[ind << 1],
                    seg[ind << 1 | 1])
                     
# Query in a range qs to qe
def query(qs, qe, ns, ne, ind):
  
    x = node()
    x.l0 = x.r0 = -1
    x.min0 = sys.maxsize
  
    # If the range lies in this segment
    if (qs <= ns and qe >= ne):
        return seg[ind]
  
    # If the range is out of the bounds
    # of this segment
    if (ne < qs or ns > qe or ns > ne):
        return x
  
    # Else query for the right and left
    # child node of this subtree
    # and merge them
    mid = (ns + ne) >> 1
  
    l = query(qs, qe, ns, mid, ind << 1)
    r = query(qs, qe, mid + 1, ne, ind << 1 | 1)
  
    x = task(l, r)
     
    return x
 
# Driver code 
if __name__=="__main__":
     
    arr = [ 1, 1, 0, 1, 0, 1, 0,
            1, 0, 1, 0, 1, 1, 0 ]
  
    n = len(arr)
  
    # Build the segment tree
    build(0, n - 1, 1, arr)
     
    # Queries
    Q = [ [ 3, 9 ], [ 10, 13 ] ]
     
    for i in range(2):
  
        # Finding the answer for every query
        # and printing it
        ans = query(Q[i][0], Q[i][1], 0,
                    n - 1, 1)
         
        print(ans.min0)
 
# This code is contributed by rutvik_56


输出:

2
3