cowfood

题目描述

农民 John 购买了一处肥沃的矩形牧场，分成 M*N(1 <= M <= 12; 1 <= N <= 12)个格子。他想在那里的一些格子中种植美味的玉米。遗憾的是，有些格子区域的土地是贫瘠的，不能耕种。
精明的 FJ 知道奶牛们进食时不喜欢和别的牛相邻，所以一旦在一个格子中种植玉米，那么他就不会在相邻的格子中种植，即没有两个被选中的格子拥有公共边。他还没有最终确定哪些格子要选择种植玉米。
作为一个思想开明的人，农民 John 希望考虑所有可行的选择格子种植方案。由于太开明，他还考虑一个格子都不选择的种植方案！请帮助农民 John 确定种植方案总数。

输入

* Line 1: 两个用空格分隔的整数 M 和 N
* Lines 2..M+1: 第 i+1 行描述牧场第 i 行每个格子的情况， N 个用空格分隔的整数，表示
这个格子是否可以种植(1 表示肥沃的、适合种植，0 表示贫瘠的、不可种植)

输出

* Line 1: 一个整数:FJ 可选择的方案总数 除以 100,000,000 的余数。

样例输入

2 3

1 1 1

0 1 0

样例输出

9

提示

给可以种植玉米的格子编号:

1 2 3

4

只种一个格子的方案有四种 (1, 2, 3, 或 4)，种植两个格子的方案有三种 (13, 14,

或 34)，种植三个格子的方案有一种 (134)，还有一种什么格子都不种。 4+3+1+1=9。

递归算法超时版本。

思想：把可以种植的地分离出来没，data [] one 记录了哪块地能种植

转化为把能种植的地插入到牧地矩阵当中，有多少种插法

当n=9时，就超时了。

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

public class cid_100000550_pid_0 {
	static int num = 0;
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		int m = cin.nextInt();
		int n = cin.nextInt();
		int a[][] = new int[m][n];// 种植地矩阵
		data[] one = new data[m * n];//可以种植的地（包含a的x，y）
		int index = 0;
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				int in = cin.nextInt();
				if (in == 1) {
					one[index] = new data();
					one[index].x = i;
					one[index++].y = j;
				}
			}
		}

		boolean b[] = new boolean[index];
		f(a,Arrays.copyOf(one, index), b, 0, 0);
		System.out.println(num);
	}

	/**
	 * @param a  :种植地矩阵
	 * @param one ：可以种植的地（包含a的x，y）
	 * @param b ：是否被种植
	 * @param curr ：当前处理哪块地
	 * @param dep ：递归深度
	 */
	private static void f(int[][] a, data[] one, boolean b[], int curr, int dep) {

		if (curr > 0&&b[curr - 1] == true) {
			data d = one[curr - 1];
			// 判断上下是否已经种植
			if (d.x >= 1 && d.x < a.length - 1) {
				if (a[d.x - 1][d.y] == 1 || a[d.x + 1][d.y] == 1)return;
				
			} else {
				if (d.x == 0 && d.x < a.length - 1 && a[1][d.y] == 1) return;
				if (d.x == a.length - 1 && d.x > 0 && a[d.x-1][d.y] == 1)return;
			}
			// 判断左右是否被种植
			if (d.y >= 1 && d.y < a[0].length - 1) {
				if (a[d.x][d.y - 1] == 1 || a[d.x][d.y + 1] == 1) return;
			} else {
				if (d.y == 0 && d.y < a[0].length - 1
						&& a[d.x][d.y + 1] == 1) return;
				if (d.y > 0 && d.y == a[0].length - 1
						&& a[d.x][d.y - 1] == 1)return;
			}
		}

		if (dep == b.length) {// 递归的深度
			num = ++num % 100000000;
			return;
		}
		if (curr > one.length - 1) {
			return;
		}
		int i = curr;
		// 0(...) ->1 1(...)-->2 2(...)-->3 3(...) --->4 4
		a[one[i].x][one[i].y] = 0;
		b[i] = false;// 第i颗不种，后交给下一个状态
		f(a, one, b, i + 1, dep + 1);

		// 尝试种植第i颗，后交给下一个状态
		b[i] = true;
		a[one[i].x][one[i].y] = 1;
		f(a, one, b, i + 1, dep + 1);

		// 回溯
		b[i] = false;
		a[one[i].x][one[i].y] = 0;
	}
}
class data {
	int x;
	int y;
}