suisen-cp · suisen-cp · Sep 25, 2020 · Sep 12, 2020 · Sep 12, 2020 · Sep 12, 2020
diff --git a/2SAT/TwoSAT.java b/2SAT/TwoSAT.java
@@ -16,6 +16,8 @@ public TwoSAT(int n) {
     }
 
     public void addClause(int x, boolean f, int y, boolean g) {
+        rangeCheck(x);
+        rangeCheck(y);
         scc.addEdge(x << 1 | (f ? 0 : 1), y << 1 | (g ? 1 : 0));
         scc.addEdge(y << 1 | (g ? 0 : 1), x << 1 | (f ? 1 : 0));
     }
@@ -48,6 +50,14 @@ public boolean[] answer() {
         return null;
     }
 
+    private void rangeCheck(int x) {
+        if (x < 0 || x >= n) {
+            throw new IndexOutOfBoundsException(
+                String.format("Index %d out of bounds for length %d", x, n)
+            );
+        }
+    }
+
     private static final class EdgeList {
         long[] a;
         int ptr = 0;

diff --git a/Convolution/Convolution.java b/Convolution/Convolution.java
@@ -4,7 +4,7 @@
  * @verified https://atcoder.jp/contests/practice2/tasks/practice2_f
  * @verified https://judge.yosupo.jp/problem/convolution_mod_1000000007
  */
-public class Convolution {
+class Convolution {
     /**
      * Find a primitive root.
      *

diff --git a/Convolution/README.md b/Convolution/README.md
@@ -2,7 +2,8 @@
 
 - - -
 
-NTTで剰余Convolutionを計算するクラスです。
+NTTで剰余Convolutionを計算するクラスです。内部でModIntを使用しているメソッドが1個あるので、
+それを削除するか、使用する場合はModIntも貼り付けてください。
 
 ## 使い方
 

diff --git a/DSU/DSU.java b/DSU/DSU.java
@@ -1,14 +1,11 @@
-import java.util.ArrayList;
-import java.util.Arrays;
-
 class DSU {
 	private int n;
 	private int[] parentOrSize;
 
 	public DSU(int n) {
 		this.n = n;
 		this.parentOrSize = new int[n];
-		Arrays.fill(parentOrSize, -1);
+		java.util.Arrays.fill(parentOrSize, -1);
 	}
 
 	int merge(int a, int b) {
@@ -53,21 +50,21 @@ int size(int a) {
 		return -parentOrSize[leader(a)];
 	}
 
-	ArrayList<ArrayList<Integer>> groups() {
+	java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
 		int[] leaderBuf = new int[n];
 		int[] groupSize = new int[n];
 		for (int i = 0; i < n; i++) {
 			leaderBuf[i] = leader(i);
 			groupSize[leaderBuf[i]]++;
 		}
-		ArrayList<ArrayList<Integer>> result = new ArrayList<>(n);
+		java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
 		for (int i = 0; i < n; i++) {
-			result.add(new ArrayList<>(groupSize[i]));
+			result.add(new java.util.ArrayList<>(groupSize[i]));
 		}
 		for (int i = 0; i < n; i++) {
 			result.get(leaderBuf[i]).add(i);
 		}
-		result.removeIf(ArrayList::isEmpty);
+		result.removeIf(java.util.ArrayList::isEmpty);
 		return result;
 	}
-}
+}
diff --git a/FenwickTree/README.md b/FenwickTree/README.md
@@ -1,5 +1,4 @@
 # クラス FenwickTree
-- - -
 
 長さ $N$ の long型配列に対し,
 

diff --git a/LazySegTree/.gitignore b/LazySegTree/.gitignore
@@ -0,0 +1,3 @@
+test/answer
+test/in
+test/out
diff --git a/LazySegTree/LazySegTree.java b/LazySegTree/LazySegTree.java
@@ -236,4 +236,65 @@ private void inclusiveRangeCheck(int p) {
             );
         }
     }
+
+    // **************** DEBUG **************** //
+
+    private int indent = 6;
+
+    public void setIndent(int newIndent) {
+        this.indent = newIndent;
+    }
+
+    @Override
+    public String toString() {
+        return toSimpleString();
+    }
+
+    private S[] simulatePushAll() {
+        S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
+        F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
+        for (int k = 1; k < N; k++) {
+            if (simLaz[k] == Id) continue;
+            int lk = k << 1 | 0, rk = k << 1 | 1;
+            simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
+            simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
+            if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
+            if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
+            simLaz[k] = Id;
+        }
+        return simDat;
+    }
+
+    public String toDetailedString() {
+        return toDetailedString(1, 0, simulatePushAll());
+    }
+
+    private String toDetailedString(int k, int sp, S[] dat) {
+        if (k >= N) return indent(sp) + dat[k];
+        String s = "";
+        s += toDetailedString(k << 1 | 1, sp + indent, dat);
+        s += "\n";
+        s += indent(sp) + dat[k];
+        s += "\n";
+        s += toDetailedString(k << 1 | 0, sp + indent, dat);
+        return s;
+    }
+
+    private static String indent(int n) {
+        StringBuilder sb = new StringBuilder();
+        while (n --> 0) sb.append(' ');
+        return sb.toString();
+    }
+
+    public String toSimpleString() {
+        S[] dat = simulatePushAll();
+        StringBuilder sb = new StringBuilder();
+        sb.append('[');
+        for (int i = 0; i < N; i++) {
+            sb.append(dat[i + N]);
+            if (i < N - 1) sb.append(',').append(' ');
+        }
+        sb.append(']');
+        return sb.toString();
+    }
 }
diff --git a/LazySegTree/Readme.md b/LazySegTree/Readme.md
@@ -77,7 +77,7 @@ public S prod(int l, int r)
 
 `op(a[l], ..., a[r - 1])` を、モノイドの性質を満たしていると仮定して計算します。`l = r` のときは単位元 `e` を返します。
 
-計算量: $O(n)$
+計算量: $O(\log n)$
 
 制約: `0 <= l <= r <= n`
 

diff --git a/LazySegTree/test/Gen.java b/LazySegTree/test/Gen.java
@@ -0,0 +1,101 @@
+package test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Random;
+
+public class Gen {
+    static final int TESTCASE_NUM = 100;
+
+    static final Random rnd = new Random(System.nanoTime());
+
+    static final int N_MIN = 1;
+    static final int N_MAX = 5000;
+    static final int Q_MIN = 1;
+    static final int Q_MAX = 10000;
+    static final int A_MIN = -1000000000;
+    static final int A_MAX = 1000000000;
+    static final int V_MIN = -1000000000;
+    static final int V_MAX = 1000000000;
+    static final int QUERY_MIN = 0;
+    static final int QUERY_MAX = 7;
+
+    public static void main(String[] args) {
+        for (int i = 0; i < TESTCASE_NUM; i++) {
+            String fileName = String.format("LazySegTree/test/in/testcase_%d", i);
+            try (PrintWriter out = new PrintWriter(new File(fileName))) {
+                gen(out);
+            } catch (IOException e) {
+                e.printStackTrace();
+                System.exit(1);
+            }
+        }
+    }
+
+    public static void gen(PrintWriter out) {
+        final int N = rndIntClosedRange(N_MIN, N_MAX);
+        final int Q = rndIntClosedRange(Q_MIN, Q_MAX);
+        final int P_MIN = 0, P_MAX = N - 1;
+        final int L_MIN = 0, L_MAX = N;
+        final int R_MIN = 0, R_MAX = N;
+        out.print(N); out.print(' '); out.print(Q); out.print('\n');
+        final int[] A = new int[N];
+        for (int i = 0; i < N; i++) {
+            A[i] = rndIntClosedRange(A_MIN, A_MAX);
+            out.print(A[i]);
+            if (i < N - 1) {
+                out.print(' ');
+            } else {
+                out.print('\n');
+            }
+        }
+        for (int i = 0; i < Q; i++) {
+            int type = rndIntClosedRange(QUERY_MIN, QUERY_MAX);
+            out.print(type);
+            if (type == 0) { // set
+                int p = rndIntClosedRange(P_MIN, P_MAX);
+                int v = rndIntClosedRange(V_MIN, V_MAX);
+                out.print(' ');out.print(p);out.print(' ');out.print(v);out.print('\n');
+            } else if (type == 1) { // apply
+                int p = rndIntClosedRange(P_MIN, P_MAX);
+                int v = rndIntClosedRange(V_MIN, V_MAX);
+                out.print(' ');out.print(p);out.print(' ');out.print(v);out.print('\n');
+            } else if (type == 2) { // apply
+                int l = rndIntClosedRange(L_MIN, L_MAX);
+                int r = rndIntClosedRange(R_MIN, R_MAX);
+                int v = rndIntClosedRange(V_MIN, V_MAX);
+                if (l > r) {
+                    int tmp = l; l = r; r = tmp;
+                }
+                out.print(' ');out.print(l);out.print(' ');out.print(r);out.print(' ');out.print(v);out.print('\n');
+            } else if (type == 3) { // get
+                int p = rndIntClosedRange(P_MIN, P_MAX);
+                out.print(' '); out.print(p);out.print('\n');
+            } else if (type == 4) { // prod
+                int l = rndIntClosedRange(L_MIN, L_MAX);
+                int r = rndIntClosedRange(R_MIN, R_MAX);
+                if (l > r) {
+                    int tmp = l; l = r; r = tmp;
+                }
+                out.print(' ');out.print(l);out.print(' ');out.print(r);out.print('\n');
+            } else if (type == 5) { // prodAll
+                out.print('\n');
+            } else if (type == 6) { // maxRight
+                int l = rndIntClosedRange(L_MIN, L_MAX);
+                int v = rndIntClosedRange(V_MIN, V_MAX);
+                out.print(' ');out.print(l);out.print(' ');out.print(v);out.print('\n');
+            } else if (type == 7) { // minLeft
+                int r = rndIntClosedRange(R_MIN, R_MAX);
+                int v = rndIntClosedRange(V_MIN, V_MAX);
+                out.print(' ');out.print(r);out.print(' ');out.print(v);out.print('\n');
+            } else {
+                throw new AssertionError();
+            }
+        }
+    }
+
+    public static int rndIntClosedRange(int l, int r) {
+        return rnd.nextInt(r - l + 1) + l;
+    }
+}
diff --git a/LazySegTree/test/Main.java b/LazySegTree/test/Main.java
@@ -0,0 +1,14 @@
+package test;
+
+public class Main {
+    public static void main(String[] args) {
+        test();
+    }
+
+    static void test() {
+        Gen.main(null);
+        NaiveSolution.main(null);
+        Solution.main(null);
+        Test.main(null);
+    }
+}
diff --git a/LazySegTree/test/NaiveSolution.java b/LazySegTree/test/NaiveSolution.java
@@ -0,0 +1,93 @@
+package test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class NaiveSolution {
+    static final int TEST_CASE_NUM = Gen.TESTCASE_NUM;
+    public static void main(String[] args) {
+        for (int i = 0; i < TEST_CASE_NUM; i++) {
+            String inputFileName = String.format("LazySegTree/test/in/testcase_%d", i);
+            String outputFileName = String.format("LazySegTree/test/answer/answer_%d", i);
+            try (Scanner sc = new Scanner(new File(inputFileName))) {
+                try (PrintWriter pw = new PrintWriter(new File(outputFileName))) {
+                    solve(sc, pw);
+                    sc.close();
+                    pw.flush();
+                    pw.close();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                System.exit(1);
+            }
+        }
+    }
+
+    static final long INF = 1l << 60;
+
+    public static void solve(Scanner sc, PrintWriter pw) {
+        final int N = Integer.parseInt(sc.next());
+        final int Q = Integer.parseInt(sc.next());
+        final long[] A = new long[N];
+        Arrays.setAll(A, i -> Integer.parseInt(sc.next()));
+        for (int i = 0; i < Q; i++) {
+            int queryType = Integer.parseInt(sc.next());
+            if (queryType == 0) {
+                int p = Integer.parseInt(sc.next());
+                int v = Integer.parseInt(sc.next());
+                A[p] = v;
+            } else if (queryType == 1) {
+                int p = Integer.parseInt(sc.next());
+                int v = Integer.parseInt(sc.next());
+                A[p] += v;
+            } else if (queryType == 2) {
+                int l = Integer.parseInt(sc.next());
+                int r = Integer.parseInt(sc.next());
+                int v = Integer.parseInt(sc.next());
+                for (int j = l; j < r; j++) {
+                    A[j] += v;
+                }
+            } else if (queryType == 3) {
+                int p = Integer.parseInt(sc.next());
+                pw.println(A[p]);
+            } else if (queryType == 4) {
+                int l = Integer.parseInt(sc.next());
+                int r = Integer.parseInt(sc.next());
+                long min = INF;
+                for (int j = l; j < r; j++) {
+                    min = Math.min(min, A[j]);
+                }
+                pw.println(min == INF ? "INF" : min);
+            } else if (queryType == 5) {
+                long min = INF;
+                for (int j = 0; j < N; j++) {
+                    min = Math.min(min, A[j]);
+                }
+                pw.println(min);
+            } else if (queryType == 6) {
+                int l = Integer.parseInt(sc.next());
+                int v = Integer.parseInt(sc.next());
+                for (int j = l; j <= N; j++) {
+                    if (j == N || A[j] <= v) {
+                        pw.println(j);
+                        break;
+                    }
+                }
+            } else if (queryType == 7) {
+                int r = Integer.parseInt(sc.next());
+                int v = Integer.parseInt(sc.next());
+                for (int j = r; j >= 0; j--) {
+                    if (j == 0 || A[j - 1] <= v) {
+                        pw.println(j);
+                        break;
+                    }
+                }
+            } else {
+                throw new AssertionError();
+            }
+        }
+    }
+}