给定一个长度为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.
方法：我们将使用广度优先搜索的概念来解决这个问题。
- 我们最初将假定给定的整数集作为根元素并将其推送到队列和哈希中。
- 然后对于任何元素，比如 X，我们将简单地检查是否遇到 (X-1) 或 (X+1) 或不使用哈希图。如果到目前为止还没有遇到它们中的任何一个，那么我们将该元素推送到我们的答案数组、队列和散列中。
- 重复这个直到我们遇到 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 bgangwar59C#
// 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 输出：
-2 0 3
时间复杂度： O(M*log(M)) ，其中 M = N + K。