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

Type:

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

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\n",num);
    }
    return 0;
}