[CQOI2018] 解锁屏幕

Description

使用过Android手机的同学一定对手势解锁屏幕不陌生。Android的解锁屏幕由3x3个点组成，手指在屏幕上画一条

线将其中一些点连接起来，即可构成一个解锁图案。如下面三个例子所示：

画线时还需要遵循一些规则

1．连接的点数不能少于4个。也就是说只连接两个点或者三个点会提示错误。

2．两个点之间的连线不能弯曲。

3．每个点只能"使用"一次，不可重复。这里的"使用"是指手指划过一个点，该点变绿。

4．两个点之间的连线不能"跨过"另一个点，除非那个点之前已经被"使用"过了。

对于最后一条规则，参见下图的解释。左边两幅图违反了该规则：而右边两幅图(分别为2→4→1→3→6和→5→4→1→9→2)

则没有违反规则，因为在"跨过"点时，点已经被"使用"过了。

现在工程师希望改进解锁屏幕，增减点的数目，并移动点的位置，不再是一个九宫格形状，但保持上述画线的规则不变。

请计算新的解锁屏幕上，一共有多少满足规则的画线方案。

Input

输入文件第一行，为一个整数n，表示点的数目。

接下来n行，每行两个空格分开的整数xi和yi，表示每个点的坐标。

-1000≤xi,Yi≤l000，1≤n<20。各点坐标不相同

Output

输出文件共一行，为题目所求方案数除以100000007的余数。

Sample Input

4
0 0
1 1
2 2
3 3

Sample Output

8
解释：设4个点编号为1到4，方案有1→2→3→4，2→1→3→4，3→2→1→4，2→3→1→4，
及其镜像4→3→2→1,3→4→2→1,2→3→4→1,3→2→4→1.

Solution

        很明显的状压dp，记 f[i][s] 为最后走到 i 时，状态为 s 的方案数。预处理从 i 走到 j 需要先走的点的集合。

        然后从小到大枚举状态dp就可以了。

Code

#include 
#include 

#define R register
#define ll long long

using namespace std;

namespace Dntcry
{
	inline int read()
	{
		R int a = 0, b = 1; R char c = getchar();
		for(; c < '0'|| c > '9'; c = getchar()) (c == '-') ? b = -1 : 0;
		for(; c >= '0' && c <= '9'; c = getchar()) a = (a << 1) + (a << 3) + c - '0';
		return a * b;
	}
	const int Maxn = 1010, Mod = 100000007;
	int n, x[21], y[21], need[21][21], f[21][1 << 19], lim, Ans;
	bool Check(R int s)
	{
		R int res = 0;
		for(R int i = 1; i <= n; i++) if((1 << i - 1) & s) res++;
		return res > 3; 
	}
	int Min(R int a, R int b) { return a < b ? a : b; }
	int Max(R int a, R int b) { return a > b ? a : b; }
	bool atline(R int a, R int b, R int c)
	{
		if(x[c] > Max(x[a], x[b]) || x[c] < Min(x[a], x[b])) return 0;
		if(y[c] > Max(y[a], y[b]) || y[c] < Min(y[a], y[b])) return 0;
		return (y[c] - y[a]) * (x[c] - x[b]) - (y[c] - y[b]) * (x[c] - x[a]) == 0;
	}
	int Main()
	{
		n = read();
		for(R int i = 1; i <= n; i++) x[i] = read(), y[i] = read();
		lim = (1 << n) - 1;
		for(R int i = 1; i <= n; i++)
			for(R int j = 1; j <= n; j++)
				if(j != i)
					for(R int k = 1; k <= n; k++)
						if(k != i && k != j && atline(i, j, k))
							need[i][j] |= 1 << k - 1;
		for(R int i = 1; i <= n; i++) f[i][1 << i - 1] = 1;
		for(R int s = 0; s <= lim; s++)
		{
			R bool flag = Check(s);
			for(R int i = 1; i <= n; i++)
				if(f[i][s])
				{
					for(R int j = 1; j <= n; j++)
						if(!((1 << j - 1) & s)&& (need[i][j] & s) == need[i][j])
							f[j][s | (1 << j - 1)] = (f[j][s | (1 << j - 1)] + f[i][s]) % Mod;
					if(flag) Ans = (Ans + f[i][s]) % Mod;
				}
		}
		printf("%d\n", Ans);
		return 0;
	}
}
int main() { return Dntcry :: Main(); }