BZOJ1501 [NOI2005]智慧珠游戏

最新推荐文章于 2024-05-26 19:46:54 发布
最新推荐文章于 2024-05-26 19:46:54 发布
阅读量78 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/zhouzhendong/p/BZOJ1501.html
版权

欢迎访问~原文出处——博客园-zhouzhendong

去博客园看该题解

题目（传送门）

题解

DLX  +  矩阵构建  （两个传送门）

对于这一题，矩阵的构建和数独有比较大的不同，常量表也打了很长。

我们要精确覆盖的信息有两种：

1.  每种形状限用一次

2.  每个格子限填一次

然后对于每个位置的每种形状的每个形态，建立相应的行即可。

常量表贼长。

我这样打，虽然比较长，但是有助于找茬。

代码

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
using namespace std;
const int z[12]={4,2,8,1,4,8,4,8,8,1,4,8};
const int p[12][8][4][4]={
    //A
    {
        {
            {1,1,0,0},
            {1,0,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},
            {1,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},
            {0,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,1,0,0},
            {1,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        }
    },
    //B
    {
        {
            {1,1,1,1},
            {0,0,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},
            {1,0,0,0},
            {1,0,0,0},
            {1,0,0,0}
        }
    },
    //C
    {
        {
            {1,0,0,0},//1
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,1,0},//2
            {1,0,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,0,1,0},//3
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,1,0},//4
            {0,0,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//5
            {1,0,0,0},
            {1,1,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//6
            {1,0,0,0},
            {1,0,0,0},
            {0,0,0,0}
        },
        {
            {0,1,0,0},//7
            {0,1,0,0},
            {1,1,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//8
            {0,1,0,0},
            {0,1,0,0},
            {0,0,0,0}
        }
    },
    //D
    {
        {
            {1,1,0,0},//1
            {1,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        }
    },
    //E
    {
        {
            {1,1,1,0},//1
            {1,0,0,0},
            {1,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//2
            {1,0,0,0},
            {1,1,1,0},
            {0,0,0,0}
        },
        {
            {1,1,1,0},//3
            {0,0,1,0},
            {0,0,1,0},
            {0,0,0,0}
        },
        {
            {0,0,1,0},//4
            {0,0,1,0},
            {1,1,1,0},
            {0,0,0,0}
        }
    },
    //F
    {
        {
            {1,1,1,1},//1
            {0,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,1,1},//2
            {0,0,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,1,0,0},//3
            {1,1,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,0,1,0},//4
            {1,1,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//5
            {1,1,0,0},
            {1,0,0,0},
            {1,0,0,0}
        },
        {
            {1,0,0,0},//6
            {1,0,0,0},
            {1,1,0,0},
            {1,0,0,0}
        },
        {
            {0,1,0,0},//7
            {1,1,0,0},
            {0,1,0,0},
            {0,1,0,0}
        },
        {
            {0,1,0,0},//8
            {0,1,0,0},
            {1,1,0,0},
            {0,1,0,0}
        }
    },
    //G
    {
        {
            {1,1,1,0},//1
            {1,0,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,1,0},//2
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//3
            {1,0,0,0},
            {1,1,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//4
            {0,1,0,0},
            {1,1,0,0},
            {0,0,0,0}
        }
    },
    //H
    {
        {
            {1,1,1,0},//1
            {1,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,1,0},//2
            {0,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//3
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,1,1,0},//4
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//5
            {1,1,0,0},
            {1,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//6
            {1,1,0,0},
            {1,1,0,0},
            {0,0,0,0}
        },
        {
            {0,1,0,0},//7
            {1,1,0,0},
            {1,1,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//8
            {1,1,0,0},
            {0,1,0,0},
            {0,0,0,0}
        }
    },
    //I
    {
        {
            {1,1,1,0},//1
            {0,0,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,0,1,1},//2
            {1,1,1,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,1,1,1},//3
            {1,1,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//4
            {0,1,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//5
            {1,0,0,0},
            {1,1,0,0},
            {0,1,0,0}
        },
        {
            {0,1,0,0},//6
            {1,1,0,0},
            {1,0,0,0},
            {1,0,0,0}
        },
        {
            {1,0,0,0},//7
            {1,1,0,0},
            {0,1,0,0},
            {0,1,0,0}
        },
        {
            {0,1,0,0},//8
            {0,1,0,0},
            {1,1,0,0},
            {1,0,0,0}
        }
    },
    //J
    {
        {
            {0,1,0,0},
            {1,1,1,0},
            {0,1,0,0},
            {0,0,0,0}
        }        
    },
    //K
    {
        {
            {1,0,0,0},//1
            {1,1,0,0},
            {0,1,1,0},
            {0,0,0,0}
        },
        {
            {1,1,0,0},//2
            {0,1,1,0},
            {0,0,1,0},
            {0,0,0,0}
        },
        {
            {0,1,1,0},//3
            {1,1,0,0},
            {1,0,0,0},
            {0,0,0,0}
        },
        {
            {0,0,1,0},//4
            {0,1,1,0},
            {1,1,0,0},
            {0,0,0,0}
        }
    },
    //L
    {
        {
            {1,1,1,1},//1
            {0,0,0,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,1,1,1},//2
            {1,0,0,0},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//3
            {1,1,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {0,0,0,1},//4
            {1,1,1,1},
            {0,0,0,0},
            {0,0,0,0}
        },
        {
            {1,0,0,0},//5
            {1,0,0,0},
            {1,0,0,0},
            {1,1,0,0}
        },
        {
            {1,1,0,0},//6
            {1,0,0,0},
            {1,0,0,0},
            {1,0,0,0}
        },
        {
            {1,1,0,0},//7
            {0,1,0,0},
            {0,1,0,0},
            {0,1,0,0}
        },
        {
            {0,1,0,0},//8
            {0,1,0,0},
            {0,1,0,0},
            {1,1,0,0}
        }
    }
};
/**********************************************************/
const int N=4000,M=100,S=N*7+M;
//构建矩阵： 每个格子一个，每个形状一个 
struct DLX{
    int n,m,cnt;
    int x[S],y[S],L[S],R[S],U[S],D[S];
    int C[M],anscnt,ans[N];
    void init(int c){
        memset(x,0,sizeof x),memset(y,0,sizeof y);
        memset(L,0,sizeof L),memset(R,0,sizeof R);
        memset(U,0,sizeof U),memset(D,0,sizeof D);
        memset(C,0,sizeof C),memset(ans,0,sizeof ans);
        anscnt=0,m=c;
        for (int i=0;i<=m;i++)
            L[i]=i-1,R[i]=i+1,U[i]=D[i]=i;
        L[0]=m,R[m]=0,cnt=m;
    }
    void link(int i,int j){
        cnt++;
        x[cnt]=i;
        y[cnt]=j;
        L[cnt]=cnt-1;
        R[cnt]=cnt+1;
        D[cnt]=j;
        D[U[j]]=cnt;
        U[cnt]=U[j];
        U[j]=cnt;
        C[j]++;
    }
    void Delete(int k){
        L[R[k]]=L[k];
        R[L[k]]=R[k];
        for (int i=D[k];i!=k;i=D[i])
            for (int j=R[i];j!=i;j=R[j]){
                U[D[j]]=U[j];
                D[U[j]]=D[j];
                C[y[j]]--;
            }
    }
    void Reset(int k){
        L[R[k]]=k;
        R[L[k]]=k;
        for (int i=U[k];i!=k;i=U[i])
            for (int j=L[i];j!=i;j=L[j]){
                U[D[j]]=j;
                D[U[j]]=j;
                C[y[j]]++;
            }
    }
    bool solve(){
        if (R[0]==0)
            return true;
        anscnt++;
        int k=R[0];
        for (int i=R[k];i!=0;i=R[i])
            if (C[i]<C[k])
                k=i;
        Delete(k);
        for (int i=D[k];i!=k;i=D[i]){
            ans[anscnt]=x[i];
            for (int j=R[i];j!=i;j=R[j])
                Delete(y[j]);
            if (solve())
                return true;
            for (int j=L[i];j!=i;j=L[j])
                Reset(y[j]);
        }
        Reset(k);
        anscnt--;
        return false;
    }
}dlx;
const int L=15,n=10;
int Row;
char ch[L][L];
bool matched[12];
struct PIC{
    int x,y,i,j;
}built[N];
bool match(int x,int y,int i,int j){
    char CHAR=i+'A';
    for (int a=0;a<4;a++)
        for (int b=0;b<4;b++)
            if (p[i][j][a][b]&&(x+a>n||y+b>x+a||ch[x+a][y+b]!=CHAR))
                return 0;
    return 1;
}
bool nmatch(int x,int y,int i,int j){
    for (int a=0;a<4;a++)
        for (int b=0;b<4;b++)
            if (p[i][j][a][b]&&(x+a>n||y+b>x+a||ch[x+a][y+b]!='.'))
                return 0;
    return 1;
}
int hash(int a,int b){
    return a*(a-1)/2+b;
}
void build(int x,int y,int i,int j){
    Row++;
    built[Row].x=x;
    built[Row].y=y;
    built[Row].i=i;
    built[Row].j=j;
    int first=dlx.cnt+1;
    for (int a=0;a<4;a++)
        for (int b=0;b<4;b++)
            if (p[i][j][a][b])
                dlx.link(Row,hash(x+a,y+b));
    dlx.link(Row,55+i+1);
    dlx.L[first]=dlx.cnt;
    dlx.R[dlx.cnt]=first;
}
void addPIC(int x,int y,int i,int j){
    char CHAR=i+'A';
    for (int a=0;a<4;a++)
        for (int b=0;b<4;b++)
            if (p[i][j][a][b])
                ch[x+a][y+b]=CHAR;
}
int main(){
    for (int i=1;i<=n;i++)
        scanf("%s",ch[i]+1);
    dlx.init(55+12);
    memset(matched,0,sizeof matched);
    Row=0;
    for (int i=1;i<=n;i++)
        for (int j=1,imat=0;j<=i;imat=0,j++)
            for (int x=0;x<12&&!imat;x++)
                for (int y=0;y<z[x]&&!imat;y++)
                    if (match(i,j,x,y)){
                        matched[x]=imat=1;
                        build(i,j,x,y);
                    }
    for (int i=1;i<=n;i++)
        for (int j=1;j<=i;j++)
            for (int x=0;x<12;x++){
                if (matched[x])
                    continue;
                for (int y=0;y<z[x];y++)
                    if (nmatch(i,j,x,y))
                        build(i,j,x,y);
            }
    bool found=dlx.solve();
    if (!found)
        printf("No solution");
    else {
        for (int i=1;i<=dlx.anscnt;i++){
            int bh=dlx.ans[i];
            if (!matched[built[bh].i])
                addPIC(built[bh].x,built[bh].y,built[bh].i,built[bh].j);
        }
        for (int i=1;i<=n;puts(""),i++)
            for (int j=1;j<=i;j++)
                printf("%c",ch[i][j]);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/zhouzhendong/p/BZOJ1501.html

weixin_30699465
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[DLX] [NOI2005] 智慧珠游戏
drj
09-24 1163
具体题目详见 NOI2005 第一试试题。 这显然是一个 NP 问题。怎么做呢？答案很明显，搜索。 说到搜索，这道题所要求的并不是最优解，也不是方案数，而且数据保证如果有解则只有一组解。 然后再对照这个题目：用所有的“智慧珠”来填满棋盘中每一个空。 想到了什么？对，精确覆盖模型。用每一个智慧珠和棋盘中的每一空为列，以智慧珠翻转和旋转所得的 60 个形态在每一个位置上的填补为行，即可。 顺
wangjunrui666#bzoj-problem##3240. [Noi2013]矩阵游戏1
07-25
她生成的这个矩阵满足一个神奇的性质：若用F[i][j]来表示矩阵中第i行第j列的元素，则F[i][j]满足下面的递推式:递推式中a,b,c,d都是给定的常数。由
【洛谷P4205】智慧珠游戏【dfs】
stoorz
10-29 1134
题目大意： 题目链接：https://www.luogu.org/problem/P4205 智慧珠游戏拼盘由一个三角形盘件和 12 个形态各异的零件组成。拼盘的盘 件如图 1 所示 可以放到盘件的任一位置，条件是能有地方放，且 尺寸合适，所有的零件都允许旋转(0º、90º、180º、270º)和翻转(水平、竖直)。 现给出一个盘件的初始布局，求一种可行的智慧珠摆放方案，使所有的零件 都能放...
【BZOJ1501】【NOI2005】智慧珠游戏（搜索）
小蒟蒻yyb的博客
02-27 392
[BZOJ1501][NOI2005]智慧珠游戏（搜索）题面我要一改我懒惰的作风这道题目必须放题面DescriptionInput文件中包含初始的盘件描述，一共有10行，第i行有i个字符。如果第i行的第j个字符是字母”A”至”L”中的一个，则表示第i行第j列的格子上已经放了零件，零件的编号为对应的字母。如果第i行的第j个字符是”.”，则表示第i行第j列的格子上没有放零件。输入保证预放的零件已摆放在盘
Luogu P4205 [NOI2005]智慧珠游戏
weixin_30240349的博客
10-17 243
P4205 [NOI2005]智慧珠游戏 题意 题目描述 智慧珠游戏拼盘由一个三角形盘件和\(12\)个形态各异的零件组成。拼盘的盘 件如图\(1\)所示 对于由珠子构成的零件，可以放到盘件的任一位置，条件是能有地方放，且尺寸合适，所有的零件都允许旋转(\(0º,90º,180º,270º\))和翻转(水平、竖直)。 现给出一个盘件的初始布局，求一种可行的智慧珠摆放方案，使所有的零件都能放进...
BZOJ 1501 NOI2005 智慧珠游戏 Dancing-Links(DLX)
世界
09-05 3770
题目大意：给定一个10*10的三角形棋盘和12种零件，每种零件只能放一次，可以旋转和翻转，一些零件已经放在了上面，求一种方案，使12个零件无重叠地放在棋盘上 首先这题目一看就是DLX 但是建图真心恶心 需要枚举每一个零件的最多八个朝向的所有位置 我一开始想要全部代码处理 但是后来发现真做不了 于是我选择了打表录入12个零件的所有60种朝向，选择第一排最左面的点作为基点，依次得出每个点关于基点的
BZOJ 1501 NOI2005 智慧珠游戏（虐心搜索）
苦鬼·。
03-28 531
1501: [NOI2005]智慧珠游戏Time Limit: 5 Sec Memory Limit: 64 MB Submit: 297 Solved: 184 [Submit][Status][Discuss] DescriptionInput文件中包含初始的盘件描述，一共有10行，第i行有i个字符。如果第i行的第j个字符是字母”A”至”L”中的一个，则表示第i行第j列的格子上已经放了
BZOJ 1501([NOI2005]智慧珠游戏-DLX)
nike0good |Oier&ACMer | 熟能生巧
07-14 786
DLX，但是要考虑12个模型4种旋转是否镜像12*4*2种情况放在55个位置的情况，还有剪枝删除一些没用的 MLE卡了半天……考场上要哭晕 #include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n) for(int i=k;i<=n;i++) #def
BZOJ1501 (NOI2005 智慧珠游戏）
逗比yilong
10-08 466
传送门@百度 1501: [NOI2005]智慧珠游戏 Time Limit: 5 Sec  Memory Limit: 64 MB Description Input 文件中包含初始的盘件描述，一共有10行，第i行有i个字符。如果第i行的第j个字符是字母”A”至”L”中的一个，则表示第i行第j列的格子上已经放了零件，零件的编号为对应的字母。如
[BZOJ1501][NOI2005]智慧珠游戏
abcyan1235的博客
02-27 93
bzoj luogu sol pj难度，打表打到死。 int b[12]={4,2,8,1,4,8,4,8,8,1,4,8}; int c[12]={3,4,4,4,5,5,5,5,5,5,5,5}; 以上\(b,c\)数组分别表示每个块的旋转方式以及块的大小。这就是打表的总量。 直接按位置dfs即可。 我一开始还按块的编号dfs结果T到飞我真的太naive了 code 打表，比yyb的...
bzoj测试数据118题数据
05-07
八中OJ,又简作BZOJ,以原题巨多而著称，该数据为BZOJ上的1000-1109和1130-1139的测试数据节点，没有题目，有需要题目的可以到https://hydro.ac/d/bzoj/p网站查找对应的题目。
陈立杰历年课件和BZOJ代码
12-04
其中有WJMZBMR历年来的用的课件，还有几乎BZOJ上的所有代码，给大家提供借鉴，相信能起到帮助
wangjunrui666#bzoj-problem##3255. 一个关于序列的游戏1
07-25
第一行一个整数N，表示序列长度 第二行N个数，V1、V2VN，代表每个长度对应的分数 第三行N个数，A1、A2AN，代表初始序列的每个元素
wangjunrui666#bzoj-problem##2319. 黑白棋游戏1
07-25
第一行一个数N 第二行N个数，第i个数表示第i个01序列中黑棋的个数 第三行N个数，第i个数表示第i个01序列中白棋的个数
力扣230. 二叉搜索树中第K小的元素
LNsupermali的博客
05-24 281
力扣230. 二叉搜索树中第K小的元素
堆与堆排序算法实现分享
Mrluo386的博客
05-22 298
在计算机科学中，堆是一种特殊的完全二叉树数据结构，常被用于实现优先队列等应用场景。本文将通过一个C语言示例，详细介绍如何实现一个基于数组的大顶堆及其基本操作——包括堆的创建、插入元素（入堆）、删除最大元素（出堆）以及利用这些操作实现堆排序算法。本代码实例主要涉及到了一个Heap结构体的定义、堆的创建、元素的插入与删除，以及堆排序的整个过程。
Leetcode 3161. Block Placement Queries
最新发布
codename_cys的博客
05-26 369
Leetcode 3161. Block Placement Queries
Matlab-遗传算法
qq_45751976的博客
05-21 1085
Matlab遗传算法
洛谷 P1640 BZOJ 1854 [SCOI2010]连续攻击游戏
05-14
这道题目需要进行博弈论的思考。我们可以使用动态规划来解决这道题目。 首先，我们可以定义 $f_{i,j}$ 表示当前剩下 $i$ 到 $j$ 这些数时，当前玩家最多能获得的分数。我们可以发现，在这个状态中，当前玩家只能从 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值