poj_1084 剪枝-IDA*

题目大意

给出一个由2*S*(S+1)构成的S*S大小的火柴格。火柴可以构成1x1,2x2...SxS大小的方格。其中已经拿走了几个火柴，问最少再拿走几个火柴可以使得这些火柴无法构成任何一个方格。

题目分析

本题，采用的是搜索+剪枝来实现。需要做的是保存每个搜索节点的状态，以及通过合理的记录数据，对状态进行推演。
这里状态为：当前需要被拆除的火柴序号（match_index,可以拆除或者不拆除)+当前剩余的完整的方格的数目(left_square_num)+
当前已经拆除的火柴数目（taken_num,可以用于最优化剪枝）。
而记录数据可以为：火柴i是否位于方块j中 gMatchInSquare[i][j]. 方块s中最大的火柴序号 gMaxMatchInSquare[s]（用于剪枝）。
这样，使用最优化剪枝，DFS搜索。剪枝：
（1）对于当前节点，若taken_num > gMinTakenNum,则剪枝返回；
（2）如果火柴 match_index 不存在任何一个剩余的完整的方块中，则不必拆除match_index，即剪枝拆除match_index的情况；
（3）如果火柴 match_index 是当前剩余的某个完整方块的构成火柴的最大的序号，则必须进行拆除（因为，对于火柴是按照序号从小到大进行递归搜索，如果match_index为某个方格的最大序号，则若不删除，之后的任何火柴都不在该方格中，无法破坏该方格），即剪枝不拆除的情况；

单纯使用以上剪枝，仍然会超时，则考虑使用估计函数来进行深度剪枝：考虑当前剩余的所有完整方格中不相交的方格的个数K，则从当前状态开始，至少还需要拆除K个火柴，才可能达到没有完整方格的状态。因此

taken_num >= gMinTakenNum

改为

taken_num + SeperateCompleteSquareNum() > gMinTakenNum

，进行剪枝。

[b]实现方法[/b]
可以采用单纯的剪枝，或者采用IDA算法。

实现(c++)

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<algorithm>
#define INFINITE 1 << 30
#define MAX_MATCH_NUM 2*5*6
#define MAX_SQUARE_NUM MAX_MATCH_NUM*5
using namespace std;
bool gMatchInSquare[MAX_MATCH_NUM][MAX_SQUARE_NUM];	//判断火柴i是否位于方块j中
bool gSquareComplete[MAX_SQUARE_NUM];	//方块s是否完整
int gMaxMatchInSquare[MAX_SQUARE_NUM];	//方块s中最大的火柴序号

int gMinTakenNum;	//最少需要拿走的火柴数目
int gTotalSquareNum;	//没有任何火柴被拿走的情况下，总的方格数目
int gTotalMatchNum;	//没有任何火柴被拿走的情况下，总的火柴数

vector<int> gNotMissedMatch;	//没有被拿走的火柴集合，从中选择拿走的火柴

//初始化，主要是对于S*S的网格，判断 每个火柴位于那些方格中，以及每个方格中的最大的火柴序号
void Init(int size){
memset(gMatchInSquare, false, sizeof(gMatchInSquare));
memset(gSquareComplete, true, sizeof(gSquareComplete));

gTotalMatchNum = 2 * (size + 1)*size;
int s = size;
gTotalSquareNum = 0;
while (s > 0){
gTotalSquareNum += s*s;
s--;
}
s = 1;
int total_square_index = 0;
while (s <= size){

for (int square_index = 0; square_index < (size - s + 1)*(size - s + 1); square_index++){
int match_index = (square_index / (size - s + 1))*(2 * size + 1) + (square_index % (size - s + 1));
int up_beg = match_index;
int left_beg = match_index + size;
int right_beg = left_beg + s;
int down_beg = up_beg + s*(1 + size*2);

for (int i = 0; i < s; i++){
gMatchInSquare[up_beg + i][total_square_index] = true;
gMatchInSquare[down_beg + i][total_square_index] = true;
gMatchInSquare[left_beg + i*(2 * size + 1)][total_square_index] = true;
gMatchInSquare[right_beg + i*(2 * size + 1)][total_square_index] = true;
}
gMaxMatchInSquare[total_square_index] = down_beg + s - 1;
total_square_index++;
}
s++;
}
}

//判断火柴m位于那些完整的方格中，以及m是否是某些网格的最大序号火柴
void MatchInCompleteSquare(int m, vector<int>& complete_square_contain_match, bool* match_is_max){
*match_is_max = false;
for (int s = 0; s < gTotalSquareNum; s++){
if (gMatchInSquare[m][s] && gSquareComplete[s]){
complete_square_contain_match.push_back(s);
if (gMaxMatchInSquare[s] == m){
*match_is_max = true;
}
}
}
}

//获得当前剩余的完整网格中，不相交的网格的数目
int SeperateCompleteSquareNum(int n){
int result = 0;
typedef pair<int, int> MatchNumSquarePair;
vector<MatchNumSquarePair> ms_vec;
for (int s = 0; s < gTotalSquareNum; s++){
if (!gSquareComplete[s])
continue;
int num = 0;
for (int m = 0; m < gTotalMatchNum; m++){
if (gMatchInSquare[m][s])
num++;
}
ms_vec.push_back(MatchNumSquarePair(num, s));
}
sort(ms_vec.begin(), ms_vec.end());
vector<bool> match_used(gTotalMatchNum, false);

for (int i = 0; i < ms_vec.size(); i++){
MatchNumSquarePair ms_pair = ms_vec[i];
bool ok = true;
for (int m = n; m < gTotalMatchNum; m++){
if (match_used[m] && gMatchInSquare[m][ms_pair.second]){
ok = false;
}
}
if (ok){
for (int m = n; m < gTotalMatchNum; m++){
if (gMatchInSquare[m][ms_pair.second]){
match_used[m] = true;
}
}
result++;
}
}
return result;
}
/*

//单纯的估计函数进行剪枝，不适用IDA算法
void Destroy(int n, int taken_num, int left_complete_square){
if (n == gNotMissedMatch.size()){
return;
}
if (left_complete_square == 0){
gMinTakenNum = gMinTakenNum < taken_num ? gMinTakenNum : taken_num;
return;
}

//估价函数剪枝
if (taken_num + SeperateCompleteSquareNum(gNotMissedMatch
) >= gMinTakenNum){
return;
}

int match = gNotMissedMatch
;
vector<int> complete_square_contain_match;
bool match_is_max_in_square;
MatchInCompleteSquare(match, complete_square_contain_match, &match_is_max_in_square);

//如果火柴 match_index 不存在任何一个剩余的完整的方块中，则不必拆除match_index，剪枝1
if (complete_square_contain_match.empty()){
Destroy(n + 1, taken_num, left_complete_square);
}
else{
//如果火柴 match_index 是当前剩余的某个完整方块的构成火柴的最大的序号，则必须进行拆除，即剪枝不拆除的情况；剪枝2
if (!match_is_max_in_square){
Destroy(n + 1, taken_num, left_complete_square);
}
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = false;
}
Destroy(n + 1, taken_num + 1, left_complete_square - complete_square_contain_match.size());
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = true;
}
}
}*/
/*
//IDA 迭代加深，每次只增加1个深度
void Destroy(int n, int taken_num, int left_complete_square, bool* destroy_over){
if (*destroy_over)
return;

if (n == gNotMissedMatch.size()){
return;
}
if (left_complete_square == 0){
*destroy_over = true;
return;
}
int seperate_complete_square_num = SeperateCompleteSquareNum(gNotMissedMatch
);
if (taken_num + seperate_complete_square_num > gMinTakenNum){
return;
}

int match = gNotMissedMatch
;
vector<int> complete_square_contain_match;
bool match_is_max_in_square;
MatchInCompleteSquare(match, complete_square_contain_match, &match_is_max_in_square);

if (complete_square_contain_match.empty()){
Destroy(n + 1, taken_num, left_complete_square, destroy_over);
}
else{
if (!match_is_max_in_square){
Destroy(n + 1, taken_num, left_complete_square, destroy_over);
}
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = false;
}
Destroy(n + 1, taken_num + 1, left_complete_square - complete_square_contain_match.size(), destroy_over);
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = true;
}
}
}
*/
//IDA迭代加深，每次可能增加多个深度，由next_min_taken_num指定
void Destroy(int n, int taken_num, int left_complete_square, int & next_min_taken_num){
if (next_min_taken_num <= gMinTakenNum){
return;
}
if (n == gNotMissedMatch.size()){
return;
}
if (left_complete_square == 0){
next_min_taken_num = next_min_taken_num < taken_num ? next_min_taken_num : taken_num;
return;
}
int seperate_complete_square_num = SeperateCompleteSquareNum(gNotMissedMatch
);
if (taken_num + seperate_complete_square_num > gMinTakenNum){
next_min_taken_num = next_min_taken_num < taken_num + seperate_complete_square_num ? next_min_taken_num : seperate_complete_square_num + taken_num;
return;
}

int match = gNotMissedMatch
;
vector<int> complete_square_contain_match;
bool match_is_max_in_square;
MatchInCompleteSquare(match, complete_square_contain_match, &match_is_max_in_square);

if (complete_square_contain_match.empty()){
Destroy(n + 1, taken_num, left_complete_square, next_min_taken_num);
}
else{
if (!match_is_max_in_square){
Destroy(n + 1, taken_num, left_complete_square, next_min_taken_num);
}
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = false;
}
Destroy(n + 1, taken_num + 1, left_complete_square - complete_square_contain_match.size(), next_min_taken_num);
for (int i = 0; i < complete_square_contain_match.size(); i++){
int s = complete_square_contain_match[i];
gSquareComplete[s] = true;
}
}
}

//IDA方法
void Resolve(int left_complete_square){
gMinTakenNum =  SeperateCompleteSquareNum(gNotMissedMatch[0]);
int next_min_taken_num;
bool destroy_over;
while (true){

//IDA2
next_min_taken_num = INFINITE;
Destroy(0, 0, left_complete_square, next_min_taken_num);
if (next_min_taken_num <= gMinTakenNum){
gMinTakenNum = next_min_taken_num;
return;
}
gMinTakenNum = next_min_taken_num;
/*
IDA1
destroy_over = false;

Destroy(0, 0, left_complete_square, &destroy_over);
if (destroy_over){
return;
}
gMinTakenNum++;
*/
}
}

int main(){
int T;
scanf("%d", &T);
while (T--){
int size, k;
scanf("%d %d", &size, &k);
Init(size);
gNotMissedMatch.clear();
for (int i = 0; i < gTotalMatchNum; i++){
gNotMissedMatch.push_back(i);
}
gMinTakenNum = INFINITE;
int missed_match_index, left_complete_square = gTotalSquareNum;
for (int i = 0; i < k; i++){
scanf("%d", &missed_match_index);
missed_match_index--;
gNotMissedMatch.erase(find(gNotMissedMatch.begin(), gNotMissedMatch.end(), missed_match_index));
for (int j = 0; j < gTotalSquareNum; j++){
if (gMatchInSquare[missed_match_index][j] && gSquareComplete[j]){
gSquareComplete[j] = false;
left_complete_square--;
}
}
}
//普通的 估价剪枝
//Destroy(0, 0, left_complete_square);
//IDA 1或者2
Resolve(left_complete_square);
printf("%d\n", gMinTakenNum);
}
return 0;
}