hdu 2541 Another Eight Puzzle(dfs)

Another Eight Puzzle

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 859    Accepted Submission(s): 542

Problem Description

Fill the following 8 circles with digits 1~8,with each number exactly once . Conntcted circles cannot be filled with two consecutive numbers.
There are 17 pairs of connected cicles:
A-B , A-C, A-D
B-C, B-E, B-F
C-D, C-E, C-F, C-G
D-F, D-G
E-F, E-H
F-G, F-H
G-H

Filling G with 1 and D with 2 (or G with 2 and D with 1) is illegal since G and D are connected and 1 and 2 are consecutive .However ,filling A with 8 and B with 1 is legal since 8 and 1 are not consecutive .

In this problems,some circles are already filled,your tast is to fill the remaining circles to obtain a solution (if possivle).

 

Input

The first line contains a single integer T(1≤T≤10),the number of test cases. Each test case is a single line containing 8 integers 0~8,the numbers in circle A~H.0 indicates an empty circle.

 

Output

For each test case ,print the case number and the solution in the same format as the input . if there is no solution ,print “No answer”.If there more than one solution,print “Not unique”.

 

Sample Input

  
  

   
   3
7 3 1 4 5 8 0 0
7 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0
  
  

 

Sample Output

  
  

   
   Case 1: 7 3 1 4 5 8 6 2
Case 2: Not unique
Case 3: No answer
  
  

 

Source

ECJTU 2008 Autumn Contest

题目分析:模拟+搜索,不用剪枝都能过,只要cnt>1跳出搜索即可

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#define MAX 11

using namespace std;

int t;
int num[MAX];
int ans[MAX];
bool used[MAX];

struct Edge
{
    int v,next;
}e[MAX*10];

int head[MAX];
int cc;

void add ( int u , int v )
{
    e[cc].v = v;
    e[cc].next = head[u];
    head[u] = cc++;
}

void init ( )
{
    cc = 0;
    memset ( head , -1 , sizeof ( head ) );
    add ( 1 , 2 );
    add ( 1 , 3 );
    add ( 1 , 4 );
    add ( 2 , 1 );
    add ( 2 , 3 );
    add ( 2 , 5 );
    add ( 2 , 6 );
    add ( 3 , 1 );
    add ( 3 , 2 );
    add ( 3 , 4 );
    add ( 3 , 5 );
    add ( 3 , 6 );
    add ( 3 , 7 );
    add ( 4 , 1 );
    add ( 4 , 3 );
    add ( 4 , 6 );
    add ( 4 , 7 );
    add ( 5 , 2 );
    add ( 5 , 3 );
    add ( 5 , 6 );
    add ( 5 , 8 );
    add ( 6 , 2 );
    add ( 6 , 3 );
    add ( 6 , 4 );
    add ( 6 , 5 );
    add ( 6 , 7 );
    add ( 6 , 8 );
    add ( 7 , 4 );
    add ( 7 , 6 );
    add ( 7 , 3 );
    add ( 7 , 8 );
    add ( 8 , 5 );
    add ( 8 , 6 );
    add ( 8 , 7 );
}

int cnt;

bool check ( int u , int digit )
{
    for ( int i = head[u] ; ~i ; i = e[i].next )
    {
        int v = e[i].v;
        if ( !num[v] ) continue;
        if ( num[v] == digit-1 || num[v] == digit+1 ) return false;
    }
    return true;
}

void dfs ( int n )
{
    if ( cnt > 1 ) return;
    if ( n == 9 )
    {
        cnt++;
        for ( int i = 1 ; i <= 8 ; i++ )
            ans[i] = num[i];
        return;
    }
    if ( num[n] )
        dfs ( n+1 );
    else 
    for ( int i = 1 ; i < 9 ; i++ )
    {
        if ( used[i] ) continue;
        if ( check ( n , i ) ) 
        {
            num[n] = i;
            used[i] = true;
            dfs ( n+1 );
            num[n] = 0;
            used[i] = false; 
        }
    }
}

int main ( )
{
    scanf ( "%d" , &t );
    int c = 1;
    init ( );
    while ( t-- )
    {
        memset ( used , 0 , sizeof ( used ) );
        for ( int i = 1 ; i <= 8 ; i++ )
        {
            scanf ( "%d" , &num[i] );
            used[num[i]] = true;
        }
        cnt = 0;
        dfs ( 1 );
        printf ( "Case %d: " , c++ );
        if ( cnt > 1 ) puts ( "Not unique" );
        else if ( cnt == 0 ) puts ( "No answer" );
        else
        {
            for ( int i = 1 ; i < 8 ; i++ )
                printf ( "%d " , ans[i] );
            printf ( "%d\n" , ans[8] );
        }
    }
}