# Minimum number of Bottles visible when a bottle can be enclosed inside another Bottle

Given N bottles. The ith bottle has A[i] radius. Once a bottle is enclosed inside another bottle, it ceases to be visible. The task is to minimize the number of visible bottles. You can put the ith bottle into a jth bottle if the following condition is fulfilled.

1. ith bottle itself is not enclosed in another bottle.
2. jth bottle does not enclose any other bottle.
3. Radius of bottle i is smaller than bottle j ( i.e. A[i] < A[j] ).

Examples:

```Input :
8
1 1 2 3 4 5 5 4
Output :
2
Explanation:
1 -> 2 [1, 2, 3, 4, 5, 5, 4]
2 -> 3 [1, 3, 4, 5, 5, 4]
3 -> 4 [1, 4, 5, 5, 4]
4 -> 5 [1, 5, 5, 4]
1 -> 4 [5, 5, 4]
4 -> 5 [5, 5]

Finally, there are 2 bottles
left which are visible.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: If you carefully observe, you will find that the number of minimum visible bottles will be equal to the maximum number of repeated bottles. Here intuition is, as these repeated bottles cannot be fit in single bigger bottle hence we require at least as many bigger bottles as the number of repeated bottles.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std; ` ` `  `void` `min_visible_bottles(``int``* arr, ``int` `n) ` `{ ` `    ``map<``int``, ``int``> m; ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``m[arr[i]]++; ` `        ``ans = max(ans, m[arr[i]]); ` `    ``} ` ` `  `    ``cout << ``"Minimum number of "` `         ``<< ``"Visible Bottles are: "` `         ``<< ans << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 8; ` `    ``int` `arr[] = { 1, 1, 2, 3, 4, 5, 5, 4 }; ` ` `  `    ``// Find the solution ` `    ``min_visible_bottles(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java code for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `    ``static` `void` `min_visible_bottles(``int``[] arr, ``int` `n) ` `    ``{ ` `        ``HashMap mp = ``new` `HashMap(); ` `        ``int` `ans = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``if` `(mp.containsKey(arr[i])) ` `            ``{ ` `                ``mp.put(arr[i], mp.get(arr[i]) + ``1``); ` `            ``}  ` `            ``else`  `            ``{ ` `                ``mp.put(arr[i], ``1``); ` `            ``} ` `            ``ans = Math.max(ans, mp.get(arr[i])); ` `        ``} ` ` `  `        ``System.out.print(``"Minimum number of "` `+  ` `                      ``"Visible Bottles are: "` `+  ` `                                   ``ans + ``"\n"``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `n = ``8``; ` `        ``int` `arr[] = { ``1``, ``1``, ``2``, ``3``, ``4``, ``5``, ``5``, ``4` `}; ` ` `  `        ``// Find the solution ` `        ``min_visible_bottles(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 code for the above approach ` `def` `min_visible_bottles(arr, n): ` ` `  `    ``m ``=` `dict``() ` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(n): ` `        ``m[arr[i]] ``=` `m.get(arr[i], ``0``) ``+` `1` `        ``ans ``=` `max``(ans, m[arr[i]]) ` ` `  `    ``print``(``"Minimum number of"``, ` `          ``"Visible Bottles are: "``, ans) ` ` `  `# Driver code ` `n ``=` `8` `arr ``=` `[``1``, ``1``, ``2``, ``3``, ``4``, ``5``, ``5``, ``4``] ` ` `  `# Find the solution ` `min_visible_bottles(arr, n) ` ` `  `# This code is contributed  ` `# by Mohit Kumar `

## C#

 `// C# code for the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `    ``static` `void` `min_visible_bottles(``int``[] arr, ``int` `n) ` `    ``{ ` `        ``Dictionary<``int``,  ` `                   ``int``> mp = ``new` `Dictionary<``int``, ` `                                            ``int``>(); ` `        ``int` `ans = 0; ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``if` `(mp.ContainsKey(arr[i])) ` `            ``{ ` `                ``mp[arr[i]] = mp[arr[i]] + 1; ` `            ``}  ` `            ``else` `            ``{ ` `                ``mp.Add(arr[i], 1); ` `            ``} ` `            ``ans = Math.Max(ans, mp[arr[i]]); ` `        ``} ` ` `  `        ``Console.Write(``"Minimum number of "` `+  ` `                   ``"Visible Bottles are: "` `+  ` `                                ``ans + ``"\n"``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `n = 8; ` `        ``int` `[]arr = { 1, 1, 2, 3, 4, 5, 5, 4 }; ` ` `  `        ``// Find the solution ` `        ``min_visible_bottles(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Minimum number of Visible Bottles are: 2
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : mohit kumar 29, Rajput-Ji