Tyvj_P1035

描述

给出一张n*n(n<=100)的国际象棋棋盘，其中被删除了一些点，问可以使用多少1*2的多米诺骨牌进行掩盖。
输入格式

第一行为n，m（表示有m个删除的格子）
第二行到m+1行为x,y，分别表示删除格子所在的位置
x为第x行
y为第y列
输出格式

一个数，即最大覆盖格数
测试样例1

输入

8 0
输出

32

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    private static int n;
    private static int m;
    private static int[][] mat;
    private static Point[][] points;
    private static ArrayList<Point> S=new ArrayList<Point>();
    private static ArrayList<Point> V=new ArrayList<Point>();
    private static boolean[][] used;
    private static int sum=0;

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        init();
        for(int i=0;i<V.size();i++){
            Point p=V.get(i);
            if(mat[p.x][p.y]!=1){
                for(int j=1;j<=n;j++){
                    Arrays.fill(used[j],false);
                }

                if(find(p)){
                    sum++;
                }
            }
        }
        System.out.println(sum);


    }
    private static void init(){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        mat=new int[n+1][n+1];
        points=new Point[n+1][n+1];
        used=new boolean[n+1][n+1];
        for(int i=0;i<m;i++){
            int x=sc.nextInt();
            int y=sc.nextInt();
            mat[x][y]=1;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                points[i][j]=new Point(i,j);
                if((i+j)%2==0){
                    S.add(points[i][j]);
                }else{
                    V.add(points[i][j]);
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (mat[i][j] != 1) {
                    if (i + 1 <= n && mat[i + 1][j] != 1) {
                        points[i][j].next.add(points[i + 1][j]);
                    }
                    if (j + 1 <= n && mat[i][j + 1] != 1) {
                        points[i][j].next.add(points[i][j + 1]);
                    }
                    if (i - 1 >= 1 && mat[i - 1][j] != 1) {
                        points[i][j].next.add(points[i - 1][j]);
                    }
                    if (j - 1 >= 1 && mat[i][j - 1] != 1) {
                        points[i][j].next.add(points[i][j - 1]);
                    }
                }
            }
        }
    }

    private static boolean find(Point p){
        for(int i=0;i<p.next.size();i++){
            if(used[p.next.get(i).x][p.next.get(i).y]==false){
                used[p.next.get(i).x][p.next.get(i).y]=true;
                if(p.next.get(i).connect==null||find(p.next.get(i).connect)){
                    p.next.get(i).connect=p;
                    return true;
                }
            }
        }
        return false;
    }
}

class Point{
    int x;
    int y;
    Point connect;
    ArrayList<Point> next=new ArrayList<Point>();

    public Point(int x,int y){
        this.x=x;
        this.y=y;
    }
}