找到一个数组 B，其中 B 中的至少 arr[i] 个元素不等于 B[i]

给定一个大小为N的数组arr[] ，任务是找到一个大小为N的数组，使得对于数组arr[]的每个第 i^个元素，输出数组应至少包含arr[i]元素等于输出数组的第 i^个元素。如果不存在这样的数组，则打印“ Impossible ”。

例子：

Input: N = 5, arr[] = {4, 4, 4, 4, 4}
Output: 1 2 3 4 5

Input: N = 10, arr[] = {7, 7, 7, 7, 7, 9, 8, 8, 7, 9}
Output: 4 4 4 5 5 1 3 3 5 2

方法：给定的问题可以基于以下观察来解决：应该有最多N-arr[i]个元素等于输出数组的第 i^个元素。请按照以下步骤解决问题：

• 初始化一个数组，比如大小为N+5的res[] ，以存储输出数组。
• 此外，初始化一个对数组，比如大小为N+5 的 V，其中V[i]存储元素计数等于res[i]和索引i 的对。
• 使用变量i在[1, N]范围内迭代，并在每次迭代中将{N-arr[i], i}对的值赋给V[i]。
• 按升序对对数组进行排序。
• 初始化两个变量，比如l和r为0来遍历数组。
• 使用变量l迭代范围[0, N-1]并执行以下步骤：  
  • 使用变量r遍历范围[l, N-1]并执行以下操作：
    • 如果V[r + 1].first不等于V[r]。首先，然后打破循环。
  • 如果相同元素的计数，即(r-l+1)不能被V[l].first整除，则打印“ Impossible ”并返回。
  • 初始化一个变量，比如X ，为1以将值分配给数组res[]。
  • 使用变量i迭代范围[l, r]并执行以下步骤：
    • 使用变量j迭代范围[i, i+V[l].first] ，然后在每次迭代中将X分配给res[V[j].second] 。
    • i增加V[l].first和X增加1 。
  • 将l的值更新为r+1 。
• 最后，完成以上步骤后，打印数组， res[]。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the possible
// output array
void findPossibleArray(int N, int arr[])
{
    pair V[N + 5];
 
    // Stores the output array
    int res[N + 5];
 
    int cnt = 0;
    // Iterate over the range [1, N]
    for (int i = 0; i < N; i++) {
        // Update V[i]
        V[i].first = N - arr[i];
        V[i].second = i;
    }
 
    // Sort the the array
    sort(V, V + N);
 
    // Iterate in the range [1, N]
    for (int l = 0, r = 0; l < N; l = r + 1) {
 
        // Iterate until r is less than N
        for (r = l; r < N - 1; ++r) {
 
            // If V[i+1].first is equal to
            // V[r].first
            if (V[r + 1].first != V[r].first) {
                break;
            }
        }
 
        // If r-l+1 is divisible by V[i].first
        if ((r - l + 1) % V[l].first) {
            cout << "Impossible" << endl;
            return;
        }
 
        // Otherwise,
        for (int i = l; i <= r; i += V[l].first) {
            cnt++;
            // Traverse the array over the range
            // [i, i+V[l].second]
            for (int j = i; j < i + V[l].first && j < N;
                 ++j)
                res[V[j].second] = cnt;
        }
    }
 
    // Print the array res[]
    for (int i = 0; i < N; i++)
        cout << res[i] << ' ';
}
 
// Driver Code
int main()
{
 
    int arr[] = { 4, 4, 4, 4, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    findPossibleArray(N, arr);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.Arrays;
 
class GFG {
 
    // Function to find the possible
    // output array
    public static void findPossibleArray(int N, int arr[]) {
        int[][] V = new int[N][2];
 
        // Stores the output array
        int[] res = new int[N + 5];
 
        int cnt = 0;
        // Iterate over the range [1, N]
        for (int i = 0; i < N; i++) {
            // Update V[i]
            V[i][0] = N - arr[i];
            V[i][1] = i;
        }
 
        // Sort the the array
        Arrays.sort(V, (a, b) -> a[0] - b[0]);
 
        // Iterate in the range [1, N]
        for (int l = 0, r = 0; l < N; l = r + 1) {
 
            // Iterate until r is less than N
            for (r = l; r < N - 1; ++r) {
 
                // If V[i+1][0] is equal to
                // V[r][0]
                if (V[r + 1][0] != V[r][0]) {
                    break;
                }
            }
 
 
            // If r-l+1 is divisible by V[i][0]
            if (V[l][0] == 0 || ((r - l + 1) % V[l][0]) > 0) {
                System.out.println("Impossible");
                return;
            }
 
            // Otherwise,
            for (int i = l; i <= r; i += V[l][0]) {
                cnt++;
                // Traverse the array over the range
                // [i, i+V[l][1]]
                for (int j = i; j < i + V[l][0] && j < N; ++j)
                    res[V[j][1]] = cnt;
            }
        }
 
        // Print the array res[]
        for (int i : res) {
            if (i > 0) {
                System.out.print(i + " ");
            }
        }
    }
 
    // Driver Code
    public static void main(String args[]) {
 
        int arr[] = { 4, 4, 4, 4, 4 };
        int N = arr.length;
 
        findPossibleArray(N, arr);
    }
}
 
//This code is contributed by saurabh_jaiswal.

Javascript

// Javascript program for the above approach
 
// Function to find the possible
// output array
function findPossibleArray(N, arr)
{
    let V = new Array(N + 5).fill(0).map(() => new Array(2));
 
    // Stores the output array
    let res = new Array(N + 5);
 
    let cnt = 0;
     
    // Iterate over the range [1, N]
    for (let i = 0; i < N; i++)
    {
     
        // Update V[i]
        V[i][0] = N - arr[i];
        V[i][1] = i;
    }
 
    // Sort the the array
    V.sort((a, b) => a[0] - b[0]);
 
    // Iterate in the range [1, N]
    for (let l = 0, r = 0; l < N; l = r + 1) {
 
        // Iterate until r is less than N
        for (r = l; r < N - 1; ++r) {
 
            // If V[i+1][0] is equal to
            // V[r][0]
            if (V[r + 1][0] != V[r][0]) {
                break;
            }
        }
 
        // If r-l+1 is divisible by V[i][0]
        if ((r - l + 1) % V[l][0]) {
            document.write("Impossible" + "<br>");
            return;
        }
 
        // Otherwise,
        for (let i = l; i <= r; i += V[l][0]) {
            cnt++;
            // Traverse the array over the range
            // [i, i+V[l][1]]
            for (let j = i; j < i + V[l][0] && j < N; ++j)
                res[V[j][1]] = cnt;
        }
    }
 
    // Print the array res[]
    for (let i = 0; i < N; i++)
        document.write(res[i] + ' ');
}
 
// Driver Code
let arr = [4, 4, 4, 4, 4];
let N = arr.length
 
findPossibleArray(N, arr);
 
// This code is contributed by _saurabh_jaiswal.

输出

1 2 3 4 5 

时间复杂度： O(N*log(N))
辅助空间： O(N)