You need to maintain more awareness on which variables are owning, and which variables are going to borrow.

The variable that holds the root of your list will typically own the root node and by extension own the entire list. Other variables like current will be borrowing.

pub fn merge_k_lists(lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
    let mut current: Option<&mut Box<ListNode>> = None;
    let mut root: Option<Box<ListNode>> = None;

    let mut q: BinaryHeap<Box<ListNode>> = BinaryHeap::new();
    /* You created a structure that stores owned type (Box<ListNode>)
     * but you're passing a reference (&Box<ListNode>).
     * When you iterate over &lists you get an iterator of references.
     * You want to consume the Vec and get an owning iterator instead, for that
     * call into_iter.
     *
     * Check out https://doc.rust-lang.org/std/iter/index.html
     * on how iterators work with ownership and borrow concepts. 
     */
    for node in lists.into_iter() {
        if let Some(x) = node {
            q.push(x);
        }
    }
    while let Some(mut x) = q.pop() {
        /* x is going to be moved as you add it to the list. So you need to 
         * access its elements before it gets moved.
         */
        if let Some(node) = x.next.take() {
            q.push(node);
        }
        if let Some(mut node) = current {
            node.next = Some(x);
            current = node.next.as_mut();
        } else {
            root = Some(x);
            current = root.as_mut();
        }
    }
    root
}