Construction of multiple AP Arrays

Given an array A[] of N integers, the task is to check if it is possible to construct several arrays (at least one) using all the elements of the array A[] such that in each array, the value of each element is equal to the number of elements to its left.

Examples:

Input: N = 9, A[] = {0, 0, 0, 0, 1, 1, 1, 2, 2}
Output: YES
Explanation: The array A[] can be divided into 4 arrays as follows –

• {0,1,2} -> 1st element (0) has 0 elements to its left, 2nd element (1) has 1 element to its left and 3rd element (2) has 2 elements to its left
• {0,1} -> 1st element (0) has 0 elements to its left and 2nd element (1) has 1 element to its left
• {0,1,2} -> 1st element (0) has 0 elements to its left, 2nd element (1) has 1 element to its left and 3rd element (2) has 2 elements to its left
• {0} -> 1st element (0) has 0 elements to its left

Input: N = 3, A[] = {0, 0, 2}
Output: NO

Approach: To solve the problem follow the below observations:

Observation:

• The problem can be rephrased as ” Is it possible to divide input array in Arithmetic Progressions each having the first digit 0 and a common difference equal to 1 “?
  • For each A.P., if an integer X is a part of it, then X-1 must also be there. So, in the whole sequence if X occurs “count” times, then X-1 must also occur at least count times.

Following is the code based on the above approach:

C++

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to Check if it is possible
// to construct several number
// of arrays from the given array
// satisfying the given condition
bool isPossible(int N, int A[])
{

    // Initialize flag variable to
    // store the answer
    bool flag = true;

    // Initializing an unordered_map to
    // store frequency of each element
    unordered_map<int, int> mp;

    // Iterating through the array
    for (int i = 0; i < N; i++) {
        // If the current element is less
        // than N, increment
        // its frequency in map
        if (A[i] < N) {
            mp[A[i]]++;
        }

        // Else, make the value of flag = false
        // (as there can never be more than
        // N elements before any
        // element in the array)
        else {
            flag = false;
        }
    }

    // Iterate from 1 to N and check the
    // required condition
    for (int i = 1; i <= N; i++) {
        if (mp[i] > mp[i - 1]) {
            flag = false;
            break;
        }
    }

    return flag;
}

// Driver code
int main()
{
    int N = 9;
    int A[] = { 0, 0, 0, 0, 1, 1, 1, 2, 2 };

    // Function Call
    int answer = isPossible(N, A);
    if (answer == 1) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
}

Java

import java.util.HashMap;

public class GFG {

    // Function to Check if it is possible
    // to construct several number
    // of arrays from the given array
    static boolean isPossible(int N, int[] A) {

        // Initialize flag variable to
        // store the answer
        boolean flag = true;

        // Initializing a HashMap to
        // store frequency of each element
        HashMap<Integer, Integer> map = new HashMap<>();

        // Iterating through the array
        for (int i = 0; i < N; i++) {
            // If the current element is less
            // than N, increment
            // its frequency in the map
            if (A[i] < N) {
                map.put(A[i], map.getOrDefault(A[i], 0) + 1);
            }

            // Else, make the value of flag = false
            // (as there can never be more than
            // N elements before any
            // element in the array)
            else {
                flag = false;
            }
        }

        // Iterate from 1 to N and check the
        // required condition
        for (int i = 1; i <= N; i++) {
            if (map.getOrDefault(i, 0) > map.getOrDefault(i - 1, 0)) {
                flag = false;
                break;
            }
        }

        return flag;
    }

    // Driver code
    public static void main(String[] args) {
        int N = 9;
        int[] A = { 0, 0, 0, 0, 1, 1, 1, 2, 2 };

        // Function Call
        boolean answer = isPossible(N, A);
        if (answer) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

Python3

# Python code for the above approach

# Function to Check if it is possible
# to construct several number
# of arrays from the given array
# satisfying the given condition
def isPossible(N, A):
    # Initialize flag variable to
    # store the answer
    flag = True

    # Initializing a dictionary to
    # store frequency of each element
    mp = {}

    # Iterating through the array
    for i in range(N):
        # If the current element is less
        # than N, increment
        # its frequency in the dictionary
        if A[i] < N:
            if A[i] in mp:
                mp[A[i]] += 1
            else:
                mp[A[i]] = 1
        # Else, make the value of flag = false
        # (as there can never be more than
        # N elements before any
        # element in the array)
        else:
            flag = False

    # Iterate from 1 to N and check the
    # required condition
    for i in range(1, N + 1):
        if i in mp and mp[i] > mp.get(i - 1, 0):
            flag = False
            break

    return flag

# Driver code
N = 9
A = [0, 0, 0, 0, 1, 1, 1, 2, 2]

# Function Call
answer = isPossible(N, A)
if answer:
    print("YES")
else:
    print("NO")

# this code is contributed by uttamdp_10

C#

using System;
using System.Collections.Generic;

class GFG {
    // Function to Check if it is possible
    // to construct several number
    // of arrays from the given array
    static bool IsPossible(int N, int[] A)
    {
        // Initialize flag variable to
        // store the answer
        bool flag = true;

        // Initializing a Dictionary to
        // store frequency of each element
        Dictionary<int, int> map
            = new Dictionary<int, int>();

        // Iterating through the array
        for (int i = 0; i < N; i++) {
            // If the current element is less
            // than N, increment
            // its frequency in the dictionary
            if (A[i] < N) {
                if (map.ContainsKey(A[i])) {
                    map[A[i]]++;
                }
                else {
                    map[A[i]] = 1;
                }
            }

            // Else, make the value of flag = false
            // (as there can never be more than
            // N elements before any
            // element in the array)
            else {
                flag = false;
            }
        }

        // Iterate from 1 to N and check the
        // required condition
        for (int i = 1; i <= N; i++) {
            if (map.TryGetValue(i, out int countI)
                && map.TryGetValue(i - 1,
                                   out int countPrev)) {
                if (countI > countPrev) {
                    flag = false;
                    break;
                }
            }
        }

        return flag;
    }

    // Driver code
    public static void Main(string[] args)
    {
        int N = 9;
        int[] A = { 0, 0, 0, 0, 1, 1, 1, 2, 2 };

        // Function Call
        bool answer = IsPossible(N, A);
        if (answer) {
            Console.WriteLine("YES");
        }
        else {
            Console.WriteLine("NO");
        }
    }
}

Javascript

// Added by: Nikunj Sonigara

// Function to check if it's possible to create an array of length N
// with values ranging from 0 to N-1 using the input array A.
function isPossible(N, A) {
    // Initialize a flag as true to assume it's possible.
    let flag = true;
    // Create a Map to store counts of each element.
    const map = new Map();

    // Loop through the input array A.
    for (let i = 0; i < N; i++) {
        if (A[i] < N) {
            // Update the count of A[i] in the map.
            map.set(A[i], (map.get(A[i]) || 0) + 1);
        } else {
            // If any element in A is greater than or equal to N, set flag to false.
            flag = false;
        }
    }

    // Loop through numbers from 1 to N and check if their counts are non-decreasing.
    for (let i = 1; i <= N; i++) {
        if ((map.get(i) || 0) > (map.get(i - 1) || 0)) {
            // If counts are not non-decreasing, set flag to false.
            flag = false;
            // Exit the loop.
            break;
        }
    }
    // Return the final flag indicating if it's possible.
    return flag;
}

// Test input values
const N = 9;
const A = [0, 0, 0, 0, 1, 1, 1, 2, 2];

// Call the isPossible function with the test input and print "YES" or "NO" accordingly.
const answer = isPossible(N, A);
if (answer) {
    console.log("YES");
} else {
    console.log("NO");
}

Output

YES

Time Complexity: O(N).
Auxiliary Space: O(N)