POJ初阶枚举算法小结_POJ1753+POJ2965

原创于 2021-05-09 20:53:04 发布 · 178 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

poj 专栏收录该内容

6 篇文章

订阅专栏

本文通过分析POJ1753和POJ2965两道题目，总结了枚举算法在解决翻转问题中的应用。作者指出，这类问题可以通过限制树的高度并用前序遍历来实现翻转，逐步回溯以找到最小步骤。通过画图辅助理解，可以更好地掌握这种枚举方法。

POJ1753:http://poj.org/problem?id=1753
POJ2965:http://poj.org/problem?id=2965

详细注释见代码:
反思:两道题都很类似,第一道题是翻转四周,第二道题是翻转整行整列,都是求翻转的最小步骤,我们发现这些题目都看似无从下手,只能一个一个试一试(大神勿喷~)
这就是枚举啊,我们使用step来限制树的高度,使用前序遍历来进行翻转,回溯,看似复杂,实际上这两句话仔细体会,再画个树形图,差不多理解就够了.

#include<iostream>
/*
	每一次翻转都会影响上下左右进行翻转,截止状态为全黑或者全白,求最少翻转次数 
*/

/*
	思路:最多翻转16次不同地方,因为两次翻转同一个区域就相当于是,没有翻转过 
	
	在1~16次之间dfs搜索,依次搜索,如果有满足的就一定是最优解的情况
	搜索方法很有意思,按照先序遍历方法来搜索,但是限制了step,也就是说限制了step的深度,相当于用
	一层逻辑把树的下半部分截断了,只考虑上班部分的深度优先搜索,这样无疑保证了每次搜索出来的step
	一定是当前最短的step 
*/ 
using namespace std;

bool chess[6][6]={false};		//四周保持边界,以免出现下标越界的情况 
int flag=false;
int step; 
int r[5]={-1,1,0,0,0}; 		//行和列的上下左右中5个位置都要改变 
int c[5]={0,0,-1,1,0};		//注意:坑:自己也要移动,移动的位置是00 

bool isOver()
{
	for(int i=1;i<5;++i)
	{
		for(int j=1;j<5;++j)
		{
			if(chess[i][j]!=chess[1][1])	return false;
		}
	}
	return true; 
} 

void flip(int row,int col)		
{
	for(int i=0;i<5;++i)				//注意自己的位置也是要翻转的 
	{
		chess[row+r[i]][col+c[i]]=!chess[row+r[i]][col+c[i]];
	}
} 

void dfs(int row,int col,int deep)		//使用deep来表示递归的深度 
{
	if(deep==step){				//这里的判定条件相当于是加上了逻辑上的"断层",切割了下面的树部分 
		flag=isOver();
		return;
	}
	if(row>=5||flag)			//这里注意要加判定条件flag,要么是当前到达叶子节点了(标志就是row==5),要么就是已经找到了最小的step后falg=true 
	return;
	flip(row,col);
	if(col<4){
		dfs(row,col+1,deep+1);	//<1>进入下一层,相当于是进入深度+1的树节点,先翻转再递归,使用先序遍历 
	}
	else{
		dfs(row+1,1,deep+1);
	}
	flip(row,col);				//回溯 
	if(col<4)
	{
		dfs(row,col+1,deep);	//<2>相当于是考虑本层的其他节点,上面的<1>处.相当于是进入下面的树枝,此处的<2>相当于是进入判断本层的兄弟节点 
	}
	else{
		dfs(row+1,1,deep);
	}
	return;
}

int main()
{
	char C;				//注意:根据寻址原理,列这里的参数是一定要写实值的 
	for(int i=1;i<5;++i)
	{
		for(int j=1;j<5;++j)
		{
			cin>>C;
			if(C=='b')	chess[i][j]=true;	//因为本题的单元格只有黑和白两种状态,所以可以使用bool类型来保存 
		}	
	} 
	for(step=0;step<=16;++step)
	{
		dfs(1,1,0);							//注意为了防止不必要的下标越界等错误,这里在4*4的棋盘四周加上了一层防护,所以索引上的行列和逻辑上的行和列一样 
		if(flag)	break;
	} 
	if(flag)
	{
		cout<<step<<endl;
	}
	else{
		cout<<"Impossible"<<endl;
	}
	return 0;
}

再对比一下这道题目我们就会发现两道题目真简直一模一样

#include<iostream>

using namespace std;

bool status[6][6]={false};		//关为true,开为false,题目要求最终为全开状态 
int count;
bool flag;
int res[30][2]; 
int step;

bool isOver()
{
	for(int i=1;i<5;++i)
	{
		for(int j=1;j<5;++j)
		{
			if(status[i][j])	return false; 
		}
	}
	return true; 
}

void flip(int row,int col)
{
	for(int i=1;i<5;++i)
	{
		status[i][col]=!status[i][col];
	}
	for(int i=1;i<5;++i)
	{
		status[row][i]=!status[row][i];
	}
	status[row][col]=!status[row][col];
} 


void dfs(int row,int col,int deep)
{
	if(deep==step)
	{
		flag=isOver();
		return;
	}
	if(flag || row==5)  
    {  
        return;  
    }  
    flip(row,col);
	res[deep][0] = row;
	res[deep][1] = col;				//只用翻转的时候记住操作即可,因为同层会被依次覆盖,找到了就直接返回,不存在壶盖问题 
    if(col<=3)  
    {  
        dfs(row,col+1,deep+1);  
    }  
    else  
    {  
        dfs(row+1,1,deep+1);  
    }  
    flip(row,col);  
    if(col<=3)  
    {  
        dfs(row,col+1,deep);  
    }  
    else  
    {  
        dfs(row+1,1,deep);  
    }    
} 

int main()
{
	char tmp;
	for(int i=1;i<5;++i)
	{
		for(int j=1;j<5;++j)
		{
			cin>>tmp;
			if('+'==tmp)
			{
				status[i][j]=true;
			}
		}
	}
	for(step=0;step<=16;++step)
	{
		dfs(1,1,0);		//注意这里的起始位置 
		if(flag)	break;	
	} 
	cout<<step<<endl;
	for(int i=0;i<step;i++)
	{
		cout<<res[i][0]<<" "<<res[i][1]<<endl;
	}
	return 0;
}