sol.py

    def largestEvenSum(self, nums: List[int], k: int) -> int:
        if k > len(nums):
            return -1
        evens = [-n for n in nums if n % 2 == 0]
        odds = [-n for n in nums if n % 2 == 1]
        heapq.heapify(evens)
        heapq.heapify(odds)
        if k == 1:
            return -(evens[0]) if len(evens) > 0 else -1
        sum = 0
        if len(odds) == 0:
            for i in range(k):
                sum += -(heapq.heappop(evens))
            return sum

        if len(evens) == 0:
            if k % 2 == 1:
                return -1
            for i in range(k):
                sum += -(heapq.heappop(odds))
            return sum

        added_odds = []
        added_evens = []
        sum = 0
        i = 0
        while i < k and (len(evens) > 0 or len(odds) > 0):
            max_even = -(evens[0]) if len(evens) > 0 else 0
            max_odd = -(odds[0]) if len(odds) > 0 else 0
            if max_even > max_odd or len(odds) == 0:
                sum += max_even
                added_evens.append(max_even)
                max_even = -(heapq.heappop(evens))
            else:
                sum += max_odd
                added_odds.append(max_odd)
                max_odd = -(heapq.heappop(odds))
            i += 1
        if sum % 2 == 0:
            return sum

        if len(odds) == 0 and len(evens) == 0 and sum % 2 != 0:
            return -1

        if len(odds) == 0:
            return sum - added_odds[-1] + -(evens[0])

        if len(evens) == 0:
            return sum - added_evens[-1] + -(odds[0])

        try_remove_odd = 0
        if len(added_odds) > 0:
            try_remove_odd = sum - added_odds[-1] + -(evens[0])
        try_remove_even = 0
        if len(added_evens) > 0:
            try_remove_even = sum - added_evens[-1] + -(odds[0])
        return max(try_remove_odd, try_remove_even)