按发生顺序将银行交易合并，以使它们的金额保持正数

给定一个由代表N个交易的N个整数组成的数组arr [] ，任务是按照交易发生的顺序合并给定的交易列表，以使在任何时间点已执行交易的总和为非负数。如果发现为负，则打印“ -1” 。否则，打印合并的事务列表。

例子：

Input: arr[][] = {{100 → 400 → -1000 → -500}, {-300 → 2000 → -500}}
Output: 100 → 400 → -300 → 2000 → -500 → -1000 → -500
Explanation: The sum at every instant of the above list of transactions is given by {100, 500, 200, 2200, 1700, 700, 200}, which has no negative values.

Input: arr[][] = [[100 → 400]]
Output: 100 400

方法：给定的问题可以可视化为合并的K排序链表的变体，其标准是在任何瞬间交易合并表的总和应为非负数。
请按照以下步骤解决问题：

• 初始化一个新节点，例如P ，它表示构造的链表的头部。
• 初始化大小为N的优先级队列(例如PQ)以实现Max Heap 。
• 将前N个事务作为节点插入PQ中。
• 迭代直到PQ为非空，然后执行以下步骤：
  • 弹出优先级队列的顶部节点，并将该节点插入列表的末尾，头为P。
  • 如果弹出节点的下一个节点存在，则将弹出节点的下一个节点插入PQ中。
• 完成上述步骤后，打印形成的标题为P的链表。

下面是上述方法的实现：

Java

// Java program for the above approach
  
import java.util.*;
  
// Structure of a Node
// in the Linked List
class Node {
  
    int val;
    Node next;
  
    // Constructor
    Node(int val)
    {
        this.val = val;
        this.next = null;
    }
}
  
class GFG {
  
    // Function to merge the Bank sheets
    public static void mergeSheets(
        Node lists[])
    {
        // Initialize Max_Heap
        PriorityQueue pq
  
            = new PriorityQueue<>(
                new Comparator() {
  
                    // Comparator Function
                    // to make it maxHeap
                    public int compare(Node a, Node b)
                    {
                        return b.val - a.val;
                    }
  
                });
  
        // Stores the output list
        Node p, head = new Node(0);
        p = head;
  
        // Insert the first element
        // of each list
        for (int i = 0;
             i < lists.length; i++) {
  
            // If the list is not NULL
            if (lists[i] != null) {
  
                // Insert element in
                // the priority queue
                pq.add(lists[i]);
            }
        }
  
        // Iterate until PQ is non-empty
        while (!pq.isEmpty()) {
            p.next = pq.poll();
            p = p.next;
  
            if (p.next != null)
                pq.add(p.next);
        }
  
        p = head.next;
  
        // Print the output list
        while (p.next != null) {
            System.out.print(p.val + " ");
            p = p.next;
        }
  
        System.out.print(p.val);
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int N = 2;
  
        Node arr[] = new Node[N];
  
        arr[0] = new Node(100);
        arr[0].next = new Node(400);
        arr[0].next.next = new Node(-1000);
        arr[0].next.next.next = new Node(-500);
  
        arr[1] = new Node(-300);
        arr[1].next = new Node(2000);
        arr[1].next.next = new Node(-500);
  
        // Function Call
        mergeSheets(arr);
    }
}

输出：

100 400 -300 2000 -500 -1000 -500

时间复杂度： O(N * log K)
辅助空间： O(K)