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 ci 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 ci (ci > 0), denoting the number of cells where the i-th color should be used.

It’s guaranteed that c1 + c2 + · · · + cK = 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;
}