[洛谷P3444] [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 111 , and the length and width of the field are the integers nnn and mmm .

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 (i,j)(i,j)(i,j) , for 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 kkk - 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 kkk , mmm and nnn 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想耕种他那块矩形的田，他每次能耕种矩形的一边（上下左右都行），在他每次耕完后，剩下的田也一定是矩形，每块小区域边长为 111 ，耕地的长宽分别为 mmm 和 nnn ，不幸的是Byteasar只有一匹老弱的马，从马开始耕地开始，只有当它耕完了一边才会停下休息。但有些地会非常难耕以至于马会非常的累，因此Byteasar需要特别小心。当耕完了一边之后，马可以停下来休息恢复体力。每块地耕种的难度不一，但是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: kkk , mmm and nnn ,separated by single spaces, 1≤k≤200 000 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 nnn lines there are the ploughing-difficulty coefficients.

The line no. j+1j+1j+1 contains the coefficients 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：

8

说明

感谢@NaVi_Awson 提供翻译




sto Navi_Awson orz

一句话题意: 一个矩形中每个位置有一个值,你的马也有一个体力值,每次可以选择当前矩形中的最上下左右四个方向耕地,前提是这一条的权值和小于等于马的体力值.问最少耕地次数.

题解: 首先假设我们不考虑体力的限制,那么最少耕地的次数就是\(min(n, m)\).也就是说,有一个贪心策略是一直按照横着取,直到取不了再按照横着取.

这个贪心策略是正确的,因为最优策略(在不考虑体力值的情况下)是只横着耕地或是只竖着耕地,而一直横着耕地直到不能横着耕地再按照竖着耕地的方法,是最接近最优策略的,所以这个贪心是没有问题的.

但是我们需要考虑这样一个问题:假设我们一直按照横着取,横着取不了了,现在要取竖的,那么我怎么知道要取左边一条还是右边的一条呢?显然这个是会影响到答案的,所以这个不能忽略掉.为了避免这样的判断导致答案不是最优,我们通过枚举竖着取的条数,每次枚举左边选取的条数不超过我枚举的值,这样就可以通过枚举-贪心的方法枚举出所有的情况计算,并通过贪心策略取得最优值.复杂度\(O(n^2)\)

#include<bits/stdc++.h>
using namespace std;
const int N=2000+5;
const int inf=2147483647;

int k, n, m, a[N][N], l[N][N], c[N][N], ans = inf;

inline int gi(){
    int ans = 0, f = 1; char i = getchar();
    while(i>'9' || i<'0'){ if(i == '-') f = -1; i = getchar(); }
    while(i>='0' && i<='9') ans = ans*10+i-'0', i = getchar();
    return ans * f;
}

inline int column_ans(int lim){
    register int res = 0, lc = 1, rc = m, ul = 1, dl = n;
    while(lc <= rc && ul <= dl){
		res++;
		if(c[dl][lc]-c[ul-1][lc] <= k){ lc++; continue; } // left -> right
		if(c[dl][rc]-c[ul-1][rc] <= k){ rc--; continue; } // right -> left
		if(l[ul][rc]-l[ul][lc-1] <= k && ul < lim){ ul++; continue; } // up -> down
		if(l[dl][rc]-l[dl][lc-1] <= k){ dl--; continue; } // down -> up
		return inf;
    }
    return res;
}

inline int line_ans(int lim){
    register int res = 0, lc = 1, rc = m, ul = 1, dl = n;
    while(lc <= rc && ul <= dl){
		res++;
		if(l[ul][rc]-l[ul][lc-1] <= k){ ul++; continue; } // up -> down
		if(l[dl][rc]-l[dl][lc-1] <= k){ dl--; continue; } // down -> up
		if(c[dl][lc]-c[ul-1][lc] <= k && lc < lim){ lc++; continue; } // left -> right
		if(c[dl][rc]-c[ul-1][rc] <= k){ rc--; continue; } // right -> left
		return inf;
    }
    return res;
}

int main(){
    //freopen("ork.in", "r", stdin);
    //freopen("ork.out", "w", stdout);
    k = gi(), m = gi(), n = gi();
    for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++) a[i][j] = gi();
    for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++) l[i][j] = l[i][j-1]+a[i][j];
    for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++) c[i][j] = c[i-1][j]+a[i][j];

    for(int i=1;i<=n;i++) ans = min(ans, line_ans(i));
    for(int i=1;i<=m;i++) ans = min(ans, column_ans(i));
    cout << ans << endl;
    return 0;
}