题目描述：在三维空间中有一个物体由多个单位立方体组成，现在给出这个物体在XY、YZ、ZX面上的投影，问这样的联通物体是否存在，联通的定义是有一个公共面

解题思路：如果某一个点（x，y，z）在三个面上的投影都存在，那么在这个你放放一个单位立方体肯定是没问题的，否则一定是不能放的！！！

然后，check是否存在某个联通块的投影和给出的投影相同，存在就是yes，否则no

//#pragma comment(linker,"/STACK:102400000,102400000")
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<string>
#define ll long long
#define db double
#define PB push_back
#define lson k<<1
#define rson k<<1|1
using namespace std;

const int N = 15;

int op[][3]=
{
    {0,0,1},
    {0,0,-1},
    {0,1,0},
    {0,-1,0},
    {1,0,0},
    {-1,0,0}
};

struct node
{
    int x,y,z;
    node (int _x=0,int _y=0,int _z=0):x(_x),y(_y),z(_z){}
}q[N*N*N];

class ShadowSculpture
{
    int mp[N][N][N],n;
    bool mk[N][N][N];
    int l,r;
    char xy[N][N],yz[N][N],zx[N][N];
    bool range(int x,int y,int z)
    {
        if(x>=0&&x<n&&y>=0&&y<n&&z>=0&&z<n) return true;
        return false;
    }
    void bfs(int x,int y,int z)
    {
        mk[x][y][z]=true;
        l=r=0;
        q[r++]=node(x,y,z);
        while(l<r)
        {
            node t=q[l++];
            for(int i=0;i<6;i++)
            {
                x=t.x+op[i][0];
                y=t.y+op[i][1];
                z=t.z+op[i][2];
                if(range(x,y,z)&&mp[x][y][z]&&!mk[x][y][z])
                {
                    mk[x][y][z]=true;
                    q[r++]=node(x,y,z);
                }
            }
        }
    }
    bool check(const vector<string> &XY,const vector<string> &YZ,const vector<string> &ZX)
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            xy[i][j]=yz[i][j]=zx[i][j]='N';
        for(int i=0;i<r;i++)
        {
            node t=q[i];
            xy[t.x][t.y]=yz[t.y][t.z]=zx[t.z][t.x]='Y';
        }
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
        {
            if(xy[i][j]==XY[i][j]&&yz[i][j]==YZ[i][j]&&zx[i][j]==ZX[i][j]){}
            else return false;
        }
        return true;
    }
    bool isnull(const vector<string> &xy,const vector<string> &yz,const vector<string> &zx)
    {
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            if(xy[i][j]=='N'&&yz[i][j]=='N'&&zx[i][j]=='N'){}
            else return false;
        return true;
    }
public:
    string possible(vector <string> XY, vector <string> YZ, vector <string> ZX)
    {
        int sz=XY.size();
        n=sz;
        if(isnull(XY,YZ,ZX)) return "Possible";
        bool fl=true;
        memset(mp,0,sizeof(mp));
        memset(mk,false,sizeof(mk));
        for(int i=0;i<sz;i++)
        {
            for(int j=0;j<sz;j++)
            {
                if(XY[i][j]=='Y')
                {
                    bool tg=false;
                    for(int k=0;k<sz;k++)
                    {
                        if(YZ[j][k]=='Y')
                        {
                            tg=true;
                            if(ZX[k][i]=='Y'){
                                mp[i][j][k]=1;
                            }
                        }
                    }
                    if(!tg) fl=false;
                    if(!fl) break;
                    tg=false;
                    for(int k=0;k<sz;k++)
                    {
                        if(ZX[k][i]=='Y')
                        {
                            tg=true;
                            if(YZ[j][k]=='Y'){
                                mp[i][j][k]=1;
                            }
                        }
                    }
                    if(!tg) fl=false;
                    if(!fl) break;
                }
            }
            if(!fl) break;
        }
        if(!fl) {
                return "Impossible";
        }
        fl=false;
        for(int i=0;i<sz;i++)
        {
            for(int j=0;j<sz;j++)
            {
                for(int k=0;k<sz;k++)
                {
                    if(mp[i][j][k]&&!mk[i][j][k])
                    {
                        bfs(i,j,k);
                        if(check(XY,YZ,ZX))
                        {
                            fl=true;
                            break;
                        }
                    }
                }
                if(fl) break;
            }
            if(fl) break;
        }
        if(fl) return "Possible";
        else return "Impossible";
    }
} ;