P3444 [POI2006]ORK-Ploughing

weixin_30467087

于 2018-07-15 19:33:00 发布

阅读量90

点赞数

原文链接：http://www.cnblogs.com/five20/p/9314594.html

版权

题目描述

Byteasar, the farmer, wants to plough his rectangular field. He can begin with ploughing a slice from any of the field's edges, then he can plough a slice from any unploughed field's edges, and so on, until the whole field is ploughed. After the ploughing of every successive slice, the yet-unploughed field has a rectangular shape. Each slice has a span of

Unfortunately, Byteasar has only one puny and frail nag (horse) at his disposal for the ploughing. Once the nag starts to plough a slice, it won't stop until the slice is completely ploughed. However, if the slice is to much for the nag to bear, it will die of exhaustion, so Byteasar has to be careful. After every ploughed slice, the nag can rest and gather strength. The difficulty of certain parts of the field varies, but Byteasar is a good farmer and knows his field well, hence he knows every part's ploughing-difficulty.

Let us divide the field into $m×nm\times nm×n unitary squares - these are called tiles in short.$

We identify them by their coordinates $1≤i≤m1\le i\le m1≤i≤m and 1≤j≤n1\le j\le n1≤j≤n .$

Each tile has its ploughing-difficulty - a non-negative integer.

Let $ti,jt_{i,j}ti,j denote the difficulty of the tile which coordinates are (i,j)(i,j)(i,j) .$

For every slice, the sum of ploughing-difficulties of the tiles forming it up cannot exceed a certain constant

A difficult task awaits Byteasar: before ploughing each subsequent slice he has to decide which edge of the field he'll plough, so that the nag won't die. On the other hand, he'd like to plough as few slices as possible.

TaskWrite a programme that:

reads the numbers

Byteasar想耕种他那块矩形的田，他每次能耕种矩形的一边（上下左右都行），在他每次耕完后，剩下的田也一定是矩形，每块小区域边长为 $m×nm\times nm×n 块单位矩形——我们用坐标 (i,j)(i,j)(i,j) 来定义它们。每块地都有一个整数 ti,jt_{i,j}ti,j ,来定义 (i,j)(i,j)(i,j) 的耕种难度。所以每次马耕一边地时的难度就是所有它耕种的地的难度总和，对于这匹虚弱的马而言，这个值不能超过他的体力值。Byteasar想知道在马不死掉的情况下最少需要耕多少次才能把地耕完。$

输入输出格式

输入格式：

There are three positive integers in the first line of the input file: $0001\le k\le 200\ 000\ 0001≤k≤200 000 000 , 1≤m,n≤20001\le m,n\le 20001≤m,n≤2000 .$

In the following

The line no. $t1,j,t2,j...,tn,mt_{1,j},t_{2,j}...,t_{n,m}t1,j,t2,j...,tn,m , separated by single spaces, 0≤ti,j≤100 0000\le t_{i,j}\le 100\ 0000≤ti,j≤100 000 .$

输出格式：

Your programme should write one integer to the output file: the minimum number of slices required to plough the field while satisfying the given conditions. Since we care for animals, we guarantee that the field can be ploughed according to the above rules. But remember, saving the nag is up to you!

输入输出样例

输入样例#1：

12 6 4
6 0 4 8 0 5
0 4 5 4 6 0
0 5 6 5 6 0
5 4 0 0 5 4

输出样例#1：

说明

感谢@NaVi_Awson 提供翻译

Solution：

　　大鸡哥翻译题，贼有意思。

　　本题一眼的不可做，连随机化都没有去打。

　　正解非常神奇的贪心。

　　首先可以确定的是答案的范围：$min(n,m)\leq ans\leq n+m$（显然的）。

　　然后我们可以对纵列贪心，即尽可能的删两边的纵列，不行时再删最上和最下两行，至于上下两行被删的顺序，我们可以设定一个阀值$p,\; p\in[1,n]$，表示上层删的行数不超过$p$，当达到该阀值时就直接删最下行，这样确定出的优先级是先左右后上下。同理，将优先级改为先上下后左右，尽可能的删顶底的两行。在每次枚举时更新答案就好了。

　　贪心的正确性证明：首先可以确定当横纵都能删时，按先左右后上下的优先级删去纵列后不会影响横行的删去（上次横纵都能删，现在删掉纵列，显然横行还是可以删去）;而若纵列能删而横行不能删，那么删去纵列，横行能删的可能性会更高;而若横能删而纵不能删，则删去横行后，要删的纵列数并不会减少，所以后面还是尽可能的删去列，这样可以确定在纵列先与横行的优先级下，删行不会使得答案更优，保持该优先级能确保横行删的次数尽可能的少，所以答案最优为$m+k_1,\; k_1\in[1,n]$。但是可能某种情况下删行时最优（比如每行每列都能删，而行数小于列数），于是确定先上下后左右的优先级后，尽可能减少删列的次数，删行的最优解为$n+k_2,\; k_2\in[1,m]$。两者取最小值就是答案了。

代码：

#include<bits/stdc++.h>
#define il inline
#define ll long long
#define For(i,a,b) for(int (i)=(a);(i)<=(b);(i)++)
#define Bor(i,a,b) for(int (i)=(b);(i)>=(a);(i)--)
using namespace std;
const int N=2005;
int k,n,m,sl[N][N],sr[N][N],a[N][N],ans=0x7fffffff;

il int gi(){
    int a=0;char x=getchar();
    while(x<'0'||x>'9')x=getchar();
    while(x>='0'&&x<='9')a=(a<<3)+(a<<1)+x-48,x=getchar();
    return a;
}

il void solve(){
    int ln,rn,lm,rm,tot,sum;
    For(p,1,m){
        ln=1,rn=n,lm=1,rm=m,tot=0;
        while(ln<=rn&&lm<=rm){
            tot++;
            sum=sl[ln][rm]-sl[ln][lm-1];
            if(sum<=k){ln++;continue;}
            sum=sl[rn][rm]-sl[rn][lm-1];
            if(sum<=k){rn--;continue;}
            sum=sr[lm][rn]-sr[lm][ln-1];
            if(sum<=k&&lm<p){lm++;continue;}
            sum=sr[rm][rn]-sr[rm][ln-1];
            if(sum<=k){rm--;continue;}
            tot=0x7fffffff;break;
        }
        ans=min(ans,tot);
    }
    For(p,1,n){
        ln=1,rn=n,lm=1,rm=m,tot=0;
        while(ln<=rn&&lm<=rm){
            tot++;
            sum=sr[lm][rn]-sr[lm][ln-1];
            if(sum<=k){lm++;continue;}
            sum=sr[rm][rn]-sr[rm][ln-1];
            if(sum<=k){rm--;continue;}
            sum=sl[ln][rm]-sl[ln][lm-1];
            if(sum<=k&&ln<p){ln++;continue;}
            sum=sl[rn][rm]-sl[rn][lm-1];
            if(sum<=k){rn--;continue;}
            tot=0x7fffffff;break;
        }
        ans=min(ans,tot);
    }
}

int main(){
    k=gi(),m=gi(),n=gi();
    For(i,1,n) For(j,1,m) a[i][j]=gi(),sl[i][j]=sl[i][j-1]+a[i][j];
    For(i,1,m) For(j,1,n) sr[i][j]=sr[i][j-1]+a[j][i];
    solve();
    cout<<ans;
    return 0;
}