HDU 5725 Game（计数）

[题目链接]

[题意]
n*m的棋盘上有一些守卫，守卫的攻击范围是一行一列以及周围8格，不会有一个守卫出现在另一个守卫的攻击范围内。现在任选不含守卫的起点和终点，求不经过守卫的最短路的平均值。

[分析]
根据守卫间的相互限制关系，可以发现任意两点间的最短路最多只会被一个守卫影响，即最多只需要绕行2格即可。
所以可以分为2步计算：
1.计算出所有合法点对间的曼哈顿距离之和
2.计算出需要绕行的点对的数量，答案加上它*2

第一步可以分解为横纵坐标，分别求
第二步比较麻烦
首先想到，如果起点在守卫正上方，终点在守卫正下方，一定会绕行，同理一左一右也是
但需要绕行的情况远不止这样

可以看到，红色区域到黄色区域的所有点都需要绕行
可以发现，如果连续几行有守卫，且他们的列坐标是单调上升的，那么所有守卫左边的区域到最后一个守卫右边的区域都需要绕行，同理单调下降就将右边的累计起来
发现了这一点就好办了，逐行扫描一次，再逐列扫描一次即可完成统计

[代码]

#include <bits/stdc++.h>
using namespace std ;
const int N = 1000 + 5 ;
typedef long long LL ;

int T , n , m ;
int row[N] , col[N] ;

char s[N][N] ;

int main()
{
    scanf( "%d" , &T ) ;
    while( T-- )
    {
        memset(row,0,sizeof(row)) ;
        memset(col,0,sizeof(col)) ;
        scanf( "%d%d" , &n , &m ) ;
        for( int i = 1 ; i <= n ; i++ )
            scanf( "%s" , s[i]+1 ) ;
        double sum = 0 ;
        LL tot = 0 , sx = 0 , sy = 0 ;
        for( int i = 1 ; i <= n ; i++ )
        {
            for( int j = 1 ; j <= m ; j++ )
            {
                if( s[i][j] == '#' )
                {
                    sx += i ;
                    tot++ ;
                    sum += tot*i - sx ;
                }
                else
                {
                    row[i] = j ;
                    col[j] = i ;
                }
            }
        }
        tot = 0 ;
        for( int j = 1 ; j <= m ; j++ )
        {
            for( int i = 1 ; i <= n ; i++ )
            {
                if( s[i][j] == '#' )
                {
                    sy += j ;
                    tot++ ;
                    sum += tot*j - sy ;
                }
            }
        }
        sum *= 2 ;
        int pre = 0 , L = 0 , R = 0 ;
        for( int i = 1 ; i <= n ; i++ )
        {
            if( !row[i] )
            {
                pre = L = R = 0 ;
                continue ;
            }
            if( row[i] > pre )
            {
                L += row[i]-1 ;
                R = m-row[i] ;
            }
            else
            {
                L = row[i]-1 ;
                R += m-row[i] ;
            }
            sum += 4*L*R ;
            pre = row[i] ;
        }
        pre = L = R = 0 ;
        for( int i = 1 ; i <= m ; i++ )
        {
            if( !col[i] )
            {
                pre = L = R = 0 ;
                continue ;
            }
            if( col[i] > pre )
            {
                L += col[i]-1 ;
                R = n-col[i] ;
            }
            else
            {
                L = col[i]-1 ;
                R += n-col[i] ;
            }
            sum += 4*L*R ;
            pre = col[i] ;
        }
        if( tot ) sum /= 1.0*tot*tot ;
        printf( "%.4f\n" , sum ) ;
    }
    return 0 ;
}