HDU-4331 Image Recognition 关系转换+离线处理+树状数组

这题是按照解题报告上的思想来写的。觉得这个想法确实是很麻烦。现大概说下思路：

首先我们需要通过dp求出每一个点上下左右的延伸距离，这个距离就是连续的1的个数。预处理好这个信息后。我们不是去枚举每个点，而是去枚举每条对角线上的点，按照上面的说法，一条很明显的规则：所有边由1组成的正方形的对角线一定是矩形的对角线，相比N^2的枚举每个点，这个做法有个好处就是减少重复计算。我们的主要思想还是确定一个点为目标正方形的左上角点，然后取右、下的较小值作为其可及域，我们只需要统计这个区域内的点是否能够能够反向覆盖。

对于对角线 L， 我们从左上角到右下角进行遍历， 设当前点的坐标为(i, j)，对角线坐标是1（左上角点）其可及区域（对角线坐标区域）为：i + min(r[i][j], d[i][j]) - 1；设这个值为E，那么我们需要在[i, E]寻找某一点(对角线坐标为k，实际坐标为(t, p)) 满足 S[k] = k - min(u[t][p], l[t][p]) + 1 大于等于i。将问题作了这个转化后，我们需要对每条对角线的点k预处理出S[k]，然后就是离线处理的技巧了，对于对角线上的每一个不为0的点，都是有权成为目标正方形的左上角的，于是我们将每个非0点构成的可及区域进行统计，然后将其排序，这样当每遇到一个左端点时，就减去小于该端点（k）的统计值，原因是前面的坐标不合法，到一个右端点就要加上小于（k）的值，这样就抵消了前面减去的值。

说起来真纠结，主要是要理解树状数组的用法。

代码如下：

#include <cstring>

#include <cstdio>

#include <cstdlib>

#include <algorithm>

#define MAXN 1005

using namespace std;



int N, G[MAXN][MAXN], c[MAXN], idx;



int dgn[MAXN];  // 计算出所有对角线的特性



int l[MAXN][MAXN], r[MAXN][MAXN], u[MAXN][MAXN], d[MAXN][MAXN];



struct Node

{

    int x, sign, key;

    bool operator < (Node temp) const

    {

        if (x != temp.x) {

            return x < temp.x;

        }    

        else {

            return sign < temp.sign;    

        }

    }

}p[MAXN<<1];  // 保留所有的端点



int lowbit(int x)

{

    return x  & -x;

}



void addpoint(int a, int b)

{ // 0代表左端点，1代表右端点 

    ++idx;

    p[idx].x = a, p[idx].sign = 0;

    p[idx].key = a;

    ++idx;

    p[idx].x = b, p[idx].sign = 1;

    p[idx].key = a;

}



void add(int x)

{

    for (int i = x; i <= N; i += lowbit(i)) {

        c[i] += 1;    

    }

}



int sum(int x)

{

    int ret = 0;

    for (int i = x; i > 0; i -= lowbit(i)) {

        ret += c[i];

    }    

    return ret;

}



int solve()

{

    // 先枚举下三角+主对角线

    int ret = 0;

    for (int i = N; i >= 1; --i) {

        idx = -1;

        for (int j = 1; j <= (N-i+1); ++j) {  // 该条对角线共有i个点

            if (G[i+j-1][j]) {

                addpoint(j, j+min(r[i+j-1][j], d[i+j-1][j])-1);

                dgn[j] = j - min(u[i+j-1][j], l[i+j-1][j])+1;

            }  // 初始化好了一条对角线的特征值

        }

        if (idx == -1) { continue; }

        sort(p, p+idx+1);  // 从0开始，有idx+1个元素

        memset(c, 0, sizeof (c));

        for (int k = 0; k <= idx; ++k) {

            if (!p[k].sign) {  // 左端点 

                ret -= sum(p[k].key);

                add(dgn[p[k].x]);

            }

            else {  // 右端点 

                ret += sum(p[k].key);

            }

        }

    }

    // 枚举上三角对角线 

    for (int j = 2; j <= N; ++j) {

        idx = -1;

        for (int i = 1; i <= (N-j+1); ++i) {

            if (G[i][j+i-1]) {

                addpoint(i, i+min(r[i][j+i-1], d[i][j+i-1])-1);

                dgn[i] = i - min(u[i][j+i-1], l[i][j+i-1])+1;

            }    

        }

        if (idx == -1) { continue; }

        sort(p, p+idx+1);

        memset(c, 0, sizeof (c));

        for (int k = 0; k <= idx; ++k) {

            if (!p[k].sign) {

                ret -= sum(p[k].key);

                add(dgn[p[k].x]);

            }

            else {

                ret += sum(p[k].key);

            }

        }

    }

    return ret;

}



int main()

{

    int T, ca = 0;

    scanf("%d", &T);

    while (T--) {

        scanf("%d", &N);

        memset(d, 0, sizeof (d));

        memset(r, 0, sizeof (r));

        for (int i = 1;  i<= N; ++i) {

            for (int j = 1; j <= N; ++j) {

                scanf("%d", &G[i][j]);

                if (G[i][j]) {

                    u[i][j] = G[i-1][j] ? u[i-1][j] + 1 : 1;

                    l[i][j] = G[i][j-1] ? l[i][j-1] + 1 : 1;

                }

            }

        }

        for (int  i = N; i >= 1; --i) {

            for (int j = N; j >= 1; --j) {

                if (G[i][j]) {

                    d[i][j] = G[i+1][j] ? d[i+1][j] + 1 : 1;

                    r[i][j] = G[i][j+1] ? r[i][j+1] + 1 : 1;    

                }

            }

        }  // 统计出每个点上下左右1的连续个数

        printf("Case %d: %d\n", ++ca, solve());

    }

    return 0;    

}