<p>Given an <code>n x n</code> <code>matrix</code> where each of the rows and columns is sorted in ascending order, return <em>the</em> <code>k<sup>th</sup></code> <em>smallest element in the matrix</em>.</p>

<p>Note that it is the <code>k<sup>th</sup></code> smallest element <strong>in the sorted order</strong>, not the <code>k<sup>th</sup></code> <strong>distinct</strong> element.</p>

<p>You must find a solution with a memory complexity better than <code>O(n<sup>2</sup>)</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
<strong>Output:</strong> 13
<strong>Explanation:</strong> The elements in the matrix are [1,5,9,10,11,12,13,<u><strong>13</strong></u>,15], and the 8<sup>th</sup> smallest number is 13
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> matrix = [[-5]], k = 1
<strong>Output:</strong> -5
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == matrix.length == matrix[i].length</code></li>
	<li><code>1 &lt;= n &lt;= 300</code></li>
	<li><code>-10<sup>9</sup> &lt;= matrix[i][j] &lt;= 10<sup>9</sup></code></li>
	<li>All the rows and columns of <code>matrix</code> are <strong>guaranteed</strong> to be sorted in <strong>non-decreasing order</strong>.</li>
	<li><code>1 &lt;= k &lt;= n<sup>2</sup></code></li>
</ul>

<p>&nbsp;</p>
<p><strong>Follow up:</strong></p>

<ul>
	<li>Could you solve the problem with a constant memory (i.e., <code>O(1)</code> memory complexity)?</li>
	<li>Could you solve the problem in <code>O(n)</code> time complexity? The solution may be too advanced for an interview but you may find reading <a href="http://www.cse.yorku.ca/~andy/pubs/X+Y.pdf" target="_blank">this paper</a> fun.</li>
</ul>

class node {
        public:
            int data;
            int arrayno;
            int index;
        
        node(int data, int row, int col){
            this->data = data;
            arrayno = row;
            index = col;
        }
    };
    class compare{
        public:
            bool operator()(node* a, node* b){
                return a->data > b->data;
            }
    };
class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        priority_queue<node*,vector<node*>,compare> minheap;

        // store first element of every array (k)
        
        for (int i=0; i<matrix.size(); i++) {
            node* temp = new node(matrix[i][0], i, 0); // first element
            minheap.push(temp);
        }
        
        // 
        int count = 0;
        int result = 0;
        
        while (count<k){
            node* temp = minheap.top();
            minheap.pop();

            result = temp->data;
            count++;
            
            int arrayno = temp->arrayno;
            int index = temp->index;
            
            // check size for next element
            if (index+1 < matrix[arrayno].size()){
                node* next = new node(matrix[arrayno][index+1], arrayno, index+1);
                minheap.push(next);
            }
            
        }
        
        return result;
    }
};
20000