poj 1691 状态压缩DP

最新推荐文章于 2024-10-01 18:52:56 发布

原创最新推荐文章于 2024-10-01 18:52:56 发布 · 571 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #dp

动态规划同时被 2 个专栏收录

296 篇文章

订阅专栏

状态压缩DP

23 篇文章

订阅专栏

本文介绍了一个使用动态规划解决的涂色问题。通过定义状态dp[statu][i]为在状态statu下所有块被涂色，且最后一个被涂的是i时所需的最少刷子拿起次数。特别注意，如果一个方块在另一个方块的上方有任何接触，则认为它们相邻。文章给出了详细的AC代码实现。

WA了一次。。。。

dp[statu][i] 表示状态statu中的块都已经涂了且最后一次涂得i所需要的最少拿起刷子次数

然后转移就是枚举所有的块，判断能否刷，能刷就更新

这题有一点要注意的是：只要是在该方块的上方有一部分接触就算邻接方块！！！

妈蛋！我开始还以为要全部邻接才行

AC代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

#define MAX 0x3f3f3f3f

struct Node{
    int x[2], y[2];
    int c;
};

Node node[20];
int N;
int dp[1<<16][16];

bool judge( int statu, int i ){
    bool mark[20];
    memset( mark, false, sizeof( mark ) );
    for( int k = 0; k < N; k++ ){
        if( k != i && node[k].x[1] == node[i].x[0] ){
            if( node[k].y[1] <= node[i].y[1] && node[k].y[0] >= node[i].y[0] ){
                mark[k] = true;
            }
			if( node[k].y[1] <= node[i].y[1] && node[k].y[1] > node[i].y[0] ){
                mark[k] = true;
            }
			if( node[k].y[0] >= node[i].y[0] && node[k].y[0] < node[i].y[1] ){
                mark[k] = true;
            }
        }
    }
    for( int k = 0; k < N; k++ ){
        if( mark[k] ){
            if( !( statu & ( 1 << k ) ) ){
                return false;
            }
        }
    }
    return true;
}

int main(){
    int T;

    scanf( "%d", &T );
    while( T-- ){
        scanf( "%d", &N );
        for( int i = 0; i < N; i++ ){
            scanf( "%d%d%d%d%d", &node[i].x[0], &node[i].y[0], &node[i].x[1], &node[i].y[1], &node[i].c );
        }
        memset( dp, -1, sizeof( dp ) );
        for( int i = 0; i < N; i++ ){
            if( node[i].x[0] == 0 ){
                dp[1<<i][i] = 1;
            }
        }
        for( int i = 0; i < ( 1 << N ); i++ ){
            for( int j = 0; j < N; j++ ){
                if( dp[i][j] != -1 ){
                    for( int k = 0; k < N; k++ ){
                        if( i & ( 1 << k ) ){
                            continue;
                        }
                        if( judge( i, k ) ){
                            if( node[j].c == node[k].c ){
                                if( dp[i|(1<<k)][k] == -1 ){
                                    dp[i|(1<<k)][k] = dp[i][j];
                                }else{
                                    dp[i|(1<<k)][k] = min( dp[i|(1<<k)][k], dp[i][j] );
                                }
                            }else{
                                if( dp[i|(1<<k)][k] == -1 ){
                                    dp[i|(1<<k)][k] = dp[i][j] + 1;
                                }else{
                                    dp[i|(1<<k)][k] = min( dp[i|(1<<k)][k], dp[i][j] + 1 );
                                }
                            }
                        }
                    }
                }
            }
        }
        int ans = MAX;
        for( int i = 0; i < N; i++ ){
			if( dp[(1<<N)-1][i] != -1 ){
				ans = min( ans, dp[(1<<N)-1][i] );
			}
        }
        cout << ans << endl;
    }
    return 0;
}