hdu 5885 XM Reserves (FFT建模)

Problem Description

As an eligible Ingress Resistance Agent you should know your power source, the Exotic Matter.
We call it XM, which is the driving force behind all of our actions in Ingress.
XM allows us to construct items through hacking portals, to attack enemy portals, make links and create fields.
We try to collect XM from the ground. XM concentration come from location based services, meaning that areas with a lot of foot traffic have higher amounts versus places that don't.
You can collect XM by moving through those areas.
The XM will be automatically harvested by your Scanner when it is within your interaction circle/range.
Alice decides to select a location such that she can collect XM as much as possible.
To simplify the problem, we consider the city as a grid map with size `n*m' numbered from (0,0) to (n−1,m−1).
The XM concentration inside the block (i,j) is p(i,j).
The radius of your interaction circle is r.
We can assume that XM of the block (i,j) are located in the centre of this block.
The distance between two blocks is the Euclidean distance between their centres.

Alice stands in the centre of one block and collects the XM.
For each block with the distance d smaller than r to Alice, and whose XM concertation is p(i,j), Alice's scanner can collects p(i,j)/(1+d) XM from it.
Help Alice to determine the maximum XM which she can collect once he stands in the centre of one block.

 

Input

There are multiple cases.
For each case, the first line consists two integers n,m (1≤n,m≤500) and one float-point number r (0≤r≤300).
Each of the following n line consists m non-negative float-point numbers corresponding to the XM concentrations inside each blocks.

Output

For each case, output the maximum XM which Alice can collect in one line.
Your answers should be rounded to three decimal places.

 

Sample Input

3 3 1

1 3 6

7 9 4

2 8 1

3 3 2

1 3 6

7 9 4

2 8 1

5 5 1.

5 4 3 2 9

1 3 4 3 2

8 9 4 3 2

1 2 3 0 1

2 6 3 4 3 1

 

Sample Output

9.000

24.142

17.956

 

题意就是给你一个n*m的格子,每个格点上有一个p[i,j]

让你选取一个位置,对于所有在以这个点为中心,半径为r的圆内的点的Σp(i,j)/(d+1)最大, d为点到圆心的距离

 

思路:我们可以对于每个点统计它能对那些格点造成的贡献,然后我们遍历每一个格点就能找到答案了

我们从坐标变换的角度来思考,假如一个点的坐标为(x,y),圆心跟它的坐标差为(dx,dy)那么圆心的坐标

就是(x+dx,y+dy),由于格点横纵坐标都是整数,我们可以在整数上离散化dx,dy,实际上-r<=dx,dy<=r

那么我们对于一个格点,如果它当作圆心(也就是我们选取的位置),剩下能对它产生贡献的点(称为贡献点)都有一个共同的特性

那就是对于每一个贡献点经过一个(dx,dy)的向量偏移后都会到达圆心,即对于所有贡献点(xi+dx,yi+dy)都相等

联想到FFT是来求什么的?两个多项式做乘积,能得出结果中每个幂次的系数,我们把每个圆心的坐标看成是多项式乘积结果的每个幂次

就把这个问题转化成了一个卷积的问题了

不要忘了坐标是二维的,我们就把坐标转换成一维的, (x,y)→x*M+j (M=max(n+2R,m+2R))

我们看下叉姐的题解...

为什么要用M呢?为什么要加个2R呢? 　　我们注意到dx,dy是有可能是负数,为了避免这种情况我们在定义坐标转换的时候把dx,dy都加上R对应图上B数组

这样一行原本m个数,最后经过dx,dy平移后就有了m+2*R种位置

举个例子B[(-2+R)*M+3+R]里面存的其实是向量(2.3),即横坐标-2,纵坐标+3

 #include <bits/stdc++.h>

 using namespace std;
 const int maxn = <<;
 const double pi = acos(-1.0);
 #define fft FFT
 #define r real
 struct Complex
 {
     double r,i;
     Complex(double _r,double _i):r(_r),i(_i){}
     Complex(){}
     Complex operator +(const Complex &b)
     {
         return Complex(r+b.r,i+b.i);
     }
     Complex operator -(const Complex &b)
     {
         return Complex(r-b.r,i-b.i);
     }
     Complex operator *(const Complex &b)
     {
         return Complex(r*b.r-i*b.i,r*b.i+i*b.r);
     }
 };
 void change(Complex y[],int len)
 {
     int i,j,k;
     for(i = , j = len/;i < len-;i++)
     {
         if(i < j)swap(y[i],y[j]);
         k = len/;
         while( j >= k)
         {
             j -= k;
             k /= ;
         }
         if(j < k)j += k;
     }
 }
 void fft(Complex y[],int len,int on)
 {
     change(y,len);
     for(int h = ;h <= len;h <<= )
     {
         Complex wn(cos(-on**pi/h),sin(-on**pi/h));
         for(int j = ;j < len;j += h)
         {
             Complex w(,);
             for(int k = j;k < j+h/;k++)
             {
                 Complex u = y[k];
                 Complex t = w*y[k+h/];
                 y[k] = u+t;
                 y[k+h/] = u-t;
                 w = w*wn;
             }
         }
     }
     if(on == -)
         for(int i = ;i < len;i++)
             y[i].r /= len;
 }
 Complex a[maxn],b[maxn];
 int n,m;
 double rr;
 int main()
 {
     //freopen("de.txt","r",stdin);
     while (~scanf("%d%d%lf",&n,&m,&rr)){
         int R = ceil(rr);
         int M = max(n,m)+*R;
         int len = ;
         while (len<=M*M) len<<=;
         for (int i=;i<len;++i)
             a[i]=Complex(0.0,0.0),b[i]=Complex(0.0,0.0);
         for (int i=;i<n;++i){
             for(int j=;j<m;++j){
                 double p;
                 scanf("%lf",&p);
                 a[i*M+j]=Complex(p,);
             }
         }
         for (int i=-R;i<=R;++i){
             for (int j=-R;j<=R;++j){
                 if (sqrt(i*i+j*j)<rr)
                     b[(i+R)*M+j+R]=Complex(1.0/(sqrt(i*i+j*j)+),0.0);
             }
         }
         FFT(a,len,);
         FFT(b,len,);
         for (int i=;i<len;++i)
             a[i] = a[i]*b[i];
         FFT(a,len,-);
         double ans = ;
         for (int i=;i<n;++i){
             for(int j=;j<m;++j)
                 ans = max(ans,a[(i+R)*M+j+R].r);//答案让求实数的时候后面"+0.5"精度处理就不加了
         }
         printf("%.3lf\n",ans);
     }
     return ;
 }