Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Check if it’s possible to completely fill every container with same ball

  • Last Updated : 10 Nov, 2021

Given two arrays, arr[ ] C of containers and arr[ ] B of balls, the task is to find if it’s possible to completely fill every container with the given balls, if each container can only store balls of the same type. In array C, C[i] stores the maximum number of balls that the i-th container can store. In array B, B[i] stores the type of the i-th ball.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: C = [1, 2, 3], B = [1, 2, 2, 2, 3, 3, 4, 4, 4]
Output: YES
Explanation: fill first container with ball 1, second with 2 balls with number 3 and third container with ball having number 2

Input: C = [2], B = [1, 2, 3]
Output: NO
Explanation: there’s no possible combination to fill the containers



Approach: The idea is to use Backtracking to check if it’s possible to fill every container or not. It can be observed that there is only a need for the frequency of each type of ball, so we store the frequency of each type of balls in a map. Lets look at the steps involved in implementation of our approach:

  • Store the frequency of the same type of balls in a map.
  • Call the function getans to check if its possible to fill the containers.
  • Try to fill the container with balls whose frequency is more that equal to the container’s capacity. If its possible return true else backtrack and check for other balls.
  • If no combination exists return false.

Below is the implementation of the above approach.

C++




// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// A boolean function that returns true if it's possible to
// completely fill the container else return false
bool getans(int i, vector<int> v, vector<int> q)
{
    // Base Case
    if (i == q.size())
        return true;
 
    // Backtracking
    for (int j = 0; j < v.size(); j++) {
        if (v[j] >= q[i]) {
            v[j] -= q[i];
            if (getans(i + 1, v, q)) {
                return true;
            }
            v[j] += q[i];
        }
    }
    return false;
}
 
// Function to check the conditions
void Check(vector<int> c, vector<int> b)
{
 
    // Storing frequencies
    map<int, int> m;
    for (int i = 0; i < b.size(); i++) {
        m[b[i]]++;
    }
    vector<int> v;
    for (auto i : m) {
        v.push_back(i.second);
    }
 
    // Function Call for backtracking
    bool check = getans(0, v, c);
    if (check)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
 
// Driver Code
int main()
{
    // Given Input
    vector<int> c = { 1, 3, 3 };
    vector<int> b = { 2, 2, 2, 2, 4, 4, 4 };
 
    // Function Call
    Check(c, b);
    return 0;
}

Python3




# Python 3 program for above approach
 
# A boolean function that returns true if it's possible to
# completely fill the container else return false
def getans(i, v, q):
   
    # Base Case
    if (i == len(q)):
        return True
 
    # Backtracking
    for j in range(len(v)):
        if(v[j] >= q[i]):
            v[j] -= q[i]
            if (getans(i + 1, v, q)):
                return True
            v[j] += q[i]
    return False
 
# Function to check the conditions
def Check(c, b):
   
    # Storing frequencies
    m = {}
    for i in range(len(b)):
        if b[i] in m:
            m[b[i]] += 1
        else:
            m[b[i]] = 1
    v = []
    for key,value in m.items():
        v.append(value)
 
    # Function Call for backtracking
    check = getans(0, v, c)
    if (check):
        print("YES")
    else:
        print("NO")
 
# Driver Code
if __name__ == '__main__':
   
    # Given Input
    c = [1, 3, 3]
    b = [2, 2, 2, 2, 4, 4, 4]
 
    # Function Call
    Check(c, b)
     
    # This code is contributed by ipg2016107.

C#




// C# program for above approach
using System;
using System.Collections.Generic;
class GFG
{
   
    // A boolean function that returns true if it's possible
    // to completely fill the container else return false
    static bool getans(int i, List<int> v, int[] q)
    {
        // Base Case
        if (i == q.Length)
            return true;
 
        // Backtracking
        for (int j = 0; j < v.Count; j++) {
            if (v[j] >= q[i]) {
                v[j] -= q[i];
                if (getans(i + 1, v, q)) {
                    return true;
                }
                v[j] += q[i];
            }
        }
        return false;
    }
 
    // Function to check the conditions
    static void Check(int[] c, int[] b)
    {
 
        // Storing frequencies
        Dictionary<int, int> m = new Dictionary<int, int>();
        for (int i = 0; i < b.Length; i++)
            m[b[i]] = 0;
        for (int i = 0; i < b.Length; i++) {
            m[b[i]]++;
        }
        List<int> v = new List<int>();
        foreach(KeyValuePair<int, int> i in m)
        {
            v.Add(i.Value);
        }
 
        // Function Call for backtracking
        bool check = getans(0, v, c);
        if (check)
            Console.WriteLine("YES");
        else
            Console.WriteLine("NO");
    }
 
    // Driver Code
    public static void Main()
    {
       
        // Given Input
        int[] c = { 1, 3, 3 };
        int[] b = { 2, 2, 2, 2, 4, 4, 4 };
 
        // Function Call
        Check(c, b);
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
// Javascript program for above approach
 
// A boolean function that returns true if it's possible to
// completely fill the container else return false
function getans(i, v, q) {
  // Base Case
  if (i == q.length) return true;
 
  // Backtracking
  for (let j = 0; j < v.length; j++) {
    if (v[j] >= q[i]) {
      v[j] -= q[i];
      if (getans(i + 1, v, q)) {
        return true;
      }
      v[j] += q[i];
    }
  }
  return false;
}
 
// Function to check the conditions
function Check(c, b) {
  // Storing frequencies
  let m = new Map();
  for (let i = 0; i < b.length; i++) {
    if (m.has(b[i])) {
      m.set(b[i], m.get(b[i]) + 1);
    } else {
      m.set(b[i], 1);
    }
  }
 
  let v = [];
  for (i of m) {
    v.push(i[1]);
  }
 
  // Function Call for backtracking
  let check = getans(0, v, c);
  if (check) document.write("YES");
  else document.write("NO");
}
 
// Driver Code
 
// Given Input
let c = [1, 3, 3];
let b = [2, 2, 2, 2, 4, 4, 4];
 
// Function Call
Check(c, b);
 
// This code is contributed by _saurabh_jaiswal.
</script>

 
 

Output: 
YES

 

 

Time Complexity: O(m^n), where n is the size of arr[ ] C and m is the size of arr[ ] B.
  
Auxiliary Space: O(m)

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!