一、剪枝

在搜索算法中优化中，剪枝，就是通过某种判断，避免一些不必要的遍历过程，形象的说，就是剪去了搜索树中的某些“枝条”，故称剪枝。应用剪枝优化的核心问题是设计剪枝判断方法，即确定哪些枝条应当舍弃，哪些枝条应当保留的方法。

剪枝算法按照其判断思路可大致分成两类：可行性剪枝及最优性剪枝。

POJ2676

给你一个9*9的九宫格，有部分已经填上了数字，要求将九宫格用1-9填满，每行中的数字各不相同，每列中的数字各不相同，从从第一行开始每3*3组成一个小九宫格，小九宫格中的数字也各不相同。

解题思路，从左上角开始试着填数，这个数应该是该行、该列和方块中都未出现的数字(因此，需要判断一个格子是否能填某个数)，这个方法叫做剪枝，深度优先搜索直到填满所有的数。

#include<iostream>
#include<cstdio>
using name space std;
int a[10][10];
char s[10][10];
//下标都是从0到8
//判断(x,y)处能否放置k
bool flag;
bool ok(int k,int x,int y)
{
for(int i=0;i<9;i++){
if(a[i][y]==k) return false;
}
for(int j=0;j<9;j++){
if(a[x][j]==k) return false;
}
int u=x-x%3,v=y-y%3;
for(int i=u;i<u+3;i++){
for(int j=v;j<v+3;j++){
if(a[i][j]==k) return false;
}
}
return true;
}
//从当前点(x,y)开始深度优先搜索
void dfs(int x,int y)
{
//flag是成功的标志，而放置数字是按行从上到下开始，因此x==9也是成功的标志
if(flag||x==9){
flag=true;
return;
}
//(x,y)处已放置数字，放置下一个格子
while(a[x][y]){
if(y==8){
x++;
y=0;
}
else y++;
if(x==9){
flag=true;
return;
}
}
//枚举九个数字
for(int k=1;k<=9;k++){
if(ok(k,x,y)){
a[x][y]=k;
if(y==8) dfs(x+1,0);
else dfs(x,y+1);
if(flag) return;
a[x][y]=0;
}
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--){
for(int i=0;i<9;i++){
scanf("%s",s[i]);
for(int j=0;j<9;j++){
a[i][j]=s[i][j]-'0';
}
}
flag=false;
dfs(0,0);
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
printf("%d",a[i][j]);
}
printf("\n");
}
}
return 0;
}

POJ1084

题意：n*n的矩形阵(n<=5)，由2*n*(n+1)根火柴构成，那么其中会有很多诸如边长为1，为2…为n的正方形，现在可以拿走一些火柴，那么就会有一些正方形被破坏掉。问，在已经拿走一些火柴的情况下，还需要拿走至少多少根就可以把所有的正方形破坏掉。

题解：可以用dancing links做，让火柴做为行，让所有的正方形作为列，且如果i火柴能让j正方形破坏掉，就让第i行第j列为1，然后做一次可重复的覆盖，取最小值便可以得到答案。另外，涉及两个优化，

1、最优化剪枝，即最好情况下也不会比当前最优值更优的剪枝。

2、不必一开始就将所有的火柴棍与正方形的对应关系加入到DLX中，应该在读完所有数据之后，判断哪些正方形已经被删除了(即该列无效)，只加入有效的结点。

#include<cstdio>
#include<cstring>
#include<algorithm>
using name space std;
const int inf=1<<30;
const int NUM=100*60;
int cnt,L[NUM],R[NUM],S[NUM],D[NUM],U[NUM],C[NUM],O[NUM],H[NUM],X[NUM];
/*
NUM:最大结点数
U,D,L,R：上下左右结点
C：列的头指针位置
O：储存答案
X：与O配合代表第几行（X[O[i]]]）
通过link（r,c）加点，dfs（0）运算
*/
void remove(int c)
{
for(int i=D[c];i!=c;i=D[i])
{
L[R[i]]=L[i];
R[L[i]]=R[i];
}
}
void resume(int c)
{
for(int i=D[c];i!=c;i=D[i])
{
L[R[i]]=i;
R[L[i]]=i;
}
}
int geth()
{
bool has[80];
memset(has, false, sizeof(has));
int res=0;
for(int i=R[0]; i!=0; i=R[i])
if(!has[i])
{
res++;
for(int j=D[i]; j!=i; j=D[j])
for(int k=R[j]; k!=j; k=R[k])
has[C[k]]=true;
}
return res;
}
int ans;
void dfs(int k)
{
if(!R[0])
{
ans=min(k,ans);
return;
}
else if(k+geth()>=ans)
return;
int c=R[0];
for(int t=R[0],ms=inf; t!=0; t=R[t])
if(S[t]<ms)
ms=S[t],c=t;
for(int i=D[c];i!=c;i=D[i])
{
remove(i);
for(int j=R[i]; j!=i; j=R[j])
{
remove(j);
S[C[j]]--;
}
dfs(k+1);
for(int j=L[i]; j!=i; j=L[j])
{
resume(j);
S[C[j]]++;
}
resume(i);
}
}
void build(int r,int c)
{
for(int i=0;i<=c;i++)
{
U[i]=D[i]=i;
L[i+1]=i;
R[i]=i+1;
C[i]=i;
S[i]=0;
}
R[cnt=c]=0;
while(r)
H[r--]=-1;
}
void link(int r,int c)
{
++S[C[++cnt]=c];
X[cnt]=r;
D[cnt]=D[c];
U[D[c]]=cnt;
U[cnt]=c;
D[c]=cnt;
if(H[r]<0)
H[r]=L[cnt]=R[cnt]=cnt;
else
{
R[cnt]=R[H[r]];
L[R[H[r]]]=cnt;
L[cnt]=H[r];
R[H[r]]=cnt;
}
}
bool mark[80][80];
void init(int n)
{
memset(mark,false,sizeof(mark));
int i,j,k,si,num=0,c=1;
for(si=1;si<=n;si++)
{
for(i=1;i<=n-si+1;i++)
{
for(j=1;j<=n-si+1;j++)
{
for(k=0;k<si;k++)
{
mark[(i-1)*(2*n+1)+j+k][c]=true;
mark[(i-1+si)*(2*n+1)+j+k][c]=true;
mark[i*n+(i-1)*(n+1)+j+k*(2*n+1)][c]=true;
mark[i*n+(i-1)*(n+1)+j+k*(2*n+1)+si][c]=true;
}
c++;
}
}
}
}
int main()
{
int T,n;
for(scanf("%d",&T);T;T--)
{
scanf("%d",&n);
int num,row=2*n*(n+1),col=0;
for(int i=1;i<=n;i++)
col+=i*i;
build(row,col);
init(n);
scanf("%d",&num);
bool vis[80];
memset(vis,false,sizeof(vis));
for(int i=0;i<num;i++)
{
int r;
scanf("%d",&r);
for(int j=1;j<=col;j++)
{
if(mark[r][j])
{
if(!vis[j])
{
vis[j]=true;
R[L[j]]=R[j];
L[R[j]]=L[j];
R[j]=L[j]=0;
}
}
}
}
for(int i=1;i<=row;i++)
for(int j=1;j<=col;j++)
if(mark[i][j]&&!vis[j])
link(i,j);
ans=100000;
dfs(0);
printf("%d\n",ans);
}
return 0;
}

二、坐标离散化

区域的个数：w*h的格子上画了n条或垂直或水平的宽度为1的直线，求出这些线将格子划分成了多少个区域。
已知：
1≤w,h≤1000000
1≤n≤500
sample input
w= 10,h = 10,n = 5
x1= {1 , 1 , 4 , 9 , 10}
y1= {4 , 8 , 1 , 1 , 6}
x2= {6 , 10 , 4 , 9 , 10}
y2= {4 , 8 , 10 , 5 , 10}
(对应上图，横向为x，纵向为y)
利用BFS或dfs可以求出被分割的区域，但是w,h太大，不能创建w*h的数组，所以需要用到“坐标离散化” 这一技巧。如下图：

将前后左右没有变化的行列消除后并不会影响区域的个数。数组里重要存储有直线的行列以及其前后的行列就足够了。这样的话最多6n*6n就足够了，因此可以创建出数组并利用搜索求出区域的个数。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<queue>
#include<algorithm>
using name space std;
const int maxn = 500;
int W,H,N;
int X1[maxn],X2[maxn],Y1[maxn],Y2[maxn];
bool fld[maxn*6][maxn*6];
int dx[4]={0,0,-1,1};
int dy[4]={1,-1,0,0};
//对x1和x2进行坐标离散化，并返回离散后的宽度。（对于y1,y2同理）
//将x1,x2更新为离散后的x1,x2.y不变在x方向上缩小。（处理y1,y2时同理）
int compress(int *x1,int *x2,int w)
{
vector<int> xs;
for(int i = 0;i < N;i++)//确定离散后x轴上哪些值还存在
{
for(int d = -1;d <= 1; d++)
{
int tx1 = x1[i] + d, tx2 = x2[i] +d;
if(1 <= tx1 && tx1 <=w) xs.push_back(tx1);
if(1 <= tx2 && tx2 <=W) xs.push_back(tx2);
}
}
sort(xs.begin(),xs.end());
xs.erase(unique(xs.begin(),xs.end()),xs.end());//去重
for(int i = 0; i < N; i++)//转化为新的x1,x2;
{
x1[i] =find(xs.begin(),xs.end(),x1[i])-xs.begin();
x2[i] =find(xs.begin(),xs.end(),x2[i])-xs.begin();
}
return xs.size();
}
void solve()
{
//离散化
W = compress(X1,X2,W);
H = compress(Y1,Y2,H);
//填充新的网格
memset(fld,0,sizeof(fld));
for(int i=0;i<N;i++)
{
for(int y=Y1[i];y<=Y2[i];y++)
{
for(int x=X1[i];x<=X2[i];x++)
{
fld[y][x]=true;
}
}
}
//利用BFS计算区域数
int ans=0;
for(int y=0;y<H;y++)
{
for(int x=0;x<W;x++)
{
if(fld[y][x]) continue;
ans++;
queue<pair<int, int> >que;
que.push(make_pair(x,y));
while(!que.empty())
{
int sx=que.front().first,sy=que.front().second;
que.pop();
for(int i=0;i<4;i++)
{
int tx=sx + dx[i],ty=sy +dy[i];
if(tx<0 || tx>=W ||ty<0 || ty>=H || fld[ty][tx]) continue;
que.push(make_pair(tx,ty));
fld[ty][tx]=true;
}
}
}
}
printf("%d\n",ans);
}
intmain()
{
while(scanf("%d%d%d",&W,&H,&N)==3)
{
for(int i=0;i<N;i++)
scanf("%d",&X1[i]);
for(int i=0;i<N;i++)
scanf("%d",&X2[i]);
for(int i=0;i<N;i++)
scanf("%d",&Y1[i]);
for(int i=0;i<N;i++)
scanf("%d",&Y2[i]);
solve();
}
return 0;
}
/*
输入：
1010 5
11 4 9 10
610 4 9 10
48 1 1 6
48 10 5 10
输出：
6
*/