HDU 5301 Buildings(思维题)

Buildings

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 541    Accepted Submission(s): 124

Problem Description

Your current task is to make a ground plan for a residential building located in HZXJHS. So you must determine a way to split the floor building with walls to make apartments in the shape of a rectangle. Each built wall must be paralled to the building's sides.

The floor is represented in the ground plan as a large rectangle with dimensions 

n×m, where each apartment is a smaller rectangle with dimensions  a×b located inside. For each apartment, its dimensions can be different from each other. The number  a and  b must be integers.

Additionally, the apartments must completely cover the floor without one 

1×1 square located on  (x,y). The apartments must not intersect, but they can touch.

For this example, this is a sample of 

n=2,m=3,x=2,y=2.

To prevent darkness indoors, the apartments must have windows. Therefore, each apartment must share its at least one side with the edge of the rectangle representing the floor so it is possible to place a window.

Your boss XXY wants to minimize the maximum areas of all apartments, now it's your turn to tell him the answer.

Input

10000 testcases.
For each testcase, only four space-separated integers,  n,m,x,y(1≤n,m≤108,n×m>1,1≤x≤n,1≤y≤m).

Output

For each testcase, print only one interger, representing the answer.

Sample Input

2 3 2 2 3 3 1 1

Sample Output

Hint

Case 1 :

You can split the floor into five 1×1 apartments. The answer is 1. Case 2:

You can split the floor into three 2×1 apartments and two 1×1 apartments. The answer is 2.

If you want to split the floor into eight 1×1

Source

2015 Multi-University Training Contest 2

     题意：给出a*b的矩阵，里面有一个坏点，求用不覆盖这个坏点的其他矩阵填满a*b的矩阵，使得其他矩阵的最大面积最小，并输出最小面积

     思路：通过矩阵变换位置把坏点转移到矩阵的右上角（对矩阵进行翻转），因为坏点在右上角，所以求坏点到矩阵右边的和坏点到矩阵底部的距离，然后对这两个距离进行比较，最后将这两个距离中较小的数与maxx（maxx是矩阵中较小边的中点距离）进行比较，较大的那个就是要求的答案。

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

using namespace std;

__int64 a,b,c,d;

int main()
{
    while(scanf("%I64d%I64d%I64d%I64d",&a,&b,&c,&d)!=EOF)
    {
        if(a>b)
        {
            __int64 t = a;
                    a = b;
                    b = t;
                    t = c;
                    c = d;
                    d = t;
        }
        __int64 pn = (a + 1)/2;
        __int64 pm = (b + 1)/2;
        if(c>a-c+1)
        {
            c = a - c + 1;
        }
        if(d<b-d+1)
        {
            d = b - d + 1;
        }
        __int64 maxx = min(pn,pm);
        if(a == b)
        {
            if(pn == c && pm == d)
            {
                maxx--;
            }
        }
        else
        {
            __int64 num = min(a-c,b-d+1);
            maxx = max(maxx,num);
        }
        printf("%I64d\n",maxx);
    }
    return 0;
}