HDU 5547 Sudoku（dfs）

题目戳这

题意：给你一个4*4的方阵，里面包含的字符是1到4，还有*，然后要求把所有的*都替换成1到4，要求是每个上下左右四个2*2的小方阵里面1到4都要有，每一行每一列的数字不能相同，规则有点像数独。

思路：因为只有4*4，所以直接用dfs爆搜，然而也不能太暴力，直接搜到底再判断矩阵符不符合条件，这样太暴力了以至于最后一个样例都不能秒出，所以，要在每次给*赋值的时候判断是否能放这个数字，直接判断所在行和所在列有没有一样的就行了。然后到了最后，再判断这个矩阵符不符合条件。

P.S.一开始就是很傻地搜到底了再判断，以至于最后一个例子没有秒出，然后加了中间的判断之后，有个例子陷入了死循环，那就是当矩阵都是*的时候，最后一个*赋值之后没有条件进入下一步dfs了，然后就死循环了，改过就好了。然后dfs写得好挫啊，都写了两百多行了，然而不想重新写了······

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<map>
#include<stack>
#include<set>
#define ll long long
#define maxn 100010
#define PI acos(-1.0)    //圆周率
const ll INF = 1e18;
const int len=30;
using namespace std;
int T,flag;
int f[10][10];
char s[10][10];
int biao[10];
int ff[4][2]={0,0,0,1,1,0,1,1};
int kk[4][2]={0,1,0,-1,1,0,-1,0};
bool judge1(int a,int b)
{
    memset(biao,0,sizeof(biao));

    for(int i=0;i<4;i++)
    {
        int l=a+ff[i][0];
        int r=b+ff[i][1];

        biao[s[l][r]-'0']++;
        if(biao[s[l][r]-'0']>1)  return false;
    }
    return true;
}
bool judge2(int a)
{
    memset(biao,0,sizeof(biao));

    for(int i=0;i<4;i++)
    {
        biao[s[a][i]-'0']++;
        if(biao[s[a][i]-'0']>1)  return false;
    }

    return true;
}
bool judge3(int b)
{
    memset(biao,0,sizeof(biao));

    for(int i=0;i<4;i++)
    {
        biao[s[i][b]-'0']++;
        if(biao[s[i][b]-'0']>1)  return false;
    }

    return true;
}
bool judge4(int a,int b,int v)
{
    for(int i=0;i<4;i++)
    {
        if(s[i][b]-'0'==v)  return false;
    }
    for(int i=0;i<4;i++)
    {
        if(s[a][i]-'0'==v)  return false;
    }

    return true;
}
bool jud(int a,int b)
{
    if(a>=0&&a<4&&b>=0&&b<4)  return true;
    else  return false;
}
bool prin()
{
    if(judge1(0,0)&&judge1(0,2)&&judge1(2,0)&&judge1(2,2))
    {
        if(judge2(0)&&judge2(1)&&judge2(2)&&judge2(3))
        {
            if(judge3(0)&&judge3(1)&&judge3(2)&&judge3(3))  return true;
        }
    }
    return false;
}
void dfs(int a,int b,int cnt)
{
    if(flag||!jud(a,b)||f[a][b])  return ;

    if(!cnt)
    {
        if(prin())
        {
            for(int i=0;i<4;i++)  printf("%s
",s[i]);
            flag=1;
            return ;
        }
        else  return ;
    }

    if(s[a][b]=='*')
    {
        for(int i=1;i<=4;i++)
        {
            if(judge4(a,b,i))
            {
                s[a][b]=i+'0';
                cnt-=1;
                if(!cnt)  dfs(a,b,cnt);
                f[a][b]=1;
                for(int j=0;j<4;j++)
                {
                    int l=a+kk[j][0];
                    int r=b+kk[j][1];
                    if(jud(l,r)&&!f[l][r])  dfs(l,r,cnt);
                }
                cnt+=1;
                s[a][b]='*';
                f[a][b]=0;
            }
        }
    }
    else
    {
        f[a][b]=1;
        for(int j=0;j<4;j++)
        {
            int l=a+kk[j][0];
            int r=b+kk[j][1];
            if(jud(l,r)&&!f[l][r])  dfs(l,r,cnt);
        }
        f[a][b]=0;
    }

    return ;
}
int main()
{
    int cas=0;
    scanf("%d",&T);
    while(T--)
    {
        for(int i=0;i<4;i++)  scanf("%s",s[i]);

        int sum=0;
        flag=0;
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                if(s[i][j]=='*')  sum++;
            }
        }

        printf("Case #%d:
",++cas);
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                if(s[i][j]=='*')
                {
                    dfs(i,j,sum);
                    if(flag)  break;
                }
            }
            if(flag)  break;
        }
    }

    return 0;
}