Connect n ropes with minimum cost

import java.util.Scanner;

import java.util.PriorityQueue;

public class solution {

    static int minCost(int arr[], int n) {

        /*

         * Your class should be named Solution.Don't write main().Don't take

         * input, it is passed as function argument.Don't print output.Taking

         * input and printing output is handled automatically.

         */

                if(n==1)

                return arr[0];

            PriorityQueue<Integer> pq=new PriorityQueue<>();

            for(int i=0;i<n;i++)

            {

                pq.add(arr[i]);

            }

            int ans=0;

            while(!pq.isEmpty() && pq.size()>1)

            {

                int a=pq.poll();

                int b=pq.poll();

                ans+=a+b;

                pq.add(a+b);

            }

            return ans;

    }

}

#include <bits/stdc++.h>

int minCost(int arr[], int n)

{   priority_queue<int, vector<int>, greater<int>> minHeap;

    for(int i = 0; i<n; i++){

        minHeap.push(arr[i]);

    }

    int cost = 0;

    while(!minHeap.empty() && minHeap.size() > 1){

        int rope1 = minHeap.top();

        minHeap.pop();

        int rope2 = minHeap.top();

        minHeap.pop();

        cost += rope1+rope2;

        minHeap.push(rope1+rope2);

    }

    return cost;

}

    static int minCost(int arr[], int n) {

        PriorityQueue<Integer> minHeap = new PriorityQueue<>();

        for(int i=0 ; i<n ; i++){

            minHeap.add(arr[i]);

        }

        int ans = 0;

        while(minHeap.size() > 1){

            int a = minHeap.remove();

            int b = minHeap.remove();

            int temp = a+b;

            ans += temp;

            minHeap.add(temp);

        }

        return ans;

    }

Step 1. Add all rope lengths into Priority Queue (Min Heap)

Step 2 : Take two min rope lengths, join them and add it to your total cost and add the joined rope length into the min Heap // Java Code   

PriorityQueue<Integer> pq = new PriorityQueue<>();

         int cost = 0;

        for(int i=0;i<n;i++){

            pq.add(arr[i]);

        }

        while(!pq.isEmpty()){

            int count = 0;

            int len = 0;

            while(count < 2){

                int value = pq.poll();

                len += value;

                cost += value;

                count++;

            }

            if(pq.isEmpty()) break;

            pq.add(len);

        }

        return cost;  

int minCost(int arr[], int n)
{
	/*Write your code here. 
	 *Don't write main().
	 *Don't take input, it is passed as function argument.
	 *Don't print output.
	 *Taking input and printing output is handled automatically.
	*/
	priority_queue<int, vector<int>, greater<int>> pq;
        for(int i = 0; i < n; i++)
            pq.push(arr[i]);
        int cost = 0;
        while(pq.size() > 1)
        {
            int a = pq.top();
            pq.pop();
            int b = pq.top();
            pq.pop();
            int sum = a + b;
            cost += sum;
            pq.push(sum);
        }
        return cost;
}

int minCost(int arr[], int n)

{

    int ans=0;

    priority_queue<int,vector<int>,greater<int>> pq;

    for(int i=0;i<n;i++){

        pq.push(arr[i]);

    }

    while(pq.size()>1){

        int x=pq.top();

        pq.pop();

        int y=pq.top();

        pq.pop();

        ans+=(x+y);

        pq.push(x+y);

    }

    return ans;

}

static int minCost(int arr[], int n) {

        PriorityQueue<Integer> pq=new PriorityQueue<>();

        for(int i:arr)

        {

            pq.offer(i);

        }

        int cost=0;

        while(pq.size()>1)

        {

            int a=pq.poll();

            a+=pq.poll();

            cost+=a;

            pq.offer(a);

        }

        return cost;

    }

#include<bits/stdc++.h>
int minCost(int arr[], int n)
{ 
	if(n==1)return arr[0];
	priority_queue<int,vector<int>,greater<int>>pq;
	for(int i=0;i<n;i++)
	{
		pq.push(arr[i]);
	}
	int cost=0;
	while(pq.size()>1)
	{
		int first=pq.top();
pq.pop();
       int second=pq.top();
pq.pop();
	   int sum=first+second;
	   cost+=sum;
	   pq.push(sum);
	}
	return cost;
}

int minCost(int arr[], int n){

    priority_queue<int, vector<int>, greater<int>> pq;

    for(int i=0; i<n; i++){

        pq.push(arr[i]);

    }

    int res = 0;

    while(pq.size() != 1){

        int n1 = pq.top();

        pq.pop();

        int n2 = pq.top();

        pq.pop();

        int sum = n1+n2;

        res += sum;

        pq.push(sum);

    }

    return res;

}

//Tejash maurya

priority_queue<int, vector<int>, greater<int> > pq; //creation of min heap

        for(int i=0;i<n;i++)

        {

            pq.push(arr[i]);

        }

        int cost = 0;

        while(pq.size() > 1)

        {

            int a = pq.top();

            pq.pop();

            int b = pq.top();

            pq.pop();

            int ans = a + b;

            cost = ans + cost;

            pq.push(ans);

        }

        return cost;

}