ZOJ3209 Treasure Map —— Danc Links 精确覆盖

最新推荐文章于 2024-11-11 20:59:17 发布

alince20008

最新推荐文章于 2024-11-11 20:59:17 发布

阅读量109

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/DOLFAMINGO/p/7538570.html

版权

题目链接：https://vjudge.net/problem/ZOJ-3209

Treasure Map

Time Limit: 2 Seconds Memory Limit: 32768 KB

Your boss once had got many copies of a treasure map. Unfortunately, all the copies are now broken to many rectangular pieces, and what make it worse, he has lost some of the pieces. Luckily, it is possible to figure out the position of each piece in the original map. Now the boss asks you, the talent programmer, to make a complete treasure map with these pieces. You need to make only one complete map and it is not necessary to use all the pieces. But remember, pieces are not allowed to overlap with each other (See sample 2).

Input

The first line of the input contains an integer T (T <= 500), indicating the number of cases.

For each case, the first line contains three integers n m p (1 <= n, m <= 30, 1 <= p <= 500), the width and the height of the map, and the number of pieces. Then p lines follow, each consists of four integers x1 y1 x2 y2 (0 <= x1 < x2 <= n, 0 <= y1 < y2 <= m), where (x1, y1) is the coordinate of the lower-left corner of the rectangular piece, and (x2, y2) is the coordinate of the upper-right corner in the original map.

Cases are separated by one blank line.

Output

If you can make a complete map with these pieces, output the least number of pieces you need to achieve this. If it is impossible to make one complete map, just output -1.

Sample Input

Sample Output

1
-1
2

Hint

For sample 1, the only piece is a complete map.

For sample 2, the two pieces may overlap with each other, so you can not make a complete treasure map.

For sample 3, you can make a map by either use the first 3 pieces or the last 2 pieces, and the latter approach one needs less pieces.

题解：

题意：有p个矩形，每个矩形的坐标均已知，问能否找到若干个矩形（不能有重叠），组成一个n*m的大矩形？如果能？找出最小值。

两个注意点：

1.一开始以为覆盖的对象是“点”，结果发现在拼接处会重复覆盖。后来才知道覆盖的对象是一个“小格”，即单位正方形。这样才是以面积覆盖掉n*m的大矩形。代码中以（x,y）这个点代表了（（x-1，y-1）（x，y））这个单位正方形，所以这个大矩形的横纵坐标从1开始。

2.在写Dance()函数时，忘了修改代码。由于此题要求求出最小值，所以即使当前找到某个值，也不一定是最小值，还要继续回溯。所以Dance()函数的类型是 void，而不是bool。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
#define ms(a,b) memset((a),(b),sizeof((a)))
using namespace std;
typedef long long LL;
const int INF = 2e9;
const int MAXN = 1e3+10;
const int MAXM = 1e3+10;
const int maxnode = 1e6+10;

struct DLX      //矩阵的行和列是从1开始的
{
    int n, m, size; //size为结点数
    int U[maxnode], D[maxnode], L[maxnode], R[maxnode], Row[maxnode], Col[maxnode];
    int H[MAXN], S[MAXM];   //H为每一行的头结点，但不参与循环。S为每一列的结点个数
    int ansd;

    void init(int _n, int _m)   //m为列
    {
        n = _n;
        m = _m;
        for(int i = 0; i<=m; i++)   //初始化列的头结点
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i] = i-1;
            R[i] = i+1;
        }
        R[m] = 0; L[0] = m;
        size = m;
        for(int i = 1; i<=n; i++) H[i] = -1;    //初始化行的头结点
    }

    void Link(int r, int c)
    {
        size++; //类似于前向星
        Col[size] = c;
        Row[size] = r;
        S[Col[size]]++;
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if(H[r]==-1) H[r] = L[size] = R[size] = size; //当前行为空
        else        //当前行不为空： 头插法，无所谓顺序，因为Row、Col已经记录了位置
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void remove(int c)  //c是列的编号， 不是结点的编号
    {
        L[R[c]] = L[c]; R[L[c]] = R[c];     //在列的头结点的循环队列中， 越过列c
        for(int i = D[c]; i!=c; i = D[i])
        for(int j = R[i]; j!=i; j = R[j])
        {
            //被删除结点的上下结点仍然有记录
            U[D[j]] = U[j];
            D[U[j]] = D[j];
            S[Col[j]]--;
        }
    }

    void resume(int c)
    {
        L[R[c]] = R[L[c]] = c;
        for(int i = U[c]; i!=c; i = U[i])
        for(int j = L[i]; j!=i; j = L[j])
        {
            U[D[j]] = D[U[j]] = j;
            S[Col[j]]++;
        }
    }

    void Dance(int d)
    {
        if(d>=ansd) return;
        if(R[0]==0)
        {
            ansd = d;
            return;
        }

        int c = R[0];
        for(int i = R[0]; i!=0; i = R[i])   //挑结点数最少的那一列，否则会超时，那为什么呢?
            if(S[i]<S[c])
                c = i;

        remove(c);
        for(int i = D[c]; i!=c; i = D[i])
        {
            for(int j = R[i]; j!=i; j = R[j]) remove(Col[j]);
            Dance(d+1);
            for(int j = L[i]; j!=i; j = L[j]) resume(Col[j]);
        }
        resume(c);
    }
};

DLX dlx;
int main()
{
    int T;
    int n, m, p;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d%d", &n, &m, &p);
        dlx.init(p, n*m);
        for(int i = 1; i<=p; i++)
        {
            int x1, x2, y1, y2;
            scanf("%d%d%d%d",&x1, &y1, &x2, &y2);
            for(int x = x1+1; x<=x2; x++)
                for(int y = y1+1; y<=y2; y++)
                    dlx.Link(i, (x-1)*m+y);
        }
        dlx.ansd = INF;
        dlx.Dance(0);
        printf("%d\n", dlx.ansd==INF?-1:dlx.ansd);
    }
    return 0;
}

转载于:https://www.cnblogs.com/DOLFAMINGO/p/7538570.html