git reimport

archive/2018.09/2018.09.18 - unsorted/Task.java

@@ -0,0 +1,39 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class Task extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    int s = in.nextInt();
+    int n = in.nextInt();
+    int[] a = in.nextIntArray(n);
+
+    boolean[][] dp = new boolean[2][s + 1];
+    dp[0][0]= true;
+    for (int i = 1; i < n + 1; i++) {
+      for (int j = 0; j < s + 1; j++) {
+        dp[i % 2][j] = dp[(i - 1) % 2][j];
+        if (j - a[i - 1] >= 0 && dp[(i - 1) % 2][j - a[i - 1]]) {
+          dp[i % 2][j] = true;
+        }
+      }
+    }
+
+    for (int i = s; i >= 0; i--) {
+      if (dp[n % 2][i]) {
+        out.println(i);
+        return;
+      }
+    }
+    out.println(0);
+  }
+}

archive/2018.09/2018.09.18 - unsorted/Task.json

@@ -0,0 +1,38 @@
+{
+  "name" : "Task",
+  "testType" : "SINGLE",
+  "input" : {
+    "type" : "STANDARD",
+    "fileName" : "knapsack.in"
+  },
+  "output" : {
+    "type" : "STANDARD",
+    "fileName" : "knapsack.out"
+  },
+  "tests" : [ {
+    "input" : "10 3\n1 4 8",
+    "output" : "9",
+    "index" : 0,
+    "active" : true
+  }, {
+    "input" : "20 4\n5 7 12 18",
+    "output" : "19",
+    "index" : 1,
+    "active" : true
+  } ],
+  "location" : "src/chelper",
+  "vmArgs" : "-Xmx256m -Xss64m",
+  "mainClass" : "Main",
+  "taskClass" : "chelper.Task",
+  "checkerClass" : "net.egork.chelper.checkers.TokenChecker",
+  "checkerParameters" : "",
+  "testClasses" : [ ],
+  "date" : "2018.09.18",
+  "contestName" : "",
+  "truncate" : true,
+  "inputClass" : "io.InputReader",
+  "outputClass" : "io.OutputWriter",
+  "includeLocale" : false,
+  "failOnOverflow" : false,
+  "interactive" : false
+}

archive/2018.09/2018.09.18 - unsorted/Task2.java

@@ -0,0 +1,50 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class Task2 extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  List<Integer> piramidSizes = new ArrayList<>();
+  int max = 300_001;
+  int[] dp = new int[max];
+
+  {
+    piramidSizes.add(0);
+    for (int i = 1; true; i++) {
+      piramidSizes.add(piramidSizes.get(i - 1) + (1 + i) * i / 2);
+      if (piramidSizes.get(i) >= max) {
+        break;
+      }
+    }
+
+    Arrays.fill(dp, max);
+    dp[0] = 0;
+    for (int i = 1; i < max; i++) {
+      for (int j : piramidSizes) {
+        if (j > i) {
+          break;
+        }
+        dp[i] = Math.min(dp[i], dp[i - j] + 1);
+      }
+    }
+  }
+
+  @Override
+  public void solve(int testNumber) {
+
+    int x = in.nextInt();
+    out.println(dp[x]);
+
+  }
+}

archive/2018.09/2018.09.18 - unsorted/Task2.json

@@ -0,0 +1,33 @@
+{
+  "name" : "Task2",
+  "testType" : "MULTI_NUMBER",
+  "input" : {
+    "type" : "STANDARD",
+    "fileName" : "input.txt"
+  },
+  "output" : {
+    "type" : "STANDARD",
+    "fileName" : "output.txt"
+  },
+  "tests" : [ {
+    "input" : "5\n1\n5\n9\n15\n91",
+    "output" : "1\n2\n3\n3\n2",
+    "index" : 0,
+    "active" : true
+  } ],
+  "location" : "src/chelper",
+  "vmArgs" : "-Xmx256m -Xss64m",
+  "mainClass" : "Main",
+  "taskClass" : "chelper.Task2",
+  "checkerClass" : "net.egork.chelper.checkers.TokenChecker",
+  "checkerParameters" : "",
+  "testClasses" : [ ],
+  "date" : "2018.09.18",
+  "contestName" : "",
+  "truncate" : true,
+  "inputClass" : "io.InputReader",
+  "outputClass" : "io.OutputWriter",
+  "includeLocale" : false,
+  "failOnOverflow" : false,
+  "interactive" : false
+}

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/A - Vasya And Password.task

@@ -0,0 +1,30 @@
+22 A - Vasya And Password
+12 MULTI_NUMBER
+8 STANDARD
+9 input.txt
+8 STANDARD
+10 output.txt
+1
+0
+16 2
+abcDCE
+htQw27
+
+14 abcD4E
+htQw27
+
+1
+11 src/chelper
+8 -Xmx256M
+4 Main
+13 chelper.TaskA
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2018.09.20
+50 Educational Codeforces Round 51 (Rated for Div. 2)
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/B - Relatively Prime Pairs.task

@@ -0,0 +1,31 @@
+26 B - Relatively Prime Pairs
+6 SINGLE
+8 STANDARD
+-1
+8 STANDARD
+-1
+1
+0
+4 1 8
+
+20 YES
+2 7
+4 1
+3 8
+6 5
+
+1
+11 src/chelper
+8 -Xmx256M
+4 Main
+13 chelper.TaskB
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2018.09.20
+50 Educational Codeforces Round 51 (Rated for Div. 2)
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/C - Vasya and Multisets.task

@@ -0,0 +1,42 @@
+23 C - Vasya and Multisets
+6 SINGLE
+8 STANDARD
+-1
+8 STANDARD
+-1
+3
+0
+10 4
+3 5 7 1
+
+9 YES
+BABA
+
+1
+1
+8 3
+3 5 1
+
+3 NO
+
+1
+2
+9 4
+1 2 2 2
+8 YES
+ABAA
+1
+11 src/chelper
+8 -Xmx256M
+4 Main
+13 chelper.TaskC
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2018.09.20
+50 Educational Codeforces Round 51 (Rated for Div. 2)
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/D - Bicolorings.task

@@ -0,0 +1,63 @@
+15 D - Bicolorings
+6 SINGLE
+8 STANDARD
+-1
+8 STANDARD
+-1
+9
+0
+4 3 4
+
+3 12
+
+1
+1
+4 4 1
+
+2 2
+
+1
+2
+4 1 2
+
+2 2
+
+1
+3
+9 1000 2000
+1 2
+1
+4
+3 1 1
+1 2
+1
+5
+3 1 2
+1 2
+1
+6
+6 1000 1
+1 2
+1
+7
+3 2 2
+2 12
+1
+8
+3 3 0
+1 0
+1
+11 src/chelper
+8 -Xmx256M
+4 Main
+13 chelper.TaskD
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2018.09.20
+50 Educational Codeforces Round 51 (Rated for Div. 2)
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/TaskA.java

@@ -0,0 +1,111 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskA extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  int getType(char c) {
+    if ('A' <= c && c <= 'Z') {
+      return 0;
+    }
+    if ('a' <= c && c <= 'z') {
+      return 1;
+    }
+    if ('0' <= c && c <= '9') {
+      return 2;
+    }
+    throw new RuntimeException();
+  }
+
+  char getChar(int type) {
+    if (type == 0) {
+      return 'A';
+    }
+    if (type == 1) {
+      return 'a';
+    }
+    if (type == 2) {
+      return '0';
+    }
+    throw new RuntimeException();
+  }
+
+  boolean isOk(int[] a) {
+    int[] counts = new int[3];
+
+    for (int i : a) {
+      counts[i]++;
+    }
+
+    return counts[0] > 0 && counts[1] > 0 && counts[2] > 0;
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    String s = in.nextString();
+
+    int n = s.length();
+
+    char[] chars = s.toCharArray();
+
+    int[] types = new int[n];
+    int[] counts = new int[3];
+
+    for (int i = 0; i < n; i++) {
+      types[i] = getType(chars[i]);
+      counts[types[i]]++;
+    }
+
+    if (isOk(types)) {
+      out.println(s);
+      return;
+    }
+
+    int[] t = new int[n];
+
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < 3; j++) {
+        for (int k = 0; k < n; k++) {
+          t[k] = types[k];
+        }
+
+        t[i] = j;
+
+        if (isOk(t)) {
+          chars[i] = getChar(j);
+          out.println(new String(chars));
+          return;
+        }
+      }
+    }
+
+    for (int i = 0; i < n - 1; i++) {
+      for (int j1 = 0; j1 < 3; j1++) {
+        for (int j2 = j1 + 1; j2 < 3; j2++) {
+          for (int k = 0; k < n; k++) {
+            t[k] = types[k];
+          }
+
+          t[i] = j1;
+          t[i + 1] = j2;
+
+          if (isOk(t)) {
+            chars[i] = getChar(j1);
+            chars[i + 1] = getChar(j2);
+            out.println(new String(chars));
+            return;
+          }
+        }
+      }
+    }
+
+    
+  }
+}

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/TaskB.java

@@ -0,0 +1,25 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskB extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    long l = in.nextLong();
+    long r = in.nextLong();
+
+    out.println("YES");
+
+    for (long i = l; i <= r; i += 2) {
+      out.println(i + " " + (i + 1));
+    }
+  }
+}

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/TaskC.java

@@ -0,0 +1,82 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskC extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    int n = in.nextInt();
+    int[] a = in.nextIntArray(n);
+    
+    int[] counts = new int[200];
+    for (int i : a) {
+      counts[i]++;
+    }
+
+    int size1 = 0;
+    int size2 = 0;
+    int size3Plus = 0;
+
+    for (int count : counts) {
+      if (count == 1) {
+        size1++;
+      }
+      if (count == 2) {
+        size2++;
+      }
+      if (count >= 3) {
+        size3Plus++;
+      }
+    }
+
+    if (size1 % 2 == 1 && size3Plus == 0) {
+      out.println("NO");
+      return;
+    }
+
+    boolean[] mask = new boolean[n];
+
+    boolean parity = true;
+    boolean shouldUse3Plus = size1 % 2 == 1;
+
+    for (int i = 0; i < 200; i++) {
+      if (counts[i] == 1) {
+        for (int j = 0; j < n; j++) {
+          if (a[j] == i) {
+            mask[j] = parity;
+          }
+        }
+
+        parity = !parity;
+      }
+
+      if (counts[i] >= 3 && shouldUse3Plus) {
+        boolean first = true;
+
+        for (int j = 0; j < n; j++) {
+          if (a[j] == i) {
+            mask[j] = parity == first;
+            first = false;
+          }
+        }
+
+        parity = !parity;
+        shouldUse3Plus = false;
+      }
+    }
+
+
+    out.println("YES");
+    for (boolean b : mask) {
+      out.print(b ? 'A' : 'B');
+    }
+  }
+}

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/TaskD.java

@@ -0,0 +1,58 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskD extends SimpleSavingChelperSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  int MOD = 998244353;
+
+  int[][] componentChanges = {
+      {0, 1, 1, 1}, //00
+      {0, 0, 2, 0}, //01
+      {0, 2, 0, 0}, //10
+      {1, 1, 1, 0}, //11
+  };
+
+  @Override
+  public void solve(int testNumber) {
+    int n = in.nextInt();
+    int colors = in.nextInt();
+
+    int[][][] dp = new int[n][colors + 10][4];
+
+    dp[0][1][0]++;
+    dp[0][2][1]++;
+    dp[0][2][2]++;
+    dp[0][1][3]++;
+
+    for (int i = 0; i < n - 1; i++) {
+      for (int k = 0; k <= colors; k++) {
+        for (int curMask = 0; curMask < 4; curMask++) {
+          for (int nextMask = 0; nextMask < 4; nextMask++) {
+            int newK = k + componentChanges[curMask][nextMask];
+            if (newK > colors) {
+              continue;
+            }
+
+            dp[i + 1][newK][nextMask] += dp[i][k][curMask];
+            dp[i + 1][newK][nextMask] %= MOD;
+          }
+        }
+      }
+    }
+
+    int result = 0;
+    for (int i = 0; i < 4; i++) {
+      result += dp[n - 1][colors][i];
+      result %= MOD;
+    }
+    out.println(result);
+  }
+}

archive/2018.09/2018.09.20 - Educational Codeforces Round 51 (Rated for Div. 2)/TaskF.java

@@ -0,0 +1,303 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Set;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.Pair;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskF extends SimpleSavingChelperSolution {
+
+  public static final long INF = Long.MAX_VALUE / 100;
+  private Map<Integer, Map<Integer, Long>> edges;
+  private int n;
+  private int m;
+  private int treeCount;
+  private int[] vertexTreeId;
+  private Set<Integer> treeEgressPointsSet;
+  private int[] vertexTreeHeight;
+  private long[] vertexTreeLength;
+  private boolean[] tainted;
+  private int[] dfsIn;
+  private int[] dfsOut;
+  private int timer;
+  private int[][] upside;
+  private List<List<Integer>> egressPointsByTree;
+  private List<int[]> edges2Dest;
+  private List<long[]> edges2Dist;
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    TaskF task = this;
+
+    Thread thread = new Thread(null, new Runnable() {
+      @Override
+      public void run() {
+        task.wrapSolve(testNumber, in, out);
+      }
+    }, "Test", 1 << 26);
+    thread.start();
+    try {
+      thread.join();
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+
+//    wrapSolve(testNumber, in, out);
+  }
+
+  static final int UPSIDE_L = 20;
+
+  @Override
+  public void solve(int testNumber) {
+    long startTime = System.nanoTime();
+
+    n = in.nextInt();
+    m = in.nextInt();
+
+    edges = new HashMap<>();
+    for (int i = 0; i < n; i++) {
+      edges.put(i, new HashMap<>());
+    }
+
+    for (int i = 0; i < m; i++) {
+      int a = in.nextInt() - 1;
+      int b = in.nextInt() - 1;
+      long c = in.nextLong();
+
+      edges.get(a).put(b, c);
+      edges.get(b).put(a, c);
+    }
+
+    treeCount = 0;
+    vertexTreeId = new int[n];
+    vertexTreeHeight = new int[n];
+    vertexTreeLength = new long[n];
+    Arrays.fill(vertexTreeId, -1);
+
+    treeEgressPointsSet = new HashSet<>();
+
+    dfsIn = new int[n];
+    dfsOut = new int[n];
+    timer = 1;
+
+    upside = new int[n][UPSIDE_L + 1];
+    for (int i = 0; i < n; i++) {
+      Arrays.fill(upside[i], -1);
+    }
+
+    tainted = new boolean[n];
+
+    treefy();
+//    treefy2();
+
+    debug.println("Treefy finish " + (System.nanoTime() - startTime) / 1e9);
+    debug.println("Trees: " + treeCount);
+    debug.println("TEP: " + treeEgressPointsSet.size());
+
+    egressPointsByTree = new ArrayList<>();
+    for (int i = 0; i < treeCount; i++) {
+      egressPointsByTree.add(new ArrayList<>());
+    }
+
+    for (int v1 : treeEgressPointsSet) {
+      egressPointsByTree.get(vertexTreeId[v1]).add(v1);
+    }
+
+    edges2Dest = new ArrayList<>();
+    edges2Dist = new ArrayList<>();
+
+    for (int v = 0; v < n; v++) {
+      int m = edges.get(v).size();
+
+      int[] dest = new int[m];
+      long[] dist = new long[m];
+      int k = 0;
+      for (Map.Entry<Integer, Long> entry : edges.get(v).entrySet()) {
+        int vv = entry.getKey();
+        long c = entry.getValue();
+
+        dest[k] = vv;
+        dist[k] = c;
+        k++;
+      }
+      edges2Dest.add(dest);
+      edges2Dist.add(dist);
+    }
+
+    Map<Integer, long[]> egressDistances = new HashMap<>();
+    for (int origin : treeEgressPointsSet) {
+      long[] distances = new long[n];
+      Arrays.fill(distances, INF);
+      distances[origin] = 0;
+
+      egressDistances.put(origin, distances);
+
+      egressDijkstra(origin, distances);
+    }
+    debug.println("Dijkstra finish " + (System.nanoTime() - startTime) / 1e9);
+
+    debug.println("preprocess finish " + (System.nanoTime() - startTime) / 1e9);
+
+    int requestCount = in.nextInt();
+    for (int i = 0; i < requestCount; i++) {
+      int a = in.nextInt() - 1;
+      int b = in.nextInt() - 1;
+
+      long res = INF;
+
+      if (vertexTreeId[a] == vertexTreeId[b]) {
+        res = Math.min(res, insideTreeDistance(a, b));
+      }
+
+      for (int v1 : egressPointsByTree.get(vertexTreeId[a])) {
+        long dist = egressDistances.get(v1)[a] + egressDistances.get(v1)[b];
+
+        res = Math.min(res, dist);
+      }
+
+      out.println(res);
+    }
+  }
+
+  boolean isUpsideInTree(int a, int b) {
+    return dfsIn[a] <= dfsIn[b] && dfsOut[a] >= dfsOut[b];
+  }
+
+  int lca(int a, int b) {
+    if (isUpsideInTree(a, b)) {
+      return a;
+    }
+    if (isUpsideInTree(b, a)) {
+      return b;
+    }
+    for (int l = UPSIDE_L; l >= 0; l--) {
+      if (upside[a][l] == -1) {
+        continue;
+      }
+      if (!isUpsideInTree(upside[a][l], b)) {
+        a = upside[a][l];
+      }
+    }
+    return upside[a][0];
+  }
+
+  long insideTreeDistance(int v1, int v2) {
+    int l = lca(v1, v2);
+
+    return vertexTreeLength[v1] + vertexTreeLength[v2] - vertexTreeLength[l] * 2;
+  }
+
+  void treefyDfs(int v, List<Integer> stack) {
+    dfsIn[v] = timer++;
+
+    for (Map.Entry<Integer, Long> edge : edges.get(v).entrySet()) {
+      int vv = edge.getKey();
+      long c = edge.getValue();
+
+      if (vertexTreeId[vv] == -1 && !tainted[vv]) {
+        for (Map.Entry<Integer, Long> edge2 : edges.get(vv).entrySet()) {
+          int vvv = edge2.getKey();
+
+          if (vertexTreeId[vvv] == vertexTreeId[v] && vvv != v) {
+            tainted[vv] = true;
+          }
+        }
+
+        if (tainted[vv]) {
+          continue;
+        }
+
+        vertexTreeId[vv] = vertexTreeId[v];
+        vertexTreeHeight[vv] = vertexTreeHeight[v] + 1;
+        vertexTreeLength[vv] = vertexTreeLength[v] + c;
+
+        stack.add(vv);
+
+        for (int l = 0; l <= UPSIDE_L; l++) {
+          int j = stack.size() - 1 - (1 << l);
+          if (j < 0) {
+            break;
+          }
+          upside[vv][l] = stack.get(j);
+        }
+        treefyDfs(vv, stack);
+
+        stack.remove(stack.size() - 1);
+      }
+
+      if (vertexTreeId[v] != vertexTreeId[vv] && vertexTreeId[vv] != -1) {
+        treeEgressPointsSet.add(v);
+        treeEgressPointsSet.add(vv);
+      }
+    }
+
+    dfsOut[v] = timer++;
+  }
+
+  void egressDijkstra(int origin, long[] distances) {
+    PriorityQueue<long[]> queue = new PriorityQueue<>(new Comparator<long[]>() {
+      @Override
+      public int compare(long[] o1, long[] o2) {
+        return Long.compare(o1[0], o2[0]);
+      }
+    });
+    Arrays.fill(tainted, false);
+
+    int treeId = vertexTreeId[origin];
+
+    queue.add(new long[]{0L, origin});
+    tainted[origin] = true;
+
+    while (!queue.isEmpty()) {
+      int v = (int) queue.poll()[1];
+
+      int[] dest = edges2Dest.get(v);
+      long[] dist = edges2Dist.get(v);
+
+      for (int i = 0; i < dest.length; i++) {
+        int vv = dest[i];
+        long c = dist[i];
+
+        distances[vv] = Math.min(distances[vv], distances[v] + c);
+
+        if (tainted[vv]) {
+          continue;
+        }
+
+        tainted[vv] = true;
+        queue.add(new long[]{distances[vv], vv});
+      }
+    }
+
+  }
+
+
+  void treefy() {
+    for (int v = 0; v < n; v++) {
+      if (vertexTreeId[v] == -1) {
+        Arrays.fill(tainted, false);
+
+        int treeId = treeCount;
+        treeCount++;
+        vertexTreeId[v] = treeId;
+        vertexTreeHeight[v] = 0;
+        vertexTreeLength[v] = 0;
+
+        List<Integer> stack = new ArrayList<>();
+        stack.add(v);
+
+        treefyDfs(v, stack);
+      }
+    }
+  }
+}

archive/2018.09/2018.09.20 - unsorted/TaskFGen.java

@@ -0,0 +1,100 @@
+package chelper;
+
+import static chelper.TaskF.INF;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskFGen extends SimpleSavingChelperSolution {
+
+  public static final int N = 100000;
+  public static final int M = 100020;
+  public static final int Q = 100000;
+  public static final int MAX_D = 1000000000;
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    boolean input = true;
+
+    if (input) {
+      out.println(N);
+      out.println(M);
+    }
+
+    Random random = new Random(0);
+    Map<Integer, Map<Integer, Long>> edges = new HashMap<>();
+    for (int i = 0; i < N; i++) {
+      edges.put(i, new HashMap<>());
+    }
+
+    for (int i = 0; i < N - 1; i++) {
+      long c = random.nextInt(MAX_D) + 1;
+      edges.get(i).put(i + 1, c);
+      edges.get(i + 1).put(i, c);
+      if (input) {
+        out.println((i + 1) + " " + (i + 2) + " " + c);
+      }
+
+      edges.get(i).put(i, 0L);
+    }
+
+    for (int i = 0; i < M - N + 1; i++) {
+      long c = random.nextInt(MAX_D) + 1;
+
+      int a = random.nextInt(N);
+      int b = a;
+
+      while (b == a || edges.get(a).containsKey(b)) {
+        b = random.nextInt(N);
+      }
+
+      edges.get(a).put(b, c);
+      edges.get(b).put(a, c);
+      if (input) {
+        out.println((a + 1) + " " + (b + 1) + " " + c);
+      }
+    }
+
+//    for (int k : edges.keySet()) {
+//      for (int i : edges.keySet()) {
+//        for (int j : edges.keySet()) {
+//          edges.get(i).put(j, Math.min(
+//              edges.get(i).getOrDefault(j, INF),
+//              edges.get(i).getOrDefault(k, INF) + edges.get(k).getOrDefault(j, INF)
+//          ));
+//        }
+//      }
+//    }
+
+    if (input) {
+      out.println(Q);
+    }
+
+    for (int i = 0; i < Q; i++) {
+      int a = random.nextInt(N);
+      int b = a;
+
+      while (b == a) {
+        b = random.nextInt(N);
+      }
+      if (input) {
+        out.println((a + 1) + " " + (b + 1));
+      }
+
+      if (!input) {
+        out.println(edges.get(a).get(b));
+      }
+    }
+
+  }
+}

archive/2018.09/2018.09.20 - unsorted/TaskFGen.json

@@ -0,0 +1,32 @@
+{
+  "name" : "TaskFGen",
+  "testType" : "SINGLE",
+  "input" : {
+    "type" : "STANDARD",
+    "fileName" : "input.txt"
+  },
+  "output" : {
+    "type" : "STANDARD",
+    "fileName" : "output.txt"
+  },
+  "tests" : [ {
+    "input" : "",
+    "index" : 0,
+    "active" : true
+  } ],
+  "location" : "src/chelper",
+  "vmArgs" : "-Xmx256m -Xss64m",
+  "mainClass" : "Main",
+  "taskClass" : "chelper.TaskFGen",
+  "checkerClass" : "net.egork.chelper.checkers.TokenChecker",
+  "checkerParameters" : "",
+  "testClasses" : [ ],
+  "date" : "2018.09.20",
+  "contestName" : "",
+  "truncate" : true,
+  "inputClass" : "io.InputReader",
+  "outputClass" : "io.OutputWriter",
+  "includeLocale" : false,
+  "failOnOverflow" : false,
+  "interactive" : false
+}

archive/2018.09/2018.09.30 - unsorted/TaskA.java

@@ -0,0 +1,69 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.GCJSolution;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskA extends GCJSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  HashSet<ArrayList<Integer>> set = new HashSet<>();
+
+  ArrayList<Integer> gen() {
+    ArrayList<Integer> res = new ArrayList<>();
+
+    for (int i = 0; i < 26; i++) {
+      res.add(0);
+    }
+
+    return res;
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    int n = in.nextInt();
+    char[] a = in.nextString().toCharArray();
+    char[] b = in.nextString().toCharArray();
+
+
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j <= n; j++) {
+        ArrayList<Integer> chars = gen();
+
+        for (int k = i; k < j; k++) {
+          chars.set(b[k] - 'A', chars.get(b[k] - 'A') + 1);
+        }
+
+        set.add(chars);
+      }
+    }
+
+    int res = 0;
+
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j <= n; j++) {
+        ArrayList<Integer> chars = gen();
+
+        for (int k = i; k < j; k++) {
+          chars.set(a[k] - 'A', chars.get(a[k] - 'A') + 1);
+        }
+
+        if (set.contains(chars)) {
+          res++;
+        }
+      }
+    }
+
+    out.println(res);
+    out.println(res);
+  }
+}

archive/2018.09/2018.09.30 - unsorted/TaskA.json

@@ -0,0 +1,33 @@
+{
+  "name" : "TaskA",
+  "testType" : "MULTI_NUMBER",
+  "input" : {
+    "type" : "STANDARD",
+    "fileName" : "input.txt"
+  },
+  "output" : {
+    "type" : "STANDARD",
+    "fileName" : "output.txt"
+  },
+  "tests" : [ {
+    "input" : "6\n3\nABB\nBAB\n3\nBAB\nABB\n6\nCATYYY\nXXXTAC\n9\nSUBXXXXXX\nSUBBUSUSB\n4\nAAAA\nAAAA\n19\nPLEASEHELPIMTRAPPED\nINAKICKSTARTFACTORY",
+    "output" : "Case #1: 5\nCase #2: 6\nCase #3: 6\nCase #4: 6\nCase #5: 10\nCase #6: 9",
+    "index" : 0,
+    "active" : true
+  } ],
+  "location" : "src/chelper",
+  "vmArgs" : "-Xmx256m -Xss64m",
+  "mainClass" : "Main",
+  "taskClass" : "chelper.TaskA",
+  "checkerClass" : "net.egork.chelper.checkers.TokenChecker",
+  "checkerParameters" : "",
+  "testClasses" : [ ],
+  "date" : "2018.09.30",
+  "contestName" : "",
+  "truncate" : true,
+  "inputClass" : "io.InputReader",
+  "outputClass" : "io.OutputWriter",
+  "includeLocale" : false,
+  "failOnOverflow" : false,
+  "interactive" : false
+}

archive/2018.09/2018.09.30 - unsorted/TaskATwo.java

@@ -0,0 +1,68 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.GCJSolution;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskATwo extends GCJSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+
+
+  ArrayList<Integer> gen() {
+    ArrayList<Integer> res = new ArrayList<>();
+
+    for (int i = 0; i < 26; i++) {
+      res.add(0);
+    }
+
+    return res;
+  }
+  
+  @Override
+  public void solve(int testNumber) {
+    HashSet<ArrayList<Integer>> set = new HashSet<>();
+    int n = in.nextInt();
+    char[] a = in.nextString().toCharArray();
+    char[] b = in.nextString().toCharArray();
+
+
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j <= n; j++) {
+        ArrayList<Integer> chars = gen();
+
+        for (int k = i; k < j; k++) {
+          chars.set(b[k] - 'A', chars.get(b[k] - 'A') + 1);
+        }
+
+        set.add(chars);
+      }
+    }
+
+    int res = 0;
+
+    for (int i = 0; i < n; i++) {
+      for (int j = i + 1; j <= n; j++) {
+        ArrayList<Integer> chars = gen();
+
+        for (int k = i; k < j; k++) {
+          chars.set(a[k] - 'A', chars.get(a[k] - 'A') + 1);
+        }
+
+        if (set.contains(chars)) {
+          res++;
+        }
+      }
+    }
+
+    out.println(res);
+  }
+}

archive/2018.09/2018.09.30 - unsorted/TaskB.java

@@ -0,0 +1,244 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.TreeMap;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.Algo;
+import misc.Couple;
+import misc.GCJSolution;
+
+
+public class TaskB extends GCJSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+
+
+    int n = in.nextInt();
+    int m = in.nextInt();
+
+    Map<Integer, List<Couple<Integer>>> edges = new HashMap<>();
+
+    for (int i = 0; i < n; i++) {
+      edges.put(i, new ArrayList<>());
+    }
+
+    int special1 = -1;
+    int special2 = -1;
+
+    for (int i = 0; i < m; i++) {
+      int a = in.nextInt() - 1;
+      int b = in.nextInt() - 1;
+
+      int c = in.nextInt();
+
+      if (c == 0) {
+        special1 = a;
+        special2 = b;
+      }
+
+      edges.get(a).add(new Couple<>(b, c));
+      edges.get(b).add(new Couple<>(a, c));
+    }
+
+//    long ans1 = solveBrute(n, m, edges);
+//    out.println(ans1);
+    long ans2 = solveSmart2(n, m, edges, special1, special2);
+    out.println(ans2);
+
+//    if (ans1 != ans2) {
+////      out.println("case " + testNumber + " : " + n + " " + m);
+//    }
+  }
+
+  long solveBrute(int n, int m, Map<Integer, List<Couple<Integer>>> edges) {
+    int[][] distances = new int[n][n];
+
+    for (int i = 0; i < n; i++) {
+      Arrays.fill(distances[i], 100000000);
+      distances[i][i] = 0;
+    }
+
+    for (int v = 0; v < n; v++) {
+      for (Couple<Integer> edge : edges.get(v)) {
+        int vv = edge.first;
+        int c = edge.second;
+
+        distances[v][vv] = Math.min(distances[v][vv], c);
+        distances[vv][v] = Math.min(distances[vv][v], c);
+      }
+    }
+
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        for (int k = 0; k < n; k++) {
+          distances[i][j] = Math.min(distances[i][j], distances[i][k] + distances[k][j]);
+        }
+      }
+    }
+
+    int res = 0;
+    int bestSum = Integer.MAX_VALUE;
+
+    for (int mask = 1; mask < (1 << n) - 1; mask++) {
+      boolean[] colors = new boolean[n];
+
+      for (int i = 0; i < n; i++) {
+        colors[i] = (mask & (1 << i)) > 0;
+      }
+
+      int sum = 0;
+
+      for (int i = 0; i < n; i++) {
+        int min = Integer.MAX_VALUE;
+
+        for (int j = 0; j < n; j++) {
+          if (colors[i] != colors[j]) {
+            min = Math.min(min, distances[i][j]);
+          }
+        }
+
+        sum += min;
+      }
+
+      if (sum < bestSum) {
+        debug.println("new best sum " + sum);
+        bestSum = sum;
+        res = 0;
+      }
+
+      if (sum == bestSum) {
+        res++;
+      }
+
+      if (sum == 2) {
+        for (boolean color : colors) {
+          debug.print(color ? '1' : '0');
+        }
+        debug.println();
+      }
+    }
+
+    return res;
+  }
+
+
+  long solveSmart2(int n, int m, Map<Integer, List<Couple<Integer>>> edges, int special1, int special2) {
+    TreeMap<Integer, Couple<Integer>> edgesSorted = new TreeMap<>();
+
+    for (int v = 0; v < n; v++) {
+      for (Couple<Integer> edge : edges.get(v)) {
+        int vv = edge.first;
+        int c = edge.second;
+
+        edgesSorted.put(c, new Couple<>(v, vv));
+      }
+    }
+
+    int components = 0;
+    int zeroAdjacent = 0;
+
+    boolean[] visited = new boolean[n];
+
+    for (Map.Entry<Integer, Couple<Integer>> edge : edgesSorted.entrySet()) {
+      int c = edge.getKey();
+
+      int v = edge.getValue().first;
+      int vv = edge.getValue().second;
+
+      if (!visited[v] && !visited[vv]) {
+        components++;
+      }
+
+      if (visited[v] != visited[vv]) {
+        if (v == special1 || v == special2 || vv == special1 || vv == special2) {
+          zeroAdjacent++;
+        }
+      }
+
+      visited[v] = true;
+      visited[vv] = true;
+    }
+
+    return 1L << (components + zeroAdjacent);
+  }
+
+  long solveSmart(int n, int m, Map<Integer, List<Couple<Integer>>> edges, int special1, int special2) {
+
+
+    int components = 0;
+    int specialAdd = 0;
+
+    boolean[] visited = new boolean[n];
+
+    if (special1 != -1) {
+      List<Integer> specialStarting = new ArrayList<>();
+      specialStarting.add(special1);
+      specialStarting.add(special2);
+
+      specialAdd = bfs(specialStarting, edges, visited) + 1;
+    }
+
+    for (int i = 0; i < n; i++) {
+      if (!visited[i]) {
+        List<Integer> starting = new ArrayList<>();
+        starting.add(i);
+
+        bfs(starting, edges, visited);
+
+        components++;
+      }
+    }
+
+    return 1L << (components + specialAdd);
+  }
+
+  int bfs(List<Integer> starting, Map<Integer, List<Couple<Integer>>> edges, boolean[] visited) {
+    Queue<Integer> queue = new LinkedList<>(starting);
+
+    Set<Integer> immediateNeighbours = new HashSet<>();
+
+    for (int v : starting) {
+      visited[v] = true;
+
+      for (Couple<Integer> edge : edges.get(v)) {
+        int vv = edge.first;
+        int c = edge.second;
+
+        immediateNeighbours.add(vv);
+      }
+    }
+    immediateNeighbours.removeAll(starting);
+
+    while (!queue.isEmpty()) {
+      int v = queue.poll();
+
+      for (Couple<Integer> edge : edges.get(v)) {
+        int vv = edge.first;
+        int c = edge.second;
+
+        if (!visited[vv]) {
+          visited[vv] = true;
+          queue.add(vv);
+        }
+
+      }
+    }
+
+    return immediateNeighbours.size();
+  }
+}