git reimport

archive/2016.10/2016.10.22 - Canada Cup 2016/TaskD.java

@@ -0,0 +1,136 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import io.InputReader;
+import io.OutputWriter;
+
+public class TaskD {
+  class Team implements Comparable<Team> {
+    public final long score;
+    public final long weight;
+    public final long leeway;
+    private final int index;
+
+    public Team(int index, long score, long weight) {
+      this.index = index;
+      this.score = score;
+      this.weight = weight;
+      leeway = weight - score + 1;
+    }
+
+    @Override
+    public int compareTo(Team o) {
+      return Long.compare(leeway, o.leeway);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Team team = (Team) o;
+
+      if (score != team.score) return false;
+      if (weight != team.weight) return false;
+      if (leeway != team.leeway) return false;
+      return index == team.index;
+
+    }
+
+    @Override
+    public int hashCode() {
+      int result = (int) (score ^ score >>> 32);
+      result = 31 * result + (int) (weight ^ weight >>> 32);
+      result = 31 * result + (int) (leeway ^ leeway >>> 32);
+      result = 31 * result + index;
+      return result;
+    }
+  }
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    int n = in.nextInt() - 1;
+    long ourScore = in.nextLong();
+    long ourWeight = in.nextLong();
+    List<Team> teams = new ArrayList<>();
+
+    for (int i = 0; i < n; i++) {
+      Team team = new Team(i, in.nextLong(), in.nextLong());
+      teams.add(team);
+    }
+
+    Collections.sort(teams);
+
+    List<Team> left = new ArrayList<>();
+    List<Team> right = new ArrayList<>();
+
+    for (Team team : teams) {
+      if (team.score > ourScore) {
+        left.add(team);
+      } else {
+        right.add(team);
+      }
+    }
+
+    Collections.sort(right, new Comparator<Team>() {
+      @Override
+      public int compare(Team o1, Team o2) {
+        return -Long.compare(o1.score, o2.score);
+      }
+    });
+
+    long ans = left.size() + 1;
+
+    SortedMap<Long, Long> leftMap = new TreeMap<>();
+
+    for (Team team : left) {
+      if (!leftMap.containsKey(team.leeway)) {
+        leftMap.put(team.leeway, 0L);
+      }
+      leftMap.put(team.leeway, leftMap.get(team.leeway) + 1);
+    }
+
+    int rightPos = 0;
+    int ourPlace = left.size() + 1;
+
+    while (!leftMap.isEmpty()) {
+      long minLeeway = leftMap.firstKey();
+      ourScore -= minLeeway;
+      if (ourScore < 0) {
+        break;
+      }
+      long minVal = leftMap.get(minLeeway) - 1;
+      if (minVal == 0) {
+        leftMap.remove(minLeeway);
+      } else {
+        leftMap.put(minLeeway, minVal);
+      }
+      ourPlace--;
+
+      while (rightPos < right.size()) {
+        Team team = right.get(rightPos);
+        if (team.score > ourScore) {
+          if (!leftMap.containsKey(team.leeway)) {
+            leftMap.put(team.leeway, 0L);
+          }
+          leftMap.put(team.leeway, leftMap.get(team.leeway) + 1);
+          rightPos++;
+          ourPlace++;
+        } else {
+          break;
+        }
+      }
+
+      ans = Math.min(ans, ourPlace);
+    }
+
+    out.println(ans);
+  }
+}