[poj 1691] Painting A Board dfs+拓扑排序

Painting A Board

Time Limit: 1000MS Memory Limit: 10000K

Total Submissions: 3611 Accepted: 1795

Description

The CE digital company has built an Automatic Painting Machine (APM) to paint a flat board fully covered by adjacent non-overlapping rectangles of different sizes each with a predefined color.

To color the board, the APM has access to a set of brushes. Each brush has a distinct color C. The APM picks one brush with color C and paints all possible rectangles having predefined color C with the following restrictions:

To avoid leaking the paints and mixing colors, a rectangle can only be painted if all rectangles immediately above it have already been painted. For example rectangle labeled F in Figure 1 is painted only after rectangles C and D are painted. Note that each rectangle must be painted at once, i.e. partial painting of one rectangle is not allowed.

You are to write a program for APM to paint a given board so that the number of brush pick-ups is minimum. Notice that if one brush is picked up more than once, all pick-ups are counted.

Input

The first line of the input file contains an integer M which is the number of test cases to solve (1 <= M <= 10). For each test case, the first line contains an integer N, the number of rectangles, followed by N lines describing the rectangles. Each rectangle R is specified by 5 integers in one line: the y and x coordinates of the upper left corner of R, the y and x coordinates of the lower right corner of R, followed by the color-code of R.

Note that:

Color-code is an integer in the range of 1 .. 20.
Upper left corner of the board coordinates is always (0,0).
Coordinates are in the range of 0 .. 99.
N is in the range of 1..15.

Output

One line for each test case showing the minimum number of brush pick-ups.

Sample Input

1

7

0 0 2 2 1

0 2 1 6 2

2 0 4 2 1

1 2 4 4 2

1 4 3 6 1

4 0 6 4 1

3 4 6 6 2

Sample Output

3

Source

Tehran 1999

题目链接：http://poj.org/problem?id=1691

题意：

墙上有一面黑板，现划分为多个矩形，每个矩形都要涂上一种预设颜色C。

由于涂色时，颜料会向下流，为了避免处于下方的矩形的颜色与上方流下来的颜料发生混合，要求在对矩形i着色时，处于矩形i上方直接相邻位置的全部矩形都必须已填涂颜色。

在填涂颜色a时，若预设颜色为a的矩形均已着色，或暂时不符合着色要求，则更换新刷子，填涂颜色b。

1、 当对矩形i涂色后，发现矩形i下方的矩形j的预设颜色与矩形i一致，且矩形j上方的全部矩形均已涂色，那么j符合填涂条件，可以用 填涂i的刷子对j填涂，而不必更换新刷子。

2、 若颜色a在之前填涂过，后来填涂了颜色b，现在要重新填涂颜色a，还是要启用新刷子，不能使用之前用于填涂颜色a的刷子。

3、 若颜色a在刚才填涂过，现在要继续填涂颜色a，则无需更换新刷子。

4、 矩形着色不能只着色一部分，当确认对矩形i着色后，矩形i的整个区域将被着色。

思路：

1.按照题目的规则–》拓扑排序；在矩形正上方连下方矩形一条边；然后按颜色dfs；

if(rec[x].lx>=rec[y].lx&&rec[x].lx<rec[y].rx) return 1;
if(rec[x].lx<=rec[y].lx&&rec[x].rx>=rec[y].rx) return 1;
if(rec[x].rx<=rec[y].rx&&rec[x].rx>rec[y].lx) return 1;

2.dfs（num，col，step）

当col==0时即刚换刷子！

代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<vector>
using namespace std;

struct node
{
int lx,ly,rx,ry;
int col,r;
bool flag;
int lin[15];
int now;
} rec[33];
int n;
int T;
int minn=20;
bool can(int x,int y)
{
if(rec[x].lx>=rec[y].lx&&rec[x].lx<rec[y].rx) return 1;
if(rec[x].lx<=rec[y].lx&&rec[x].rx>=rec[y].rx) return 1;
if(rec[x].rx<=rec[y].rx&&rec[x].rx>rec[y].lx) return 1;
return 0;

}
void cut(int x,int y)
{
for(int i=1;i<=rec[x].now;i++)
rec[rec[x].lin[i]].r+=y;

}
void dfs(int x,int c,int b)
{

if(b>=minn) return ;
if(x==n)
{
minn=min(b,minn);
return ;
}

if(c==0)
{
for(int i=1;i<=n;i++)
if(rec[i].r==0&&rec[i].flag==0)
{
rec[i].flag=1;
cut(i,-1);
dfs(x+1,rec[i].col,b);
cut(i,1);
rec[i].flag=0;
}
}
else
{

int tag=0;
for(int i=1;i<=n;i++)
if(rec[i].col==c&&rec[i].r==0&&rec[i].flag==0)
{

tag=1;
rec[i].flag=1;
cut(i,-1);
dfs(x+1,c,b);
cut(i,1);
rec[i].flag=0;
}
if(!tag) dfs(x,0,b+1);
}

}
void init()
{
for(int i=1;i<=n;i++)
{
rec[i].now=0;
rec[i].r=0;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
if(i!=j&&rec[i].ry==rec[j].ly)
{
if(can(i,j)==1)
{
rec[j].r++;
rec[i].now++;
rec[i].lin[rec[i].now]=j;
}
}
}

}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
minn=20;
for(int i=1;i<=n;i++)
{
scanf("%d%d%d%d%d",&rec[i].ly,&rec[i].lx,&rec[i].ry,&rec[i].rx,&rec[i].col);
}
init();
dfs(0,0,1);
printf("%d\n",minn);
}

}