Volatile Kite

time limit per test 2 second memory limit per test 256 megabytes
You are given a convex polygon P with n distinct vertices p1,p2,…,pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.

You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.

Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.

传送门:CF801D

Input

The first line has one integer n (4≤n≤1000) — the number of vertices.
The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).

Output

Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.
Your answer will be considered correct if its absolute or relative error does not exceed 10-6.
Namely, let’s assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if .

Sample Input

1
2
3
4
5
4
0 0
0 1
1 1
1 0

Sample Output

1
0.3535533906

题解

题意:
给你一个凸多边形,让你求一个最大距离,每个点移动不超过这个距离,使这个多边形依旧是凸多边形
关键是点线距离 画个图模拟一下 一个点最大移动的距离是它到相邻的两个点连成的线段的距离的一半 超过这个就凹进去了

AC code:(不包含输入类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.io.*;  
import java.util.*;
public class Main {

public static void main(String[] args) {
FastScanner sc=new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
pw.flush();
while(sc.hasNext()){
int n=sc.nextInt();
Node[]node=new Node[n];
for(int i=0;i<n;i++){
int x=sc.nextInt();
int y=sc.nextInt();
node[i]=new Node(x*1.0,y*1.0);
}

double min=1e12;
for(int i=0;i<n;i++){
int l=(i+1)%n;
int r=(i+2)%n;
min=Math.min(min,Geometry.disLineAndNode(node[l], node[i], node[r]));
}
pw.println(min/2);
pw.flush();
}
}

}
class Node{
double x;
double y;
Node(double a,double b){
this.x=a;
this.y=b;
}
}
class Geometry{
static double disLineAndNode(Node target,Node linea,Node lineb){
return squareofTri(target,linea,lineb)*2/disofline(linea,lineb);
}
static double squareofTri(Node a,Node b,Node c){
double x1=a.x-b.x;
double y1=a.y-b.y;
double x2=b.x-c.x;
double y2=b.y-c.y;
return Math.abs(x1*y2-x2*y1)/2;
}
static double disofline(Node a,Node b){
return Math.sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
}