zoj 3861(dfs)

Valid Pattern Lock

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

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

题目描述 ：
读题读了半天，没读懂，真对自己无语，能不能灵活点，孩子。给你一张图，如图所示，然后给你一些点，将这些点相连，中途不经过其他的点可直接相连，如果经过其他的点的话，那么这些点之前已经
被连过（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.）。
想法是深搜，但是有两个点需要注意，下一步的选择，怎么去处理。由于定义的状态是位置，所以无脑地枚举了24个位置，并且判断相连的点有无经过其他的点，也是枚举。
太无脑了，我们可以把数字定义为状态（其实想到了跟用深搜生成排列差不多，可是受到图的干扰，以后要想清楚，抽象好问题），然后枚举下一个可以到达的点。
由于是要按照字典序输出，先将a数组排序。接下来就是对（然后给你一些点，将这些点相连，中途不经过其他的点可直接相连，如果经过其他的点的话，那么这些点之前已经
被连过）这句话的处理。既然要能相连，要么不经过其它点，要么经过已经访问过的点。我们可以将两种情形转化为一种情况，能相连的不经过其他点的，中间给他加上已经
访问过的点，那么所有能相连的点中间都要有访问过的点，以后每次只需判断这种情况就可以。
通过预处理，将要判断的情况减少。
最后再说一句，第一次遇到这种格式错误，注意一下。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 150000
using namespace std;

int n;
int a[][];
int visit[];
int sum;
int _result[maxn][];
int result[maxn];
int b[];
void init()
{
    memset(_result,,sizeof(_result));
    sum=;
}
void dfs(int x,int _add)
{
    if(_add==n)
    {
      sum+=;
      for(int i=;i<n;i++)
       _result[sum][i]=result[i];
      return ;
    }
   for(int i=;i<=n;i++)
   {
        if(visit[  a[x][b[i]]  ]== && visit[b[i]]==)
        {
            visit[b[i]]=;
           // _visit[b[i]]=1;
            result[_add]=b[i];
            dfs(b[i],_add+);
            visit[b[i]]=;
           // _visit[b[i]]=0;
        }
   }
}

int main()
{
 /* for(int i=0;i<24;i++)

  {
  for(int j=0;j<2;j++)
    printf("%d ",walk[i][j]);
    printf("\n");
  }*/
  for(int i=;i<;i++)
    for(int j=;j<;j++)
     a[i][j]=;
      memset(visit,,sizeof(visit));
      visit[]=;
   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

   a[][]=;
   a[][]=;

    int T;
    scanf("%d",&T);
    while(T--)
    {
      init();
      scanf("%d",&n);
      int data;
      for(int i=;i<=n;i++)
      {
         scanf("%d",&b[i]);
      }
      sort(b+,b+n+);

      for(int i=;i<=n;i++)
       {
          result[]=b[i];
           visit[b[i]]=;
          dfs(b[i],);
           visit[b[i]]=;
       }

       printf("%d\n",sum);
       for(int i=;i<=sum;i++)
        {
           printf("%d",_result[i][]);
          for(int j=;j<n;j++)
          printf(" %d",_result[i][j]);
          printf("\n");
        }

    }

    return ;
}

下面是没有预处理的减少判断的，而且傻逼了的想法。

不过可以进行优化，判断下一个状态与当前状态之间有无其他点，

如果没有可以访问下一个点，如果有，判断是否被访问。而判断是否

被访问，可以通过预处理，判断只需O(1)时间,极大简化代码，缩短时间。

在过程中判断，情况太多。

#include <iostream>

#include <cstdio>
#include <cstring>
#define maxn 100000
using namespace std;

int a[][];;
int n;
int visit[][];
int sum;
int _result[maxn][];
int result[maxn];
int t1,t2;
int walk[][]={
 -,-, -,-, -,, -,, -,,
 -,-, -,-, -,, -,, -,,
 ,-,  ,-,        ,,  ,,
 ,-,  ,-,  ,,  ,,  ,,
 ,-,  ,-,  ,,  ,,  ,
 };
void init()
{
   memset(visit,,sizeof(visit));
   for(int i=;i<;i++)
    for(int j=;j<;j++)
     a[i][j]=-;
    memset(_result,,sizeof(_result));
    sum=;
    t1=;
    t2=;
}
void dfs(int x,int y,int _add)
{
    if(_add==n)
    {
      sum+=;
      for(int i=;i<n;i++)
       _result[sum][i]=result[i];
      return ;
    }
   int xx,yy;
   for(int i=;i<;i++)
   {
      xx=x+walk[i][];
      yy=y+walk[i][];
      if(xx>= && xx<= && yy>= && yy<= && a[xx][yy]!=-)
      {
         if(x==xx && yy-y==)
         {
            if(visit[x][y+]==)
            continue ;
            else
            {
              result[_add]=a[xx][yy];
              dfs(xx,yy,_add+);
            }
         }
         else if(x==xx && y-yy==)
         {
            if(visit[x][y-]==)
            continue ;
            else
            {
              result[_add]=a[xx][yy];
              dfs(xx,yy,_add+);
            }

         }
         else if(y==yy && xx-x==)
         {
            if(visit[x][x+]==)
            continue ;
            else
            {
              result[_add]=a[xx][yy];
              dfs(xx,yy,_add+);
            }
         }
         else if(y==yy && x-xx==)
         {
            if(visit[x][x-]==)
            continue ;
            else
            {
              result[_add]=a[xx][yy];
              dfs(xx,yy,_add+);
            }
         }

         else if(
                    (x== &&  y== && xx== && yy==)
                    || (x== && y== && xx== && yy==)
                    || (x== && y== && xx== && yy==)
                    || (x== && yy== && xx== && yy==)
                )
         {
               if(visit[][]==)
               continue ;
              else
             {
               result[_add]=a[xx][yy];
               dfs(xx,yy,_add+);
             }
         }

        else if(visit[xx][yy]==)
         {
            visit[xx][yy]=;
            result[_add]=a[xx][yy];
            dfs(xx,yy,_add+);
            visit[xx][yy]=;
         }
      }
   }
}

int main()
{
 /* for(int i=0;i<24;i++)

  {
  for(int j=0;j<2;j++)
    printf("%d ",walk[i][j]);
    printf("\n");
  }*/

    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
      scanf("%d",&n);
      int data;
      for(int i=;i<=n;i++)
      {
         scanf("%d",&data);
         if(data==)
          a[][]=data;
         if(data==)
          a[][]=data;
         if(data==)
          a[][]=;
         if(data==)
          a[][]=;
         if(data==)
          a[][]=;
         if(data==)
          a[][]=;
         if(data==)
          a[][]=;
          if(data==)
          a[][]=;
          if(data==)
          a[][]=;
      }
      for(int i=;i<=;i++)
       for(int j=;j<=;j++)
       {
         if(a[i][j]!=-)
         {
            result[]=a[i][j];
            visit[i][j]=;
            dfs(i,j,);
            visit[i][j]=;
         }
       }
       printf("%d\n",sum);
       for(int i=;i<=sum;i++)
        {
            printf("%d",_result[i][]);
          for(int j=;j<n;j++)
          printf(" %d",_result[i][j]);
          printf("\n");
        }

    }

    return ;
}