Merge pull request #5753 from Tirth1410/CSES-Apartments

Updated Java Solution solutions/silver/cses-1084.mdx

Author: eysbutno

solutions/silver/cses-1084.mdx

@@ -8,10 +8,10 @@ author: Nathan Gong, Danh Ta Chi Thanh
 [Unofficial Editorial (C++)](https://codeforces.com/blog/entry/83295)
 
 We can use a greedy approach to solve this problem. First, sort the applicants
-and apartments. We can keep two pointers $i$ and $j$ (initialized to 0),
-which keep track of the current index of the applicant and apartment we are
-looking at respectively. Then, while there are more applicants and apartments to
-look through, we repeatedly run the following check:
+and apartments. We can keep two pointers $i$ and $j$ (initialized to 0), which
+keep track of the current index of the applicant and apartment we are looking at
+respectively. Then, while there are more applicants and apartments to look
+through, we repeatedly run the following check:
 
 - If $|\texttt{applicants}[i] - \texttt{apartments}[j]| \leq k$, we have found a
   suitable apartment for the current applicant. Thus, we increment $i$, $j$, and
@@ -84,54 +84,58 @@ int main() {
 
 <JavaSection>
 
-<Warning>
-Java will TLE on test case #17.
-</Warning>
-
 ```java
 import java.io.*;
 import java.util.*;
 
 public class Apartments {
-	public static void main(String[] args) {
-		Kattio io = new Kattio();
+	public static void main(String[] args) throws java.lang.Exception {
+		BufferedReader fr = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(System.out);
+
+		String[] t = fr.readLine().split(" ");
+		int n = Integer.parseInt(t[0]);
+		int m = Integer.parseInt(t[1]);
+		long k = Integer.parseInt(t[2]);
+
+		List<Integer> applicants = new ArrayList<>();
+		List<Integer> apartments = new ArrayList<>();
+
+		for (String ele : fr.readLine().split(" ")) {
+			applicants.add(Integer.parseInt(ele));
+		}
 
-		int n = io.nextInt();  // number of applicants
-		int m = io.nextInt();  // number of apartments
-		int k = io.nextInt();  // max diff between desired and actual size
+		for (String ele : fr.readLine().split(" ")) {
+			apartments.add(Integer.parseInt(ele));
+		}
 
-		int[] applicants = new int[n];
-		int[] apartments = new int[m];
-		for (int i = 0; i < n; i++) { applicants[i] = io.nextInt(); }
-		for (int i = 0; i < m; i++) { apartments[i] = io.nextInt(); }
+		Collections.sort(applicants);
+		Collections.sort(apartments);
 
-		Arrays.sort(applicants);
-		Arrays.sort(apartments);
+		int p1 = 0;
+		int p2 = 0;
 
-		int i = 0;
-		int j = 0;
 		int ans = 0;
-		while (i < n && j < m) {
-			// Found suitable apartment
-			if (Math.abs(applicants[i] - apartments[j]) <= k) {
-				i++;
-				j++;
+		while (p1 < n && p2 < m) {
+			// Found a suitable apartment for the applicant
+			if (Math.abs(applicants.get(p1) - apartments.get(p2)) <= k) {
+				p1++;
+				p2++;
 				ans++;
+				continue;
 			}
-			// Apartment is too small -> increment apartment pointer
-			else if (applicants[i] > apartments[j]) {
-				j++;
-			}
-			// Apartment is too big -> increment applicant pointer
-			else {
-				i++;
-			}
+
+			// If the desired apartment size is too small,
+			// skip that applicant and move to the next person
+			if (applicants.get(p1) < apartments.get(p2)) p1++;
+
+			// If the desired apartment size of the applicant is too big,
+			// move the apartment pointer to the right to find a bigger one
+			else p2++;
 		}
-		io.println(ans);
-		io.close();
+		out.println(ans);
+		out.close();
 	}
-
-	// CodeSnip{Kattio}
 }
 ```