Hdu 2513 区间DP

Cake slicing

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 149    Accepted Submission(s): 86

Problem Description

A rectangular cake with a grid of m*n unit squares on its top needs to be sliced into pieces. Several cherries are scattered on the top of the cake with at most one cherry on a unit square. The slicing should follow the rules below:
1.  each piece is rectangular or square;
2.  each cutting edge is straight and along a grid line;
3.  each piece has only one cherry on it;
4.  each cut must split the cake you currently cut two separate parts

For example, assume that the cake has a grid of 3*4 unit squares on its top, and there are three cherries on the top, as shown in the figure below.

One allowable slicing is as follows.

For this way of slicing , the total length of the cutting edges is 2+4=6.
Another way of slicing is 

In this case, the total length of the cutting edges is 3+2=5.

Give the shape of the cake and the scatter of the cherries , you are supposed to find
out the least total length of the cutting edges.

Input

The input file contains multiple test cases. For each test case:
The first line contains three integers , n, m and k (1≤n, m≤20), where n*m is the size of the unit square with a cherry on it . The two integers show respectively the row number and the column number of the unit square in the grid .
All integers in each line should be separated by blanks.

Output

Output an integer indicating the least total length of the cutting edges.

Sample Input

3 4 3 1 2 2 3 3 2

Sample Output

Case 1: 5

 

Accepted Code:

/*************************************************************************
    > File Name: 2513.cpp
    > Author: Stomach_ache
    > Mail: sudaweitong@gmail.com
    > Created Time: 2014年07月10日 星期四 18时34分23秒
    > Propose: 
 ************************************************************************/

#include <cmath>
#include <string>
#include <cstdio>
#include <fstream>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define min(x, y) ((x) < (y) ? (x) : (y))

int n, m, cherry;
int dp[22][22][22][22];
int a[22][22], sum[22][22];

int DP(int sx, int ex, int sy, int ey) {
      if (dp[sx][ex][sy][ey] != -1) return dp[sx][ex][sy][ey];
    int cnt = 0;
    for (int i = sx; i <= ex; i++) for (int j = sy; j <= ey; j++) 
          if (a[i][j]) cnt++;
    if (cnt == 1) return dp[sx][ex][sy][ey] = 0;

    int ans = 0x3f3f3f3f;
    for (int i = sx; i < ex; i++) {
          int tmp = sum[i][ey] - sum[i][sy-1] - sum[sx-1][ey] + sum[sx-1][sy-1];
          if (tmp) {
              ans = min(ans, DP(sx, i, sy, ey)+DP(i+1, ex, sy, ey)+ey-sy+1);
        }
    }
    for (int i = sy; i < ey; i++) {
          int tmp = sum[ex][i] - sum[ex][sy-1] - sum[sx-1][i] + sum[sx-1][sy-1];
        if (tmp) {
              ans = min(ans, DP(sx, ex, sy, i)+DP(sx, ex, i+1, ey)+ex-sx+1);
        }
    }
    return dp[sx][ex][sy][ey] = ans;
}

int main(void) {
      int c = 1;
      while(~scanf("%d %d %d", &n, &m, &cherry)) {
          memset(a, 0, sizeof(a));
          for (int i = 0; i < cherry; i++) {
              int x, y;
            scanf("%d %d", &x, &y);
            a[x][y] = 1;
        }
        memset(sum, 0, sizeof(sum));
        for (int i = 1; i <= n; i++) {
              for (int j = 1; j <= m; j++) {
                  sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1];
                  if (a[i][j]) sum[i][j]++;
            }
        }
        memset(dp, -1, sizeof(dp));
        DP(1, n, 1, m);
        printf("Case %d: %d
", c++, dp[1][n][1][m]);
    }

    return 0;
}