OIBH的NOIP模拟试题 巧置挡板

题面

题意

猫猫送走了客人，留住了蜗牛点点，晃晃悠悠走到池子边，又打起了鱼的主意。俯瞰池子，猫猫发现鱼阵明显乱了。“难道鱼们故意让我无法下嘴？”猫猫看到正在池边散步的点点，心想：“一定是他告的密……”猫猫愤怒地抓起点点，把他关进了抽屉里。猫猫想：“好啊，鱼儿啊，你们不就是会传递信息吗？有什么了不起？用挡板把你们隔离开，看你们还怎么交流！”猫猫随即从后花园里拿来若干挡板，打算用这些挡板在水中设立“隔离室”，把鱼们分开。池塘已经被猫猫抽象成了n 行m列小方格，每个小方格中或有鱼，或无鱼。挡板必 须沿着小方格的边缘放置。猫猫需要用挡板围出若干个“隔离室”，使得每个隔离室中有且只有一条鱼，而且，每个“隔离室”都必须为矩形（包括正方形）。那么，将鱼们隔离开来，猫猫最少需要多少个长度单位的木板呢？
例如：
n=4 ，m=3 时的一种情况（0 表示小方格内无鱼，1 表示有鱼）。
0 1 0
0 0 0
1 0 1
0 0 0
可以这么分：

由于池塘边框不需要放置挡板，所以这个分割方案所需的挡板总长度为5。
输入格式
第一行有两个整数n和m，描述池塘规模。接下来的n行，每行有m个数字（非“0”即“1”）。每两个数字之间用空格隔开。
对于20% 的数据，有1≤n,m≤10
对于40% 的数据，有1≤n,m≤16
对于70% 的数据，有1≤n,m≤24
对于100%的数据，有1≤n,m≤32
输出格式
对于每组输入数据，输出一行：一个数字，猫猫所需挡板的最短总长度。

简单来说就是给出一个01矩阵，问至少放几块挡板（每块挡板长度为1）可以将其分为若干块矩形，使每块矩形中有且只有一个1.

法一

此方法复杂度不对，一旦鱼很多就会超时，但因数据水，可以过

搜索+剪枝。
逐行考虑，首先枚举这一行哪些位置放挡板，因为最后被分成了若干矩形，所以当且仅当这块挡板上面与其相邻的两块横着的挡板（或者是边框）都存在时，它才能随便放，否则它是否放置由它上面这个位置是否放置挡板决定。另外在递归时记录一下这行是否已经有1（剪枝掉这一行存在两个1，且中间没有放置挡板的情况）
当这行竖着的挡板考虑完后，考虑这一行下面是否放置横着的挡板，可以根据竖着的挡板将这一行分成多块，若这一块已经含有1，且下一行的这部分也有1，则必须放置横着的挡板（若不放将导致一个矩形中有2个1），若这一块中还没有1，则不能放置横着的挡板，这样就可以使搜索情况大大减少，如果这行已经是最后一行，则还要判断一下是不是没块中都只有1个1。
在搜索时还要加入估价函数进行剪枝：可以发现，如果这一行有k个1，则至少要放置k-1个挡板，这一列上也同理，这样可以预处理出当前行下的整个矩形至少要放置几块挡板，若此时答案加上估价函数已经大于等于ans，直接剪枝。
为了较快得到较优解（为了可以利用估价函数剪掉较多的枝），可以先搜不放的情况，再搜较放的情况。

代码

#include<iostream>
#include<cstdio>
#include<vector>
#define INF 0x3f3f3f3f
#define N 40
using namespace std;

int m,n,qz[N][N],need[N],ha[N],zt[N][N],ans=INF;
bool mm[N][N],h[N][N],l[N][N];
vector<int>gb[N];

inline int ask(int u,int v,int p,int q)
{
    return qz[p][q]-qz[p][v-1]-qz[u-1][q]+qz[u-1][v-1];
}

void dfs(int u,int v,int sum,bool have);
void Dfs(int u,int v,int sum)
{
    if(sum+need[u+1]>=ans) return;
    if(v==gb[u].size()-1)
    {
        dfs(u+1,1,sum,0);
        return;
    }
    if(zt[u][v]==1)
    {
        int i,j,p,q;
        p=gb[u][v];
        q=gb[u][v+1]-1;
        for(i=p;i<=q;i++)
        {
            h[u][i]=0;
        }
        Dfs(u,v+1,sum);
        for(i=p;i<=q;i++)
        {
            sum++;
            h[u][i]=1;
        }
        Dfs(u,v+1,sum);
    }
    else Dfs(u,v+1,sum);
}

void dfs(int u,int v,int sum,bool have)
{
    if(sum+need[u+1]>=ans) return;
    if(mm[u][v]&&have) return;
    have|=mm[u][v];
    if(v==n)
    {
        int i,j,p,q,o;
        gb[u].clear();
        gb[u].push_back(1);
        for(i=1; i<n; i++) if(l[u][i]) gb[u].push_back(i+1);
        gb[u].push_back(n+1);
        if(u==m)
        {
            for(i=0; i<gb[u].size()-1; i++)
            {
                p=gb[u][i];
                q=gb[u][i+1]-1;
                for(j=u-1; !h[j][p]; j--);j++;
                if(ask(j,p,u,q)!=1) return;
            }
            ans=sum;
            return;
        }
        for(i=0; i<gb[u].size()-1; i++)
        {
            p=gb[u][i];
            q=gb[u][i+1]-1;
            for(j=u-1; !h[j][p]; j--);j++;
            zt[u][i]=ask(j,p,u,q);
            if(zt[u][i]&&ask(u+1,p,u+1,q)) zt[u][i]=2;
            if(!zt[u][i])
            {
                for(j=p;j<=q;j++)
                {
                    h[u][j]=0;
                }
            }
            else if(zt[u][i]==2)
            {
                for(j=p;j<=q;j++)
                {
                    sum++;
                    h[u][j]=1;
                }
            }
        }
        Dfs(u,0,sum);
        return;
    }
    if(!h[u-1][v] || !h[u-1][v+1])
    {
        l[u][v]=l[u-1][v];
        dfs(u,v+1,sum+l[u][v],l[u][v]?0:have);
    }
    else
    {
        l[u][v]=0;
        dfs(u,v+1,sum,have);
        l[u][v]=1;
        dfs(u,v+1,sum+1,0);
    }
}

int main()
{
    int i,j,t;
    cin>>m>>n;
    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            scanf("%d",&mm[i][j]);
        }
    }
    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            qz[i][j]=qz[i-1][j]+qz[i][j-1]-qz[i-1][j-1]+mm[i][j];
        }
    }
    for(i=m-1; i>=1; i--) ha[i]+=ha[i+1];
    for(i=1; i<=m; i++)
    {
        for(j=i;j<=m;j++)
        {
            t=ask(j,1,j,n)-1;
            need[i]+=max(t,0);
        }
        for(j=1;j<=n;j++)
        {
            t=ask(i,j,m,j)-1;
            need[i]+=max(t,0);
        }
    }
    for(i=1; i<=n; i++) h[0][i]=1;
    dfs(1,1,0,0);
    cout<<ans;
}

法二

我们可以按一定的顺序枚举矩形，使任何时候，枚举的矩形拼起来可以组成一个阶梯形：

因此我们存状态时就只要存储这条边界即可，而且可以发现，如果下面任何一块红色区域内没有鱼，则必然不存在合法解：
或或
可以以此来剪枝。
然后每次状态转移时枚举矩形即可。

代码

#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#define ll long long
#define INF 0x3f3f3f3f
#define base 127
#define N 50
using namespace std;

int m,n,qz[N][N],ans;
bool mm[N][N];
vector<int>tmp;
map<ll,int>dp;

inline int ask(int u,int v,int p,int q)
{
    return qz[p][q]+qz[u][v]-qz[p][v]-qz[u][q];
}

inline ll hsh(vector<int>u)
{
    int i;
    ll res=0;
    for(i=0; i<n; i++)
    {
        res=res*base+u[i];
    }
    return res;
}

int dfs(vector<int>u)
{
    int i;
    for(i=0; i<n; i++) if(u[i]!=m) break;
    if(i==n) return 0;
    ll zt=hsh(u);
    if(dp.count(zt)) return dp[zt];
    for(i=0; i<n; i++)
    {
        if(i&&u[i]!=u[i-1] || !i&&u[i]!=m)
        {
            if(!ask(u[i],i,m,n)) return dp[zt]=INF;
        }
    }
    int j,k,l,ii,t,res=INF,p;
    vector<int>v;
    for(i=0; i<n; i=j)
    {
        for(j=i+1; j<n&&u[j]==u[i]; j++);
        for(k=i+1; k<=j; k++)
        {
            p=i?u[i-1]:m;
            for(l=u[i]+1; l<=p; l++)
            {
                t=ask(u[i],i,l,k);
                if(t==1)
                {
                    v=u;
                    for(ii=i; ii<k; ii++) v[ii]=l;
                    res=min(res,dfs(v)+k-i+l-u[i]);
                }
                else
                {
                    if(!t) continue;
                    break;
                }
            }
        }
    }
    return dp[zt]=res;
}

int main()
{
    int i,j,p;
    cin>>m>>n;
    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            scanf("%d",&mm[i][j]);
            qz[i][j]=qz[i-1][j]+qz[i][j-1]-qz[i-1][j-1]+mm[i][j];
        }
    }
    for(i=1; i<=n; i++) tmp.push_back(0);
    ans=dfs(tmp)-m-n;
    cout<<ans;
}