DFS+思维-PKU Online Judge-1054:Cube

题目链接：

http://poj.openjudge.cn/practice/1054/

题目意思：

在2D空间里，有N个村庄，有N-1条路（所有的路都是水平或竖直的），使得N个村庄两两间都连通。有一个正方体，每次可以沿着路像上下左右滚动一格，如果正方体从村庄A出发滚，滚到村庄B后的六个面的状态和开始在村庄A的状态一样，则记村庄A和村庄B具有关系，求每个的村庄i,求出于它有关系的村庄的个数。

解题思路：

思维题。

发现：从点A滚动到B再从B滚动到A具有互逆过程，状态不变。所以从A->B的滚动过程可以等价的转化为从A->树根->B.如果在A和在B的状态相同记为S，则逆过来，从A到根：状态从S->ss,根到B:ss->S.所以可以等价为从根到A和同样的根到B的状态一样。

所以可以将根置为任意状态ss，DFS一遍，找到从根到任意位置的状态T，相同状态的点集表示相互具有关系。

num[i][j][k]:表示正上方为i,正前方为j,右侧面为k的状态的点数。

正方体标号时：对面的两标号之和为7.

这样当从状态x,y,z沿x轴转动时，y不变，另外四个分别为x,7-z,7-x,z，求出步数对应的下一状态即可。

同理对于y轴上的转动。

代码：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<sstream>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<ctime>
#include<bitset>
#define eps 1e-6
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define ll __int64
#define LL long long
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
#define M 1000000007
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

#define Maxn 110000

int num[10][10][10];
int cnt,n;

struct Pos
{
    int x,y,z;
}pp[Maxn];

struct Edge
{
    int v;
    int len[2];
    struct Edge * next;
}edge[Maxn<<1],*head[Maxn<<1];

void add(int a,int b,int len,int flag)
{
    ++cnt;
    edge[cnt].v=b,edge[cnt].len[flag]=len;
    edge[cnt].len[flag^1]=0; //另外一个标记为0
    edge[cnt].next=head[a];
    head[a]=&edge[cnt];

}

void dfs(int cur,int fa)
{
    int x=pp[cur].x,y=pp[cur].y,z=pp[cur].z;
    
    num[x][y][z]++;

    struct Edge * p=head[cur];

    while(p)
    {
        int v=p->v;
        if(v!=fa)
        {
            if(p->len[0]) //说明是x轴方向的
            {
                int tmp[4],tt;

                tmp[0]=x,tmp[1]=7-z,tmp[2]=7-x,tmp[3]=z; //注意是方向
                tt=((p->len[0])%4+4)%4; //求出正上方的位置，

                int xx=tmp[tt],yy=y,zz=tmp[((tt-1)%4+4)%4];

                pp[v].x=xx; //xx:表示正上方，yy:表示正前方 zz表示右侧面
                pp[v].y=yy;
                pp[v].z=zz;

                dfs(v,cur);

            }
            else   //说明y轴方向
            {
                int tmp[4],tt;

                tmp[0]=x,tmp[1]=y,tmp[2]=7-x,tmp[3]=7-y;
                tt=((p->len[1])%4+4)%4;

                int xx=tmp[tt],yy=tmp[(tt+1)%4],zz=z;

                pp[v].x=xx;
                pp[v].y=yy;
                pp[v].z=zz;

                dfs(v,cur);
            }
        }
        p=p->next;
    }

}

int main()
{
    //init();
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
            scanf("%d%d",&pp[i].x,&pp[i].y);

        memset(head,NULL,sizeof(head));
        cnt=0;

        for(int i=1;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            if(pp[a].x==pp[b].x)
            {
                add(a,b,pp[b].y-pp[a].y,1); //y值差大小
                add(b,a,pp[a].y-pp[b].y,1);
            }
            else
            {
                add(a,b,pp[b].x-pp[a].x,0); //x值差
                add(b,a,pp[a].x-pp[b].x,0);
            }
        }
        memset(num,0,sizeof(num));
        pp[1].x=1,pp[1].y=3,pp[1].z=2; //初始状态
        dfs(1,-1);
        for(int i=1;i<=n;i++)
            printf("%d\n",num[pp[i].x][pp[i].y][pp[i].z]-1);
        
    }
   return 0;
}