51node 1487 占领资源【思维+暴力枚举】

1487 占领资源

题目来源：  TopCoder

基准时间限制：1 秒 空间限制：131072 KB 分值: 40  难度：4级算法题

有一个矩形区域被划分为N行M列的网格，每个格子里有一定数量的资源并记录在矩阵val中，坐标(x,y)位置上资源量为val[x][y]，其val中每个元素的值为0~9的整数。如果你在某个网格(a,b)上造一座保护塔，那么你可以占领K个网格中的资源，这K个格子分别是(a+dx[1],b+dy[1]),(a+dx[2],b+dy[2]),...,(a+dx[K],b+dy[K])，注意（a，b）这格本身可能未必会被占领。现在你能建造不超过2个塔，问最多能占领多少资源？一个网格被多个塔占领时其资源只计算一次。另外如果计算的位置(a+dx[i],b+dy[i])在网格外，则不贡献任何资源。

Input

多组测试数据，第一行一个整数T，表示测试数据数量，1<=T<=5
每组测试数据有相同的结构构成：
每组数据第一行三个整数N，M，K,其中2<=N，M<=100，1<=K<=10。
之后会有N行，每行M个元素，表示val矩阵。每个元素为0~9，占一个字符，元素间没空格。
再接下来有K行，每行两个整数dx[i]与dy[i],其中-(N-1)<=dx[i]<=N-1,-(M-1)<=dy[i]<=(M-1).

Output

每组数据一行输出，即可占领的最大资源总量。

Input示例

3
2 2 2
11
11
0 0
0 1
2 2 2
11
11
0 0
1 1
2 2 1
15
61
0 0

Output示例

4
3
11

思路：

1、首先我们读完题之后肯定第一反应就是暴力枚举两个点，统计其价值和之后，维护最大，然而其时间复杂度很高，会达到O（n^4*k）【假设n==m】；显然会超时，那么考虑进行优化。

2、我们如果极限去想，不难想到这样一个思路：

我们O（nm）枚举一个点，将其值进行维护，维护出最大价值点，进行记录。然后再O（nm）的枚举另外一个点，同时对这个点进行值的记录，最后统计两个点的和，维护最大。

显然这种思路是有纰漏的，因为如果是次大值的点和第三大的点的和比上述维护的最终最大值大，那么这个思路就尴尬了。

但是不用丧气，因为我们只要在上述过程中加入更多暴力的思路就可以了：

我们不单单维护最大值的点，而是维护较多点，进行统计即可。我们可以脑补一下，反正维护100个点就肯定够了，那么对应我们开一个优先队列，将每一个点的价值都统计出来之后，放入队列中，每次取队头，然后O（nm）枚举第二个点，对两个点的总价值进行统计，并且维护最终的最大即可。

然后经过测试，后台数据维护3个点就够了。。（然而我不会证明。反正思路大方向对了能Ac就好啦）

Ac代码：

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
struct node
{
    int sum;
    int x,y;
    friend bool operator <(node a,node b)
    {
        return a.sum<b.sum;
    }
}now,nex;
int vis[500][500];
char a[500][500];
int fx[15];
int fy[15];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m,k;
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<n;i++)
        {
            scanf("%s",a[i]);
        }
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&fx[i],&fy[i]);
        }
        priority_queue<node>s;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                int sum=0;
                for(int l=0;l<k;l++)
                {
                    int xx=fx[l]+i;
                    int yy=fy[l]+j;
                    if(xx>=0&&xx<n&&yy>=0&&yy<m)
                    {
                        sum+=a[xx][yy]-'0';
                    }
                    else
                    {
                        sum+=0;
                    }
                }
                now.sum=sum;
                now.x=i;
                now.y=j;
                s.push(now);
            }
        }
        int ans=0;
        int cont=3;
        while(!s.empty())
        {
            cont--;
            if(cont<0)break;
            now=s.top();
            s.pop();
            memset(vis,0,sizeof(vis));
            for(int l=0;l<k;l++)
            {
                int xx=fx[l]+now.x;
                int yy=fy[l]+now.y;
                if(xx>=0&&xx<n&&yy>=0&&yy<m)
                {
                    vis[xx][yy]=1;
                }
            }
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<m;j++)
                {
                    int sum=0;
                    for(int l=0;l<k;l++)
                    {
                        int xx=fx[l]+i;
                        int yy=fy[l]+j;
                        if(xx>=0&&xx<n&&yy>=0&&yy<m)
                        {
                            if(vis[xx][yy]==1)continue;
                            else sum+=a[xx][yy]-'0';
                        }
                    }

                    ans=max(ans,sum+now.sum);
                }
            }
        }
        printf("%d\n",ans);
    }
}