SRM 552 - 500 FoxAndFlowerShopDivOne

题目链接：

http://community.topcoder.com/stat?c=problem_statement&pm=11387

题目大意：

一个矩阵中种了两种花，

一个方格里最多种一支花，可以不种。

现在要在矩阵中选取两个不相交的子矩阵，使其中两种花数量之差不超过规定值，且两种花的总数最大。

算法：

这道题是很水的一道枚举题。

两个不相交子矩阵，要不就是没有公共行，要不就是没有公共列。

所以枚举行分界做一遍，再枚举列分界做一遍。

cot1[i][j]代表在列i的左边的子矩阵中，两种花数量之差为i的子矩阵所能具有的最大花总数。

以此类推。

如果以列分界就是分界列左边找一个自矩阵，右边找一个子矩阵，且数量之差要符合要求，枚举即可。

代码：

#include <string>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <climits>
#include <cmath>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;

const int maxn = 30;
int cot1[maxn][maxn * maxn * 2 + 1], cot2[maxn][maxn * maxn * 2 + 1], cot3[maxn][maxn * maxn * 2 + 1], cot4[maxn][maxn * maxn * 2 + 1];
int sum1[maxn][maxn], sum2[maxn][maxn];

inline int cal1(int x1, int y1, int x2, int y2)
{
    int tmp = sum1[x2][y2];
    if (x1)
    {
        tmp -= sum1[x1 - 1][y2];
    }
    if (y1)
    {
        tmp -= sum1[x2][y1 - 1];
    }
    if (x1 && y1)
    {
        tmp += sum1[x1 - 1][y1 - 1];
    }
    return tmp + maxn * maxn;
}


inline int cal2(int x1, int y1, int x2, int y2)
{
    int tmp = sum2[x2][y2];
    if (x1)
    {
        tmp -= sum2[x1 - 1][y2];
    }
    if (y1)
    {
        tmp -= sum2[x2][y1 - 1];
    }
    if (x1 && y1)
    {
        tmp += sum2[x1 - 1][y1 - 1];
    }
    return tmp;
}


class FoxAndFlowerShopDivOne
{
public:
    int theMaxFlowers(vector <string> flowers, int maxDiff)
    {
        int ans = -1;
        int n = flowers.size();
        int m = flowers[0].size();
        memset(sum1, 0, sizeof(sum1));
        memset(sum2, 0, sizeof(sum2));
        memset(cot1, -1, sizeof(cot1));
        memset(cot2, -1, sizeof(cot2));
        memset(cot3, -1, sizeof(cot3));
        memset(cot4, -1, sizeof(cot4));
        for (int i = 0; i < n; i ++)
        {
            for (int j = 0; j < m; j ++)
            {
                if (flowers[i][j] == 'L')
                {
                    sum1[i][j] ++;
                    sum2[i][j] ++;
                }
                else if (flowers[i][j] == 'P')
                {
                    sum1[i][j] --;
                    sum2[i][j] ++;
                }
                if (j)
                {
                    sum1[i][j] += sum1[i][j - 1];
                    sum2[i][j] += sum2[i][j - 1];
                }
            }
            if (i)
            {
                for (int j = 0; j < m; j ++)
                {
                    sum1[i][j] += sum1[i - 1][j];
                    sum2[i][j] += sum2[i - 1][j];
                }
            }
        }
        for (int x1 = 0; x1 < n; x1 ++)
        {
            for (int y1 = 0; y1 < m; y1 ++)
            {
                for (int x2 = x1; x2 < n; x2 ++)
                {
                    for (int y2 = y1; y2 < m; y2 ++)
                    {
                        cot1[x1][cal1(x1, y1, x2, y2)] = max(cot1[x1][cal1(x1, y1, x2, y2)], cal2(x1, y1, x2, y2));
                        cot2[x2][cal1(x1, y1, x2, y2)] = max(cot2[x2][cal1(x1, y1, x2, y2)], cal2(x1, y1, x2, y2));
                        cot3[y1][cal1(x1, y1, x2, y2)] = max(cot3[y1][cal1(x1, y1, x2, y2)], cal2(x1, y1, x2, y2));
                        cot4[y2][cal1(x1, y1, x2, y2)] = max(cot4[y2][cal1(x1, y1, x2, y2)], cal2(x1, y1, x2, y2));
                        if(n==3&&m==3)printf("%d %d %d %d %d %d\n",x1,y1,x2,y2,cal1(x1, y1, x2, y2),cal2(x1, y1, x2, y2));
                    }
                }
            }
        }
        for (int i = n - 1; i >= 0; i --)
        {
            for (int k = maxn * maxn - n * m; k <= maxn * maxn + n * m; k ++)
            {
                if (i < n - 1)
                {
                    cot1[i][k] = max(cot1[i][k], cot1[i + 1][k]);
                }
            }
        }
        for (int i = 0; i < n; i ++)
        {
            for (int k = maxn * maxn - n * m; k <= maxn * maxn + n * m; k ++)
            {
                if (i)
                {
                    cot2[i][k] = max(cot2[i][k], cot2[i - 1][k]);
                }
            }
        }
        for (int j = m - 1; j >= 0; j --)
        {
            for (int k = maxn * maxn - n * m; k <= maxn * maxn + n * m; k ++)
            {
                if (j < m - 1)
                {
                    cot3[j][k] = max(cot3[j][k], cot3[j + 1][k]);
                }
            }
        }
        for (int j = 0; j < m; j ++)
        {
            for (int k = maxn * maxn - n * m; k <= maxn * maxn + n * m; k ++)
            {
                if (j)
                {
                    cot4[j][k] = max(cot4[j][k], cot4[j - 1][k]);
                }
            }
        }
        for (int i = 1; i < n; i ++)
        {
            for (int k1 = min(maxDiff + 2 * maxn * maxn, 2 * maxn * maxn + n * m); k1 >= 0; k1 --)
            {
                for (int k2 = maxDiff + 2 * maxn * maxn - k1; k2 >= 0 && k1 + k2 >= 2 * maxn * maxn - maxDiff; k2 --)
                {
                    if (cot2[i - 1][k2] != -1 && cot1[i][k1] != -1)
                    {
                        ans = max(ans, cot2[i - 1][k2] + cot1[i][k1]);
                    }
                }
            }
        }
        for (int j = 1; j < m; j ++)
        {
            for (int k1 = min(maxDiff + 2 * maxn * maxn, 2 * maxn * maxn + n * m); k1 >= 0; k1 --)
            {
                for (int k2 = maxDiff + 2 * maxn * maxn - k1; k2 >= 0 && k1 + k2 >= 2 * maxn * maxn - maxDiff; k2 --)
                {
                    if (cot4[j - 1][k2] != -1 && cot3[j][k1] != -1)
                    {
                        ans = max(ans, cot4[j - 1][k2] + cot3[j][k1]);
                    }
                }
            }
        }
        return ans;
    }
};