HDU 4285 circuits( 插头dp , k回路 )

circuits

Time Limit: 30000/15000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 793    Accepted Submission(s): 253

Problem Description

　
　Given a map of N * M (2 <= N, M <= 12) , '.' means empty, '*'
means walls. You need to build K circuits and no circuits could be
nested in another. A circuit is a route connecting adjacent cells in a
cell sequence, and also connect the first cell and the last cell. Each
cell should be exactly in one circuit. How many ways do we have?

 

Input

　　The first line of input has an integer T, number of cases.
　　For each case:
　　The first line has three integers N M K, as described above.
　　Then the following N lines each has M characters, ‘.’ or ‘*’.

 

Output

　　For each case output one lines.
　　Each line is the answer % 1000000007 to the case.

 

Sample Input

2

4 4 1

**..

....

....

....

 

4 4 1

....

....

....

....

 

Sample Output

2

6

#include <bits/stdc++.h>
using namespace std ;
const int N =  ;
const int M =  ;
const int MAXN = ;
const int mod = 1e9+;
int n , m , K ;
int maze[N][N] ;
int code[N] ;
int ch[N] , num ;
int ex , ey ;

struct HASHMAP {
    int head[M] , next[MAXN] , tot  ;
    long long st[MAXN] , f[MAXN] ;
    void init() {
        memset( head , - , sizeof head ) ;
        tot =  ;
    }
    void push( long long state , long long ans ) {
        int u = state % M ;
        for( int i = head[u] ; ~i ; i = next[i] ) {
            if( st[i] == state ) {
                f[i] += ans ;
                f[i] %= mod ;
                return ;
            }
        }
        st[tot] = state ;
        f[tot] = ans % mod ;
        next[tot] = head[u] ;
        head[u] = tot++ ;
    }
} mp[] ;

void decode ( int* code , int m , long long st ) {
    num = st &  ;
    st >>=  ;
    for( int i = m ; i >=  ; --i ) {
        code[i] = st& ;
        st >>=  ;
    }
}

long long encode( int *code , int m ) {
    int cnt =  ;
    long long st =  ;
    memset( ch , - , sizeof ch) ;
    ch[] =  ;
    for( int i =  ; i <= m ; ++i ) {
        if( ch[code[i]] == - ) ch[ code[i] ] = cnt++ ;
        code[i] = ch[ code[i] ] ;
        st <<=  ;
        st |= code[i] ;
    }
    st <<=  ;
    st |= num ;
    return st ;
}

void shift( int *code , int m ) {
    for( int i = m ; i >  ; --i ) {
        code[i] = code[i-] ;
    } code[] =  ;
}

void dpblank( int i , int j , int cur ) {
    int left , up ;
    for( int k =  ; k < mp[cur].tot ; ++k ) {
        decode( code , m , mp[cur].st[k] );
        left = code[j-] ;
        up = code[j] ;
        if( left && up ) {
            if( left == up ) {
                if( num >= K ) continue ;
                int c =  ;
                for( int y =  ; y < j -  ; ++y )
                    if( code[y] ) c++ ;
                if( c& ) continue ;
                num++ ;
                code[j-] = code[j] =  ;
                if( j == m ) shift( code , m ) ;
                mp[cur^].push( encode(code,m),mp[cur].f[k] );
            }else {
                code[j-] = code[j] =  ;
                for( int t =  ; t <= m ; ++t ) {
                    if( code[t] == up )
                        code[t] = left ;
                }
                if( j == m ) shift( code,m );
                mp[cur^].push(encode(code,m),mp[cur].f[k]) ;
            }
        }
        else if( ( left && ( !up ) ) || ( up && (!left ) ) ) {
            int  t ;
            if( left ) t = left ;
            else t = up ;
            if( maze[i][j+] ) {
                code[j-] =  ;
                code[j] = t ;
                mp[cur^].push( encode(code,m) , mp[cur].f[k] ) ;
            }
            if( maze[i+][j] ) {
                code[j-] = t ;
                code[j] =  ;
                if( j == m ) shift( code , m );
                mp[cur^].push(encode(code,m),mp[cur].f[k]);

            }
        }
        else {
            if( maze[i][j+] && maze[i+][j] ) {
                code[j-] = code[j] =  ;
                mp[cur^].push( encode(code,m),mp[cur].f[k]);
            }
        }
    }
}
void dpblock( int i , int j , int cur ) {
    for( int k =  ; k < mp[cur].tot ; ++k ) {
        decode( code , m , mp[cur].st[k] );
        code[j-] = code[j] =  ;
        if( j == m ) shift( code , m );
        mp[cur^].push( encode(code,m) , mp[cur].f[k] );
    }
}

void Solve() {
    int v =  ;
    mp[v].init();
    mp[v].push(,);
    for( int i =  ; i <= n ; ++i ) {
        for( int j =  ; j <= m ; ++j ) {
            mp[v^].init() ;
            if( maze[i][j] ) dpblank( i , j , v ) ;
            else dpblock( i , j , v );
            v ^=  ;
        }
    }
    long long ans =  ;
    for( int i =  ; i < mp[v].tot ; ++i ) {
       if( mp[v].st[i] == K ) ans = ( ans + mp[v].f[i] ) % mod ;
    }
    cout << ans << endl ;
}
string s ;

int main () {
//    freopen("in.txt","r",stdin);
    ios::sync_with_stdio();
    int _ ; cin >> _ ;
    while( _-- ) {
        cin >> n >> m >> K ;
        ex =  ;
        memset( maze ,  , sizeof maze ) ;
        for( int i =  ; i <= n ; ++i ) {
            cin >> s ;
            for( int j =  ; j < m ; ++j ) {
                if( s[j] == '.' ) {
                    ex = i , ey = j +  ;
                    maze[i][j+] =  ;
                }
            }
        }
        if( !ex ) { cout << '' << endl ; continue ; }
        else Solve();
    }
    return  ;
}