ZOJ 3861 Valid Pattern Lock（深度优先遍历dfs，有限制条件的全排列）

Valid Pattern Lock

Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

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.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains an integer n (3 ≤ n ≤ 9), indicating the number of active points. The second line contains n distinct integers a₁, a₂, … a_n (1 ≤ a_i ≤ 9) which denotes the identifier of the active points.

Output

For each test case, print a line containing an integer m, indicating the number of valid pattern lock.

In the next m lines, each contains n integers, indicating an valid pattern lock sequence. The m sequences should be listed in lexicographical order.

Sample Input

1
3
1 2 3

Sample Output

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

题目大意：

手机解锁，现在给你说 有 那几个 号 ，然后 让你给出所有的可能解锁顺序，结果按字典序输出。

限制条件：

● 每个点只能走一次

●  如果两个点中间有一个点，那么，必须中间这个点走过的情况下才能将这两个点连到一块

分析思想：

既然要字典序输出，可能为是求n的全排列，只是把其中不符合条件的去掉而已，所以，递归搜索求解全排列的思想求解，不过需要将两点中间那个点表示出来，然后对两点的那个键进行判断。

这里 我用了  一个二维数组表示出来，path[x][y]  表示 x号 和 y号  中间的键是 几号，如果x 和 y 是相邻的，那么就把他赋值成 0 ，也就是 0 表示两个 是相邻的。这样搜索的时候判断一下就行了

附上代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;
int a[15];
int n;
int visit[15];
int path[15][15];
int ans[15];
int ans_n;
int Ans[500000][10];
void dfs(int x ,int t)
{
	if(t == n)
	{
		for(int i = 0;i < n;i++)
		{
			Ans[ans_n][i] = ans[i];
		}
		ans_n ++;
	}
	else
	{
		for(int i = 0;i < n;i++)
		{
			if(!visit[a[i]] && visit[path[x][a[i]]])   //  判断 x 到 a[i] 能划不能
			{
				ans[t] = a[i];
				visit[a[i]] = 1;
				dfs(a[i],t + 1);
				visit[a[i]] = 0;
			}
		}
	}
}

int main()
{
	//freopen("out.txt","w",stdout);
	memset(path,0,sizeof(path));
	path[1][3] = 2;path[3][1] = 2;       //  表示出 每两个按键之间的那个按键
	path[1][7] = 4;path[7][1] = 4;
	path[4][6] = 5;path[6][4] = 5;
	path[7][9] = 8;path[9][7] = 8;
	path[3][9] = 6;path[9][3] = 6;
	path[2][8] = 5;path[8][2] = 5;
	path[1][9] = 5;path[9][1] = 5;
	path[3][7] = 5;path[7][3] = 5;
	int t;
	cin >> t;
	while(t--)
	{
		ans_n = 0;
		scanf("%d",&n);
		for(int i = 0;i < n;i++)
		{
			scanf("%d",&a[i]);
		}
		sort(a,a + n);
		memset(visit,0,sizeof(visit));
		for(int i = 0;i < n;i++)
		{
			visit[a[i]] = 1;
			visit[0] = 1;
			ans[0] = a[i];
			dfs(a[i],1);
			visit[a[i]] = 0;
		}
		cout << ans_n << endl;
		for(int i = 0;i < ans_n;i++)
		{
			for(int j = 0;j < n;j++)
			{
				if(j > 0) printf(" ");            //  由于结果比较多，输出要用 c 语言输出，若用 c++  输出，会超时
				printf("%d",Ans[i][j]);
			}
			printf("\n");
		}
	}
	return 0;
}