算法技能树——放棋子(递归)

于 2022-07-07 01:17:37 发布
阅读量349 收藏
点赞数 1
分类专栏： 笔记 文章标签： 算法 c++ 数据结构 递归
此文为笔者原创，如需转载请联系笔者:hyscc1994@foxmail.com
本文链接：https://blog.csdn.net/Scc_hy/article/details/125650105
版权

一、题目

今有6×6的棋盘，其中某些格子已预放了棋子。现在要再放上去一些，使得每行每列都正好有3颗棋子。最多有多少种放法？
在这里插入图片描述

二、数据分析

需要每次都计算行和列，所以需要做好准备工作

  • int direct_sum(int arr[6][6], int idx, char direction)数组在某个方向上的和
  • bool check_arr(int arr[6][6]) 检查每个行列上是否满足条件
int direct_sum(int arr[6][6], int idx, char direction){
    int out = 0;
    if(direction == 'r')
        for(int i=0; i<6; i++) out += arr[idx][i];
    if(direction == 'c')
        for(int i=0; i<6; i++) out += arr[i][idx];
    return out;
}

bool check_arr(int arr[6][6]){
    for(int idx=0; idx<6; idx++){
        int row_sum = 0, col_sum = 0;
        for(int nd=0; nd<6; nd++){
            row_sum += arr[idx][nd];
            col_sum += arr[nd][idx];
        }
        if(row_sum != 3 | col_sum != 3) return false;
    }
    return true;
}

void observe_1(int arr[6][6]){
    for(int r=0; r<6; r++){
        int nd = 3 - direct_sum(arr, r, 'r');
        cout << "row[ " << r << " ]: need_extra-p: " << nd << endl;

        nd = 3 - direct_sum(arr, r, 'c');
        cout << "col[ " << r << " ]: need_extra-p: " << nd << endl;
    }
}

int main(){
    int arr[6][6] = {
        {1,0,0,0,0,0}, // 2
        {0,0,1,0,1,0}, // 1
        {0,0,1,1,0,1}, // 0
        {0,1,0,0,1,0}, // 1
        {0,0,0,1,0,0}, // 2
        {1,0,1,0,0,1}  // 0
    //   1 2 0 1 1 1
    };
    observe_1(arr);
    return 0;
}

row[ 0 ]: need_extra-p: 2
col[ 0 ]: need_extra-p: 1
row[ 1 ]: need_extra-p: 1
col[ 1 ]: need_extra-p: 2
row[ 2 ]: need_extra-p: 0
col[ 2 ]: need_extra-p: 0
row[ 3 ]: need_extra-p: 1
col[ 3 ]: need_extra-p: 1
row[ 4 ]: need_extra-p: 2
col[ 4 ]: need_extra-p: 1
row[ 5 ]: need_extra-p: 0
col[ 5 ]: need_extra-p: 1

三、解题

因为存在多种填充解，显然可以用递归遍历多个路径。我们可以先用循环写出一个路径，然后再逐步改成递归

3.1 找出其中一种解

  • 逐行遍历
    • 当行上满足条件的时候直接看下一行
    • 当棋盘上已经有棋子,继续行上下一个位置
    • 当列上可以添加棋子的时候，添加棋子
int main(){
    int arr[6][6] = {
        {1,0,0,0,0,0}, // 2
        {0,0,1,0,1,0}, // 1
        {0,0,1,1,0,1}, // 0
        {0,1,0,0,1,0}, // 1
        {0,0,0,1,0,0}, // 2
        {1,0,1,0,0,1}  // 0
    //   1 2 0 1 1 1
    };

    for(int r=0; r<6; r++){
        // 逐行遍历
        for(int c=0; c<6; c++){
            // 当行上满足条件的时候直接看下一行
            if(direct_sum(arr, r, 'r') == 3 ) break;
            // 当棋盘上已经有棋子,继续
            if(arr[r][c]) continue;
            // 当列上可以添加棋子的时候，添加
            if(direct_sum(arr, c, 'c') < 3){
                arr[r][c] = 1;
            }
        }
    }
    cout << check_arr(arr) << endl;
    observe_1(arr);
    return 0;
}

3.2 递归修改

从循环中我们可以得到一个终止条件:

  • 行遍历结束 <=> r == 6
    • 在终止的时候我们需要判断下是否满足了我们的需求

几个进入下一个递归的条件:

  • 当行上满足条件的时候直接看下一行
    • direct_sum(arr, r, 'r') == 3
  • 当棋盘上已经有棋子直接下步
    • arr[r][c]
  • 当列上满足条件直接下步
    • direct_sum(arr, c, 'c') == 3

同时我们需要构建一个next_step 直接下一步的辅助递归函数，
从下列的实现我们可以看出基本是和循环一致的，仅仅是将循环的一些跳跃动作break ; continue 用if else连接。
增加了多种可能性的探索将下棋的点不落子，继续下一步

int N=0;
void final_fill_arr(int arr[6][6], int r, int c);
void next_step(int x[6][6], int r, int c)
{
if( c < 6 )
    final_fill_arr(x, r, c+1);
else
    final_fill_arr(x, r+1, 0);
};


void final_fill_arr(int arr[6][6], int r, int c){
    if(r==6){
        if(check_arr(arr)){
            N++;
            bool show_flag = true;
            if(show_flag){
                cout << " " << endl;
                show_arr(arr);
            }
        }
        return;
    }
    // 当行上满足条件的时候直接看下一行
    if(direct_sum(arr, r, 'r') == 3) final_fill_arr(arr, r + 1, 0);
    // 当棋盘上已经有棋子, 看下一步
    else if(arr[r][c])  next_step(arr, r, c);
    // 当列上可以添加则添加
    else if( direct_sum(arr, c, 'c') < 3 ){
        arr[r][c] = 1;
        next_step(arr, r, c);
        // 多种可能遍历
        arr[r][c] = 0;
        next_step(arr, r, c);
    }else{
        next_step(arr, r, c);
    }
    
}

四、完整解

# include<iostream>
# include<string>
# include<stdio.h>
using namespace std;


int direct_sum(int arr[6][6], int idx, char direction){
    int out = 0;
    if(direction == 'r')
        for(int i=0; i<6; i++) out += arr[idx][i];
    if(direction == 'c')
        for(int i=0; i<6; i++) out += arr[i][idx];
    return out;
}

bool check_arr(int arr[6][6]){
    for(int idx=0; idx<6; idx++){
        int row_sum = 0, col_sum = 0;
        for(int nd=0; nd<6; nd++){
            row_sum += arr[idx][nd];
            col_sum += arr[nd][idx];
        }
        if(row_sum != 3 | col_sum != 3) return false;
    }
    return true;
}

void observe_1(int arr[6][6]){
    for(int r=0; r<6; r++){
        int nd = 3 - direct_sum(arr, r, 'r');
        cout << "row[ " << r << " ]: need_extra-p: " << nd << endl;

        nd = 3 - direct_sum(arr, r, 'c');
        cout << "col[ " << r << " ]: need_extra-p: " << nd << endl;
    }
}

void show_arr(int arr[6][6]){
{
    for(int i=0; i<6; i++)
    {
        for(int j=0; j<6; j++) printf("%2d", arr[i][j]);
        printf("\n");
    }
    printf("\n");
}
}



int N=0;
void final_fill_arr(int arr[6][6], int r, int c);
void next_step(int x[6][6], int r, int c)
{
if( c < 6 )
    final_fill_arr(x, r, c+1);
else
    final_fill_arr(x, r+1, 0);
};


void final_fill_arr(int arr[6][6], int r, int c){
    if(r==6){
        if(check_arr(arr)){
            N++;
            bool show_flag = true;
            if(show_flag){
                cout << " " << endl;
                show_arr(arr);
            }
        }
        return;
    }
    // 当行上满足条件的时候直接看下一行
    if(direct_sum(arr, r, 'r') == 3) final_fill_arr(arr, r + 1, 0);
    // 当棋盘上已经有棋子, 看下一步
    else if(arr[r][c])  next_step(arr, r, c);
    // 当列上可以添加则添加
    else if( direct_sum(arr, c, 'c') < 3 ){
        arr[r][c] = 1;
        next_step(arr, r, c);
        arr[r][c] = 0;
        next_step(arr, r, c);
    }else{
        next_step(arr, r, c);
    }
    
}



int main(){
    int arr[6][6] = {
        {1,0,0,0,0,0}, // 2
        {0,0,1,0,1,0}, // 1
        {0,0,1,1,0,1}, // 0
        {0,1,0,0,1,0}, // 1
        {0,0,0,1,0,0}, // 2
        {1,0,1,0,0,1}  // 0
    //   1 2 0 1 1 1
    };
    show_arr(arr);
    final_fill_arr(arr, 0, 0);
    cout << N << endl;
    // show_arr(arr);
    return 0;
}

输出

 ./try
 1 0 0 0 0 0
 0 0 1 0 1 0
 0 0 1 1 0 1
 0 1 0 0 1 0
 0 0 0 1 0 0
 1 0 1 0 0 1


 1 1 0 1 0 0
 1 0 1 0 1 0
 0 0 1 1 0 1
 0 1 0 0 1 1
 0 1 0 1 1 0
 1 0 1 0 0 1


 1 1 0 1 0 0
 0 1 1 0 1 0
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 0 0 1 1 1
 1 0 1 0 0 1


 1 1 0 1 0 0
 0 1 1 0 1 0
 0 0 1 1 0 1
 0 1 0 0 1 1
 1 0 0 1 1 0
 1 0 1 0 0 1


 1 1 0 1 0 0
 0 0 1 0 1 1
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 1 0 1 1 0
 1 0 1 0 0 1


 1 1 0 0 1 0
 1 0 1 0 1 0
 0 0 1 1 0 1
 0 1 0 1 1 0
 0 1 0 1 0 1
 1 0 1 0 0 1


 1 1 0 0 1 0
 0 1 1 0 1 0
 0 0 1 1 0 1
 0 1 0 1 1 0
 1 0 0 1 0 1
 1 0 1 0 0 1


 1 1 0 0 1 0
 0 0 1 1 1 0
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 1 0 1 0 1
 1 0 1 0 0 1


 1 1 0 0 1 0
 0 0 1 1 1 0
 0 0 1 1 0 1
 0 1 0 0 1 1
 1 1 0 1 0 0
 1 0 1 0 0 1


 1 1 0 0 1 0
 0 0 1 0 1 1
 0 0 1 1 0 1
 0 1 0 1 1 0
 1 1 0 1 0 0
 1 0 1 0 0 1


 1 1 0 0 0 1
 1 0 1 0 1 0
 0 0 1 1 0 1
 0 1 0 1 1 0
 0 1 0 1 1 0
 1 0 1 0 0 1


 1 1 0 0 0 1
 0 1 1 0 1 0
 0 0 1 1 0 1
 0 1 0 1 1 0
 1 0 0 1 1 0
 1 0 1 0 0 1


 1 1 0 0 0 1
 0 0 1 1 1 0
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 1 0 1 1 0
 1 0 1 0 0 1


 1 0 0 1 1 0
 0 1 1 0 1 0
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 1 0 1 0 1
 1 0 1 0 0 1


 1 0 0 1 1 0
 0 1 1 0 1 0
 0 0 1 1 0 1
 0 1 0 0 1 1
 1 1 0 1 0 0
 1 0 1 0 0 1


 1 0 0 1 0 1
 0 1 1 0 1 0
 0 0 1 1 0 1
 1 1 0 0 1 0
 0 1 0 1 1 0
 1 0 1 0 0 1


 1 0 0 0 1 1
 0 1 1 0 1 0
 0 0 1 1 0 1
 0 1 0 1 1 0
 1 1 0 1 0 0
 1 0 1 0 0 1

16
acwing-372. 棋盘覆盖(二分图)
m0_46656833的博客
05-05 252
给定一个 N 行 N 列的棋盘，已知某些格子禁止放置。 求最多能往棋盘上放多少块的长度为 2、宽度为 1 的骨牌，骨牌的边界与格线重合（骨牌占用两个格子），并且任意两张骨牌都不重叠。 输入格式 第一行包含两个整数 N 和 t，其中 t 为禁止放置的格子的数量。 接下来 t 行每行包含两个整数 x 和 y，表示位于第 x 行第 y 列的格子禁止放置，行列数从 1 开始。 输出格式 输出一个整数，表示结果。 数据范围 1≤N≤100, 0≤t≤100 输出样例： 8 0 输出样例： 32 #include&l
算法分析与设计实验——递归与分治算法
最新发布
qq_54375829的博客
06-24 828
2、在一个2k×2k （k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。棋盘覆盖问题要求用4种不同形状的L型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。+aj 的最大值（1≤i≤j≤n），当序列中所有整数均为负整数时，其最大子段和为0。printf("请输入棋盘size大小（size为2的k次方）：");棋盘用二维数组board[size][size]表示，size=2^k。L型骨牌：个数为（4^k-1）/3，用t表示。
简单博弈树算法(nim游戏)
mahongquan的专栏
02-17 2274
简单博弈树算法(nim游戏)的python实现。 import random import treelib tagid=0 def gentag(): global tagid tagid+=1 return str(tagid) def next(c): if(c>3): return [c-1,c-2,c-3] elif (c>2): return [c-1,c
算法：棋子移动问题
Hello，Sunpro!
04-12 3551
问题： 设有2n+2个排成一排的格子，最左边两个格子是空的，其后的格子一次放入A子和B子：
算法笔记——棋子换位
艾醒的博客
11-26 840
蓝桥杯真题——棋子换位题目描述分析代码实现
[第七届蓝桥杯省赛C++B组]放棋子
代码中枢：软件工程理论与实践的桥梁
03-28 326
题目来源：第七届蓝桥杯省赛C++B组 考点标签：程序理解，dfs 题目描述： 今有 6 x 6 的棋盘格。其中某些格子已经预先放好了棋子。现在要再放上去一些，使得：每行每列都正好有3颗棋子。我们希望推算出所有可能的放法。下面的代码就实现了这个功能。 初始数组中，“1”表示放有棋子，“0”表示空白。 int N = 0; bool CheckStoneNum(int x[][6]) { f...
五大常见算法策略之——回溯策略，算法数据结构
04-07
"五大常见算法策略之回溯策略，算法数据结构" 回溯策略是一种常见的算法策略，主要用于解决复杂的组合优化问题。其核心思想是将解空间看作是一棵树的结构，从树根到其中一个叶节点的路径就是一个可能的解，根据约束...
数据结构之算法——递归
MannerXu的博客
09-02 632
递归，其实就是函数调用其本身来实现某些算法。 在非必要情况下，尽可能不用递归，而是使用迭代来进行处理。即，使用for、while、foreach等循环来取代递归。 迭代使用的是循环结构，递归使用的是选择结构。 每个递归定义必须至少有一个条件，当满足条件时递归不再进行。 递归的优点：结构更清晰，代码更简洁，更容易让人理解，从而减少代码的阅读时间。 下面是两个经典的问题，一个经典的汉诺塔问题，是递归入门的基础，一个八皇后问题，一般是回溯算法的经...
第二章——递归
weixin_55835175的博客
05-21 3095
递归的定义，递归算法，递归模型 在数学和计算机科学中，递归是指在在一个过程或函数的定义时出现调用本过程或本函数的成分。 若在函数中调用函数自身或者在过程的子部分中调用子部分自身的内容，称之为直接递归，又称自递归。若不同的函数和子过程之间互相调用，则称之为间接递归，任何间接递归都可以等价地转换为直接递归(自递归)。 如果一个递归过程或递归函数中，递归调用语句是最后一条执行语句，则称这种递归调用为尾递归。 一个有趣且经典的介绍递归的例子如下： 递归的定义：请查阅“递归的定义”。 这个例子不仅很好的体现了递归的特
西南交通大学数据结构实验报告黑白棋.doxc递归算法设计及堆栈消除递归
03-16
首先，我们来看第一个知识点——递归算法设计。实验要求实现一个黑白棋子交换的游戏，游戏的目标是通过有限步数将初始的棋盘布局（三个白子在前，三个黑子在后）转换为目标布局（三个黑子在前，三个白子在后）。游戏...
简化的围棋棋子规则（C++实现）
hhhhhhhhhk的博客
05-12 1383
笔试题
放棋子
huitoukest的专栏
04-23 697
/*今有 6 x 6 的棋盘格。其中某些格子已经预先放好了棋子。现在要再放上去一些，使得：每行每列都正好有3颗棋子(如图【1.jpg】)。   */ #include"stdio.h" #include"stdlib.h" int N = 0; bool CheckStoneNum(int x[][6]) {     for(int k=0; k     {
算法设计与分析之棋盘算法
ぁ風雲變色ぁ
11-25 1302
 开始算法学习的第一节，不断更新中...include//用一个二位整形数组Board表示棋盘。Board【0】【0】是棋盘的左上角方格。tile是算法中的一个全局整形变量，用来标识L型骨牌的编号，处置为零。//tr：左上方格行号；//tc：左上方格列号；//dr：特殊方格行号//dc：特殊方格列号；//时间复杂度：T(k)={k=0 O(1);k>0 4T(k-1)+O(1);}程序
递归问题之象棋中卒行走路线
qq_49750651的博客
09-23 250
一、什么是递归 首先我们来介绍一下什么是递归，递归就是程序自己调用自己的过程。我们知道一个自定义函数可以调用其余的自定义方法，当这个函数调用其自己的时候即为递归。 二、如何解决递归算法 我们已经了解了什么是递归，那么自然而然的就会想到如何解，会有什么思路来解此类问题，在此我总结了三个步骤，如下： 1.当n = 1（或n = 2）时会出现哪些情况。 2.寻找第n项与第n - 1项存在的关系。（在此不明白没有关系，下面我会利用该题具体解释）。 3.寻找边界，即特殊情况...
练习题讲解-【搜索算法】置棋问题
Lucky_Glass的C++之旅
06-04 1215
【基础算法】置棋问题 在M*N的主格中任意指定X个格子构成一个棋盘，而其它格子是残缺的，不能放棋子。在任一个构成的棋盘上放置K个棋子，要求任意两个棋子不得位于同一行或同一列上。求满足条件的所有方案数。
棋盘问题（DFS&所有摆放方案）
一身清贫怎敢入繁华
04-22 941
Description 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。 每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n <= 8...
每天算法----棋盘
m0_51373056的博客
01-23 324
1.八皇后 2.dfs
放棋子--蓝桥杯
weixin_30357231的博客
04-25 105
欢迎访问我的新博客：http://www.milkcu.com/blog/ 原文地址：http://www.milkcu.com/blog/archives/1366864680.html 简述 这是2012年第三届蓝桥杯全国软件大赛预赛（C++本科组）第7题，要求将代码补全，实现“每行每列都正好有3颗棋子”的功能。 推荐链接：《2012蓝桥杯软件大赛预赛题目汇总》 题目描述 ...
棋盘覆盖 CH6801（二分图 匈牙利算法）
宇宙无敌大可爱CUU的博客
07-11 570
描述 给定一个N行N列的棋盘，已知某些格子禁止放置。求最多能往棋盘上放多少块的长度为2、宽度为1的骨牌，骨牌的边界与格线重合（骨牌占用两个格子），并且任意两张骨牌都不重叠。N≤100。 输入格式 第一行为n，t（表示有t个删除的格子） 第二行到t+1行为x,y，分别表示删除格子所在的位置 x为第x行，y为第y列，行列编号从1开始。 输出格式 一个数，即最多能放的骨牌数 样例输入 8 0 样例输出 ...
递归与分治：一维最接近点对问题详解及应用
在这个关于最接近点对问题的讨论中，我们探讨了一种在计算机科学中常用的技术——递归与分治策略。这个问题的基本目标是在一个二维平面上的n个点集合中找到距离最近的两个点对。当我们把问题简化到一维情况，即考虑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Scc_hy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值