Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Check if given Array can be divided into subsequences of K increasing consecutive integers

Given an array arr[] of N integers and a positive integer K, the task is to check if it is possible to divide the array into increasing subsequences of K consecutive integers such each element can contribute in only a single subsequence.

Example:



Input: arr[] = {1, 2, 1, 3, 2, 3}, K = 3
Output: Yes
Explanation: The given array can be divided as {1, 2, 1, 3, 2, 3} => {1, 2, 3} and {1, 2, 1, 3, 2, 3} => {1, 2, 3}. Both subsequences have 3 consecutive integers in increasing order.

Input: arr[] = {4, 3, 1, 2}, K = 2
Output: No



 

Approach: The above problem can be solved using a Greedy Approach using Binary Search. It can be observed that for any integer arr[i], the most optimal choice is to choose the smallest index of arr[i] + 1 in the subarray arr[i+1, N). Using this observation, follow the below steps to solve the given problem:

Below is the implementation of the above approach: 




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the array can
// be divided into subsequences of K
// consecutive integers in increasing order
bool isPossible(vector<int> nums, int K)
{
    int N = nums.size();
 
    // If N is not divisible by K or
    // K>N, no possible set of required
    // subsequences exist
    if (N % K != 0 || K > N) {
        return false;
    }
 
    // Stores the indices of each
    // element in a set
    map<int, set<int> > idx;
 
    // Stores the index of each number
    for (int i = 0; i < nums.size(); i++) {
        idx[nums[i]].insert(i);
    }
 
    // Stores if the integer at current
    // index is already included in
    // a subsequence
    int visited[N] = { 0 };
 
    // Stores the count of total
    // visited elements
    int total_visited = 0;
 
    for (int i = 0; i < nums.size(); i++) {
 
        // If current integer is already
        // in a subsequence
        if (visited[i]) {
            continue;
        }
 
        // Stores the value of last element
        // of the current subsequence
        int num = nums[i];
 
        // Stores the index of last element
        // of the current subsequence
        int last_index = i;
 
        // Mark Visited
        visited[i] = 1;
 
        // Increment the visited count
        total_visited++;
 
        // Find the next K-1 elements of the
        // subsequence starting from index i
        for (int j = num + 1; j < num + K; j++) {
 
            // No valid index found
            if (idx[j].size() == 0) {
                return false;
            }
 
            // Find index of j such that it
            // is greater than last_index
            auto it = idx[j].upper_bound(last_index);
 
            // if no such index found,
            // return false
            if (it == idx[j].end()
                || *it <= last_index) {
                return false;
            }
 
            // Update last_index
            last_index = *it;
 
            // Mark current index as visited
            visited[last_index] = 1;
 
            // Increment total_visited by 1
            total_visited++;
 
            // Remove the index from set because
            // it has been already used
            idx[j].erase(it);
        }
    }
 
    // Return the result
    return total_visited == N;
}
 
// Driver Code
int main()
{
    vector<int> arr = { 4, 3, 1, 2 };
    int K = 2;
    cout << (isPossible(arr, K) ? "Yes" : "No");
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                




















import java.util.*;



 



class GFG {




    // Function to check if the array can




    // be divided into subsequences of K




    // consecutive integers in increasing order




    public static boolean isPossible(List<Integer> nums, int K) {




        int N = nums.size();



 



        // If N is not divisible by K or




        // K>N, no possible set of required




        // subsequences exist




        if (N % K != 0 || K > N) {




            return false;




        }



 



        // Stores the indices of each




        // element in a set




        Map<Integer, TreeSet<Integer>> idx = new HashMap<>();



 



        // Stores the index of each number




        for (int i = 0; i < nums.size(); i++) {




            idx.computeIfAbsent(nums.get(i), k -> new TreeSet<>()).add(i);




        }



 



        // Stores if the integer at current




        // index is already included in




        // a subsequence




        boolean[] visited = new boolean[N];



 



        // Stores the count of total




        // visited elements




        int total_visited = 0;



 



        for (int i = 0; i < nums.size(); i++) {



 



            // If current integer is already




            // in a subsequence




            if (visited[i]) {




                continue;




            }



 



            // Stores the value of last element



// of the current subsequence



int num = nums.get(i);




                  // Stores the index of last element




        // of the current subsequence




        int last_index = i;



 



        // Mark Visited




        visited[i] = true;



 



        // Increment the visited count




        total_visited++;



 



        // Find the next K-1 elements of the




        // subsequence starting from index i




        for (int j = num + 1; j < num + K; j++) {



 



            // No valid index found




            if (!idx.containsKey(j) || idx.get(j).size() == 0) {




                return false;




            }



 



            // Find index of j such that it




            // is greater than last_index




            int next_index = idx.get(j).tailSet(last_index + 1).first();



 



            // if no such index found,




            // return false




            if (next_index <= last_index) {




                return false;




            }



 



            // Update last_index




            last_index = next_index;



 



            // Mark current index as visited




            visited[last_index] = true;



 



            // Increment total_visited by 1




            total_visited++;



 



            // Remove the index from set because




            // it has been already used




            idx.get(j).remove(last_index);




        }




    }



 



    // Return the result




    return total_visited == N;



}


 


// Driver Code



public static void main(String[] args) {




    List<Integer> arr = Arrays.asList(4, 3, 1, 2);




    int K = 2;




    System.out.println(isPossible(arr, K) ? "Yes" : "No");



}


}


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program for the above approach


 


# Function to check if the array can


# be divided into subsequences of K


# consecutive integers in increasing order



def isPossible(nums, K):




    N = len(nums)




     



    # If N is not divisible by K or




    # K>N, no possible set of required




    # subsequences exist




    if (N % K != 0 or K > N):




        return False




       



     # Stores the indices of each




    # element in a set




    idx = {}




     



     # Stores the index of each number




    for i in range(N):




        if nums[i] in idx:




            idx[nums[i]].add(i)




        else:




            idx[nums[i]] = {i}




             



    # Stores if the integer at current




    # index is already included in




    # a subsequence




    visited = [0]*N




     



    # Stores the count of total




    # visited elements




    total_visited = 0




    for i in range(N):




       



        # If current integer is already




        # in a subsequence




        if(visited[i]):




            continue




             



        # Stores the value of last element




        # of the current subsequence




        num = nums[i]




         



        # Stores the index of last element




        # of the current subsequence




        last_index = i




         



        # Marked visited




        visited[i] = 1




         



         # Increment the visited count




        total_visited += 1




         



        # Find the next K-1 elements of the




        # subsequence starting from index i




        for j in range(num+1, num+K):




           



           # No valid index found




            if j not in idx or len(idx[j]) == 0:




                return False




            temp = False




             



            # Find index of j such that it




            # is greater than last_index




            for it in idx[j]:




                if it > last_index:




                    last_index = it




                    temp = True




                    break




            if(temp == False):




                return False




               



            # Update last index




            visited[last_index] = 1




             



            # Mark current index as visited




             



             # Increment total_visited by 1




            total_visited += 1




             



            # Remove the index




            idx[j].remove(it)




             



            # Return the result




    return total_visited == N



 


# Driver code



arr = [4, 3, 1, 2]




K = 2




if (isPossible(arr, K)):




    print("Yes")




else:




    print("No")




     


# This code is contributed by parthmanchanda81


















                        






                        























                                    



                                    




                                    




                                    


                                




















using System;




using System.Collections.Generic;




using System.Linq;



 



public class GFG 



{


 



  // Function to check if the array can




  // be divided into subsequences of K




  // consecutive integers in increasing order




  public static bool isPossible(List<int> nums, int K)




  {




    int N = nums.Count;



 



    // If N is not divisible by K or




    // K>N, no possible set of required




    // subsequences exist




    if (N % K != 0 || K > N) {




      return false;




    }



 


 



    // Stores the indices of each




    // element in a set




    Dictionary<int, SortedSet<int> > idx




      = new Dictionary<int, SortedSet<int> >();



 



    // Stores the index of each number




    for (int i = 0; i < nums.Count; i++) {




      if (!idx.ContainsKey(nums[i])) {




        idx.Add(nums[i], new SortedSet<int>());




      }



 



      idx[nums[i]].Add(i);




    }



 



    // Stores if the integer at current




    // index is already included in




    // a subsequence




    bool[] visited = new bool[N];



 



    // Stores the count of total




    // visited elements




    int total_visited = 0;



 



    for (int i = 0; i < nums.Count; i++) {



 



      // If current integer is already




      // in a subsequence




      if (visited[i]) {




        continue;




      }



 



      // Stores the value of last element




      // of the current subsequence




      int num = nums[i];




      // Stores the index of last element




      // of the current subsequence




      int last_index = i;



 



      // Mark Visited




      visited[i] = true;



 



      // Increment the visited count




      total_visited++;



 



      // Find the next K-1 elements of the




      // subsequence starting from index i




      for (int j = num + 1; j < num + K; j++) {



 



        // No valid index found




        if (!idx.ContainsKey(j)




            || idx[j].Count == 0) {




          return false;




        }



 



        // Find index of j such that it




        // is greater than last_index




        int next_index




          = idx[j]




          .Where(x => x > last_index + 1)




          .First();



 



        // if no such index found,




        // return false




        if (next_index <= last_index) {




          return false;




        }



 



        // Update last_index




        last_index = next_index;



 



        // Mark current index as visited




        visited[last_index] = true;



 



        // Increment total_visited by 1




        total_visited++;



 



        // Remove the index from set because




        // it has been already used




        idx[j].Remove(last_index);




      }




    }



 



    // Return the result




    return total_visited == N;




  }



 



  // Driver Code




  static public void Main()




  {




    List<int> arr = new List<int>{ 4, 3, 1, 2 };




    int K = 2;




    Console.WriteLine(isPossible(arr, K) ? "Yes"




                      : "No");




  }



}


 


// This code is contributed by akashish__


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// JavaScript program for the above approach


 


// Function to check if the array can


// be divided into subsequences of K


// consecutive integers in increasing order



function isPossible(nums, K){




    let N = nums.length




     



    // If N is not divisible by K or




    // K>N, no possible set of required




    // subsequences exist




    if (N % K != 0 || K > N)




        return false




       



     // Stores the indices of each




    // element in a set




    let idx = new Map()




     



     // Stores the index of each number




    for(let i = 0; i < N; i++){




        if(idx.has(nums[i]))




            idx.get(nums[i]).add(i)




        else{




            idx.set(nums[i],new Set())




            idx.get(nums[i]).add(i)




        }




    }




             



    // Stores if the integer at current




    // index is already included in




    // a subsequence




    let visited = new Array(N).fill(0)




     



    // Stores the count of total




    // visited elements




    total_visited = 0




    for(let i=0;i<N;i++){




       



        // If current integer is already




        // in a subsequence




        if(visited[i])




            continue




             



        // Stores the value of last element




        // of the current subsequence




        let num = nums[i]




         



        // Stores the index of last element




        // of the current subsequence




        let last_index = i




         



        // Marked visited




        visited[i] = 1




         



         // Increment the visited count




        total_visited += 1




         



        // Find the next K-1 elements of the




        // subsequence starting from index i




        for(let j=num+1;j<num+K;j++){




           



           // No valid index found




            if(idx.has(j) == false || idx[j].length == 0)




                return false




            temp = false




             



            // Find index of j such that it




            // is greater than last_index




            for(let it of idx[j]){




                if(it > last_index){




                    last_index = it




                    temp = true




                    break




                }




                if(temp == false)




                    return false




            }




               



            // Update last index




            visited[last_index] = 1




             



            // Mark current index as visited




             



             // Increment total_visited by 1




            total_visited += 1




             



            // Remove the index




            idx[j].delete(it)




             



            // Return the result




        }




    }




    return (total_visited == N)



}


 


// Driver code


let arr = [4, 3, 1, 2]


let K = 2



if (isPossible(arr, K))




    document.write("Yes","</br>")



else



    document.write("No","</br>")




     


// This code is contributed by shinjanpatra


 


</script>


















                        






                        







 
 

Output: 

No


 


 
Time Complexity: O(N*log N)
Auxiliary Space: O(N)
 

	

        Article Tags : 
        

            Arrays
DSA
Greedy
Mathematical
Searching        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Check if array can be divided into two subsequences merging whom makes Array sorted

          
2. Check if String can be divided into two Subsequences so that product of sum is odd

          
3. Divide given numeric string into at most two increasing subsequences which form an increasing string upon concatenation

          
4. Check if N can be divided into K consecutive elements with a sum equal to N

          
5. Check if a given array can be divided into pairs with even sum

          
6. Difference between ceil of array sum divided by K and sum of ceil of array elements divided by K

          
7. Absolute difference between floor of Array sum divided by X and floor sum of every Array element when divided by X

          
8. Number of K's such that the given array can be divided into two sets satisfying the given conditions

          
9. Check if array can be divided into two sub-arrays such that their absolute difference is K

          
10. Check if Array can be divided into K groups of size C and all elements of group are distinct

          
11. Check if an array of 1s and 2s can be divided into 2 parts with equal sum

          
12. Check if an array can be divided into pairs whose sum is divisible  by k

          
13. Check if a large number can be divided into two or more segments of equal sum

          
14. Check if any square (with one colored cell) can be divided into two equal parts

          
15. Check whether N items can be divided into K groups of unique size

          
16. Check if Array can be made strictly increasing by merging three consecutive elements M times

          
17. Check if given String can be split only into subsequences ABC

          
18. Check if an array can be split into 3 subsequences of equal sum or not

          
19. Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0

          
20. First N natural can be divided into two sets with given difference and co-prime sums

          
21. Find the sums for which an array can be divided into sub-arrays of equal sum

          
22. Find if array can be divided into two subarrays of equal sum

          
23. Maximum number of times N can be divided by distinct powers of prime integers

          
24. Split Array into Consecutive Subsequences of Size K or more.

          
25. Check if the given array can be constructed uniquely from the given set of subsequences