ZOJ - 3861 Valid Pattern Lock（dfs或其他，两种解法）

标签：

Submit Status

Description

Pattern lock security is generally used in Android handsets instead of a password. The pattern lock can be set by joining points on a 3 × 3 matrix in a chosen order. The points of the matrix are registered in a numbered order starting with 1 in the upper left corner and ending with 9 in the bottom right corner.

A valid pattern has the following properties:

• A pattern can be represented using the sequence of points which it‘s touching for the first time (in the same order of drawing the pattern). And we call those points as active points.
• For every two consecutive points A and B in the pattern representation, if the line segment connecting A and B passes through some other points, these points must be in the sequence also and comes before A and B, otherwise the pattern will be invalid.
• In the pattern representation we don‘t mention the same point more than once, even if the pattern will touch this point again through another valid segment, and each segment in the pattern must be going from a point to another point which the pattern didn‘t touch before and it might go through some points which already appeared in the pattern.

Now you are given n active points, you need to find the number of valid pattern locks formed from those active points.

1
3
1 2 3

4
1 2 3
2 1 3
2 3 1
3 2 1

规则就是手机手势解锁的规则，用一个数组把处于两个数字中间的数字存下来，方便判断，这题有两种思路，一种是dfs，一种是枚举所有n个数的排列，判断是否符合。dfs是要记录路径的，而且路径是多条有公用的小段，这就有点难了，还好我机智的用来个int把答案存起来，可是处理起来操作较多，用时竟然比再用一个dfs还多。第二种方法很直观。

贴下两代码：

dfs

#include<cstdio>
#include<algorithm>
#include<string>
#include<cmath>
#include<iostream>
#include<cstring>
using namespace std;
int mp[12][12];
int n, kind, used[123], a[123], b[123];
int result[400000]; 
int ans;
void init()
{
	mp[1][3] = 2; mp[3][1] = 2;
	mp[1][7] = 4; mp[7][1] = 4;
	mp[1][9] = 5; mp[9][1] = 5;
	mp[2][8] = 5; mp[8][2] = 5;
	mp[3][7] = 5; mp[7][3] = 5;
	mp[3][9] = 6; mp[9][3] = 6;
	mp[4][6] = 5; mp[6][4] = 5;
	mp[7][9] = 8; mp[9][7] = 8;
}
void dfs(int cur, int x)
{
	ans = ans * 10 + cur;
	if (x == n)
	{
		kind++;
		result[kind] = ans;
		return;
	}
	for (int i = 0; i<n; i++)
	{
		if (used[a[i]] == 0 && (mp[cur][a[i]] == 0 || used[mp[cur][a[i]]] == 1))
		{
			used[a[i]] = 1;
			dfs(a[i], x + 1);
			used[a[i]] = 0;
			ans = ans / 10;
		}
	}
}

int main()
{
	int t;
	cin >> t;
	init();
	while (t--)
	{
		scanf("%d", &n);
		for (int i = 0; i<n; i++) scanf("%d", &a[i]);
		sort(a, a + n);
		memset(used, 0, sizeof(used));
		kind = 0;
		dfs(0, 0);
		
		printf("%d\n", kind);
		
		int mod;			
		for (int i = 1; i <= kind; i++)
		{
			mod = pow(10, n - 1);
			for (int j = 0; j < n-1; j++)
			{
				printf("%d " ,result[i] / mod);
				result[i] = result[i] % mod;
				mod = mod / 10;
			}
			printf("%d\n",result[i]/mod);
		}
	}
	return 0;
}

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
using namespace std;
int a[11];
int mp[11][11];
int vis[11];
int n, kind;
int result[400000][10];
void init()
{
	mp[1][3] = 2; mp[3][1] = 2;
	mp[1][7] = 4; mp[7][1] = 4;
	mp[1][9] = 5; mp[9][1] = 5;
	mp[2][8] = 5; mp[8][2] = 5;
	mp[3][7] = 5; mp[7][3] = 5;
	mp[3][9] = 6; mp[9][3] = 6;
	mp[4][6] = 5; mp[6][4] = 5;
	mp[7][9] = 8; mp[9][7] = 8;
}

bool can()
{
	int v;
	vis[a[0]] = 1;
	for (int i = 1; i < n; i++)
	{
		v = mp[a[i]][a[i - 1]];
		if (!(!vis[a[i]] && (!v || vis[v])))
			return false;
		vis[a[i]] = 1;
	}
	return true;
}

int main()
{
	int t;
	cin >> t;
	init();
	while (t--)
	{
		scanf("%d", &n);
		for (int i = 0; i<n; i++) scanf("%d", &a[i]);
		sort(a, a + n);
		kind = 0;
		do
		{
			memset(vis, 0, sizeof(vis));
			if (can())
			{
				kind++;
				for (int i = 0; i < n; i++)
					result[kind][i] = a[i];
			}
		} while (next_permutation(a, a + n));
		
		printf("%d\n", kind);
		for (int i = 1; i <= kind; i++)
		{
			for (int j = 0; j < n - 1; j++)
				printf("%d ", result[i][j]);
			printf("%d\n", result[i][n-1]);
		}
	}
}

ZOJ - 3861 Valid Pattern Lock（dfs或其他，两种解法）

标签：

原文地址：http://blog.csdn.net/qq_18738333/article/details/45068499