📌  相关文章
📜  按照交易发生的顺序合并银行单中的交易，使其总和保持为正数

📅  最后修改于: 2021-09-07 05:11:54             🧑  作者: Mango

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

例子：

方法：给定的问题可以被可视化为合并K排序链表的变体，其标准是在任何时刻合并的事务列表的总和应该是非负的。
请按照以下步骤解决问题：

  • 初始化一个新节点，比如P ，它表示构造的链表的头部。
  • 初始化一个优先级队列，比如PQ ，大小为N以实现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)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live