[POI2006]ORK-Ploughing（贪心，枚举）

[POI2006]ORK-Ploughing

题目描述

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 11 , and the length and width of the field are the integers nn and mm .

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 imes nm×n unitary squares - these are called tiles in short.

We identify them by their coordinates (i,j)(i,j) , for 1le ile m1≤i≤m and 1le jle n1≤j≤n .

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

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

For every slice, the sum of ploughing-difficulties of the tiles forming it up cannot exceed a certain constant kk - lest the nag dies.

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 kk , mm and nn from the input file, as well as the ploughing-difficulty coefficients, determines the best way to plough Byteasar's field, writes the result to the output file.

Byteasar想耕种他那块矩形的田，他每次能耕种矩形的一边（上下左右都行），在他每次耕完后，剩下的田也一定是矩形，每块小区域边长为 11 ，耕地的长宽分别为 mm 和 nn ，不幸的是Byteasar只有一匹老弱的马，从马开始耕地开始，只有当它耕完了一边才会停下休息。但有些地会非常难耕以至于马会非常的累，因此Byteasar需要特别小心。当耕完了一边之后，马可以停下来休息恢复体力。每块地耕种的难度不一，但是Byteasar都非常清楚。我们将地分成 m imes nm×n 块单位矩形——我们用坐标 (i,j)(i,j) 来定义它们。每块地都有一个整数 t_{i,j}ti,j​ ,来定义 (i,j)(i,j) 的耕种难度。所以每次马耕一边地时的难度就是所有它耕种的地的难度总和，对于这匹虚弱的马而言，这个值不能超过他的体力值。Byteasar想知道在马不死掉的情况下最少需要耕多少次才能把地耕完。

输入输出格式

输入格式：

There are three positive integers in the first line of the input file: kk , mm and nn ,separated by single spaces, 1le kle 200 000 0001≤k≤200 000 000 , 1le m,nle 20001≤m,n≤2000 .

In the following nn lines there are the ploughing-difficulty coefficients.

The line no. j+1j+1 contains the coefficients t_{1,j},t_{2,j}...,t_{n,m}t1,j​,t2,j​...,tn,m​ , separated by single spaces, 0le 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：

8

说明

感谢@NaVi_Awson 提供翻译 同校队爷Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz Orz

考试的时候强行贪心：上下左右4条边找最大的可行边种，算边公式写错40，改对30？！
考虑如何贪心，最优的情况应该是全部竖着种或者全部横着种，对于竖着种，每多一次横着种都不会减少竖着种的次数，所以我们考虑尽量少的横着种。对于横着种也是同理。但是如果不能竖着种不符合条件的话，上和下怎么处理？我们可以直接枚举上最多种到哪里，取个min即可

#include<bits/stdc++.h>
using namespace std;
int read()
{
    int x=0,w=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*w;
}
const int N=2010;
int n,m,v,num,sum,s,x,z,y,inf=2000000000,ans;
int a[N][N],sum1[N][N],sum2[N][N];
int d[3][2];
int shang(){return sum1[d[1][0]][d[2][1]]-sum1[d[1][0]][d[1][1]-1];}
int xia(){return sum1[d[2][0]][d[2][1]]-sum1[d[2][0]][d[1][1]-1];}
int zuo(){return sum2[d[2][0]][d[1][1]]-sum2[d[1][0]-1][d[1][1]];}
int you(){return sum2[d[2][0]][d[2][1]]-sum2[d[1][0]-1][d[2][1]];}
bool check()
{
    if(d[1][0]>d[2][0]) return false;
    if(d[1][1]>d[2][1]) return false;
    return true;
}
int work1(int i)
{
    int qwe=0;d[1][0]=d[1][1]=1;d[2][0]=n;d[2][1]=m;
    while(check())
    {
        qwe++;
        s=shang();x=xia();z=zuo();y=you();
        if(z<=v) d[1][1]++;
        else if(y<=v) d[2][1]--;
        else if(s<=v&&d[1][0]<i) d[1][0]++;
        else if(x<=v) d[2][0]--;
        else {qwe=inf;break;}
    }
    return qwe;
}
int work2(int i)
{
    int qwe=0;d[1][0]=d[1][1]=1;d[2][0]=n;d[2][1]=m;
    while(check())
    {
        qwe++;
        s=shang();x=xia();z=zuo();y=you();
        if(s<=v) d[1][0]++;
        else if(x<=v) d[2][0]--;
        else if(z<=v&&d[1][1]<i) d[1][1]++;
        else if(y<=v) d[2][1]--;
        else {qwe=inf;break;}
    }
    return qwe;
}
int main()
{
    //freopen("ork.in","r",stdin);
    //freopen("ork.out","w",stdout);
    v=read();m=read();n=read();ans=inf;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    a[i][j]=read(),sum1[i][j]=sum1[i][j-1]+a[i][j],sum2[i][j]=sum2[i-1][j]+a[i][j];
    for(int i=1;i<=n;i++) ans=min(ans,work1(i));
    for(int i=1;i<=m;i++) ans=min(ans,work2(i));
    cout<<ans;
    return 0;
}