Hatena::Grouptopcoder

tsubosakaの日記

2009-01-14

SRM 250 Div1 Hard

| 20:32

2つの多角形の共通部分の面積を求める問題.O(n + m)の解法もあるけれど,ここでは線分の交差点と一方の多角形に含まれる点をすべて列挙してそれらの点で凸包を構成する.

import java.util.*;

public class ConvexPolygons {
  class Point {
    double x, y;

    Point(double a, double b) {
      this.x = a;
      this.y = b;
    }

    @Override
    public String toString() {
      return x + " : " + y;
    }

    double norm() {
      return x * x + y * y;
    }
  }


  double cross(Point a, Point b, Point c) {
    double res = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
    return res;
  }
  double cmp(Point a , Point b){
    if(a.x != b.x)return a.x - b.x;
    return a.y - b.y;
  }
  List<Point> convexHull(List<Point> ps) {
    List<Point> res = new ArrayList<Point>();
    if(ps.size() < 3)return res;
    int N = ps.size();
    int p = 0;
    for(int i = 1 ; i < N ; i++)
      if(cmp(ps.get(i) , ps.get(p)) < 0)
        p = i;
    int st = p;
    do{
      int n = -1;
      for(int i = 0 ; i < N ; i++){
        if(i == p)continue;
        if(n == -1)n = i;
        double cross = cross(ps.get(p) , ps.get(i) , ps.get(n));
        if(cross < 0)
          n = i;
      }
      res.add(ps.get(p));
      p = n;
    }while(st != p);
    return res;
  }

  double area(List<Point> lst) {
    if(lst.size() < 3)return 0.0;
    double res = 0.0;
    for (int i = 0; i < lst.size(); i++) {
      Point p1 = lst.get(i);
      Point p2 = lst.get((i + 1) % lst.size());
      res += (p1.x - p2.x) * (p1.y + p2.y);
    }
    return Math.abs(res * 0.5);
  }

  boolean include(Point point , Point[] polygon){
    for(int i = 0 ; i < polygon.length ; i++){
      Point a = polygon[i];
      Point b = polygon[(i + 1) % polygon.length];      
      double ccw = cross(point , a , b);
      if(ccw < 0)return false;
    }
    return true;
  }
  Point intersect(Point p1 , Point p2 , Point q1 , Point q2){
    double a1 = p2.y - p1.y;
    double b1 = p1.x - p2.x;
    double c1 = a1 * p1.x + b1 * p1.y;
    double a2 = q2.y - q1.y;
    double b2 = q1.x - q2.x;
    double c2 = a2 * q1.x + b2 * q1.y;
    double det = a1 * b2 - a2 * b1;
    if(det == 0.0){
      return null;
    }else{
      double x = (b2 * c1 - b1 * c2) / det;
      double y = (a1 * c2 - a2 * c1) / det;
      if(inRange(x , p1.x , p2.x) && inRange(x , q1.x , q2.x) &&
         inRange(y , p1.y , p2.y) && inRange(y , q1.y , q2.y)    
          ){
        return new Point(x , y);
      }
      return null;
    }
  }
  boolean inRange(double x , double low , double up){
    if(low > up)return inRange(x , up , low);
    return low <= x && x <= up;
  }
  List<Point> hullPoint(Point[] polygon1 , Point[] polygon2){
    List<Point> res = new ArrayList<Point>();
    for(Point p1 : polygon1){
      if(include(p1, polygon2))
        res.add(p1);
    }
    for(Point p2 : polygon2){
      if(include(p2, polygon1))
        res.add(p2);      
    }
    for(int i = 0 ; i < polygon1.length ; i++){
      for(int j = 0 ; j < polygon2.length ; j++){
        Point a = polygon1[i];
        Point b = polygon1[(i+1) % polygon1.length];
        Point c = polygon2[j];
        Point d = polygon2[(j+1) % polygon2.length];
        Point ip = intersect(a, b, c, d);
        if(ip != null)
          res.add(ip);
      }
    }
    return res;
  }
  double overlap(Point[] polygon1 , Point[] polygon2){
    return area(convexHull(hullPoint(polygon1, polygon2)));
  }
  public double overlap(String[] polygon1, String[] polygon2) {    
    return overlap(toPolygon(polygon1), toPolygon(polygon2));
  }
  Point[] toPolygon(String[] poly){
    Point ps[] = new Point[poly.length];
    for(int i = 0 ; i < ps.length ; i++){
      String p = poly[i];
      String a[] = p.split("\\s+");
      Point pt = new Point(Integer.parseInt(a[0]) , Integer.parseInt(a[1]));
      ps[i] = pt;
    }
    return ps;
  }
}

SRM 173 Div1 Hard

| 19:25

与えられた点からn個選んだ時に選んだ点の凸包の面積を最大にせよという問題.

  • 候補点は凸包の中から選べばよい
  • 始点を固定した後に、一個前の点と残りの選べる点の個数を状態としてメモ付き探索を行う
  • 再帰式はf(start , p , n) = max_q ( f(start , q , n - 1) + |start-p-q|)と書ける
import java.util.*;

public class ElectronicScarecrows {
  class Point {
    double x, y;

    Point(double a, double b) {
      this.x = a;
      this.y = b;
    }

    @Override
    public String toString() {
      return x + " : " + y;
    }

    double norm() {
      return x * x + y * y;
    }
  }
  double cross(Point a, Point b, Point c) {
    double res = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
    return res;
  }
  double cmp(Point a , Point b){
    if(a.x != b.x)return a.x - b.x;
    return a.y - b.y;
  }
  double dist(Point a , Point b){
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return dx * dx + dy * dy;
  }
  List<Point> convexHull(List<Point> ps) {
    List<Point> res = new ArrayList<Point>();
    if(ps.size() < 3)return res;
    int N = ps.size();
    int p = 0;
    for(int i = 1 ; i < N ; i++)
      if(cmp(ps.get(i) , ps.get(p)) < 0)
        p = i;
    boolean used[] = new boolean[N];
    int st = p;
    do{
      int n = -1;
      double dist = 0.0;
      for(int i = 0 ; i < N ; i++){
        if(i == p)continue;
        if(used[i])continue;
        if(n == -1)n = i;
        double cross = cross(ps.get(p) , ps.get(i) , ps.get(n));
        double d  = dist(ps.get(i) , ps.get(p));
        if(cross < 0){
          n = i;
          dist = d;
        }else if(Math.abs(cross) < 1.0E-11){
          if(d > dist){
            dist = d;
            n = i;
          }
        }
      }
      res.add(ps.get(p));
      p = n;
      used[p] = true;
    }while(st != p);
    return res;
  }
  double triarea(Point p0 , Point p1 , Point p2){
    return Math.abs(cross(p0 , p1 , p2)) * 0.5;
  }
  double memo[][];
  Point ps[];
  double rec(int pstart , int prev , int n){
    if(n == 0)return 0.0;
    if(memo[prev][n] >= 0.0)
      return memo[prev][n];
    double res = 0.0;
    int p = (prev + 1) % ps.length;
    while(p != pstart){
      double t = triarea(ps[pstart] , ps[prev] , ps[p]);
      double r = rec(pstart , p , n - 1);
      res = Math.max(res, t + r);
      p = (p + 1) % ps.length;      
    }   
    return memo[prev][n] = res;
  }
  public double largestArea(int[] x, int[] y, int n) {
    List<Point> plist = new ArrayList<Point>();
    for(int i = 0 ; i < x.length ; i++){
      plist.add(new Point(x[i] , y[i]));
    }
    List<Point> hull = convexHull(plist);
    this.ps = hull.toArray(new Point[0]);
    int hs = hull.size();
    double res = 0.0;
    for(int pstart = 0 ; pstart < hull.size() ; pstart++){
      memo = new double[hs][n];
      for(int i = 0 ; i < hs ; i++)
          Arrays.fill(memo[i] , -1);
      for(int p0 = pstart + 1 ; p0 < hs ; p0++){
        double r = rec(pstart , p0  , n - 2);
        res = Math.max(res, r);
      }
    }
    return res;
  }
}