算法日志--PTA棋盘覆盖问题(分治算法)

前言

算法日志记录PTA

题目

在一个2^k * 2^k (k为正整数,k<=10,length=2^k)个方格组成的棋盘中,恰有一个方格与其他方格不同,称该方格为一特殊方格(其坐标为aa,bb,分别代表行坐标号和列坐标号),以及有四种L型骨牌(如下图)。求用若干块这种L型骨牌实现除该特殊点棋盘的全覆盖。(本题要求采用分治算法做)
1

2
输入格式:
输入三个数,分别是aa,bb,length.

输出格式:
输出整个棋盘。其中特殊方格填为0,然后铺棋盘的顺序为:先铺四个子棋盘交界的部分,然后递归的对每个子棋盘按照左上,右上,右下,左下的顺时针顺序铺满棋盘。每一块骨牌中三个方格数字相同,按照顺序标号,即第一块骨牌全标为1,第二块骨牌全标为2,…,以此类推。输出的每个数占4个场宽,右对齐。

输入样例:

1 1 4

表示:特殊格子为(1,1),棋盘有4行4列。

输出样例:

0 2 3 3
2 2 1 3
5 1 1 4
5 5 4 4

表示:先铺三个1(一块L型骨牌),再铺三个2,…,最后铺三个5.

代码c++:

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<iomanip>
using namespace std;
int dp[2026][2026];///棋盘最大2^k*2^k ,k=10
int v[4][2]={0,0,1,0,1,1,0,1};///四个格子基于原点的坐标
//深搜递归分治
/**
*parm
*x,y棋盘左上角坐标
*aa,ay 特殊点坐标
*k 棋盘规模 2^k*2^k
*/
int step=1;
void dfs(int x,int y,int ax,int ay,int k)
{
    int mx = x+int(pow(2,k)/2)-1;
    int my = y+int(pow(2,k)/2)-1;//找出中间点坐标

    if(k==1)
    {
        for(int i=0;i<4;i++)
        {
            int tx = x+v[i][0];
            int ty = y+v[i][1];
            if(tx!=ax||ty!=ay)dp[ty][tx]=step;//填充格子
        }
        step++;

        return;
    }
    int flag = 0;//特殊点所在的棋盘
    if(ax<=mx&&ay<=my)flag=0;//特殊点在左上棋盘
    if(ax>=(mx+1)&&ay<=my)flag=1;//特殊点在右上棋盘
    if(ax>=(mx+1)&&ay>=(my+1))flag=2;//特殊点在右下棋盘
    if(ax<=mx&&ay>=(my+1))flag=3;//特殊点在左下棋盘

    for(int i=0;i<4;i++)
            if(i!=flag)dp[my+v[i][1]][mx+v[i][0]]=step;//填充非特殊点的棋盘
    step++;
    for(int i=0;i<4;i++)
    {
        //找新棋盘的原点坐标
        int tx = mx+v[i][0];
        int ty = my+v[i][1];
        int ox = tx;
        int oy = ty;

        if(i==0)
        {
            ox =ox-pow(2,k-1)+1;
            oy =oy-pow(2,k-1)+1;
        }
        if(i==1)
        {
            oy =oy-pow(2,k-1)+1;
        }
        if(i==3)
        {
            ox =ox-pow(2,k-1)+1;
        }
        if(i!=flag)
            dfs(ox,oy,tx,ty,k-1);//非特殊点的棋盘
        else
            dfs(ox,oy,ax,ay,k-1);//特殊点的棋盘

    }
}
int main()
{


    int ax,ay,len;
    cin>>ax>>ay>>len;
    int k = 0;
    while(len>>=1)k++;
    dfs(0,0,ay-1,ax-1,k);

    for(int i=0;i<pow(2,k);i++)
    {
        for(int j=0;j<pow(2,k);j++)
            printf("%4d",dp[i][j]);
        cout<<"\n";
    }

    return 0;
}

### 棋盘覆盖问题概述 棋盘覆盖问题是经典的分治算法应用之一。在一个 \(2^n \times 2^n\) 的棋盘中,有一个特殊方格被标记为障碍物,其余部分需要通过 L 型骨牌完全覆盖而不重叠[^1]。 以下是基于分治法的棋盘覆盖问题解决方案: --- ### 算法描述 #### 输入 - 一个大小为 \(2^n \times 2^n\) 的棋盘。 - 特殊方格的位置 (x, y),表示障碍物所在位置。 #### 输出 - 使用 L 型骨牌覆盖整个棋盘的结果。 #### 思想 利用递归的方式解决问题: 1. 如果当前棋盘规模为 \(1 \times 1\),则无需进一步操作。 2. 将棋盘划分为四个子棋盘 (\(A\), \(B\), \(C\), \(D\))。 3. 判断特殊方格位于哪个子棋盘。 4. 对于不包含特殊方格的三个子棋盘,在它们的交界处放置一块 L 型骨牌,使得这三个子棋盘各少了一个可用单元格。 5. 递归处理这四个子棋盘。 --- ### C++ 实现代码 ```cpp #include <iostream> using namespace std; // 定义全局变量用于记录L型骨牌编号 int tile = 1; const int MAXN = 64; // 最大棋盘尺寸 int board[MAXN][MAXN]; // 存储棋盘状态 void chessBoard(int tr, int tc, int dr, int dc, int size) { if (size == 1) return; // 当前区域只有一个格子时结束递归 int t = tile++; // 获取新的L型骨牌编号 int half = size / 2; // 计算划分后的半边长 // 处理左上角子棋盘 if (dr < tr + half && dc < tc + half) { chessBoard(tr, tc, dr, dc, half); // 左上角含有特殊方格 } else { board[tr + half - 1][tc + half - 1] = t; // 放置L型骨牌的一部分 chessBoard(tr, tc, tr + half - 1, tc + half - 1, half); } // 处理右上角子棋盘 if (dr < tr + half && dc >= tc + half) { chessBoard(tr, tc + half, dr, dc, half); // 右上角含有特殊方格 } else { board[tr + half - 1][tc + half] = t; // 放置L型骨牌的一部分 chessBoard(tr, tc + half, tr + half - 1, tc + half, half); } // 处理左下角子棋盘 if (dr >= tr + half && dc < tc + half) { chessBoard(tr + half, tc, dr, dc, half); // 左下角含有特殊方格 } else { board[tr + half][tc + half - 1] = t; // 放置L型骨牌的一部分 chessBoard(tr + half, tc, tr + half, tc + half - 1, half); } // 处理右下角子棋盘 if (dr >= tr + half && dc >= tc + half) { chessBoard(tr + half, tc + half, dr, dc, half); // 右下角含有特殊方格 } else { board[tr + half][tc + half] = t; // 放置L型骨牌的一部分 chessBoard(tr + half, tc + half, tr + half, tc + half, half); } } void printBoard(int n) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cout << setw(3) << board[i][j]; } cout << endl; } } int main() { int n, specialX, specialY; cin >> n >> specialX >> specialY; // 输入棋盘阶数和特殊方格坐标 int size = 1 << n; // 计算棋盘实际大小 chessBoard(0, 0, specialX, specialY, size); // 开始递归填充棋盘 printBoard(size); // 打印最终结果 return 0; } ``` --- ### 关键点解析 1. **递归终止条件** 当棋盘缩小到 \(1 \times 1\) 时停止递归,因为此时无法再分割棋盘[^2]。 2. **L 型骨牌放置策略** 在每次递归调用之前,先判断特殊方格所在的象限,并在其他三个象限的交界处放置 L 型骨牌[^3]。 3. **时间复杂度** 时间复杂度为 \(O(n^2)\),其中 \(n\) 是棋盘的一条边上的格子数量。这是因为每个格子都会被访问一次并赋值。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值