BNU4299——God Save the i-th Queen——————【皇后攻击，找到对应关系压缩空间】

God Save the i-th Queen

Time Limit: 5000ms

Memory Limit: 65536KB

64-bit integer IO format: %lld      Java class name: Main

Prev 

Submit Status Statistics Discuss

 Next

Type: 

None

 

  None   Graph Theory       2-SAT       Articulation/Bridge/Biconnected Component       Cycles/Topological Sorting/Strongly Connected Component       Shortest Path           Bellman Ford           Dijkstra/Floyd Warshall       Euler Trail/Circuit       Heavy-Light Decomposition       Minimum Spanning Tree       Stable Marriage Problem       Trees       Directed Minimum Spanning Tree       Flow/Matching           Graph Matching               Bipartite Matching               Hopcroft–Karp Bipartite Matching               Weighted Bipartite Matching/Hungarian Algorithm           Flow               Max Flow/Min Cut               Min Cost Max Flow   DFS-like       Backtracking with Pruning/Branch and Bound       Basic Recursion       IDA* Search       Parsing/Grammar       Breadth First Search/Depth First Search       Advanced Search Techniques           Binary Search/Bisection           Ternary Search   Geometry       Basic Geometry       Computational Geometry       Convex Hull       Pick's Theorem   Game Theory       Green Hackenbush/Colon Principle/Fusion Principle       Nim       Sprague-Grundy Number   Matrix       Gaussian Elimination       Matrix Exponentiation   Data Structures       Basic Data Structures       Binary Indexed Tree       Binary Search Tree       Hashing       Orthogonal Range Search       Range Minimum Query/Lowest Common Ancestor       Segment Tree/Interval Tree       Trie Tree       Sorting       Disjoint Set   String       Aho Corasick       Knuth-Morris-Pratt       Suffix Array/Suffix Tree   Math       Basic Math       Big Integer Arithmetic       Number Theory           Chinese Remainder Theorem           Extended Euclid           Inclusion/Exclusion           Modular Arithmetic       Combinatorics           Group Theory/Burnside's lemma           Counting       Probability/Expected Value   Others       Tricky       Hardest       Unusual       Brute Force       Implementation       Constructive Algorithms       Two Pointer       Bitmask       Beginner       Discrete Logarithm/Shank's Baby-step Giant-step Algorithm       Greedy       Divide and Conquer   Dynamic Programming                   Tag it!

Did you know that during the ACM-ICPC World Finals a big chessboard is installed every year and is available for the participants to play against each other? In this problem, we will test your basic chess-playing abilities to verify that you would not make a fool of yourself if you advance to the World Finals.

During the yesterday’s Practice Session, you tried to solve the problem of N independent rooks. This time, let’s concentrate on queens. As you probably know, the queens may move not only

horizontally and vertically, but also diagonally.

You are given a chessboard with i−1 queens already placed and your task is to find all squares that may be used to place the i-th queen such that it cannot be captured by any of the others.

 

Input

The input consists of several tasks. Each task begins with a line containing three integer numbers separated by a space: X, Y , N. X and Y give the chessboard size, 1 ≤ X, Y ≤20 000. N = i−1 is the number of queens already placed, 0 ≤ N ≤ X·Y .

After the first line, there are N lines, each containing two numbers xk, yk separated by a space. They give the position of the k-th queen, 1 ≤ xk ≤ X, 1 ≤ yk ≤ Y . You may assume that those positions are distinct, i.e., no two queens share the same square.

The last task is followed by a line containing three zeros.

 

Output

For each task, output one line containing a single integer number: the number of squares which are not occupied and do not lie on the same row, column, or diagonal as any of the existing queens.

 

Sample Input

8 8 2
4 5
5 5
0 0 0

Sample Output

20


解题思路：刚拿到题目的时候用的暴力，结果数组超内存，又用了set，又超时。后来知道，可以只开4个数组来存覆盖情况。即row，col，pie，na数组来记录行列和撇捺（对角线情况）。可以发现pie数组由x,y相加减1后得到。na数组可以将y转化为相对于右上角的位置为（Y-y+1）。然后枚举地图中各个点，然后判断该点既不在行列，也不在撇捺（对角线）的情况，记录个数即可。

#include<bits/stdc++.h>
using namespace std;
const int maxn=21000;
bool row[maxn],col[maxn],pie[maxn*2],na[maxn*2];
void init(){
    memset(row,0,sizeof(row));
    memset(col,0,sizeof(col));
    memset(pie,0,sizeof(pie));
    memset(na,0,sizeof(na));
}
int main(){
    int X,Y,n;
    while(scanf("%d%d%d",&X,&Y,&n)!=EOF&&(X+Y+n)){
        init();
        for(int i=0;i<n;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            row[x]=1;       //记录该行被覆盖
            col[y]=1;       //记录该列被覆盖
            pie[x+y-1]=1;   //记录右上到左下的对角线被覆盖
            na[Y-y+x]=1;    //记录左上到右下的对角线被覆盖
        }
        int num=0;
        for(int i=1;i<=X;i++){
            for(int j=1;j<=Y;j++){
                if((!row[i])&&(!col[j])&&(!pie[i+j-1])&&(!na[Y-j+i])){
                        //枚举各个点，如果行列撇捺都没覆盖，加1
                    num++;
                }
            }
        }
        printf("%d
",num);
    }
    return 0;
}