Cheapest way to join ropes

import heapq

def connect_ropes(ropes):
    heap = list(ropes)
    heapq.heapify(heap)                    # O(n)
    cost = 0
    while len(heap) > 1:
        a = heapq.heappop(heap)            # the two shortest ropes
        b = heapq.heappop(heap)
        cost += a + b
        heapq.heappush(heap, a + b)        # the joined rope competes again
    return cost

#include <vector>
#include <queue>
#include <functional>

long long solve(const std::vector<int>& ropes) {
    std::priority_queue<long long, std::vector<long long>, std::greater<long long>> heap(ropes.begin(), ropes.end());
    long long cost = 0;
    while (heap.size() > 1) {
        long long a = heap.top(); heap.pop();   // the two shortest ropes
        long long b = heap.top(); heap.pop();
        cost += a + b;
        heap.push(a + b);
    }
    return cost;
}

class Solution {
    public long connectRopes(int[] ropes) {
        java.util.PriorityQueue<Long> heap = new java.util.PriorityQueue<>();
        for (int r : ropes) heap.add((long) r);
        long cost = 0;
        while (heap.size() > 1) {
            long a = heap.poll(), b = heap.poll();   // the two shortest ropes
            cost += a + b;
            heap.add(a + b);
        }
        return cost;
    }
}

function connectRopes(ropes) {
  const h = [];                            // binary min-heap
  const push = x => {
    h.push(x); let i = h.length - 1;
    while (i > 0) { const p = (i - 1) >> 1; if (h[p] <= h[i]) break; [h[p], h[i]] = [h[i], h[p]]; i = p; }
  };
  const pop = () => {
    const top = h[0], last = h.pop();
    if (h.length) {
      h[0] = last; let i = 0;
      for (;;) {
        const l = 2 * i + 1, r = l + 1; let m = i;
        if (l < h.length && h[l] < h[m]) m = l;
        if (r < h.length && h[r] < h[m]) m = r;
        if (m === i) break;
        [h[m], h[i]] = [h[i], h[m]]; i = m;
      }
    }
    return top;
  };
  ropes.forEach(push);
  let cost = 0;
  while (h.length > 1) {
    const a = pop(), b = pop();            // the two shortest ropes
    cost += a + b;
    push(a + b);
  }
  return cost;
}

use std::cmp::Reverse;
use std::collections::BinaryHeap;

fn solve(ropes: &[i64]) -> i64 {
    let mut heap: BinaryHeap<Reverse<i64>> = ropes.iter().map(|&r| Reverse(r)).collect();
    let mut cost = 0;
    while heap.len() > 1 {
        let Reverse(a) = heap.pop().unwrap();   // the two shortest ropes
        let Reverse(b) = heap.pop().unwrap();
        cost += a + b;
        heap.push(Reverse(a + b));
    }
    cost
}

import qualified Data.Map.Strict as M

-- A Map from length to count serves as the min-heap.
solve :: [Int] -> Int
solve ropes = go (foldr push M.empty ropes) (length ropes) 0
  where
    push x = M.insertWith (+) x 1
    popMin m = case M.findMin m of
      (v, 1) -> (v, M.delete v m)
      (v, c) -> (v, M.insert v (c - 1) m)
    go m n cost
      | n <= 1    = cost
      | otherwise =
          let (a, m1) = popMin m          -- the two shortest ropes
              (b, m2) = popMin m1
          in go (push (a + b) m2) (n - 1) (cost + a + b)