HDU 5113 Black And White 两种搜索策略(dfs+剪纸)

Black And White

Time Limit: 2000/2000 MS (Java/Others)    Memory Limit: 512000/512000 K (Java/Others)
Total Submission(s): 3671    Accepted Submission(s): 998
Special Judge

Problem Description

In mathematics, the four color theorem, or the four color map theorem, states that, given any separation of a plane into contiguous regions, producing a figure called a map, no more than four colors are required to color the regions of the map so that no two adjacent regions have the same color.
— Wikipedia, the free encyclopedia

In this problem, you have to solve the 4-color problem. Hey, I’m just joking.

You are asked to solve a similar problem:

Color an N × M chessboard with K colors numbered from 1 to K such that no two adjacent cells have the same color (two cells are adjacent if they share an edge). The i-th color should be used in exactly c _i cells.

Matt hopes you can tell him a possible coloring.

 

Input

The first line contains only one integer T (1 ≤ T ≤ 5000), which indicates the number of test cases.

For each test case, the first line contains three integers: N, M, K (0 < N, M ≤ 5, 0 < K ≤ N × M ).

The second line contains K integers c _i (c _i > 0), denoting the number of cells where the i-th color should be used.

It’s guaranteed that c ₁ + c ₂ + · · · + c _K = N × M .

 

Output

For each test case, the first line contains “Case #x:”, where x is the case number (starting from 1). 

In the second line, output “NO” if there is no coloring satisfying the requirements. Otherwise, output “YES” in one line. Each of the following N lines contains M numbers seperated by single whitespace, denoting the color of the cells.

If there are multiple solutions, output any of them.

 

Sample Input

  
  

   
   4
1 5 2
4 1
3 3 4
1 2 2 4
2 3 3
2 2 2
3 2 3
2 2 2
  
  

 

Sample Output

  
  

   
   Case #1:
NO
Case #2:
YES
4 3 4
2 1 2
4 3 4
Case #3:
YES
1 2 3
2 3 1
Case #4:
YES
1 2
2 3
3 1
  
  

 

Source

2014ACM/ICPC亚洲区北京站-重现赛（感谢北师和上交）

 

题意：   你需要解决一个类似的问题：有一个包含从1到K一共K种颜色的N×M棋盘，使得任意两个相邻的区块不能有相同的颜色（如果它们的上、下、左、右任意一边的颜色与自身颜色不同）。第i种颜色可以被使用Ci次。

思路：先说剪枝吧，假设只有一个颜色，让你涂一个棋盘，保证两两之间不相邻，你会发现他最多有这个棋盘一半+1个位置可以涂，（自己画一个3*3,2*2的正方体就懂了），所以这个剪枝就是只要剩下的格子n/2+1比其中一个颜色少，就说明这个颜色一定会相邻。。。

我写的dfs真的是傻子写的。。。按照他的题意，看看4个方向有没有重合的。。这样复杂度比较高。。。因为4个方向都要走。。不过有些人也是这么写的，他们在main函数里用一个for枚举了第一块砖的k种可能性，其实这里只要把dfs改一下就行了，从0,1开始，这样他的四个方向只有1,1（第一块砖）符合条件，达到了要求。。这里s要==n*m，一开始写成了n*m+1，因为到了n*m不可能再递归下去了。。所以没有n*m+1。。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 30;
int book[maxn][maxn], colour[maxn], matrix[maxn][maxn];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int n, m, k, flag;
void dfs(int s, int x, int y) //s控制跳出以及剪枝要用
{
    if(flag) return ;
    for(int i = 1; i <= k; i++) //剪枝
        if((n*m-s+1)/2 < colour[i]) 
            return;
    if(s == n*m)
    {
        flag = 1;
        printf("YES\n");
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
            printf("%d%c", book[i][j], j == m ? '\n' : ' ');
        return;
    }
    for(int i = 0; i < 4; i++)
    {
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];
        if(tx <= n && ty <= m && tx >= 1 && ty >= 1 && !book[tx][ty])
        {
            for(int j = 1; j <= k; j++)  //枚举每一种颜色
            {
                if(colour[j])
                {
                    if(book[tx+1][ty] == j || book[tx][ty+1] == j || book[tx-1][ty] == j || book[tx][ty-1] == j)
                        continue;
                        book[tx][ty] = j;
                        colour[j]--;
                        dfs(s+1, tx, ty);
                        book[tx][ty] = 0; //这里都变回去
                        colour[j]++;
                }
            }
        }
    }
}
int main()
{
    int t, Case = 0;
    scanf("%d", &t);
    while(t--)
    {
        memset(book, 0, sizeof(book));
        printf("Case #%d:\n", ++Case);
        scanf("%d%d%d", &n, &m, &k);
        for(int i = 1; i <= k; i++)
            scanf("%d", &colour[i]);
        flag = 0;
        dfs(0, 0, 1); //改变一下传入值
        if(!flag) printf("NO\n");
    }
    return 0;
}

这才是正确的dfs方式。。每一行每一行的枚举，从左往右枚举列。。这样只需要判断他左面跟他上面的行不行就可以了。。。如果上面那样写，有些题要加许多if判断x-1,y-1会不会超过边界。。。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;

int n,m,k,flag,t;
int a[30],mat[7][7],vis[7][7];

void dfs(int x, int y, int d)
{
    if (!d)  //用d表示剩下多少，==0的时候就是全部枚举完了
    {
        flag = 1;
        return ;
    }
    for (int i=1; i<=k; i++) //剪枝
        if (a[i] > (d+1)/2)
            return ;
    for (int i=1; i<=k; i++)
    {
        if(!a[i])continue;
        if(x&&mat[x-1][y]==i)continue; //这里只看他上面左面就行，这里很强，让坐标从0开始，这样x&&保证了不是第一行
        if(y&&mat[x][y-1]==i)continue;
        a[i]--;
        mat[x][y] = i;
        if (y < m-1)  //如果没有到最后一列就继续列
            dfs(x, y+1, d-1);
        else
            dfs(x+1, 0, d-1); //到了最后一列枚举行
        if (flag)
            return ;
        a[i]++;
    }
    return ;
}

int main ()
{
    int T,ii;
    int i,j;
    scanf ("%d",&T);
    for (ii=1; ii<=T; ii++)
    {
        scanf ("%d%d%d",&n,&m,&k);
        for (i=1; i<=k; i++)
            scanf ("%d",&a[i]);
        flag = 0;
        dfs(0, 0, n*m);
        printf ("Case #%d:\n",ii);
        if (flag)
        {
            printf ("YES\n");
            for (i=0; i<n; i++)
            {
                for (j=0; j<m; j++)
                {
                    if (j==0)
                        printf ("%d",mat[i][j]);
                    else
                        printf (" %d",mat[i][j]);
                }
                printf ("\n");
            }
        }
        else
            printf ("NO\n");
    }
    return 0;
}