git reimport

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();
+  }
+}