[DLX+bfs] hdu 4069 Squiggly Sudoku

题意：

给你9*9的矩阵。对于每个数字，能减16代表上面有墙，能减32代表下面有墙。。。

最后剩下的数字是0代表这个位置数要求，不是0代表这个数已知了。

然后通过墙会被数字分成9块。

然后做数独，这里的数独不是分成9个3*3的小块而是通过墙分成的。

思路：

首先通过数字作出墙。

然后bfs求连通块，dfs也可以。目的是分块。

然后就是dlx数独模板题了。

这里要注意的是如果找到答案2次就说明有多组解了，就应该停止返回了。不然会TLE。

代码：

#include"stdio.h"
#include"algorithm"
#include"string.h"
#include"iostream"
#include"cmath"
#include"queue"
#include"map"
#include"vector"
#include"string"
using namespace std;
#define RN 9*9*9+5
#define CN 4*9*9+5
#define N 9*9*9*4+5
int wall[12][12][12][12];
int mp[12][12],used[12][12];
int dis[4][2]= {{0,1},{0,-1},{-1,0},{1,0}};
int kx,ff;
template<class T>inline void getd(T &x)
{
    int ch = getchar();
    bool minus = false;
    while(!isdigit(ch) && ch != '-')ch = getchar();
    if(ch == '-')minus = true, ch = getchar();
    x = ch - '0';
    while(isdigit(ch = getchar()))x = x * 10 - '0' + ch;
    if(minus)x = -x;
}

struct node
{
    int x,y;
};
void bfs(int x,int y)
{
    node cur,next;
    cur.x=x;
    cur.y=y;
    queue<node>q;
    q.push(cur);
    used[cur.x][cur.y]=kx;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            next.x=cur.x+dis[i][0];
            next.y=cur.y+dis[i][1];
            if(used[next.x][next.y]!=0 || wall[cur.x][cur.y][next.x][next.y]==1 ) continue;
            used[next.x][next.y]=kx;
            q.push(next);
        }
    }
    kx++;
    return ;
}

struct DLX
{
    int n,m,C;
    int U[N],D[N],L[N],R[N],Row[N],Col[N];
    int H[RN],S[CN],cnt,ans[RN];
    void init(int _n,int _m)
    {
        n=_n;
        m=_m;
        for(int i=0; i<=m; i++)
        {
            U[i]=D[i]=i;
            L[i]=(i==0?m:i-1);
            R[i]=(i==m?0:i+1);
            S[i]=0;
        }
        C=m;
        for(int i=1; i<=n; i++) H[i]=-1;
    }
    void link(int x,int y)
    {
        C++;
        Row[C]=x;
        Col[C]=y;
        S[y]++;
        U[C]=U[y];
        D[C]=y;
        D[U[y]]=C;
        U[y]=C;
        if(H[x]==-1) H[x]=L[C]=R[C]=C;
        else
        {
            L[C]=L[H[x]];
            R[C]=H[x];
            R[L[H[x]]]=C;
            L[H[x]]=C;
        }
    }
    void del(int x)
    {
        R[L[x]]=R[x];
        L[R[x]]=L[x];
        for(int i=D[x]; i!=x; i=D[i])
        {
            for(int j=R[i]; j!=i; j=R[j])
            {
                U[D[j]]=U[j];
                D[U[j]]=D[j];
                S[Col[j]]--;
            }
        }
    }
    void rec(int x)
    {
        for(int i=U[x]; i!=x; i=U[i])
        {
            for(int j=L[i]; j!=i; j=L[j])
            {
                U[D[j]]=j;
                D[U[j]]=j;
                S[Col[j]]++;
            }
        }
        R[L[x]]=x;
        L[R[x]]=x;
    }
    void dance(int x)
    {
        if(R[0]==0)
        {
            ff++;
            if(ff>=2) return ;
            cnt=x;
            for(int i=0; i<cnt; i++)
            {
                int tep=ans[i]-1;
                int a=tep/81,b=(tep%81)/9;
                mp[a+1][b+1]=tep%9+1;
            }
            return ;
        }
        int now=R[0];
        for(int i=R[0]; i!=0; i=R[i])
        {
            if(S[i]<S[now]) now=i;
        }
        del(now);
        for(int i=D[now]; i!=now; i=D[i])
        {
            ans[x]=Row[i];
            for(int j=R[i]; j!=i; j=R[j]) del(Col[j]);
            dance(x+1);
            if(ff>=2) return ;
            for(int j=L[i]; j!=i; j=L[j]) rec(Col[j]);
        }
        rec(now);
        return ;
    }
} dlx;
void getplace(int i,int j,int k,int &x,int &a,int &b,int &c)
{
    x=(i-1)*81+(j-1)*9+k;
    a=81+(i-1)*9+k;
    b=81*2+(j-1)*9+k;
    c=81*3+(used[i][j]-1)*9+k;
}
int main()
{
    int t,cas=1;
    cin>>t;
    while(t--)
    {
        memset(wall,0,sizeof(wall));
        for(int i=1; i<=9; i++)
        {
            for(int j=1; j<=9; j++)
            {
                int x;
                getd(x);
                if(x-128>=0)
                {
                    x-=128;
                    wall[i][j][i][j-1]=1;
                }
                if(x-64>=0)
                {
                    x-=64;
                    wall[i][j][i+1][j]=1;
                }
                if(x-32>=0)
                {
                    x-=32;
                    wall[i][j][i][j+1]=1;
                }
                if(x-16>=0)
                {
                    x-=16;
                    wall[i][j][i-1][j]=1;
                }
                mp[i][j]=x;
            }
        }
        kx=1;
        memset(used,0,sizeof(used));
        for(int i=1; i<=9; i++) for(int j=1; j<=9; j++) if(used[i][j]==0) bfs(i,j);

        dlx.init(9*9*9,4*9*9);
        for(int i=1; i<=9; i++)
        {
            for(int j=1; j<=9; j++)
            {
                int tep=(i-1)*9+j;
                int x,a,b,c;
                if(mp[i][j]==0)
                {
                    for(int k=1; k<=9; k++)
                    {
                        getplace(i,j,k,x,a,b,c);
                        dlx.link(x,tep);
                        dlx.link(x,a);
                        dlx.link(x,b);
                        dlx.link(x,c);
                    }
                }
                else
                {
                    getplace(i,j,mp[i][j],x,a,b,c);
                    dlx.link(x,tep);
                    dlx.link(x,a);
                    dlx.link(x,b);
                    dlx.link(x,c);
                }
            }
        }
        ff=0;
        dlx.dance(0);
        printf("Case %d:\n",cas++);
        if(ff==0) puts("No solution");
        else if(ff==1)
        {
            for(int i=1; i<=9; i++) for(int j=1; j<=9; j++) printf(j==9?"%d\n":"%d",mp[i][j]);
        }
        else puts("Multiple Solutions");
    }
    return 0;
}