<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code> of equal length <code>n</code> and a positive integer <code>k</code>. You must choose a <strong>subsequence</strong> of indices from <code>nums1</code> of length <code>k</code>.</p>

<p>For chosen indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, ..., <code>i<sub>k - 1</sub></code>, your <strong>score</strong> is defined as:</p>

<ul>
	<li>The sum of the selected elements from <code>nums1</code> multiplied with the <strong>minimum</strong> of the selected elements from <code>nums2</code>.</li>
	<li>It can defined simply as: <code>(nums1[i<sub>0</sub>] + nums1[i<sub>1</sub>] +...+ nums1[i<sub>k - 1</sub>]) * min(nums2[i<sub>0</sub>] , nums2[i<sub>1</sub>], ... ,nums2[i<sub>k - 1</sub>])</code>.</li>
</ul>

<p>Return <em>the <strong>maximum</strong> possible score.</em></p>

<p>A <strong>subsequence</strong> of indices of an array is a set that can be derived from the set <code>{0, 1, ..., n-1}</code> by deleting some or no elements.</p>

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

<pre>
<strong>Input:</strong> nums1 = [1,3,3,2], nums2 = [2,1,3,4], k = 3
<strong>Output:</strong> 12
<strong>Explanation:</strong> 
The four possible subsequence scores are:
- We choose the indices 0, 1, and 2 with score = (1+3+3) * min(2,1,3) = 7.
- We choose the indices 0, 1, and 3 with score = (1+3+2) * min(2,1,4) = 6. 
- We choose the indices 0, 2, and 3 with score = (1+3+2) * min(2,3,4) = 12. 
- We choose the indices 1, 2, and 3 with score = (3+3+2) * min(1,3,4) = 8.
Therefore, we return the max score, which is 12.
</pre>

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

<pre>
<strong>Input:</strong> nums1 = [4,2,3,1,1], nums2 = [7,5,10,9,6], k = 1
<strong>Output:</strong> 30
<strong>Explanation:</strong> 
Choosing index 2 is optimal: nums1[2] * nums2[2] = 3 * 10 = 30 is the maximum possible score.
</pre>

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

<ul>
	<li><code>n == nums1.length == nums2.length</code></li>
	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= nums1[i], nums2[j] &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= k &lt;= n</code></li>
</ul>

class Solution:
    def maxScore(self, nums1: List[int], nums2: List[int], k: int) -> int:
        
        zipped_list = list(zip(nums2,nums1))

        # Sorts numbers in nums2
        zipped_list.sort(reverse = True)

        heap = []

        maxScore = 0

        total = 0

        for idx, data in enumerate(zipped_list):
            print(idx,data)

            n1 = data[1]
            n2 = data[0]

            heapq.heappush(heap,n1)

            total += n1

            if idx >= k:
                # Remove the smallest value
                old = heapq.heappop(heap)
                total -= old 

            if idx >= k -1: # Start comparing
                maxScore = max(maxScore, n2 * total)

        return maxScore









        # nn = list()
        
        # maxScore = 0 
        # total    = 0

        # for i in range(len(nums1)):
        #     nn.append([nums2[i],nums1[i]]) # num2 first such that num2 will be sorted
        
        # # Sort with respect to nums2
        # nn.sort(reverse = True)

        # heap = [] # initialize an empty list

        # #print(nn)

        # for idx in range(len(nums2)):

        #     n2, n1 = nn[idx]
        #     # n2 is def the minimum of the list now

        #     # We keep track of the total
        #     total   = total + n1

        #     # Add n2 to the heap
        #     heapq.heappush(heap,n1) # n2 will actually be on our heap


        #     if idx >= k:
        #         # No we need to pop the latest element
        #         oldest_min = heapq.heappop(heap)
        #         total = total - oldest_min

        #     #print(heap,n1,total)

        #     if idx >= k - 1:
        #         # Compute the new max for the current element
        #         maxScore = max(maxScore,total * n2)

        # return maxScore
995