fix(codeforces/2108F): Correct file paths

Author: lzwjava

codeforces/2108F/src/Main.java

@@ -1,4 +1,5 @@
 import java.io.*;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
@@ -11,6 +12,7 @@ public class Main {
     long[] a;
     int n;
     long maxMEX;
+    int[] maxP;
 
     Main() {
         in = new BufferedReader(new InputStreamReader(System.in));
@@ -25,12 +27,22 @@ void solve() throws IOException {
             StringTokenizer st = new StringTokenizer(in.readLine());
             for (int i = 0; i < n; i++) {
                 a[i] = Integer.parseInt(st.nextToken());
+                if (a[i] > n) {
+                    a[i] = n;
+                }
             }
             int[] p = new int[n];
             boolean[] used = new boolean[n];
             maxMEX = 0;
+            for (int i = 0; i < n; i++) {
+                p[i] = n - 1 - i;
+            }
+            maxP = new int[n];
+
+            //maxMEX = getMex(p);
             permutation(p, used, 0);
             out.println(maxMEX);
+            // printArray(maxP);
         }
     }
 
@@ -41,43 +53,14 @@ void printArray(int[] p) {
         out.println();
     }
 
+
     void permutation(int[] p, boolean[] used, int cur) {
         if (cur == n) {
-            long[] b = a.clone();
-            for (int i = 0; i < n; i++) {
-                int pos = p[i];
-                long bpi = b[pos];
-                for (int j = 0; j < bpi; j++) {
-                    if (pos + j + 1 < n) {
-                        b[pos + j + 1] += 1;
-                    } else {
-                        break;
-                    }
-                }
-                b[pos] = 0;
-            }
-            boolean nonDecreasing = true;
-            for (int i = 0; i < n - 1; i++) {
-                if (b[i] > b[i + 1]) {
-                    nonDecreasing = false;
-                    break;
-                }
-            }
-
-            if (nonDecreasing) {
-                Set<Long> set = new HashSet<>();
-                for (int i = 0; i < n; i++) {
-                    set.add(b[i]);
-                }
-                long mex;
-                for (mex = 1; ; mex++) {
-                    if (!set.contains(mex)) {
-                        break;
-                    }
-                }
-                if (mex > maxMEX) {
-                    maxMEX = mex;
-                }
+            long mex;
+            mex = getMex(p);
+            if (mex > maxMEX) {
+                maxMEX = mex;
+                maxP = p.clone();
             }
         } else {
             for (int i = 0; i < n; i++) {
@@ -91,6 +74,45 @@ void permutation(int[] p, boolean[] used, int cur) {
         }
     }
 
+    private long getMex(int[] p) {
+        long mex;
+        long[] b = a.clone();
+        for (int i = 0; i < n; i++) {
+            int pos = p[i];
+            long bpi = b[pos];
+            for (int j = 0; j < bpi; j++) {
+                if (pos + j + 1 < n) {
+                    b[pos + j + 1] += 1;
+                } else {
+                    break;
+                }
+            }
+            b[pos] = 0;
+        }
+        boolean nonDecreasing = true;
+        for (int i = 0; i < n - 1; i++) {
+            if (b[i] > b[i + 1]) {
+                nonDecreasing = false;
+                break;
+            }
+        }
+
+        if (nonDecreasing) {
+            Set<Long> set = new HashSet<>();
+            for (int i = 0; i < n; i++) {
+                set.add(b[i]);
+            }
+            for (mex = 1; ; mex++) {
+                if (!set.contains(mex)) {
+                    break;
+                }
+            }
+        } else {
+            mex = -1;
+        }
+        return mex;
+    }
+
     void close() throws IOException {
         if (in != null) {
             in.close();

codeforces/2108F/src/p1/Main.java

@@ -4,75 +4,70 @@
 import java.util.*;
 
 public class Main {
-    BufferedReader in;
-    PrintWriter out;
+    private BufferedReader in;
+    private PrintWriter out;
+    private int[] a;
+    private int n;
 
-    Main() {
+    public Main() {
         in = new BufferedReader(new InputStreamReader(System.in));
         out = new PrintWriter(System.out);
     }
 
-    void solve() throws IOException {
-        int t = Integer.parseInt(in.readLine().trim());
-        while (t-- > 0) {
-            int n = Integer.parseInt(in.readLine().trim());
-            long[] a = new long[n];
-            StringTokenizer st = new StringTokenizer(in.readLine());
-            for (int i = 0; i < n; i++) {
-                if (!st.hasMoreTokens()) {
-                    throw new IOException("Insufficient input tokens");
-                }
-                a[i] = Long.parseLong(st.nextToken());
-                if (a[i] > n) a[i] = n; // Cap a[i] at n
+    public boolean check(int x) {
+        int[] d = new int[n];
+        for (int i = 0; i < n; i++) {
+            int need = Math.max(0, x - n + i);
+            if (i > 0) {
+                d[i] += d[i - 1];
             }
-
-            // Handle n = 1 separately
-            if (n == 1) {
-                out.println(1); // Final array is [0], MEX = 1
-                continue;
+            if (d[i] < need) {
+                return false;
             }
-
-            // Difference array for range updates
-            long[] diff = new long[n + 1];
-            for (int i = n - 1; i >= 0; i--) {
-                if (a[i] == 0) continue; // No increments if a[i] = 0
-                int start = i + 1;
-                int end = (int) Math.min((long) i + a[i], n - 1);
-                if (start <= end) {
-                    diff[start]++;
-                    if (end + 1 <= n) diff[end + 1]--;
-                }
+            int len = d[i] - need + a[i];
+            if (i + 1 < n) {
+                d[i + 1]++;
             }
-
-            // Compute final array b
-            long[] b = new long[n];
-            long sum = 0;
-            for (int i = 0; i < n; i++) {
-                sum += diff[i];
-                b[i] = sum;
+            if (i + len + 1 < n) {
+                d[i + len + 1]--;
             }
+        }
+        return true;
+    }
 
-            // Compute MEX efficiently
-            long mex = 0;
-            for (int i = 0; i < n; i++) {
-                if (b[i] > mex) break; // Gap found
-                if (b[i] == mex) mex++; // All values up to mex-1 exist
+    public void solve() throws IOException {
+        StringTokenizer st = new StringTokenizer(in.readLine());
+        n = Integer.parseInt(st.nextToken());
+
+        a = new int[n];
+        st = new StringTokenizer(in.readLine());
+        for (int i = 0; i < n; i++) {
+            a[i] = Integer.parseInt(st.nextToken());
+        }
+
+        int lo = 0, hi = n;
+        while (lo < hi) {
+            int x = (lo + hi + 1) / 2;
+            if (check(x)) {
+                lo = x;
+            } else {
+                hi = x - 1;
             }
-            out.println(mex);
         }
+        out.println(lo);
     }
 
-    void close() throws IOException {
-        if (in != null) in.close();
-        if (out != null) {
-            out.flush();
-            out.close();
+    public void run() throws IOException {
+        StringTokenizer st = new StringTokenizer(in.readLine());
+        int t = Integer.parseInt(st.nextToken());
+
+        while (t-- > 0) {
+            solve();
         }
+        out.flush();
     }
 
-    public static void main(String[] args) throws Exception {
-        Main main = new Main();
-        main.solve();
-        main.close();
+    public static void main(String[] args) throws IOException {
+        new Main().run();
     }
 }