git reimport

archive/2017.04/2017.04.30 - unsorted/TaskA.java

@@ -0,0 +1,124 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+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);
+  }
+
+  class Pancake implements Comparable<Pancake> {
+    final int r;
+    final int h;
+
+    public Pancake(int r, int h) {
+      this.r = r;
+      this.h = h;
+    }
+
+    @Override
+    public int compareTo(Pancake o) {
+      int t = -Integer.compare(r, o.r);
+      if (t != 0) {
+        return t;
+      }
+      return Integer.compare(h, o.h);
+    }
+
+    double sides() {
+      return 2 * Math.PI * r * h;
+    }
+
+    double area() {
+      return Math.PI * r * r;
+    }
+
+    double total() {
+      return sides() + area();
+    }
+
+    @Override
+    public String toString() {
+      return "Pancake{" +
+          "r=" + r +
+          ", h=" + h +
+          '}';
+    }
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    int n = in.nextInt();
+    int k = in.nextInt();
+
+    List<Pancake> pancakes = new ArrayList<>();
+
+    Random random = new Random();
+
+    for (int i = 0; i < n; i++) {
+      pancakes.add(new Pancake(in.nextInt(), in.nextInt()));
+
+//      pancakes.add(new Pancake(random.nextInt(100000), random.nextInt(100000)));
+    }
+
+    Collections.sort(pancakes);
+
+    double[][] dp = new double[n + 1][n];
+
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        dp[i][j] = -1;
+      }
+    }
+
+//    for (Pancake pancake : pancakes) {
+//      System.out.println(pancake);
+//    }
+
+    Arrays.fill(dp[0], 0);
+
+    for (int addI = 0; addI < n; addI++) {
+      Pancake add = pancakes.get(addI);
+
+      double addTotal = add.total();
+      double addArea = add.area();
+
+      for (int i = n - 1; i >= 0; i--) {
+        for (int j = 0; j < n; j++) {
+          if (dp[i][j] < 0) {
+            continue;
+          }
+
+          double newRes = dp[i][j] + addTotal;
+          if (i != 0) {
+            newRes -= addArea;
+          }
+
+          if (newRes > dp[i + 1][addI]) {
+//            System.out.println("set " + (i + 1) + " " + j + " + " + addI + " = " + newRes);
+            dp[i + 1][addI] = newRes;
+          }
+        }
+      }
+    }
+
+    double max = -1;
+    for (int i = 0; i < n; i++) {
+      max = Math.max(max, dp[k][i]);
+    }
+//    System.out.println();
+
+    out.println(max);
+  }
+}

archive/2017.04/2017.04.30 - unsorted/TaskB.java

@@ -0,0 +1,159 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.GCJSolution;
+
+
+public class TaskB extends GCJSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  class Interval implements Comparable<Interval> {
+    int start;
+    int end;
+    int kind;
+    int len;
+
+    public Interval(int start, int end, int kind) {
+      this.start = start;
+      this.end = end;
+      this.kind = kind;
+      len = end - start;
+    }
+
+    @Override
+    public int compareTo(Interval o) {
+      return Integer.compare(start, o.start);
+    }
+
+    @Override
+    public String toString() {
+      return "Interval{" +
+          "start=" + start +
+          ", end=" + end +
+          ", kind=" + kind +
+          ", len=" + len +
+          '}';
+    }
+  }
+
+  int BIG = 1000000;
+
+  int[] makeDp() {
+    int[] dp = new int[721];
+    Arrays.fill(dp, BIG);
+    return dp;
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    System.out.println("Test " + testNumber);
+    System.out.flush();
+
+    List<Interval> intervals = new ArrayList<>();
+
+    int a1 = in.nextInt();
+    int a2 = in.nextInt();
+
+    for (int i = 0; i < a1; i++) {
+      intervals.add(new Interval(in.nextInt(), in.nextInt(), 0));
+    }
+    for (int i = 0; i < a2; i++) {
+      intervals.add(new Interval(in.nextInt(), in.nextInt(), 1));
+    }
+
+    int[] dp = makeDp();
+    int[] newDp;
+
+    dp[0] = 0;
+
+    Collections.sort(intervals);
+
+    intervals.add(new Interval(intervals.get(0).start + 1440, intervals.get(0).end + 1440, intervals.get(0).kind));
+
+    int totalTaken = 0;
+
+    for (int intervalI = 0; intervalI < intervals.size() - 1; intervalI++) {
+      Interval x = intervals.get(intervalI);
+      int k = x.kind;
+
+      {
+        newDp = makeDp();
+        for (int aTaken = 0; aTaken <= 720; aTaken++) {
+          int bTaken = totalTaken - aTaken;
+
+          if (bTaken < 0 || dp[aTaken] == BIG) {
+            continue;
+          }
+
+          int aTaken2 = aTaken + (k == 0 ? x.len : 0);
+          int bTaken2 = bTaken + (k == 1 ? x.len : 0);
+
+          if (aTaken2 > 720 || bTaken2 > 720) {
+            continue;
+          }
+
+          newDp[aTaken2] = dp[aTaken];
+        }
+        totalTaken += x.len;
+        dp = newDp;
+      }
+
+      Interval next = intervals.get(intervalI + 1);
+      int k2 = next.kind;
+      int dist = next.start - x.end;
+
+      {
+        newDp = makeDp();
+        for (int aTaken = 0; aTaken <= 720; aTaken++) {
+          int bTaken = totalTaken - aTaken;
+          if (bTaken < 0 || dp[aTaken] == BIG) {
+            continue;
+          }
+
+          for (int aAdd = 0; aAdd <= dist; aAdd++) {
+            int bAdd = dist - aAdd;
+
+            int penalty = 0;
+
+            if (k != k2) {
+              penalty = 1;
+            } else {
+              if (k == 0 && bAdd > 0) {
+                penalty = 2;
+              }
+              if (k == 1 && aAdd > 0) {
+                penalty = 2;
+              }
+            }
+
+            int aTaken2 = aTaken + aAdd;
+            int bTaken2 = bTaken + bAdd;
+
+            if (aTaken2 > 720 || bTaken2 > 720) {
+              continue;
+            }
+
+            newDp[aTaken2] = Math.min(newDp[aTaken2], dp[aTaken] + penalty);
+          }
+        }
+        totalTaken += dist;
+        dp = newDp;
+      }
+    }
+
+    int ans = BIG;
+    for (int i = 0; i <= 720; i++) {
+      ans = Math.min(ans, dp[i]);
+    }
+    out.println(ans);
+  }
+}

archive/2017.04/2017.04.30 - unsorted/TaskC.java

@@ -0,0 +1,58 @@
+package chelper;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.GCJSolution;
+import misc.SimpleSavingChelperSolution;
+
+
+public class TaskC extends GCJSolution {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  double eps = 1e-9;
+
+  @Override
+  public void solve(int testNumber) {
+    int n = in.nextInt();
+    int k = in.nextInt();
+
+    double u = in.nextDouble();
+    double[] a = in.nextDoubleArray(n);
+
+    double min = 1.0;
+    for (double v : a) {
+      min = Math.min(v, min);
+    }
+
+    double l = 0.0;
+    double r = 1.1;
+    double goodAns = 0.0;
+
+    while (r - l > eps) {
+      double m = (r + l) / 2;
+      double ma = Math.min(m, 1.0);
+
+      double uLeft = u;
+      double ans = 1;
+
+      for (double v : a) {
+        double uNeed = Math.max(0, ma - v);
+        uLeft -= uNeed;
+//        ans *= ma;
+        ans *= Math.max(ma, v);
+      }
+
+      if (uLeft >= 0) {
+        l = m;
+        goodAns = Math.max(goodAns, ans);
+      } else {
+        r = m;
+      }
+    }
+
+    out.println(goodAns);
+  }
+}