hdu5113 剪枝搜索

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
  
  
  
  

   
   题意：就是说给你一个矩阵，要你在里面填数字，这个数字的前后左右都不能和自己相同，第一行输入时m n k表示 m行，n列，k表示数据的个数；
  
  
  
  

   
   然后第二行表示每个数据的个数；
  
  
  
  

   
   如果能够把这些数据成功的放入矩阵那么就输出yes 再输出随便任意一种放的方法否则输出no
  
  
  
  

   
   这里有个关键的剪枝 是  当剩余的格子向上取整的一半<小鱼任意一个剩下的数据的值 就直接退出，那么后面排数据肯定会有两个数据粘在一起；

  
  
  
  

   
   下面看代码吧
  
  
  
  

   
   代码：
  
  
  
  

   
   
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int n,m,k;
int map[6][6];
int a[100];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool jude(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m) return 1;
    return 0;
}

int dfs(int count,int count1)
{
    if(count==n*m) return 1;

    int x=count/m;
    int y=count%m;
    for(int i=1;i<=k;i++)
        if(a[i]>(n*m-count+1)/2) return 0;//这里判断只能在这里判断在下面那个for判断会判超时，
        //因为还没有找到比剩余格子的一般多的a【i】；i前面会继续深搜，本来这里是不需要深搜了的。所以还是会超时，所以一定要在外面判断，下面；
    for(int i=1;i<=k;i++)
    {
    if(a[i]!=0)
      { int flag=0;
        for(int j=0;j<4;j++)
        {
            int xx=x+dir[j][0];
            int yy=y+dir[j][1];
            if(!jude(xx,yy)) continue;
           if(map[xx][yy]==i){  flag=1;break;}
        }

        if(!flag)
        {
            map[x][y]=i;
            a[i]--;
            if(dfs(count+1,count1-1)) return 1;
            a[i]++;
            map[x][y]=-1;
        }
      }
    }
    return 0;

}
void solve()
{    memset(map,-1,sizeof(map));
     if(dfs(0,n*m)){ printf("YES\n");
          for(int i=0;i<n;i++)
          {
              for(int j=0;j<m-1;j++)
               printf("%d ",map[i][j]);
             printf("%d\n",map[i][m-1]);
          }
          return ;
     }
         printf("NO\n");


}
int main()
{
    int t;
    scanf("%d",&t);
    int count=1;
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=k;i++)
            scanf("%d",&a[i]);
        printf("Case #%d:\n",count++);
        solve();
    }
}