使用 BFS 找到距给定整数集最小距离的积分点

给定一个长度为N的整数数组A[]和一个整数K 。任务是找到给定数组中不存在的K 个不同的积分点，使得它们与A[] 中最近点的距离之和最小。

An integral point is defined as the point with both the coordinates as integers. Also, in the x-axis, we don’t need to consider y-coordinate because y-coordinated of all the points is equal to zero.

例子：

Input: A[] = { -1, 4, 6 }, K = 3 
Output: -2, 0, 3 
Explanation: 
Nearest point for -2 in A[] is -1 -> distance = 1 
Nearest point for 0 in A[] is -1 -> distance = 1 
Nearest point for 3 in A[] is 4 -> distance = 1 
Total distance = 1 + 1 + 1 = 3 which is minimum possible distance. 
Other results are also possible with the same minimum distance.
Input: A[] = { 0, 1, 3, 4 }, K = 5 
Output: -1, 2, 5, -2, 6 
Explanation: 
Nearest point for -1 in A[] is 0 -> distance = 1 
Nearest point for 2 in A[] is 3 -> distance = 1 
Nearest point for 5 in A[] is 4 -> distance = 1 
Nearest point for -2 in A[] is 0 -> distance = 2 
Nearest point for 6 in A[] is 4 -> distance = 2 
Total distance = 2 + 1 + 1 + 1 + 2 = 7 which is minimum possible distance.

方法：我们将使用广度优先搜索的概念来解决这个问题。

1. 我们最初将假定给定的整数集作为根元素并将其推送到队列和哈希中。
2. 然后对于任何元素，比如 X，我们将简单地检查是否遇到 (X-1) 或 (X+1) 或不使用哈希图。如果到目前为止还没有遇到它们中的任何一个，那么我们将该元素推送到我们的答案数组、队列和散列中。
3. 重复这个直到我们遇到 K 个新元素。

下面是上述方法的实现。

C++

// C++ implementation of above approach
 
#include 
using namespace std;
 
// Function to find points at
// minimum distance
void minDistancePoints(int A[],
                      int K,
                      int n)
{
 
    // Hash to store points
    // that are encountered
    map m;
 
    // Queue to store initial
    // set of points
    queue q;
 
    for (int i = 0; i < n; ++i) {
        m[A[i]] = 1;
        q.push(A[i]);
    }
 
    // Vector to store integral
    // points
    vector ans;
 
    // Using bfs to visit nearest
    // points from already
    // visited points
    while (K > 0) {
 
        // Get first element from
        // queue
        int x = q.front();
        q.pop();
 
        // Check if (x-1) is not
        // encountered so far
        if (!m[x - 1] && K > 0) {
            // Update hash with
            // this new element
            m[x - 1] = 1;
 
            // Insert (x-1) into
            // queue
            q.push(x - 1);
 
            // Push (x-1) as
            // new element
            ans.push_back(x - 1);
 
            // Decrement counter
            // by 1
            K--;
        }
 
        // Check if (x+1) is not
        // encountered so far
        if (!m[x + 1] && K > 0) {
            // Update hash with
            // this new element
            m[x + 1] = 1;
 
            // Insert (x+1) into
            // queue
            q.push(x + 1);
 
            // Push (x+1) as
            // new element
            ans.push_back(x + 1);
 
            // Decrement counter
            // by 1
            K--;
        }
    }
 
    // Print result array
    for (auto i : ans)
        cout << i << " ";
}
 
// Driver code
int main()
{
 
    int A[] = { -1, 4, 6 };
    int K = 3;
    int n = sizeof(A) / sizeof(A[0]);
 
    minDistancePoints(A, K, n);
 
    return 0;
}

Java

// Java implementation of above approach
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
 
class Geeks{
     
// Function to find points at
// minimum distance
static void minDistancePoints(int A[],
                              int K, int n)
{
     
    // Hash to store points
    // that are encountered
    Map m = new HashMap();
 
    // Queue to store initial
    // set of points
    Queue q = new LinkedList();
 
    for(int i = 0; i < n; ++i)
    {
        m.put(A[i], true);
        q.add(A[i]);
    }
 
    // List to store integral
    // points
    LinkedList ans = new LinkedList();
 
    // Using bfs to visit nearest
    // points from already
    // visited points
    while (K > 0)
    {
         
        // Get first element from
        // queue
        int x = q.poll();
 
        // Check if (x-1) is not
        // encountered so far
        if (!m.containsKey(x - 1) && K > 0)
        {
             
            // Update hash with
            // this new element
            m.put(x - 1, true);
 
            // Insert (x-1) into
            // queue
            q.add(x - 1);
 
            // Push (x-1) as
            // new element
            ans.add(x - 1);
 
            // Decrement counter
            // by 1
            K--;
        }
 
        // Check if (x+1) is not
        // encountered so far
        if (!m.containsKey(x + 1) && K > 0)
        {
             
            // Update hash with
            // this new element
            m.put(x + 1, true);
 
            // Insert (x+1) into
            // queue
            q.add(x + 1);
 
            // Push (x+1) as
            // new element
            ans.add(x + 1);
 
            // Decrement counter
            // by 1
            K--;
        }
    }
 
    // Print result array
    for(Integer i : ans)
        System.out.print(i + " ");
}
 
// Driver code
public static void main(String[] args)
{
    int A[] = new int[] { -1, 4, 6 };
    int K = 3;
    int n = A.length;
     
    minDistancePoints(A, K, n);
}
}
 
// This code is contributed by Rajnis09

Python3

# Python 3 implementation
# of above approach
 
# Function to find points
# at minimum distance
def minDistancePoints(A, K, n):
   
    # Hash to store points
    # that are encountered
    m = {}
 
    # Queue to store initial
    # set of points
    q = []
 
    for i in range(n):
        m[A[i]] = 1
        q.append(A[i])
 
    # Vector to store
    # integral points
    ans = []
 
    # Using bfs to visit nearest
    # points from already
    # visited points
    while (K > 0):
       
        # Get first element from
        # queue
        x = q[0]
        q = q[1::]
 
        # Check if (x-1) is not
        # encountered so far
        if ((x - 1) not in m and
             K > 0):
           
            # Update hash with
            # this new element
            m[x - 1] = m.get(x - 1, 0) + 1
 
            # Insert (x-1) into
            # queue
            q.append(x - 1)
 
            # Push (x-1) as
            # new element
            ans.append(x - 1)
 
            # Decrement counter
            # by 1
            K -= 1
 
        # Check if (x+1) is not
        # encountered so far
        if ((x + 1) not in m and
             K > 0):
            # Update hash with
            # this new element
            m[x + 1] = m.get(x + 1, 0) + 1
 
            # Insert (x+1) into
            # queue
            q.append(x + 1)
 
            # Push (x+1) as
            # new element
            ans.append(x + 1)
            # Decrement counter
            # by 1
            K -= 1
 
    # Print result array
    for i in ans:
        print(i, end = " ")
 
# Driver code
if __name__ == '__main__':
   
    A =  [-1, 4, 6]
    K = 3
    n =  len(A)
    minDistancePoints(A, K, n)
 
# This code is contributed by bgangwar59

C#

// C# implementation of above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to find points at
// minimum distance
static void minDistancePoints(int []A,
                              int K, int n)
{
     
    // Hash to store points
    // that are encountered
    Dictionary m = new Dictionary();
 
    // Queue to store initial
    // set of points
    Queue q = new Queue();
 
    for(int i = 0; i < n; ++i)
    {
        m.Add(A[i], true);
        q.Enqueue(A[i]);
    }
 
    // List to store integral
    // points
    List ans = new List();
 
    // Using bfs to visit nearest
    // points from already
    // visited points
    while (K > 0)
    {
         
        // Get first element from
        // queue
        int x = q.Dequeue();
 
        // Check if (x-1) is not
        // encountered so far
        if (!m.ContainsKey(x - 1) && K > 0)
        {
             
            // Update hash with
            // this new element
            m.Add(x - 1, true);
 
            // Insert (x-1) into
            // queue
            q.Enqueue(x - 1);
 
            // Push (x-1) as
            // new element
            ans.Add(x - 1);
 
            // Decrement counter
            // by 1
            K--;
        }
 
        // Check if (x+1) is not
        // encountered so far
        if (!m.ContainsKey(x + 1) && K > 0)
        {
             
            // Update hash with
            // this new element
            m.Add(x + 1, true);
 
            // Insert (x+1) into
            // queue
            q.Enqueue(x + 1);
 
            // Push (x+1) as
            // new element
            ans.Add(x + 1);
 
            // Decrement counter
            // by 1
            K--;
        }
    }
 
    // Print result array
    foreach(int i in ans)
        Console.Write(i + " ");
}
 
// Driver code
public static void Main(String[] args)
{
    int []A = new int[] { -1, 4, 6 };
    int K = 3;
    int n = A.Length;
     
    minDistancePoints(A, K, n);
}
}
 
// This code is contributed by Amit Katiyar

Javascript

    // Javascript implementation of above approach
     
    // Function to find points at
    // minimum distance
    function minDistancePoints(A, K, n)
    {
 
        // Hash to store points
        // that are encountered
        let m = new Map();
 
        // Queue to store initial
        // set of points
        let q = [];
 
        for(let i = 0; i < n; ++i)
        {
            m.set(A[i], true);
            q.push(A[i]);
        }
 
        // List to store integral
        // points
        let ans = [];
 
        // Using bfs to visit nearest
        // points from already
        // visited points
        while (K > 0)
        {
 
            // Get first element from
            // queue
            let x = q.shift();
 
            // Check if (x-1) is not
            // encountered so far
            if (!m.has(x - 1) && K > 0)
            {
 
                // Update hash with
                // this new element
                m.set(x - 1, true);
 
                // Insert (x-1) into
                // queue
                q.push(x - 1);
 
                // Push (x-1) as
                // new element
                ans.push(x - 1);
 
                // Decrement counter
                // by 1
                K--;
            }
 
            // Check if (x+1) is not
            // encountered so far
            if (!m.has(x + 1) && K > 0)
            {
 
                // Update hash with
                // this new element
                m.set(x + 1, true);
 
                // Insert (x+1) into
                // queue
                q.push(x + 1);
 
                // Push (x+1) as
                // new element
                ans.push(x + 1);
 
                // Decrement counter
                // by 1
                K--;
            }
        }
 
        // Print result array
        for(let i = 0; i < ans.length; i++)
            document.write(ans[i] + " ");
    }
     
    let A = [ -1, 4, 6 ];
    let K = 3;
    let n = A.length;
      
    minDistancePoints(A, K, n);
 
// This code is contributed by divyeshrabadiya07.

输出：

-2 0 3

时间复杂度： O(M*log(M)) ，其中 M = N + K。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。