POJ 1691 Painting A Board（dfs搜尋）

一開始感覺暴搜會超時，好像看錯資料範圍了啊、、、發現崔老師dfs過的啊。但是找關係的時候很噁心，x，y不好區分啊，還是看了崔老師的啊。dfs比較好像到就是找所有的如果然道第i次的時候就已經染完了，那就結束了啊。

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

Output

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

#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define eps 1e-7
#define M 1000100
///#define LL __int64
#define LL long long
#define INF 0x3fffffff
#define PI 3.1415926535898

using namespace std;

const int maxn = 110;

struct node
{
    int x1, y1;
    int x2, y2;
    int c;
} f[maxn];
int n;
int vis[maxn];
vector<int>g[maxn];

int judge1(int x, int y)
{
    if(f[x].x2 <= f[y].x1)
    {
        if(f[x].y1 < f[y].y2 && f[x].y1 > f[y].y1)
            return 1;
        else if(f[x].y2 < f[y].y2 && f[x].y2 > f[y].y1)
            return 1;
        else if(f[y].y1 < f[x].y2 && f[y].y1 > f[x].y1)
            return 1;
        else if(f[y].y2 < f[x].y2 && f[y].y2 > f[x].y1)
            return 1;
        else if(f[y].y1 == f[x].y1 && f[x].y2 == f[y].y2)
            return 1;
        else
            return 0;
    }
    return 0;
}

int judge2(int x)
{
    int i;
    int k = g[x].size();
    for(i = 0; i < k; i++)
        if(!vis[g[x][i]])
            break;
    if(i == k)
        return 1;
    return 0;
}

int dfs(int x, int c, int step)
{
    if( x < 0)
        return 0;
    if(step > n)
        return 1;
    for(int i = 1; i <= n; i++)
    {
        int flag = judge2(i);
        if(!vis[i] && flag && f[i].c == c)
        {
            vis[i] = 1;
            if(dfs(x, c, step+1))
                return 1;
            vis[i] = 0;
        }
        else if(!vis[i] && flag && f[i].c != c)
        {
            vis[i] = 1;
            if(dfs(x-1, f[i].c, step+1))
                return 1;
            vis[i] = 0;
        }
    }
    return 0;
}

int main()
{
    int T;
    cin >>T;
    while(T--)
    {
        cin >>n;
        for(int i = 0; i <= n; i++)
            g[i].clear();
        for(int i = 1; i <= n; i++)
            cin >>f[i].x1>>f[i].y1>>f[i].x2>>f[i].y2>>f[i].c;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(i != j)
                    if(judge1(i, j))
                        g[j].push_back(i);
        int i;
        for(i = 1; i <= n; i++)
        {
            memset(vis, 0, sizeof(vis));
            if(dfs(i, 0, 1))
                break;
        }
        cout<<i<<endl;
    }
}