Black And White HDU - 5113

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.

InputThe 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 1 + c 2 + · · · + c K = N × M . 
OutputFor 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 1DFS

 1 #include <iostream>
 2 using namespace std;
 3 #include<string.h>
 4 #include<set>
 5 #include<stdio.h>
 6 #include<math.h>
 7 #include<queue>
 8 #include<map>
 9 #include<algorithm>
10 #include<queue>
11 int a[30][30],yanse[30];
12 int lenx,leny,yanseshu;
13 int flag=0;
14 int b[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
15 int panduan(int x,int y,int k)
16 {
17     if(a[x-1][y]==k) return 0;
18     if(a[x][y-1]==k) return 0;
19     return 1;
20 }
21 int dfs(int x,int y)
22 {
23     if(x>leny)
24     return 1;
25     int shengyu=(leny-x)*lenx+lenx-y+2;
26     for(int i=1;i<=yanseshu;i++)
27     if(shengyu/2<yanse[i])
28     return 0;
29     for(int i=1;i<=yanseshu;i++)
30     {
31         int f=0;
32         if(yanse[i]&&panduan(x,y,i)){
33             a[x][y]=i;
34             yanse[i]--;
35             if(y==lenx)
36             f=dfs(x+1,1);
37             else
38              f=dfs(x,y+1);
39             yanse[i]++;
40         }
41         if(f)
42             return 1;
43     }
44     return 0;
45 }
46 int main()
47 {
48     int add=0,t;
49     cin>>t;
50     while(t--)
51     {
52         memset(a,0,sizeof(a));
53         memset(yanse,0,sizeof(yanse));
54         cin>>leny>>lenx>>yanseshu;
55         for(int i=1;i<=yanseshu;i++)
56             cin>>yanse[i];
57             cout<<"Case #"<<++add<<":"<<endl;
58             flag=0;
59             if(dfs(1,1))
60             {
61                 cout<<"YES"<<endl;
62                 for(int i=1;i<=leny;i++)
63                 {
64                     for(int j=1;j<=lenx;j++)
65                     {
66                         if(j==lenx)
67                         {
68                             cout<<a[i][j];
69                             continue;
70                         }
71                         cout<<a[i][j]<<‘ ‘;
72                     }
73                     cout<<endl;
74                 }
75             }
76             else
77                     cout<<"NO"<<endl;
78     }
79     return 0;
80 }

时间: 2024-10-29 05:22:37

Black And White HDU - 5113的相关文章

HDU 5113 Black And White(DFS+剪枝)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5113 题面: Black And White Time Limit: 2000/2000 MS (Java/Others)    Memory Limit: 512000/512000 K (Java/Others) Total Submission(s): 1336    Accepted Submission(s): 350 Special Judge Problem Description I

[HDU 5113] Black And White (dfs+剪枝)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5113 题目大意:给你N*M的棋盘,K种颜色,每种颜色有c[i]个(sigma(c[i]) = N*M),现在给棋盘染色,使得相邻的两个棋盘染成不同的颜色,并且把所有颜色用完. 因为棋盘最大为5*5的,因此可以考虑搜索+剪枝. 从左到右,从上到下看当前格子能够染成什么颜色. 有一个限制性条件,就是说如果当前棋盘的格子数量的一半小于一种颜色的数量时,那么就一定有两个相邻的棋盘被染成了相同的颜色. 因为假

hdu 5113 Black And White

http://acm.hdu.edu.cn/showproblem.php?pid=5113 题意:给你n*m的格子,然后在每个格子内涂色,相邻格子不能同色,然后给你每个颜色涂的格子的固定个数,然后可不可以实现,可以实现输出任意一种,否则输出NO 思路:dfs枚举,剪纸,每种颜色剩余的个数不能超过剩余格子数的一半,如果剩余格子数是奇数,不能超过一半加1,偶数是一半. 1 #include <cstdio> 2 #include <cstring> 3 #include <al

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): 854    Accepted Submission(s): 218 Special Judge Problem Description In mathematics, the four color theorem, or the four color

HDU 5113 Black And White(暴力dfs+减枝)

题目大意:给你一个n×m的矩阵,然后给你k种颜色,每种颜色有x种,所有的个数加起来恰好为n×m个.问你让你对这个矩阵进行染色问你,能不能把所有的小方格都染色,而且相邻两个颜色不同. 思路:一开始想的是构造,先按照个数进行排序,枚举每一个位置,贪心的策略先放多的,如果可以全部放下就输出YES,以及存贮的方案,否则输出NO,但是有bug,一直不对... 正解:dfs暴力枚举每一个点,裸的话需要25!,显然会超时,需要先排个序用构造的策略,让多的先放这样可以减枝.然后再dfs就可以了. Black A

hdu 5113 Black And White, 黑白染色,技巧

Black And White Time Limit: 2000/2000 MS (Java/Others)    Memory Limit: 512000/512000 K (Java/Others) Total Submission(s): 485    Accepted Submission(s): 131 Special Judge Problem Description In mathematics, the four color theorem, or the four color

搜索(剪枝优化):HDU 5113 Black And White

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 th

HDU 5113 Black And White (dfs)

题目链接: 传送门 题意: 给定你一个n*m的格子,然后k种颜色给这个图涂色,要求 相邻的两个格子的颜色不相同(四个方向),而且第i种颜 色恰好出现c[i]次,问能否给这个图涂色成功. 分析: 首先我们考虑一种情况,n*m的格子用一种颜色给他涂色,保 证相邻的格子的颜色不同那么最多可以涂(m*n+1)/2 ,那么 我们搜索的时候可以直接根据这个条件来剪枝了.然后从下 到上一层一层的进行涂色. 代码如下: #include <iostream> #include <cstdio> #

HDU 5113 Black And White ( 2014 北京区预赛 B 、搜索 + 剪枝 )

题目链接 题意 : 给出 n * m 的网格.要你用 k 种不同的颜色填给出的网格.使得相邻的格子颜色不同.若有解要输出具体的方案 分析 : 看似构造.实则搜索.手构构半天没有什么好想法 直接搜就行了.注意加上剪枝 当剩下格子不足以让剩下颜色数量最多的颜色产生间隔的话则返回 具体也很好实现.即 max( 剩下的最多数量的那种颜色的数量 ) > ( 还剩多少格子 + 1 ) / 2 #include<bits/stdc++.h> using namespace std; const int