Codeforces 677E Vanya and Balloons【断点前缀和+暴力维护+数学技巧】

最新推荐文章于 2021-06-03 21:38:06 发布
最新推荐文章于 2021-06-03 21:38:06 发布
阅读量485 收藏
点赞数
分类专栏： 思维 暴力枚举 文章标签： Codeforces 677E
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengxiang000000/article/details/64443342
版权

E. Vanya and Balloons
time limit per test
3 seconds
memory limit per test
512 megabytes
input
standard input
output
standard output

Vanya plays a game of balloons on the field of size n × n, where each cell contains a balloon with one of the values 0, 1, 2 or 3. The goal is to destroy a cross, such that the product of all values of balloons in the cross is maximum possible. There are two types of crosses: normal and rotated. For example:

**o**
**o**
ooooo
**o**
**o**

or

o***o
*o*o*
**o**
*o*o*
o***o

Formally, the cross is given by three integers r, c and d, such that d ≤ r, c ≤ n - d + 1. The normal cross consists of balloons located in cells (x, y) (where x stay for the number of the row and y for the number of the column), such that |x - r|·|y - c| = 0 and |x - r| + |y - c| < d. Rotated cross consists of balloons located in cells (x, y), such that |x - r| = |y - c| and |x - r| < d.

Vanya wants to know the maximum possible product of the values of balls forming one cross. As this value can be large, output it modulo 109 + 7.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of rows and columns in the table with balloons.

The each of the following n lines contains n characters '0', '1', '2' or '3' — the description of the values in balloons.

Output

Print the maximum possible product modulo 109 + 7. Note, that you are not asked to maximize the remainder modulo 109 + 7, but to find the maximum value and print it this modulo.

Examples
Input 
4
1233
0213
2020
0303
Output 
108
Input 
5
00300
00300
33333
00300
00300
Output 
19683
Input 
5
00003
02030
00300
03020
30000
Output 
108
Input 
5
21312
10003
10002
10003
23231
Output 
3
Input 
5
12131
12111
12112
21311
21212
Output 
24
Note

In the first sample, the maximum product is achieved for a rotated cross with a center in the cell (3, 3) and radius 1: 2·2·3·3·3 = 108.


题目大意：

让你选择一个位子作为中心，向上下左右发散或者向左上左下右上右下发散。要求发散长度相同，将发散到的区域和中心的数字相乘，问最大的值%1e9+7是多少。


思路：


1、首先，他要的值不是%后最大值，而是最大值%1e9+7的值。

那么我们首先将乘变成加，对于123取对数来统计值。


2、我们O（n^2）维护一个前缀和，L【i】【j】表示以（i，j）这个点作为中心，向左发散的最大值（其实就是向左发散最长长度没有遇到0的值相乘）。

同时维护一个lenL【i】【j】，表示最大值发散的长度。

同理，我们需要维护八对这样的数组。

在我们遇到了数字0的时候，要对前缀和进行断点。


3、然后我们O（n^2）暴力枚举一个中心，对两种发散方式进行统计，看看哪个值更大，对于过程维护最大值的位子(posx，posy)以及一个发散长度，然后在最后维护最终解即可。


Ac代码（长到辣眼睛   ....）：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<cmath>
#include<iostream>
using namespace std;
#define ll __int64
#define mod 1000000007
int n;
char a[1005][1005];
int lenL[1005][1005];
int lenR[1005][1005];
int lenU[1005][1005];
int lenD[1005][1005];
int lenLU[1005][1005];
int lenRU[1005][1005];
int lenLD[1005][1005];
int lenRD[1005][1005];
double L[1005][1005];
double R[1005][1005];
double U[1005][1005];
double D[1005][1005];
double LU[1005][1005];
double RU[1005][1005];
double LD[1005][1005];
double RD[1005][1005];
int fx[8]={0,0,1,-1,1,-1,1,-1};
int fy[8]={1,-1,0,0,1,-1,-1,1};
double getval(int i,int j)
{
    if(a[i][j]=='0'||a[i][j]=='1')return 0;
    if(a[i][j]=='2')return log(2);
    if(a[i][j]=='3')return log(3);
}
void init()
{
    memset(lenLU,0,sizeof(lenLU));
    memset(lenRU,0,sizeof(lenRU));
    memset(lenLD,0,sizeof(lenLD));
    memset(lenRD,0,sizeof(lenRD));
    memset(lenL,0,sizeof(lenL));
    memset(lenR,0,sizeof(lenR));
    memset(lenU,0,sizeof(lenU));
    memset(lenD,0,sizeof(lenD));
    memset(L,0,sizeof(L));
    memset(R,0,sizeof(L));
    memset(U,0,sizeof(L));
    memset(D,0,sizeof(L));
    memset(LU,0,sizeof(LU));
    memset(RU,0,sizeof(RU));
    memset(LD,0,sizeof(LD));
    memset(RD,0,sizeof(RD));
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(a[i][j]=='0')
            {
                lenL[i][j]=0;
                L[i][j]=0;
            }
            else
            {
                lenL[i][j]=lenL[i][j-1]+1;
                L[i][j]=L[i][j-1]+getval(i,j);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=n;j>=1;j--)
        {
            if(a[i][j]=='0')
            {
                lenR[i][j]=0;
                R[i][j]=0;
            }
            else
            {
                lenR[i][j]=lenR[i][j+1]+1;
                R[i][j]=R[i][j+1]+getval(i,j);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(a[i][j]=='0')
            {
                lenU[i][j]=0;
                U[i][j]=0;
            }
            else
            {
                lenU[i][j]=lenU[i-1][j]+1;
                U[i][j]=U[i-1][j]+getval(i,j);
            }
        }
    }
    for(int i=n;i>=1;i--)
    {
        for(int j=1;j<=n;j++)
        {
            if(a[i][j]=='0')
            {
                lenD[i][j]=0;
                D[i][j]=0;
            }
            else
            {
                lenD[i][j]=lenD[i+1][j]+1;
                D[i][j]=D[i+1][j]+getval(i,j);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(a[i][j]=='0')
            {
                LU[i][j]=0;
                lenLU[i][j]=0;
            }
            else
            {
                lenLU[i][j]=lenLU[i-1][j-1]+1;
                LU[i][j]=LU[i-1][j-1]+getval(i,j);
            }
        }
    }
    for(int i=n;i>=1;i--)
    {
        for(int j=n;j>=1;j--)
        {
            if(a[i][j]=='0')
            {
                RD[i][j]=0;
                lenRD[i][j]=0;
            }
            else
            {
                lenRD[i][j]=lenRD[i+1][j+1]+1;
                RD[i][j]=RD[i+1][j+1]+getval(i,j);
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=n;j>=1;j--)
        {
            if(a[i][j]=='0')
            {
                RU[i][j]=0;
                lenRU[i][j]=0;
            }
            else
            {
                lenRU[i][j]=lenRU[i-1][j+1]+1;
                RU[i][j]=RU[i-1][j+1]+getval(i,j);
            }
        }
    }
    for(int i=n;i>=1;i--)
    {
        for(int j=1;j<=n;j++)
        {
            if(a[i][j]=='0')
            {
                LD[i][j]=0;
                lenLD[i][j]=0;
            }
            else
            {
                lenLD[i][j]=lenLD[i+1][j-1]+1;
                LD[i][j]=LD[i+1][j-1]+getval(i,j);
            }
        }
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)scanf("%s",a[i]+1);
        init();
        double maxn=0;
        int len=0;
        int posx=-1,posy=-1;
        int flag=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(a[i][j]=='0')continue;
                int minn=0x3f3f3f3f;
                minn=min(lenL[i][j],minn);
                minn=min(lenR[i][j],minn);
                minn=min(lenU[i][j],minn);
                minn=min(lenD[i][j],minn);
                double tmp=0;
                tmp+=L[i][j]-L[i][j-minn];
                tmp+=R[i][j]-R[i][j+minn];
                tmp+=U[i][j]-U[i-minn][j];
                tmp+=D[i][j]-D[i+minn][j];
                tmp-=3*getval(i,j);
                if(tmp>maxn)
                {
                    flag=1;
                    len=minn;
                    maxn=tmp;
                    posx=i,posy=j;
                }
            }
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(a[i][j]=='0')continue;
                int minn=0x3f3f3f3f;
                minn=min(lenLU[i][j],minn);
                minn=min(lenRU[i][j],minn);
                minn=min(lenLD[i][j],minn);
                minn=min(lenRD[i][j],minn);
                double tmp=0;
                tmp+=LU[i][j]-LU[i-minn][j-minn];
                tmp+=RU[i][j]-RU[i-minn][j+minn];
                tmp+=LD[i][j]-LD[i+minn][j-minn];
                tmp+=RD[i][j]-RD[i+minn][j+minn];
                tmp-=3*getval(i,j);
                if(tmp>maxn)
                {
                    flag=2;
                    len=minn;
                    maxn=tmp;
                    posx=i,posy=j;
                }
            }
        }
        if(flag==0)
        {
            int output=0;
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    output=max(a[i][j]-'0',output);
                }
            }
            printf("%d\n",output);
        }
        else if(flag==1)
        {
            ll output=(ll)a[posx][posy]-'0';
            for(int i=1;i<len;i++)
            {
                for(int k=0;k<4;k++)
                {
                    int xx=posx+i*fx[k];
                    int yy=posy+i*fy[k];
                    output*=(a[xx][yy]-'0');
                    output%=mod;
                }
            }
            printf("%I64d\n",output);
        }
        else
        {
            ll output=(ll)(a[posx][posy]-'0');
            for(int i=1;i<len;i++)
            {
                for(int k=4;k<8;k++)
                {
                    int xx=posx+i*fx[k];
                    int yy=posy+i*fy[k];
                    output*=(a[xx][yy]-'0');
                    output%=mod;
                }
            }
            printf("%I64d\n",output);
        }
    }
}




mengxiang000000
关注
专栏目录
CodeForces 1225E Rock Is Push（dp + 前缀和优化）
alpc_qleonardo
10-26 971
大致题意：一个迷宫，里面有很多箱子，你可以向右或者向下走。当你遇到一个或者多个箱子的时候，你可以把箱子往你移动的方向推动，但是不能把箱子推出到墙壁外面。你从左上角出发，问你有多少种方法到右下角。 考虑如果没有箱子，那么就是一个很简单的递推问题，对于一个格子，要么从上面要么从左边来。有箱子的话，由于箱子可以被推动而且不能推到外面，所以我们要考虑是否可以从上面或者下面过来。 还...
[CodeForces 677D] Vanya and Treasure （二维树状数组+静态前缀最小值）
MisDeer's blog
06-04 724
CodeForces - 677D 一个N*M的网格图，每个格子有一把钥匙，上面一个权值 要求从 1到 P按顺序收集钥匙，保证 P只有一把 问收集全部钥匙的最短距离是多少 首先 dp[x][y]表示收集 (x,y)的最小距离 然后这题不能暴力，复杂度是 O(N^4) 官方题解的 bfs复杂度没看懂，所以退而求其次， 实现了一下comment的二维树状数组树状数组维护二维静态前缀
Codeforces 677E Vanya and Balloons
04-23 94
Vanya and Balloons 枚举中心去更新答案， 数字过大用log去比较， 斜着的旋转一下坐标， 然后我旋出来好多bug。。。。 #include<bits/stdc++.h> #define LL long long #define LD long double #define ull unsigned long long #define fi f...
E. Vanya and Balloons
weixin_30520015的博客
09-29 101
E. Vanya and Balloons time limit per test 3 seconds memory limit per test 512 megabytes Vanya plays a game of balloons on the field of sizen × n, where each cel...
Codeforces Round #355 (Div. 2)E. Vanya and Balloons
Fsss
07-06 524
链接：http://codeforces.com/contest/677/problem/E 题意：给定一个n*n的仅包含'0','1','2','3'的矩阵。求一个乘积最大的十字，要求十字的四边一样长。 分析：因为是十字所以可以向8个方向扩展，很明显我们会以中心点来处理出这个十字在哪。那么我们想要知道的是对于中心点(x,y)它的8个方向的2的个数有多少，3的个数有多少，那么我们显然是可以从它
[CF677E] Vanya and Balloons
ZLTJohn的博客
03-17 1521
题目大意给你一个只有0,1,2的n*n的矩阵，你现在可以选择一个叉叉或者十字，把里面的数全部取掉，贡献为取掉的数的乘积。 具体的，从某一点(i,j)出发，选择一个长度c: 你可以这样取(1为取，0为不取) 00100 00100 11111 00100 00100 或者这样取 10001 01010 00100 01010 10001 n<=1000分析很简单的思路，弄两
Codeforces 677E Vanya and Balloons(暴力+转换) category:
只玩三国的程序猿的专栏
01-18 528
题意： 给定一个矩阵，让你其中有1,2,3,0，让你在里面寻找一个十字，是的这个十字所包含的数字的乘积最大。 解法： 这个完全可以预处理处八个方向的前缀，然后暴力枚举中心即可，要注意的是，十字的四条边长是一样的，另外因为数字太大，所以用log把乘变成加，就可以比较大小了，不然直接模是无法比大小的。代码略长。。。 // // Created by CQU_CST_WuErli // Co
Codeforces 988 D. Points and Powers of Two（数学+结论）
01-20
3. 计算2的幂的前缀和，存储在lg[]数组中。 4. 遍历数组，对于每个元素，查找它与集合s中其他元素的差值，如果差值是2的幂，则将其添加到结果序列ans中。 5. 如果找到了长度大于1的ans，输出ans的长度和元素；否则，...
Codeforces Round #271 (Div. 2), problem: (D) Flowers 【DP+前缀和+取模运算】
超逸の学习技术博客
10-11 520
Codeforces Round #271 (Div. 2), problem: (D) Flowers 题目大意 土拨鼠？？？反正大概意思是拿红花或者k个白花，那么对于dp [ i ] =dp [ i - 1 ] + dp [ i - k ] 对于第 i 个长度 可以是之前最后一个红花或者k个白花 题解 题目给你的a 和 b 是一个区间范围的方法值 所以我们对我们求出的dp数组还要...
CodeForces – 1323D Present(思维+数学)
01-03
题目分析：如果暴力的话显然时间复杂度是 n * n 的，我们应该想办法去优化，比赛的时候想用线段树，但是不会在维护异或的前提下区间加法，也想过用矩阵维护，但丝毫没什么用呀，队友想到了可以按位维护，也就是维护...
Codeforces 677E Vanya and Balloons（DP + 一些技巧）
dengliugong3918的博客
07-14 97
题目大概说给一张地图，地图每个格子都有0到9中的某一个数字。现在要在一个格子放炸弹，炸弹爆炸后水柱有两种扩展方式，一种是上、下、左、右，另一种是左上、右下、右上、左下，且四个方向的长度都一样。问放哪个格子怎么爆炸使得水柱覆盖的格子上的数字乘积最大，结果模1e9+7。 这题不会做。。 首先，各个格子的值取对数，这个为了比大小，因为需要模数，通过取对数缩小值。另外也把乘法转化成加法。...
cf677E Vanya and Balloons （前缀和）
xuzonghao的博客
03-22 261
题目链接 一、感想 大半夜写题解啊喂！没有无敌激动的情感至于这样吗！至于吗至于吗！思路之前就看过，下午又复习了一遍题解，结果晚上敲起来就是十点改到一点停都停不下来啊喂！ 写完起码一点半了。我还在俱乐部。明早六点多爬起来上算法实验课。别睡了算了，修仙。 哎，实现功底需要提高。 二、题意 找到乘积最大的“十字架”。十字架的形状如题目的图所示。乘积是十字架里每一个数相乘。当然不能暴力，n*n...
Codeforces 677E - Vanya and Balloons
bannesi6888的博客
06-03 159
题意：类似炸弹人游戏，但是十字的炸弹弹道都是等长的（就是4个方向的长度一样）（可以炸十、×），然后结果是所能炸到的每个格子的乘积的最大值。 分析：一眼看下去就是DP了，但有与涉及8个方向，所以就要分别DP8个方向。每个方向就是一个一维的DP。 还有要大小的比较就要利用到log了，因为要比较【2^k1 和 3^k2(k1>k2)】的大小，直接算是...
codeforces 677E
LFLONG的博客
08-14 323
题意：给出一个1000*1000的举证，问你任意“十字乘积”的最大值。十字可以是#include using namespace std; #define N 2010 int d[N][N]; double s[8][N][N]; int p[8][N][N]; typedef long long LL; #define MOD 1000000007 //0,1 ,1,1, 1,0, 1
Codeforces677 E. Vanya and Balloons（对数转换+dp预处理）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
06-03 107
题意： 解法： 显然选的数越多越好,但是不能选到0. 对于十字: 1.预处理行的前缀积,列的前缀积. 2.预处理每个位置向四个方向能扩展的最大距离. 最后枚举格子,取最大值即可. 对于叉: 和十字差不多,就是修改为预处理斜线. 但是乘积非常大,没办法存下来, 因为我们只需要比较大小,因此可以利用对数性质log(x*y)=log(x)+log(y), 将乘法转化为加法,这样的话用double就可以直接存了,大小也可以直接比较. 除了对数转化的部分,其他部分都很常规,直接写就行了. code： #i
Codeforces 677C Vanya and Label（数学）
围巾的ACM博客
06-02 934
题意：给你一个字符串，问你有多少对相同长度的字符串 & 起来之后，恰好等于这个字符串，这个字符串的每个字符都是代表着0-63之间的数字 思路：首先每个字符是独立的，我们把每个字符的方案数知道，然后再全部乘起来就好了 0-63是 2^6，那么我们就按位去考虑就好了 如果对于这一位是0的话，那么就有3种方案0&1,1&0,0&0，如果这一位为1的话，只有一种方案 所以看一共有多少个位是0就好了
C. Vanya and Scales
wxl7777的博客
06-09 268
Vanya has a scales for weighing loads and weights of massesw0, w1, w2, ..., w100grams wherewis some integer not less than2(exactly one weight of each nominal value). Vanya wonders whether he can ...
基于java的校园美食交流系统设计与实现.docx
最新发布
09-19
基于java的校园美食交流系统设计与实现.docx
#_ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
09-19
均包含代码，文章，部分项目包含ppt
codeforces round #758 (div.1 + div. 2)
03-16
codeforces round #758 (div.1 + div. 2)是一场由Codeforces举办的比赛，包括div.1和div.2两个级别。比赛中会出现一系列算法题目，参赛者...该比赛旨在提高参赛者的算法能力和编程技巧，同时也是一次交流学习的机会。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值