Why Did the Cow Cross the Road I

#include <algorithm>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
 
using std::cout;
using std::endl;
using std::pair;
using std::vector;
 
int main() {
	std::ifstream read("helpcross.in");
 
	int num_chickens, num_cows;
	read >> num_chickens >> num_cows;
 
	vector<int> chickens(num_chickens);
	for (int &c : chickens) { read >> c; }
	std::sort(chickens.begin(), chickens.end());
 
	vector<pair<int, int>> cows(num_cows);
	for (pair<int, int> &c : cows) { read >> c.first >> c.second; }
	// ordenamos por tiempo de inicio y, en empate, por tiempo de fin
	std::sort(cows.begin(), cows.end());
 
	int num_helped = 0;
	int cow_at = 0;
	std::priority_queue<int> available_cows;
	for (int c : chickens) {
		// agregamos todas las vacas cuyos tiempos de inicio ya incluyen el de la gallina
		while (cow_at < cows.size() && cows[cow_at].first <= c) {
			available_cows.push(-cows[cow_at].second);
			cow_at++;
		}
		// quitamos todos los tiempos de fin que terminan demasiado temprano para la gallina
		while (!available_cows.empty() && -available_cows.top() < c) {
			available_cows.pop();
		}
		// hacemos que la vaca ayude a la gallina con el tiempo de fin más temprano
		if (!available_cows.empty()) {
			num_helped++;
			available_cows.pop();
		}
	}
 
	std::ofstream("helpcross.out") << num_helped << endl;
}

import java.io.*;
import java.util.*;
 
public class HelpCross {
	// BeginCodeSnip{Cow Class}
	static class Cow implements Comparable<Cow> {
		int start;
		int end;
 
		public Cow(int start, int end) {
			this.start = start;
			this.end = end;
		}
 
		@Override
		public int compareTo(Cow c) {
			return start != c.start ? start - c.start : end - c.end;
		}
	}
	// EndCodeSnip
 
	public static void main(String[] args) throws IOException {
		Kattio io = new Kattio("helpcross");
		int numChickens = io.nextInt();
		int numCows = io.nextInt();
 
		int[] chickens = new int[numChickens];
		for (int c = 0; c < numChickens; c++) { chickens[c] = io.nextInt(); }
		Arrays.sort(chickens);
 
		Cow[] cows = new Cow[numCows];
		for (int c = 0; c < numCows; c++) {
			cows[c] = new Cow(io.nextInt(), io.nextInt());
		}
		// ordenamos por tiempo de inicio y, en empate, por tiempo de fin
		Arrays.sort(cows);
 
		int numHelped = 0;
		int cowAt = 0;
		PriorityQueue<Integer> availableCows = new PriorityQueue<>();
		for (int c : chickens) {
			// agregamos todas las vacas cuyos tiempos de inicio ya incluyen el de la gallina
			while (cowAt < cows.length && cows[cowAt].start <= c) {
				availableCows.add(cows[cowAt].end);
				cowAt++;
			}
			// quitamos todos los tiempos de fin que terminan demasiado temprano para la gallina
			while (!availableCows.isEmpty() && availableCows.peek() < c) {
				availableCows.remove();
			}
			// hacemos que la vaca ayude a la gallina con el tiempo de fin más temprano
			if (!availableCows.isEmpty()) {
				numHelped++;
				availableCows.remove();
			}
		}
 
		io.println(numHelped);
		io.close();
	}
 
	// CodeSnip{Kattio}
}

import heapq
 
with open("helpcross.in") as read:
	num_chickens, num_cows = [int(i) for i in read.readline().split()]
 
	chickens = [int(read.readline()) for _ in range(num_chickens)]
 
	cows = []
	for _ in range(num_cows):
		cows.append(tuple(int(i) for i in read.readline().split()))
 
chickens.sort()
# ordenamos por tiempo de inicio y, en empate, por tiempo de fin
cows.sort()
 
num_helped = 0
cow_at = 0
available_cows = []
for c in chickens:
	# agregamos todas las vacas cuyos tiempos de inicio ya incluyen el de la gallina
	while cow_at < num_cows and cows[cow_at][0] <= c:
		heapq.heappush(available_cows, cows[cow_at][1])
		cow_at += 1
 
	"""
	quitamos todos los tiempos de fin que terminan demasiado temprano para la gallina
	como available_cows es un heap, el primer elemento es el más pequeño
	"""
	while available_cows and available_cows[0] < c:
		heapq.heappop(available_cows)
 
	# hacemos que la vaca ayude a la gallina con el tiempo de fin más temprano
	if available_cows:
		num_helped += 1
		heapq.heappop(available_cows)
 
print(num_helped, file=open("helpcross.out", "w"))