**Problem:**

Given `n`

ropes of different lengths, we need to connect these ropes into one rope. We can connect only 2 ropes at a time. The cost required to connect 2 ropes is equal to sum of their lengths. The length of this connected rope is also equal to the sum of their lengths. This process is repeated until `n`

ropes are connected into a single rope. Find the min possible cost required to connect all ropes.

**Example 1:**

```
Input: ropes = [8, 4, 6, 12]
Output: 58
Explanation: The optimal way to connect ropes is as follows
1. Connect the ropes of length 4 and 6 (cost is 10). Ropes after connecting: [8, 10, 12]
2. Connect the ropes of length 8 and 10 (cost is 18). Ropes after connecting: [18, 12]
3. Connect the ropes of length 18 and 12 (cost is 30).
Total cost to connect the ropes is 10 + 18 + 30 = 58
```

**Example 2:**

```
Input: ropes = [20, 4, 8, 2]
Output: 54
```

**Example 3:**

```
Input: ropes = [1, 2, 5, 10, 35, 89]
Output: 224
```

**Example 4:**

```
Input: ropes = [2, 2, 3, 3]
Output: 20
```

**Solution:**

Logic:

This is rather simple. Here you push all the elements in a PriorityQueue, which on polling will return the values in ascending order (as it applies the natural ordering for integers as priority).

So as you go over the priority queue, you always pick the two smallest rope segments, join them and put them the joined rope segement back in the priority queue..at last you are left with one joined rope segment and one loose rope segment which you join to form the full connected rope and also during the process keep a log of the minimum cost by adding the values to it at every join.

Got that? I would maybe later on do an illustration..that would be fun! For now check out the code below.

```
import java.util.PriorityQueue;
public class MinCostToConnectRopes {
private static int minCost(int[] ropes) {
PriorityQueue<Integer> values = new PriorityQueue<>();
for (int i=0; i<ropes.length; i++) {
values.offer(ropes[i]);
}
int minCost = 0;
while (values.size() != 1) {
int value1 = values.poll();
int value2 = values.poll();
minCost = minCost + value1 + value2;
values.offer(value1 + value2);
}
return minCost;
}
public static void main (String[] args) {
System.out.println(minCost(new int[]{8, 4, 6, 12}));
}
}
```