# 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 = , 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 ``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

 ``

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