阅读背景：

【纪中模拟2019.08.17】【JZOJ3503】粉刷

来源：互联网 

标题连接

 

题意：

　　给定一个$N\times M$的

标题连接

 

题意：

　　给定一个$N\times M$的$01$矩阵，请求笼罩所有$1$的地位，求最小操作次数。一次操作，可以竖着笼罩持续的最多$C$列，或横着笼罩持续的最多$R$行。

　　$1\le\;N,\;M,\;R,\;C\le\;15$

 

剖析：

　　数据规模较小，斟酌枚举。

　　但是不能盲目地同时枚举笼罩行、笼罩列的操作，由于这样的枚举是$O (2^{2N})$的，会$T$。

　　斟酌枚举笼罩行的操作，枚得一种计划以后贪心肠盘算笼罩列的操作，完成。

　　总的时光庞杂度$O (N^3\times 2^N)$。

 

实现：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define IL inline
using namespace std;
const int N=15;

    int n,m,r,c;
    int bod[N+3][N+3];
    int clm[N+3];
    int tbod[N+3][N+3];
    int tclm[N+3];

int main(){
    scanf("%d %d\n",&n,&m);
    memset(bod,0,sizeof bod);
    for(int i=0;i<n;i++){
        char ch;
        for(int j=0;j<m;j++){
            scanf("%c",&ch);
            bod[i][j]=ch=="X";
            
        }
        scanf("\n");
        
    }
    scanf("%d %d\n",&r,&c);
    
    memset(clm,0,sizeof clm);
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            clm[i]+=bod[j][i];
        
    memcpy(tbod,bod,sizeof bod);
    memcpy(tclm,clm,sizeof clm);
    int ans=min(n/r+1,m/c+1);
    for(int S=0;S<(1<<n);S++){
        int cnt=0;
        
        for(int i=0;i<n;i++)
        if(S>>i&1){
            cnt++;
            for(int j=0;j<r;j++)
                for(int k=0;k<m;k++)
                if(bod[i+j][k]==1){
                    bod[i+j][k]=0;
                    clm[k]--;
                    
                }
            
        }
        
        for(int i=0;i<m;i++)
        if(clm[i]>0){
            cnt++;
            for(int j=0;j<c;j++)
                clm[i+j]=0;
            
        }
        
        memcpy(bod,tbod,sizeof tbod);
        memcpy(clm,tclm,sizeof tclm);
        
        ans=min(ans,cnt);
        
    }
    
    printf("%d",ans);

    return 0;

}
View Code

 

小结：

　　斟酌搜索剪枝的同时，也斟酌一下优化搜索的构造吧。

$矩阵，请求笼罩所有

标题连接

 

题意：

　　给定一个$N\times M$的$01$矩阵，请求笼罩所有$1$的地位，求最小操作次数。一次操作，可以竖着笼罩持续的最多$C$列，或横着笼罩持续的最多$R$行。

　　$1\le\;N,\;M,\;R,\;C\le\;15$

 

剖析：

　　数据规模较小，斟酌枚举。

　　但是不能盲目地同时枚举笼罩行、笼罩列的操作，由于这样的枚举是$O (2^{2N})$的，会$T$。

　　斟酌枚举笼罩行的操作，枚得一种计划以后贪心肠盘算笼罩列的操作，完成。

　　总的时光庞杂度$O (N^3\times 2^N)$。

 

实现：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define IL inline
using namespace std;
const int N=15;

    int n,m,r,c;
    int bod[N+3][N+3];
    int clm[N+3];
    int tbod[N+3][N+3];
    int tclm[N+3];

int main(){
    scanf("%d %d\n",&n,&m);
    memset(bod,0,sizeof bod);
    for(int i=0;i<n;i++){
        char ch;
        for(int j=0;j<m;j++){
            scanf("%c",&ch);
            bod[i][j]=ch=="X";
            
        }
        scanf("\n");
        
    }
    scanf("%d %d\n",&r,&c);
    
    memset(clm,0,sizeof clm);
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            clm[i]+=bod[j][i];
        
    memcpy(tbod,bod,sizeof bod);
    memcpy(tclm,clm,sizeof clm);
    int ans=min(n/r+1,m/c+1);
    for(int S=0;S<(1<<n);S++){
        int cnt=0;
        
        for(int i=0;i<n;i++)
        if(S>>i&1){
            cnt++;
            for(int j=0;j<r;j++)
                for(int k=0;k<m;k++)
                if(bod[i+j][k]==1){
                    bod[i+j][k]=0;
                    clm[k]--;
                    
                }
            
        }
        
        for(int i=0;i<m;i++)
        if(clm[i]>0){
            cnt++;
            for(int j=0;j<c;j++)
                clm[i+j]=0;
            
        }
        
        memcpy(bod,tbod,sizeof tbod);
        memcpy(clm,tclm,sizeof tclm);
        
        ans=min(ans,cnt);
        
    }
    
    printf("%d",ans);

    return 0;

}
View Code

 

小结：

　　斟酌搜索剪枝的同时，也斟酌一下优化搜索的构造吧。

$的地位，求最小操作次数。一次操作，可以竖着笼罩持续的最多$C$列，或横着笼罩持续的最多$R$行。　　给定一个$N\times M$的

标题连接

 

题意：

　　给定一个$N\times M$的$01$矩阵，请求笼罩所有$1$的地位，求最小操作次数。一次操作，可以竖着笼罩持续的最多$C$列，或横着笼罩持续的最多$R$行。

　　$1\le\;N,\;M,\;R,\;C\le\;15$

 

剖析：

　　数据规模较小，斟酌枚举。

　　但是不能盲目地同时枚举笼罩行、笼罩列的操作，由于这样的枚举是$O (2^{2N})$的，会$T$。

　　斟酌枚举笼罩行的操作，枚得一种计划以后贪心肠盘算笼罩列的操作，完成。

　　总的时光庞杂度$O (N^3\times 2^N)$。

 

实现：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define IL inline
using namespace std;
const int N=15;

    int n,m,r,c;
    int bod[N+3][N+3];
    int clm[N+3];
    int tbod[N+3][N+3];
    int tclm[N+3];

int main(){
    scanf("%d %d\n",&n,&m);
    memset(bod,0,sizeof bod);
    for(int i=0;i<n;i++){
        char ch;
        for(int j=0;j<m;j++){
            scanf("%c",&ch);
            bod[i][j]=ch=="X";
            
        }
        scanf("\n");
        
    }
    scanf("%d %d\n",&r,&c);
    
    memset(clm,0,sizeof clm);
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            clm[i]+=bod[j][i];
        
    memcpy(tbod,bod,sizeof bod);
    memcpy(tclm,clm,sizeof clm);
    int ans=min(n/r+1,m/c+1);
    for(int S=0;S<(1<<n);S++){
        int cnt=0;
        
        for(int i=0;i<n;i++)
        if(S>>i&1){
            cnt++;
            for(int j=0;j<r;j++)
                for(int k=0;k<m;k++)
                if(bod[i+j][k]==1){
                    bod[i+j][k]=0;
                    clm[k]--;
                    
                }
            
        }
        
        for(int i=0;i<m;i++)
        if(clm[i]>0){
            cnt++;
            for(int j=0;j<c;j++)
                clm[i+j]=0;
            
        }
        
        memcpy(bod,tbod,sizeof tbod);
        memcpy(clm,tclm,sizeof tclm);
        
        ans=min(ans,cnt);
        
    }
    
    printf("%d",ans);

    return 0;

}
View Code

 

小结：

　　斟酌搜索剪枝的同时，也斟酌一下优化搜索的构造吧。

$矩阵，请求笼罩所有

标题连接

 

题意：

　　给定一个$N\times M$的$01$矩阵，请求笼罩所有$1$的地位，求最小操作次数。一次操作，可以竖着笼罩持续的最多$C$列，或横着笼罩持续的最多$R$行。

　　$1\le\;N,\;M,\;R,\;C\le\;15$

 

剖析：

　　数据规模较小，斟酌枚举。

　　但是不能盲目地同时枚举笼罩行、笼罩列的操作，由于这样的枚举是$O (2^{2N})$的，会$T$。

　　斟酌枚举笼罩行的操作，枚得一种计划以后贪心肠盘算笼罩列的操作，完成。

　　总的时光庞杂度$O (N^3\times 2^N)$。

 

实现：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define IL inline
using namespace std;
const int N=15;

    int n,m,r,c;
    int bod[N+3][N+3];
    int clm[N+3];
    int tbod[N+3][N+3];
    int tclm[N+3];

int main(){
    scanf("%d %d\n",&n,&m);
    memset(bod,0,sizeof bod);
    for(int i=0;i<n;i++){
        char ch;
        for(int j=0;j<m;j++){
            scanf("%c",&ch);
            bod[i][j]=ch=="X";
            
        }
        scanf("\n");
        
    }
    scanf("%d %d\n",&r,&c);
    
    memset(clm,0,sizeof clm);
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            clm[i]+=bod[j][i];
        
    memcpy(tbod,bod,sizeof bod);
    memcpy(tclm,clm,sizeof clm);
    int ans=min(n/r+1,m/c+1);
    for(int S=0;S<(1<<n);S++){
        int cnt=0;
        
        for(int i=0;i<n;i++)
        if(S>>i&1){
            cnt++;
            for(int j=0;j<r;j++)
                for(int k=0;k<m;k++)
                if(bod[i+j][k]==1){
                    bod[i+j][k]=0;
                    clm[k]--;
                    
                }
            
        }
        
        for(int i=0;i<m;i++)
        if(clm[i]>0){
            cnt++;
            for(int j=0;j<c;j++)
                clm[i+j]=0;
            
        }
        
        memcpy(bod,tbod,sizeof tbod);
        memcpy(clm,tclm,sizeof tclm);
        
        ans=min(ans,cnt);
        
    }
    
    printf("%d",ans);

    return 0;

}
View Code

 

小结：

　　斟酌搜索剪枝的同时，也斟酌一下优化搜索的构造吧。

$的地



你的当前访问异常,请进行认证后继续阅读剩余内容。

分享到：
你可能喜欢:
相关阅读:
随便看看: