Luogu P1784 数独 [ 模板 ] / P1074 靶形数独 题解 [ 蓝 ] [ 深搜 ] [ 剪枝 ] [ 卡常 ]

数独模板 ， 靶形数独

卡了 2h ，再也不想写数独了。

普通数独

思路

显然是对每个格子进行枚举，类似八皇后的方法去做，朴素方法是由 \((1,1)\) 到 \((9,9)\) 遍历过去。

优化

我们在做数独时，会优先选择已填格数多的行、列、区域，这样可以保证尝试次数少。

同样，这一点在本题中也可以应用，但是有两种思路。

1. 按照行里没填的格子的个数进行从小到大排序。
2. 根据单个格子可能会出现的数字的数量进行从小到大排序。

目的只有一个：减少搜索树的大小。

这里采用第二种方法，则计算这个格子可能的数字，就是竖向的数字、横向的数字、区域的数字以外的数字。

因此，我们将这三种数字开个 bitset，然后分别或一下，设结果为 \(ans\)，如果 \(ans=0\)，则证明可以填这个数。

bitset 可以用状压的方式优化，大幅减少常数。但我写的位运算版还没 bitset 版跑得快。

然后还要注意，如果搜到结果，直接 exit(0) 就好。

注意把 sort 改成 stable_sort ，因为尽可能要连续填。

于是就把数独过了。

数独代码：

第一种，bitset 版，跑洛谷的点很快，比位运算版要快：610ms。

#include <bits/stdc++.h>
using namespace std;
int a[15][15];
bitset<15>xvis[15],yvis[15],svis[15];
int s(int x,int y)
{
	return ((x-1)/3*3+(y+2)/3);
}
int cg(int x,int y)
{
	bitset<15>ans;
	int res=0;
	ans=xvis[x]|yvis[y]|svis[s(x,y)];
	for(int i=1;i<=9;i++)if(ans[i]==0)res++;
	return res;
}
struct tile{
	int x,y,g;
};
vector<tile>vct;
bool cmp(tile a,tile b)
{
	return a.g<b.g;
}
void outp()
{
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			cout<<a[i][j]<<' ';
		}
		cout<<endl;
	}
}
void dfs(int now)
{
	if(now>=vct.size())
	{
		outp();
		exit(0);
	}
	int x=vct[now].x,y=vct[now].y;
	bitset<15>ans;
	ans=xvis[x]|yvis[y]|svis[s(x,y)];
	for(int i=1;i<=9;i++)
	{
		if(ans[i]==0)
		{
			svis[s(x,y)][i]=1;
			xvis[x][i]=1;
			yvis[y][i]=1;
			a[x][y]=i;
			dfs(now+1);
			svis[s(x,y)][i]=0;
			xvis[x][i]=0;
			yvis[y][i]=0;
			a[x][y]=0;
		}
	}
}
int main()
{
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			cin>>a[i][j];
			if(a[i][j]!=0)
			{
				svis[s(i,j)][a[i][j]]=1;
				xvis[i][a[i][j]]=1;
				yvis[j][a[i][j]]=1;
			}
		}
	}
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			if(a[i][j]!=0)continue;
			tile tmp;
			tmp.x=i,tmp.y=j;
			tmp.g=cg(i,j);
			if(tmp.g!=0)vct.push_back(tmp);
		}
	}
	stable_sort(vct.begin(),vct.end(),cmp);
	dfs(0);
	return 0;
}

第二种代码，位运算版，实际比 bitset 慢：3.28s。

#include <bits/stdc++.h>
using namespace std;
int a[15][15];
int xvis[15],yvis[15],svis[15];
int s(int x,int y)
{
	return ((x-1)/3*3+(y+2)/3);
}
int cg(int x,int y)
{
	int ans;
	int res=0;
	ans=xvis[x]|yvis[y]|svis[s(x,y)];
	for(int i=1;i<=9;i++)if(ans>>i==0)res++;
	return res;
}
struct tile{
	int x,y,g;
};
vector<tile>vct;
bool cmp(tile a,tile b)
{
	return a.g<b.g;
}
void outp()
{
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			cout<<a[i][j]<<' ';
		}
		cout<<endl;
	}
}
void dfs(int now)
{
	if(now>=vct.size())
	{
		outp();
		exit(0);
	}
	int x=vct[now].x,y=vct[now].y;
	int tmps=s(x,y);
	int ans=xvis[x]|yvis[y]|svis[tmps];
	for(int i=1;i<=9;i++)
	{
		if(((ans>>i)&1)==0)
		{
			xvis[x]|=(1<<i);
			yvis[y]|=(1<<i);
			svis[tmps]|=(1<<i);
			a[x][y]=i;
			dfs(now+1);
			xvis[x]=(xvis[x]^(1<<i));
			yvis[y]=(yvis[y]^(1<<i));
			svis[tmps]=(svis[tmps]^(1<<i));
			a[x][y]=0;
		}
	}
}
int main()
{
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			cin>>a[i][j];
			if(a[i][j]!=0)
			{
				svis[s(i,j)]|=1<<a[i][j];
				xvis[i]|=1<<a[i][j];
				yvis[j]|=1<<a[i][j];
			}
		}
	}
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			if(a[i][j]!=0)continue;
			tile tmp;
			tmp.x=i,tmp.y=j;
			tmp.g=cg(i,j);
			vct.push_back(tmp);
		}
	}
	stable_sort(vct.begin(),vct.end(),cmp);
	dfs(0);
	return 0;
}

靶形数独：增加权重的数独

大致与普通数独相同，讲几个重要剪枝：

1. 增加估价函数 \(g(x)\)，计算方式为：当前剩下的没填的格子数 \(\times\) 当前没填的数字的和 \(\times 9+\) 先前加过的分。当估价函数小于当前答案时，直接剪枝。其中，\(9\) 是期望值。
2. 把 vector 改为普通数组。
3. 乱搞排序，先按能填的个数从小到大排，再按横坐标从右到左排。这个方法不适用所有题，只是针对 CCF 的数据。
4. 位运算，这里的位运算是要比 bitset 快的。
5. 使用 stable_sort。

这里不能搜到结果就直接结束，因为要使结果最大。

代码如下，本题没有完美的做法：1.77s，还是比较快的。

#include <bits/stdc++.h>
using namespace std;
int a[15][15],ans=-1,lst=81,cnt=0;
int xvis[15],yvis[15],svis[15];
int w[15][15]={{},{0,6,6,6,6,6,6,6,6,6},{0,6,7,7,7,7,7,7,7,6},{0,6,7,8,8,8,8,8,7,6},{0,6,7,8,9,9,9,8,7,6},{0,6,7,8,9,10,9,8,7,6},{0,6,7,8,9,9,9,8,7,6},{0,6,7,8,8,8,8,8,7,6},{0,6,7,7,7,7,7,7,7,6},{0,6,6,6,6,6,6,6,6,6}};
inline int s(int x,int y)
{
	return ((x-1)/3*3+(y+2)/3);
}
int cg(int x,int y)
{
	int ans;
	int res=0;
	ans=xvis[x]|yvis[y]|svis[s(x,y)];
	for(int i=1;i<=9;i++)if(ans>>i==0)res++;
	return res;
}
struct tile{
	int x,y,g;
};
tile vct[105];
bool cmp(tile a,tile b)
{
	if(a.g!=b.g)return a.g<b.g;
	return a.x>b.x;
}
void dfs(int now,int sw,int lsm)
{
	if(now>=cnt)
	{
		ans=max(ans,sw);
		return;
	}
	if(sw+9*lsm*lst<ans)return;
	int x=vct[now].x,y=vct[now].y;
	int tmps=s(x,y);
	int ans=xvis[x]|yvis[y]|svis[tmps];
	for(int i=9;i>=1;--i)
	{
		if(((ans>>i)&1)==0)
		{
			xvis[x]|=(1<<i);
			yvis[y]|=(1<<i);
			svis[tmps]|=(1<<i);
			a[x][y]=i;
			--lst;
			dfs(now+1,sw+i*w[x][y],lsm-i);
			xvis[x]=(xvis[x]^(1<<i));
			yvis[y]=(yvis[y]^(1<<i));
			svis[tmps]=(svis[tmps]^(1<<i));
			a[x][y]=0;
			++lst;
		}
	}
}
int main()
{
	int lsm=405,prsum=0;
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			cin>>a[i][j];
			if(a[i][j]!=0)
			{
				svis[s(i,j)]|=1<<a[i][j];
				xvis[i]|=1<<a[i][j];
				yvis[j]|=1<<a[i][j];
				lst--;
				lsm-=a[i][j];
				prsum+=w[i][j]*a[i][j];
			}
		}
	}
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			if(a[i][j]!=0)continue;
			tile tmp;
			tmp.x=i,tmp.y=j;
			tmp.g=cg(i,j);
			vct[cnt++]=tmp;
		}
	}
	stable_sort(vct,vct+cnt,cmp);
	dfs(0,prsum,lsm);
	cout<<ans;
	return 0;
}