Folding a Cube

最新推荐文章于 2024-10-15 09:21:11 发布

soul,,,明灵

最新推荐文章于 2024-10-15 09:21:11 发布

阅读量216

点赞数

分类专栏：水题文章标签： c++

本文链接：https://blog.youkuaiyun.com/soul_mingling/article/details/108597639

版权

水题专栏收录该内容

31 篇文章

订阅专栏

本文探讨了一个有趣的问题：如何判断六个相连的单位正方形是否能通过折叠形成一个单位立方体。通过对各种可能的形状进行分析，文章提供了一种算法来解决这个问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Folding a Cube

题目描述
It is well known that a set of six unit squares that are attached together in a “cross” can be folded into a cube.

在这里插入图片描述

But what about other initial shapes? That is, given six unit squares that are attached together along some of their sides, can we form a unit cube by folding this arrangement?
输入
Input consists of 6 lines each containing 6 characters, describing the initial arrangement of unit squares.
Each character is either a ., meaning it is empty, or a # meaning it is a unit square.
There are precisely 6 occurrences of # indicating the unit squares. These form a connected component,meaning it is possible to reach any # from any other # without touching a . by making only horizontal and vertical movements. Furthermore, there is no 2 × 2 subsquare consisting of only #. That is, the pattern

does not appear in the input.
输出
If you can fold the unit squares into a cube, display can fold. Otherwise display cannot fold.
样例输入
【样例1】
…
…

…
…
…
【样例2】
…
#…
####…
#…
…
…
【样例3】
…##…
…#…
…##…
…#…
…
…
【样例4】
…
…#…
…#…
…###.
…#…
…
样例输出
【样例1】
cannot fold
【样例2】
can fold
【样例3】
cannot fold
【样例4】
can fold
题目大意：
#代表正方形纸片，问将这些纸片折起来，能不能构成一个正方体。
在这里插入图片描述

只有这十一种方式，不要漏了就好。

#pragma GCC optimize(3,"Ofast","inline")
#pragma G++ optimize(3)
#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
typedef queue<int> q_i;
typedef queue<string> q_s;
typedef queue<double> q_d;
typedef queue<ll> q_ll;
typedef queue<char> q_c;
typedef priority_queue<int> pq_i;
typedef priority_queue<string> pq_s;
typedef priority_queue<double> pq_d;
typedef priority_queue<ll> pq_ll;
typedef stack<int> s_i;
typedef stack<string> s_s;
typedef stack<double> s_d;
typedef stack<ll> s_ll;
typedef stack<char> s_c;
typedef map<ll,ll> m_ll_ll;
typedef map<int,ll> m_i_ll;
typedef map<int,int> m_i_i;
typedef map<string,ll> m_s_ll;
typedef map<char,int> m_c_i;
typedef map<char,ll> m_c_ll;
const ll INF=0x3f3f3f3f;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define per(i,l,r) for(ll i=r;i>=l;i--)
#define eif else if
#define N 100005
#define mm(dp) memset(dp,0,sizeof(dp))
#define mm1(dp) memset(dp,-1,sizeof(dp))
#define mm2(dp) memset(dp,0x3f,sizeof(dp))
#define IT set<int>::iterator
#define fs(n) fixed<< setprecision(n)
//const double e=2.71828182845;
#define max(a,b) a>b?a:b
#define min(a,b) a<b?a:b
const double pi = acos(-1.0);
const int p=1e9+7;
inline ll read()
{
    ll s=0,w=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
        s=s*10+ch-'0',ch=getchar();
    return s*w;
}
inline void write(ll x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+'0');
}
float SqrtByCarmack( float number )
{
    int i;
    float x2, y;
    const float threehalfs = 1.5F;
    x2 = number * 0.5F;
    y  = number;
    i  = * ( int * ) &y;
    i  = 0x5f375a86 - ( i >> 1 );
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    return number*y;
}
ll qpow(ll a,ll b,ll mod)
{
    ll sum=1;
    while(b)
    {
        if(b%2==1)
        {
            sum=sum*a%mod;
        }
        b/=2;
        a=a*a%mod;
    }
    return sum;
}
int erfen(int *a,int start,int endd,int l)//小于等于l的最大值的角标
{
    int mid=(start+endd)/2;
    if((a[mid]<=l&&a[mid+1]>l)||(mid==endd&&a[mid]<=l))
        return mid;
    else if(a[mid]<=l)
        return erfen(a,mid+1,endd,l);
    else if(a[mid]>l)
    {
        if(start!=mid)
            return erfen(a,start,mid,l);
        else
            return start-1;
    }
}
ll prime[6] = {2, 3, 5, 233, 331};
ll qmul(ll x, ll y, ll mod)
{
    return (x * y - (long long)(x / (long double)mod * y + 1e-3) *mod + mod) % mod;
}
bool Miller_Rabin(ll p)
{
    if(p < 2)
        return 0;
    if(p != 2 && p % 2 == 0)
        return 0;
    ll s = p - 1;
    while(! (s & 1))
        s >>= 1;
    for(int i = 0; i < 5; ++i)
    {
        if(p == prime[i])
            return 1;
        ll t = s, m = qpow(prime[i], s, p);
        while(t != p - 1 && m != 1 && m != p - 1)
        {
            m = qmul(m, m, p);
            t <<= 1;
        }
        if(m != p - 1 && !(t & 1))
            return 0;
    }
    return 1;
}
ll gcd(ll x,ll y)
{
    if(y==0)
        return x;
    else
        return gcd(y,x%y);
}
const int MAXN=100010;
const int M=MAXN*30;
int n,q,tot,m;
int a[MAXN],t[MAXN];
int T[MAXN],lson[M],rson[M],c[M];
void Init_hash()
{
    for(int i=1;i<=n;i++)
    {
        t[i]=a[i];
    }
    sort(t+1,t+1+n);
    m=(int)(unique(t+1,t+1+n)-t-1);
}
int build(int l,int r)
{
    int root=tot++;
    c[root]=0;
    if(l!=r)
    {
        int mid=(l+r)>>1;
        lson[root]=build(l,mid);
        rson[root]-build(mid+1,r);
    }
    return root;
}
int hash_(int x)
{
    return (int)(lower_bound(t+1,t+1+m,x)-t);
}
int update(int root,int pos,int val)
{
    int newroot=tot++,tmp=newroot;
    c[newroot]=c[root]+val;
    int l=1,r=m;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(pos<=mid)
        {
            lson[newroot]=tot++;
            rson[newroot]=rson[root];
            newroot=lson[newroot];
            root=lson[root];
            r=mid;
        }
        else
        {
            rson[newroot]=tot++;
            lson[newroot]=lson[root];
            newroot=rson[newroot];
            root=rson[root];
            l=mid+1;
        }
        c[newroot]=c[root]+val;
    }
    return tmp;
}
int query(int left_root,int right_root,int k)
{
    int l=1,r=m;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(c[lson[left_root]]-c[lson[right_root]]>=k)
        {
            r=mid;
            left_root=lson[left_root];
            right_root=lson[right_root];
        }
        else
        {
            l=mid+1;
            k-=c[lson[left_root]]-c[lson[right_root]];
            left_root=rson[left_root];
            right_root=rson[right_root];
        }
    }
    return l;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    string str[7];
    int a[7][7];
    mm(a);
    rep(i,1,6)
    {
        cin>>str[i];
        str[i]=" "+str[i];
        rep(j,1,6)
        {
            if(str[i][j]=='#')
                a[i][j]=1;
        }
    }
    int flag=0;
    rep(i,2,5)
    {
        if(a[i][1]+a[i][2]+a[i][3]+a[i][4]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,1,4)
            {
                if(a[i-1][j]==1)
                    nm=1;
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[i][5]+a[i][2]+a[i][3]+a[i][4]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,2,5)
            {
                if(a[i-1][j]==1)
                    nm=1;
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[i][5]+a[i][6]+a[i][3]+a[i][4]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,3,6)
            {
                if(a[i-1][j]==1)
                    nm=1;
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
    }
 
 
    rep(i,2,5)
    {
        if(a[1][i]+a[2][i]+a[3][i]+a[4][i]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,1,4)
            {
                if(a[j][i-1]==1)
                    nm=1;
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[5][i]+a[2][i]+a[3][i]+a[4][i]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,2,5)
            {
                if(a[j][i-1]==1)
                    nm=1;
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[5][i]+a[6][i]+a[3][i]+a[4][i]==4)
        {
            int nm=0;
            int nm1=0;
            rep(j,3,6)
            {
                if(a[j][i-1]==1)
                    nm=1;
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
    }
 
 
 
    rep(i,2,5)
    {
        if(a[1][i]+a[2][i]+a[3][i]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[3][i-1]+a[4][i-1]==2)
                nm=1;
            rep(j,1,3)
            {
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[3][i+1]+a[4][i+1]==2)
                nm=1;
            rep(j,1,3)
            {
                if(a[j][i-1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[4][i]+a[2][i]+a[3][i]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[5][i-1]+a[4][i-1]==2)
                nm=1;
            if(a[1][i-1]+a[2][i-1]==2)
                nm=1;
            rep(j,2,4)
            {
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[5][i+1]+a[4][i+1]==2)
                nm=1;
            if(a[1][i+1]+a[2][i+1]==2)
                nm=1;
            rep(j,2,4)
            {
                if(a[j][i-1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[5][i]+a[4][i]+a[3][i]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[5][i+1]+a[6][i+1]==2)
                nm=1;
            if(a[3][i+1]+a[2][i+1]==2)
                nm=1;
            rep(j,3,5)
            {
                if(a[j][i-1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[5][i-1]+a[6][i-1]==2)
                nm=1;
            if(a[3][i-1]+a[2][i-1]==2)
                nm=1;
            rep(j,3,5)
            {
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[4][i]+a[5][i]+a[6][i]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[3][i-1]+a[4][i-1]==2)
                nm=1;
            rep(j,4,6)
            {
                if(a[j][i+1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[3][i+1]+a[4][i+1]==2)
                nm=1;
            rep(j,4,6)
            {
                if(a[j][i-1]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
 
    }
 
    rep(i,2,5)
    {
        if(a[i][1]+a[i][2]+a[i][3]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[i-1][3]+a[i-1][4]==2)
                nm=1;
            rep(j,1,3)
            {
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[i+1][3]+a[i+1][4]==2)
                nm=1;
            rep(j,1,3)
            {
                if(a[i-1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[i][4]+a[i][2]+a[i][3]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[i-1][5]+a[i-1][4]==2)
                nm=1;
            if(a[i-1][1]+a[i-1][2]==2)
                nm=1;
            rep(j,2,4)
            {
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[i+1][5]+a[i+1][4]==2)
                nm=1;
            if(a[i+1][1]+a[i+1][2]==2)
                nm=1;
            rep(j,2,4)
            {
                if(a[i-1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[i][4]+a[i][5]+a[i][3]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[i-1][5]+a[i-1][6]==2)
                nm=1;
            if(a[i-1][3]+a[i-1][2]==2)
                nm=1;
            rep(j,3,5)
            {
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[i+1][5]+a[i+1][6]==2)
                nm=1;
            if(a[i+1][3]+a[i+1][2]==2)
                nm=1;
            rep(j,3,5)
            {
                if(a[i-1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
        if(a[i][4]+a[i][5]+a[i][6]==3)
        {
            int nm=0;
            int nm1=0;
            if(a[i-1][3]+a[i-1][4]==2)
                nm=1;
            rep(j,4,6)
            {
                if(a[i+1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
 
            nm=0;
            nm1=0;
            if(a[i+1][3]+a[i+1][4]==2)
                nm=1;
            rep(j,4,6)
            {
                if(a[i-1][j]==1)
                    nm1=1;
            }
            if(nm+nm1==2)
            {
                flag=1;
                cout<<"can fold"<<'\n';
            }
        }
    }
    rep(i,1,4)
    {
        if(a[i][1]+a[i][2]+a[i+1][2]+a[i+1][3]+a[i+2][3]+a[i+2][4]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][2]+a[i][3]+a[i+1][3]+a[i+1][4]+a[i+2][4]+a[i+2][5]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][3]+a[i][4]+a[i+1][4]+a[i+1][5]+a[i+2][5]+a[i+2][6]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
 
        if(a[i][5]+a[i][6]+a[i+1][4]+a[i+1][5]+a[i+2][3]+a[i+2][4]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][4]+a[i][5]+a[i+1][3]+a[i+1][4]+a[i+2][2]+a[i+2][3]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][3]+a[i][4]+a[i+1][2]+a[i+1][3]+a[i+2][1]+a[i+2][2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
    }
    rep(i,1,4)
    {
        if(a[1][i]+a[2][i]+a[2][i+1]+a[3][i+1]+a[3][i+2]+a[4][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[2][i]+a[3][i]+a[3][i+1]+a[4][i+1]+a[4][i+2]+a[5][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[3][i]+a[4][i]+a[4][i+1]+a[5][i+1]+a[5][i+2]+a[6][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
 
        if(a[5][i]+a[6][i]+a[4][i+1]+a[5][i+1]+a[3][i+2]+a[4][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[4][i]+a[5][i]+a[3][i+1]+a[4][i+1]+a[2][i+2]+a[3][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[3][i]+a[4][i]+a[2][i+1]+a[3][i+1]+a[1][i+2]+a[2][i+2]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
    }
 
    rep(i,1,5)
    {
        if(a[i][1]+a[i][2]+a[i][3]+a[i+1][3]+a[i+1][4]+a[i+1][5]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][4]+a[i][2]+a[i][3]+a[i+1][6]+a[i+1][4]+a[i+1][5]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][4]+a[i][6]+a[i][5]+a[i+1][2]+a[i+1][4]+a[i+1][3]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[i][4]+a[i][3]+a[i][5]+a[i+1][2]+a[i+1][1]+a[i+1][3]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
    }
 
    rep(i,1,5)
    {
        if(a[1][i]+a[2][i]+a[3][i]+a[3][i+1]+a[4][i+1]+a[5][i+1]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[4][i]+a[2][i]+a[3][i]+a[6][i+1]+a[4][i+1]+a[5][i+1]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[4][i]+a[6][i]+a[5][i]+a[2][i+1]+a[4][i+1]+a[3][i+1]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
        if(a[4][i]+a[3][i]+a[5][i]+a[2][i+1]+a[1][i+1]+a[3][i+1]==6)
        {
            flag=1;
            cout<<"can fold"<<'\n';
        }
    }
    if(flag==0)
        cout<<"cannot fold"<<'\n';
    return 0;
}