蓝桥杯-剪格子（搜索）

剪格子：http://lx.lanqiao.org/problem.page?gpid=T27

问题描述

如下图所示，3 x 3 的格子中填写了一些整数。

+--*--+--+
|10* 1|52|
+--****--+
|20|30* 1|
*******--+
| 1| 2| 3|
+--+--+--+

我们沿着图中的星号线剪开，得到两个部分，每个部分的数字和都是60。

本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。

如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。

如果无法分割，则输出 0。

输入格式

程序先读入两个整数 m n 用空格分割 (m,n<10)。

表示表格的宽度和高度。

接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。

输出格式

输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。

样例输入1

3 3
10 1 52
20 30 1
1 2 3

样例输出1

3

样例输入2

4 3
1 1 1 1
1 30 80 2
1 1 1 100

样例输出2

10

这题数据太水了，貌似怎么写都能AC

不过为了能应对所有的情况，想了一个另类的遍历方法，但是还是无法在给定时间范围内解决存在岔路的格子问题

暂时贴在这，再想想其他的解法

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

struct Node {
    int r,c;
};

int m,n,num[11][11],sum=0,ans=105,rr,cc,rem;
bool used[11][11],vis[11][11];
const int dr[4]={-1,0,1,0},dc[4]={0,1,0,-1};

inline void myCpy(bool des[][11],const bool src[][11]) {
    for(int i=0;i<m;++i)
        for(int j=0;j<n;++j)
            des[i][j]=src[i][j];
}

inline bool isInside(int r,int c) {
    return 0<=r&&r<m&&0<=c&&c<n;
}

void ddffss(int r,int c) {
    ++rem;
    vis[r][c]=true;
    for(int i=0;i<4;++i)
        if(isInside(rr=r+dr[i],cc=c+dc[i])&&!vis[rr][cc])
            ddffss(rr,cc);
}

bool isOK(int sel) {
    myCpy(vis,used);
    for(int i=0;i<m;++i)
        for(int j=0;j<n;++j)
            if(!vis[i][j]) {
                rem=0;
                ddffss(i,j);
                return rem+sel==m*n;
            }
    return false;
}

//dfs规定图只能向下和向右走，用类似于树的层次遍历的方法，可以达成 当前点可同时向两个方向扩展
void dfs(Node pre[],int pren,int preMeth,int sel,int all) {
    if(sel>ans||all>sum)//如果选择的点的个数已大于当前最优解的点个数 或者 已选点之和大于总和一半 时返回
        return ;
    if(all==sum) {
        if(isOK(sel))//判断是否分成两部分
            ans=min(sel,ans);
        return ;
    }

    Node q[100];
    int qn=0,mxMeth,i,j,tmp,cnt;
    bool t[11][11];
    myCpy(t,used);//备份

    for(i=0;i<pren;++i) {//当前选择方式下，找到下一次所有能选择的点
        if(preMeth&(1<<i)) {
            rr=pre[i].r,cc=pre[i].c;
                if(cc>0&&!used[rr][cc-1]&&(cc==1||!used[rr][cc-2])&&(rr==0||!used[rr-1][cc-1])) {
                    q[qn].r=rr;
                    q[qn++].c=cc-1;
                    used[rr][cc-1]=true;
                }
                if(rr>0&&!used[rr-1][cc]&&(cc==0||!used[rr-1][cc-1])&&(rr==1||!used[rr-2][cc])) {
                    q[qn].r=rr-1;
                    q[qn++].c=cc;
                    used[rr-1][cc]=true;
                }
            if(rr+1<m&&!used[rr+1][cc]) {
                q[qn].r=rr+1;
                q[qn++].c=cc;
                used[rr+1][cc]=true;
            }
            if(cc+1<n&&!used[rr][cc+1]) {
                q[qn].r=rr;
                q[qn++].c=cc+1;
                used[rr][cc+1]=true;
            }
        }
    }

    myCpy(used,t);
    mxMeth=1<<qn;
    for(i=1;i<mxMeth;++i) {//枚举选择方案
        tmp=cnt=0;
        for(j=0;j<qn;++j) {
            if(i&(1<<j)) {
                used[rr=q[j].r][cc=q[j].c]=true;
                tmp+=num[rr][cc];
                ++cnt;
            }
            else
                used[q[j].r][q[j].c]=false;
        }
        dfs(q,qn,i,sel+cnt,all+tmp);
    }
    myCpy(used,t);
}

int main() {
    int i,j;
    memset(used,false,sizeof(used));
    scanf("%d%d",&n,&m);
    for(i=0;i<m;++i)
        for(j=0;j<n;++j) {
            scanf("%d",&num[i][j]);
            sum+=num[i][j];
        }
    if(sum&1)
        printf("0\n");
    else {
        sum>>=1;
        used[0][0]=true;
        Node q;
        q.r=q.c=0;
        dfs(&q,1,1,1,num[0][0]);
        printf("%d\n",ans==105?0:ans);
    }
}