ZOJ - 3537 —— Cake

题目：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=23543

1. 因为没有三个点在同一直线上，即每个点都是多边形的一个顶点而不会有点在某条边上，所以要判断这个多边形是不是凸多边性，可以用像凸包问题那样做，得到的凸包的关节点以及它们的个数num，若num==n (全体点的个数)，那么是凸多边形；否则，不是凸多边形。

2. 如果判断是凸多边形后，就要开始正式的DP了。

我们都知道，这种成环的数组的DP，可以将环拆开，变成区间DP来做！

1. 思路：首先，通过尝试去切分一些简单地多边形，我们会发现，每一条边最后都会有一个三角形。既然每条边迟早要找到自己的那个三角形，所以我们不妨从某一条边开始，为它找到一个可能的三角形，我们会发现一旦找到了一个三角形之后就会将原来的三角形切割成若干个新的多边形——原问题的子问题！，我们是不是可以递归的解决这些子问题，最后原问题也可以解决了。

2. 状态： dp[i][j] := 从下标i到下标j所构成的多边形的最小三角切分的代价（为避免重复：i <= j）

3. 状态转移：dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + cost[i][k] + cost[k][j])    (当 j-i > 2,  其中：i+1 <= k <= j-1)

　　　　　　 dp[i][j] = 0 (当 j-i <= 2)

#include <cstdio>
#include <iostream>
#include <cmath> 
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;

struct Point {
    int x, y;
    Point(int x=0, int y=0):x(x),y(y) {}
} p[305];

int dp[305][305];
int st[305];
int N, P;

typedef Point Vector;

Vector operator - (Point a, Point b)
{
    return Vector(a.x-b.x, a.y-b.y);
}

// 叉乘 
double Cross(Vector a, Vector b)
{
    return a.x*b.y - a.y*b.x;
}

// 确定浮点数的符号性质(+, -, 0) 
const double EPS = 1e-10;
int dcmp(double x)
{
    if(fabs(x) < EPS)    return 0;
    return x < 0 ? -1 : 1;    
}    

double Dist(Point a, Point b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));    
}

bool cmp(Point a, Point b) // 用于极角排序 
{
    Vector u = a-p[0], v = b-p[0];
    int sign = dcmp(Cross(u, v));
    if(sign == 0)    return Dist(a, p[0]) < Dist(b, p[0]);
    return sign > 0;
}

int grahamscan(Point *a, int n, int *st)
{
    int j=0;
    st[j++] = 0;
    st[j++] = 1;
    st[j++] = 2;
    for(int i=3; i<n; i++) {
        // 这里可以取到 等于，减少不必要的距离计算 
        while(dcmp(Cross(a[st[j-1]]-a[st[j-2]], a[i]-a[st[j-2]])) <= 0) --j; 
        st[j++] = i;
    }
    return j;
}

int Cost(int i, int j)
{
    if(abs(i-j) <= 1)    return 0;
    return abs(p[st[i]].x+p[st[j]].x) * abs(p[st[i]].y+p[st[j]].y) % P;
}

int main ()
{
    while(scanf("%d%d", &N, &P) != EOF) {
        int miny=10005, mini;
        for(int i=0; i<N; i++) {
            scanf("%d%d", &p[i].x, &p[i].y);
            if(miny > p[i].y) {
                miny = p[i].y;
                mini = i;
            }
        }
        swap(p[0], p[mini]);
        sort(p+1, p+N, cmp);
        
        if(grahamscan(p, N, st) == N) {
            
            for(int step=3; step<N; step++) { // 区间dp，一般来说都可以用这种 增加步长 的方法 
                for(int i=0; i+step<N; i++) {
                    int j = i+step;
                    dp[i][j] = INF; // 因为是求min，所以需要预设为 INF 
                    for(int k=i+1; k<j; k++) {
                        dp[i][j] = min(dp[i][j], dp[i][k]+dp[k][j]+Cost(i,k)+Cost(k,j));
                    }
                }
            }
            printf("%d\n", dp[0][N-1]);                    
        } else {
            printf("I can't cut.\n");
        }
    }
    
    return 0;    
} 

 

转载于:https://www.cnblogs.com/AcIsFun/p/5324005.html