Standard Priority Queue VI: Max Heap

Although this problem's hint #1 mentions that you should sort the rows, in reality you don't need to. Creating a max heap, adding all elements there, and removing them according to the limits given, should do the trick. Code is down below, cheers, ACC.

Maximum Sum With at Most K Elements - LeetCode

You are given a 2D integer matrix grid of size n x m, an integer array limits of length n, and an integer k. The task is to find the maximum sum of at most k elements from the matrix grid such that:

• The number of elements taken from the ith row of grid does not exceed limits[i].

Return the maximum sum.

 

Example 1:

Input: grid = [[1,2],[3,4]], limits = [1,2], k = 2

Output: 7

Explanation:

• From the second row, we can take at most 2 elements. The elements taken are 4 and 3.
• The maximum possible sum of at most 2 selected elements is 4 + 3 = 7.

Example 2:

Input: grid = [[5,3,7],[8,2,6]], limits = [2,2], k = 3

Output: 21

Explanation:

• From the first row, we can take at most 2 elements. The element taken is 7.
• From the second row, we can take at most 2 elements. The elements taken are 8 and 6.
• The maximum possible sum of at most 3 selected elements is 7 + 8 + 6 = 21.

 

Constraints:

• n == grid.length == limits.length
• m == grid[i].length
• 1 <= n, m <= 500
• 0 <= grid[i][j] <= 105
• 0 <= limits[i] <= m
• 0 <= k <= min(n * m, sum(limits))

using System.Collections;

public class Solution
{
    public long MaxSum(int[][] grid, int[] limits, int k)
    {
        PriorityQueue pQueue = new PriorityQueue(false, grid.Length * grid[0].Length);
        for (int r = 0; r < grid.Length; r++)
            for (int c = 0; c < grid[r].Length; c++)
                pQueue.Enqueue(new QueueItem(grid[r][c], r, c), grid[r][c]);

        long sum = 0;
        while (pQueue.Count > 0 && k > 0)
        {
            double dVal = 0;
            QueueItem qi = (QueueItem)pQueue.Dequeue(out dVal);

            if (limits[qi.indexRow] > 0)
            {
                sum += (long)dVal;
                k--;
                limits[qi.indexRow]--;
            }
        }

        return sum;
    }
}

public class QueueItem
{
    public int value = 0;
    public int indexRow = 0;
    public int indexCol = 0;

    public QueueItem(int value, int indexRow, int indexCol)
    {
        this.value = value;
        this.indexRow = indexRow;
        this.indexCol = indexCol;
    }
}
public class PriorityQueue
{
    public struct HeapEntry
    {
        private object item;
        private double priority;
        public HeapEntry(object item, double priority)
        {
            this.item = item;
            this.priority = priority;
        }
        public object Item
        {
            get
            {
                return item;
            }
        }
        public double Priority
        {
            get
            {
                return priority;
            }
        }
    }

    private bool ascend;
    private int count;
    private int capacity;
    private HeapEntry[] heap;

    public int Count
    {
        get
        {
            return this.count;
        }
    }

    public PriorityQueue(bool ascend, int cap = -1)
    {
        capacity = 10000000;
        if (cap > 0) capacity = cap;
        heap = new HeapEntry[capacity];
        this.ascend = ascend;
    }

    public object Dequeue(out double priority)
    {
        priority = heap[0].Priority;
        object result = heap[0].Item;
        count--;
        trickleDown(0, heap[count]);
        return result;
    }
    public object Peak(out double priority)
    {
        priority = heap[0].Priority;
        object result = heap[0].Item;
        return result;
    }

    public object Peak(/*out double priority*/)
    {
        //priority = heap[0].Priority;
        object result = heap[0].Item;
        return result;
    }

    public void Enqueue(object item, double priority)
    {
        count++;
        bubbleUp(count - 1, new HeapEntry(item, priority));
    }

    private void bubbleUp(int index, HeapEntry he)
    {
        int parent = (index - 1) / 2;
        // note: (index > 0) means there is a parent
        if (this.ascend)
        {
            while ((index > 0) && (heap[parent].Priority > he.Priority))
            {
                heap[index] = heap[parent];
                index = parent;
                parent = (index - 1) / 2;
            }
            heap[index] = he;
        }
        else
        {
            while ((index > 0) && (heap[parent].Priority < he.Priority))
            {
                heap[index] = heap[parent];
                index = parent;
                parent = (index - 1) / 2;
            }
            heap[index] = he;
        }
    }

    private void trickleDown(int index, HeapEntry he)
    {
        int child = (index * 2) + 1;
        while (child < count)
        {
            if (this.ascend)
            {
                if (((child + 1) < count) &&
                    (heap[child].Priority > heap[child + 1].Priority))
                {
                    child++;
                }
            }
            else
            {
                if (((child + 1) < count) &&
                    (heap[child].Priority < heap[child + 1].Priority))
                {
                    child++;
                }
            }
            heap[index] = heap[child];
            index = child;
            child = (index * 2) + 1;
        }
        bubbleUp(index, he);
    }
}