Rectangular Covering [POJ2836] [状压DP]

题意

平面上有 n (2 ≤ n ≤ 15) 个点，现用平行于坐标轴的矩形去覆盖所有点，每个矩形至少盖两个点，矩形面积不可为0，求这些矩形的最小面积。

Input

The input consists of several test cases. Each test cases begins with a line containing a single integer n (2 ≤ n ≤ 15). Each of the next n lines contains two integers x, y (−1,000 ≤ x, y ≤ 1,000) giving the coordinates of a point. It is assumed that no two points are the same as each other. A single zero follows the last test case.

Output

Output the minimum total area of rectangles on a separate line for each test case.

Sample Input

2
0 1
1 0
0

Sample Output

1

Analysis

枚举两个个点，再算包含在这两个点的点，算进一个矩形

然后在枚举矩形，进行状压DP

Code

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
 
using std::vector;
using std::min;
using std::max;
 
const int MAXN = 15;
const int INF = 0x3f3f3f3f;
 
struct POINT
{
    int x;
    int y;
} p[MAXN + 1];
 
struct RECTANGLE
{
    int area;
    int cover;
} r[MAXN * MAXN];
 
int n;
int dp[1 << MAXN];
int area[MAXN + 1][MAXN + 1];
int cnt;
 
int abs(int x)
{
    return x > 0 ? x : -x;
}
 
void Read()
{
    for (int i = 0; i < n; ++i)
    {
        scanf("%d%d", &p[i].x, &p[i].y);
    }
}
 
void Init()
{
    cnt = 0;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < i; ++j)
        {
            if (j != i)
            {
                int width = abs(p[i].x - p[j].x) == 0 ? 1 : abs(p[i].x - p[j].x);
                int height = abs(p[i].y - p[j].y) == 0 ? 1 : abs(p[i].y - p[j].y);
                r[cnt].area = width * height;
                r[cnt].cover = 0;
                for (int k = 0; k < n; ++k)
                {
                    if (p[k].x >= min(p[i].x, p[j].x) && p[k].x <= max(p[i].x, p[j].x) &&
                            p[k].y >= min(p[i].y, p[j].y) && p[k].y <= max(p[i].y, p[j].y))
                    {
                        r[cnt].cover |= (1 << k);
                    }
                }
                ++cnt;
            }
        }
    }
}
 
void Dp()
{
    memset(dp, 0x3f, sizeof(dp));
    dp[0] = 0;
    for (int S = 0; S < (1 << n); ++S)
    {
        if (dp[S] != INF)
        {
            for (int i = 0; i < cnt; ++i)
            {
                int news = S | r[i].cover;
                if (news != S)
                {
                    dp[news] = min(dp[news], dp[S] + r[i].area);
                }
            }
        }
    }
    printf("%d
", dp[(1 << n) - 1]);
}
 
int main()
{
    while (scanf("%d", &n) == 1 && n)
    {
        Read();
        Init();
        Dp();
    }
 
    return 0;
}