poj 2187 Beauty Contest

Beauty Contest

Time Limit: 3000MS		Memory Limit: 65536K
Total Submissions: 26087		Accepted: 8044

Description

Bessie, Farmer John's prize cow, has just won first place in a bovine beauty contest, earning the title 'Miss Cow World'. As a result, Bessie will make a tour of N (2 <= N <= 50,000) farms around the world in order to spread goodwill between farmers and their cows. For simplicity, the world will be represented as a two-dimensional plane, where each farm is located at a pair of integer coordinates (x,y), each having a value in the range -10,000 ... 10,000. No two farms share the same pair of coordinates. 

Even though Bessie travels directly in a straight line between pairs of farms, the distance between some farms can be quite large, so she wants to bring a suitcase full of hay with her so she has enough food to eat on each leg of her journey. Since Bessie refills her suitcase at every farm she visits, she wants to determine the maximum possible distance she might need to travel so she knows the size of suitcase she must bring.Help Bessie by computing the maximum distance among all pairs of farms. 

Input

* Line 1: A single integer, N 

* Lines 2..N+1: Two space-separated integers x and y specifying coordinate of each farm 

Output

* Line 1: A single integer that is the squared distance between the pair of farms that are farthest apart from each other. 

Sample Input

4
0 0
0 1
1 1
1 0

Sample Output

2

Hint

Farm 1 (0, 0) and farm 3 (1, 1) have the longest distance (square root of 2) 

Source

 

 

另加两组测试数据

5
-2 0
-1 0
0 0
1 0
2 0    答案16

4
-1 0
0 0
1 0
2 0   答案 9

要注意多个点共线的情况。

题意：给你n个点，求相距最长的距离的平方。

这是一个凸包的模板题，就是这样一个模板题，错了几次。

慢慢的看，我发现自己对凸包理解的不够清晰。这个是很要命的。

代码中，dis和distance1的效果是一样的，用后者就好了。

特殊的举例，包含了多个点平行的时候的情况，所以要考虑到这个情况。

那什么什么旋转的方法，没有学到。(⊙o⊙)…，待续。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;

struct node
{
   int x,y;
};
node a[50002],stack1[50002];
double dis(node n1,node n2)
{
    return (double)sqrt( (n1.x-n2.x)*(n1.x-n2.x)*1.0 + (n1.y-n2.y)*(n1.y-n2.y)*1.0 );
}
int distance1(node n1,node n2)
{
    return  (n1.x-n2.x)*(n1.x-n2.x) + (n1.y-n2.y)*(n1.y-n2.y);
}

double cross(node a,node n1,node n2)
{
    return (n1.x-a.x)*(n2.y-a.y) - (n1.y-a.y)*(n2.x-a.x);
}
bool cmp(node n1,node n2)
{
    double k = cross(a[0],n1,n2);
    if( k>0) return true;
    else if( k==0 && dis(a[0],n1)<dis(a[0],n2))
        return true;
    else return false;
}
void tom(node *ch,int n)
{
   int i,ans=0,j;
   for(i=0;i<=n;i++)
    for(j=i+1;j<=n;j++)
   {
       ans=max(ans,distance1(ch[i],ch[j]));
   }
   printf("%d
",ans);
}
void Graham(int n)
{
    int i,head;
    for(i=1;i<n;i++)
        if(a[i].x<a[0].x ||(a[i].x==a[0].x&&a[i].y<a[0].y ) )
            swap(a[0],a[i]);
    sort(a+1,a+n,cmp);
    a[n]=a[0];
    stack1[0]=a[0];
    stack1[1]=a[1];
    stack1[2]=a[2];
    head=2;
    for(i=3;i<n;i++)
    {
        while( head>=2 )
        {
            if( cross(stack1[head-1],stack1[head],a[i])< 0 )
            head--;
            else if( cross(stack1[head-1],stack1[head],a[i]) == 0 &&
                    ( distance1(stack1[head-1],a[i]) > distance1(stack1[head-1],stack1[head]) ) )
                        head--;
            else break;
        }
        stack1[++head]=a[i];
    }
    tom(stack1,head);
}
int main()
{
    int n,i;
    while(scanf("%d",&n)>0)
    {
        for(i=0;i<n;i++)
            scanf("%d%d",&a[i].x,&a[i].y);
        Graham(n);
    }
    return 0;
}

 关键是没有用到  旋转卡壳算法。待续。

/**

由于程序 在cmp()中，当发生多个点一起时，按距离小的排序。
这样的话，就会使得距离大的在最后面。根据代码可知
for(i=3;i<n;i++)
{
while( head>=2 && cross(stack1[head-1],stack1[head],a[i])<= 0) head--;
stack1[++head]=a[i];
}
这样的话，就不会丢失我们需要的那个点。

旋转卡壳算法，head+1传参。很明显，和求凸包的时候是一致的。
因为要对第head个点进行判断的时候，必须用到第0个点。

**/

/*旋转卡壳算法*/
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
using namespace std;

struct node
{
   int x,y;
};
node a[50002],stack1[50002];
int dis(node n1,node n2)
{
    return  (n1.x-n2.x)*(n1.x-n2.x) + (n1.y-n2.y)*(n1.y-n2.y);
}
double cross(node a,node n1,node n2)
{
    return (n1.x-a.x)*(n2.y-a.y) - (n1.y-a.y)*(n2.x-a.x);
}
bool cmp(node n1,node n2)
{
    double k = cross(a[0],n1,n2);
    if( k>0) return true;
    else if( k==0 && dis(a[0],n1)<dis(a[0],n2))
        return true;
    else return false;
}
void tom(node *ch,int n)// 旋转卡壳算法。
{
    int ans=0,p,q=1;
    ch[n]=ch[0];//这个点的增加，是为了能使得最后一个点能被证实是正确的。
    for(p=0;p<n;p++)
    {
        while( cross(ch[p+1],ch[q+1],ch[p]) > cross(ch[p+1],ch[q],ch[p]))
            q=(q+1)%n;
        ans=max(ans,max(dis(ch[p],ch[q]),dis(ch[p+1],ch[q+1])));
    }
    printf("%d
",ans);
}
void Graham(int n)
{
    int i,head;
    for(i=1;i<n;i++)
        if(a[i].x<a[0].x ||(a[i].x==a[0].x&&a[i].y<a[0].y ) )
            swap(a[0],a[i]);
    sort(a+1,a+n,cmp);
    a[n]=a[0];
    stack1[0]=a[0];
    stack1[1]=a[1];
    stack1[2]=a[2];
    head=2;
    for(i=3;i<n;i++)
    {
        while( head>=2  && cross(stack1[head-1],stack1[head],a[i])<= 0) head--;
        stack1[++head]=a[i];
    }
    tom(stack1,head+1);
}
int main()
{
    int n,i;
    while(scanf("%d",&n)>0)
    {
        for(i=0;i<n;i++)
            scanf("%d%d",&a[i].x,&a[i].y);
        Graham(n);
    }
    return 0;
}