【Foreign】画方框 [主席树]

画方框

Time Limit: 10 Sec  Memory Limit: 256 MB

Description

　　

Input

　　

Output

　　输出一行一个整数，表示 CD 最多可能画了几个方框。

Sample Input

　　3
　　1 1 1
　　1 0 1
　　1 1 1

Sample Output

　　9

HINT

　　

Main idea

　　给定一个01矩阵，1表示有标记，询问正方形方框的个数。

Solution

　　首先，我们先从 维护对角线上的点 这一层面来考虑。

　　我们先把一个点 能向左向上拓展的最大长度 以及 能向右向下的最长长度 预处理出来。

　　那么这时候，我们考虑 对于一条对角线上的点 怎么 在O(nlogn)以内 统计出答案。必然要用到某些数据结构。

　　　　举个例子，比如这个数据：
　　　　　　1 1 1 1
　　　　　　1 0 0 0
　　　　　　1 0 0 1
　　　　　　1 0 1 1
　　　　我们现在统计中间对角线的答案。
　　　　现在查询第一个点(1,1)，他向右向下拓展长度为 4 。
　　　　就是查询，后面三个点中 可以向左上拓展的长度 (2,2)>=1 (3,3)>=2 (4,4)>=3，
　　　　这三个条件满足了几个。

　　这样的话，我们发现：每次统计一个点的时候 查询的就是：在这个点 可以向右向下拓展 到的范围内，它后面的第 i 个点 可以向左向上拓展长度 是否 > i。

　　我们发现：查询后面若干个数的值是否 > 一个等差数列比较复杂。

　　于是乎，若统计第id个的答案，后面第num个点（在向右向下范围内）可以被统计所需要满足的条件是：num - id + 1 <= val 也就是 num - val + 1 <= id。（其中val表示 这个点可以向左向上拓展的长度）

　　所以我们如果把 i - val + 1 加入到一个数据结构中的话，

　　查询的就是：某一范围内 <=一个定值 的数的个数。

　　那直接用主席树来做就好了。

　　这样我们就解决了这个问题 QWQ。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<queue>
 using namespace std;
 typedef long long s64;

 const int ONE = ;
 const int INF = ;

 int n;
 int a[ONE][ONE];
 int Ans;

 struct power
 {
         int left, right;
         int up, down;
         int L, R;
 }A[ONE][ONE];

 int cnt, res;
 struct point
 {
         int root;
         int value;
         int left, right;
 }Node[ONE * ];

 int get()
 {
         int res=,Q=;char c;
         while( (c=getchar())< || c> )
         if(c=='-')Q=-;
         res=c-;
         while( (c=getchar())>= && c<= )
         res=res*+c-;
         return res*Q;
 }

 void Deal_first()
 {
         for(int i = ; i <= n; i++)
         {
             for(int j = n; j >= ; j--)
                 if(a[i][j]) A[i][j].right = A[i][j + ].right + ;
                 else A[i][j].right = ;
             for(int j = ; j <= n; j++)
                 if(a[i][j]) A[i][j].left = A[i][j - ].left + ;
                 else A[i][j].left = ;
         }

         for(int j = ; j <= n; j++)
         {
             for(int i = n; i >= ; i--)
                 if(a[i][j]) A[i][j].down = A[i + ][j].down + ;
                 else A[i][j].down = ;
             for(int i = ; i <= n; i++)
                 if(a[i][j]) A[i][j].up = A[i - ][j].up + ;
                 else A[i][j].up = ;
         }

         for(int i = ; i <= n; i++)
             for(int j = ; j <= n; j++)
                 A[i][j].L = min(A[i][j].left, A[i][j].up),
                 A[i][j].R = min(A[i][j].right, A[i][j].down);
 }

 void Update(int &x, int y, int L, int R, int Q, int val)
 {
         x = ++cnt;
         Node[x].left = Node[y].left;
         Node[x].right = Node[y].right;
         Node[x].value = Node[y].value + val;
         if(L == R) return;

         int M = L + R >> ;
         if(Q <= M)
             Update(Node[x].left, Node[y].left, L, M, Q, val);
         else
             Update(Node[x].right, Node[y].right, M + , R, Q, val);
 }

 void Query(int x, int y, int l, int r, int L, int R)
 {
         if(L <= l && r <= R)
         {
             res += Node[y].value - Node[x].value;
             return;
         }

         int mid = l + r >> ;

         if(L <= mid) Query(Node[x].left, Node[y].left, l, mid, L, R);
         if(mid +  <=R) Query(Node[x].right, Node[y].right, mid + , r, L, R);
 }

 int main()
 {
         n = get();
         for(int i = ; i <= n; i++)
             for(int j = ; j <= n; j++)
                 a[i][j] = get();

         Deal_first();

         for(int id = ; id <= n; id++)
         {
             for(int x = id, y = ; x <= n; x++, y++)
                 Update(Node[y].root, Node[y - ].root, , INF, y - A[x][y].L + , );

             for(int x = id, y = ; x <= n; x++, y++)
             {
                 res = ;
                 if(A[x][y].R)
                     Query(Node[y - ].root, Node[y + A[x][y].R - ].root, , INF, , y);
                 Ans += res;
             }

             cnt = ;
             for(int i = ; i <= cnt; i++)
                 Node[i].left = Node[i].right = Node[i].root = Node[i].value = ;
         }

         for(int id = ; id <= n; id++)
         {
             for(int y = id, x = ; y <= n; y++, x++)
                 Update(Node[x].root, Node[x - ].root, , INF, x - A[x][y].L + , );

             for(int y = id, x = ; y <= n; y++, x++)
             {
                 res = ;
                 if(A[x][y].R)
                     Query(Node[x - ].root, Node[x + A[x][y].R - ].root, , INF, , x);
                 Ans += res;
             }

             cnt = ;
             for(int i = ; i <= cnt; i++)
                 Node[i].left = Node[i].right = Node[i].root = Node[i].value = ;
         }

         printf("%d", Ans);
 }