博客

题目链接：

Birthday Gift

首先，最优解一定是一个凸包，但是接下来的算法不会显性利用到凸包的性质。

枚举每个点作为多边形最左侧的端点（然后删除他左侧的点，否则可能会错，我就因为这个问题错了好几发，虽然不知道什么情况，删了保证对），然后以这个点做极角排序，接下来dp[i][j]表示多边形上上个极角序最大的点是i，内部包含了j个点的最小周长，然后枚举下一个点就可以做到n^3转移（三角形内点的个数要O(n^4)预处理）。因为枚举了最多端点，所以dp复杂度是O(n^4)。总复杂度即O(n^4)。其实这样得到的解一定是凸包，因为不是凸包的解不可能比是凸包的解还优。

PS：有重点以及三点共线也很简单，多加一些处理即可。

#include <bits/stdc++.h>
using namespace std ;

typedef long long LL ;
typedef pair < int , int > pii ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 100 ;
const double INF = 1e60 ;
const double eps = 1e-8 ;
const double pi = acos ( -1.0 ) ;

int dcmp ( double x ) {
    return ( x > eps ) - ( x < -eps ) ;
}

struct Point {
    double x , y ;
    Point () {}
    Point ( double x , double y ) : x ( x ) , y ( y ) {}
    bool operator < ( const Point& a ) const {
        return dcmp ( x - a.x ) ? x < a.x : y < a.y ;
    }
    bool operator == ( const Point& a ) const {
        return !dcmp ( x - a.x ) && !dcmp ( y - a.y ) ;
    }
    Point operator + ( const Point& a ) const {
        return Point ( x + a.x , y + a.y ) ;
    }
    Point operator - ( const Point& a ) const {
        return Point ( x - a.x , y - a.y ) ;
    }
    double operator * ( const Point& a ) const {
        return x * a.y - y * a.x ;
    }
    double angle () {
        return atan2 ( y , x ) ;
    }
    double len () {
        return sqrt ( x * x + y * y ) ;
    }
} ;

struct Node {
    double r ;
    int idx ;
    bool operator < ( const Node& a ) const {
        return r < a.r ;
    }
} ;

Node a[MAXN] ;
Point p[MAXN] ;
int n ;
int in[MAXN][MAXN] ;
double len2[MAXN][MAXN] ;
double dp[MAXN][MAXN] ;
double len ;
int ans ;

bool PointInTri ( int i , int j , int k , int l ) {
    int a = dcmp ( ( p[i] - p[l] ) * ( p[j] - p[l] ) ) ;
    int b = dcmp ( ( p[j] - p[l] ) * ( p[k] - p[l] ) ) ;
    int c = dcmp ( ( p[k] - p[l] ) * ( p[i] - p[l] ) ) ;
    return a * b > 0 && b * c > 0 && c * a > 0 ;
}

void calc ( int m ) {
    for ( int i = 0 ; i <= m ; ++ i ) {
        for ( int j = 0 ; j <= m + 1 ; ++ j ) {
            dp[i][j] = INF ;
        }
        for ( int j = 0 ; j <= m ; ++ j ) {
            len2[i][j] = ( p[a[i].idx] - p[a[j].idx] ).len () ;
        }
    }
    for ( int i = 1 ; i <= m ; ++ i ) {
        for ( int j = i + 1 ; j <= m ; ++ j ) {
            in[i][j] = 3 ;
            for ( int l = 1 ; l <= m ; ++ l ) if ( l != i && l != j ) {
                if ( PointInTri ( a[0].idx , a[i].idx , a[j].idx , a[l].idx ) ) {
                    in[i][j] ++ ;
                }
            }
        }
    }
    for ( int i = 1 ; i <= m ; ++ i ) {
        dp[i][2] = len2[0][i] * 2 ;
        for ( int j = 0 ; j <= m + 1 ; ++ j ) {
            for ( int k = 1 ; k < i ; ++ k ) if ( dp[k][j] < 1e50 ) {
                int num = j + in[k][i] - 2 ;
                dp[i][num] = min ( dp[i][num] , dp[k][j] - len2[0][k] + len2[0][i] + len2[i][k] ) ;
            }
        }
    }
    for ( int i = 1 ; i <= m ; ++ i ) {
        for ( int j = 1 ; j <= m + 1 ; ++ j ) {
            if ( dcmp ( dp[i][j] - len ) <= 0 ) ans = max ( ans , j ) ;
            //printf ( "dp[%d][%d] = %.2f\n" , i , j , dp[i][j] ) ;
        }
    }
}

void solve () {
    scanf ( "%d%lf" , &n , &len ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%lf%lf" , &p[i].x , &p[i].y ) ;
    }
    sort ( p + 1 , p + n + 1 ) ;
    ans = 1 ;
    a[0].r = -INF ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        int m = 0 ;
        for ( int j = i + 1 ; j <= n ; ++ j ) {
            ++ m ;
            a[m].idx = j ;
            a[m].r = ( p[j] - p[i] ).angle () ;
            //if ( dcmp ( a[j].r ) < 0 ) a[j].r = 2 * pi + a[j].r ;
        }
        a[0].idx = i ;
        sort ( a + 1 , a + m + 1 ) ;
        calc ( m ) ;
    }
    printf ( "%d\n" , ans ) ;
}

int main () {
    int T ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) {
        printf ( "Case #%d: " , i ) ;
        solve () ;
    }
    return 0 ;
}