算法设计与分析复习--递归与分治(一)

全排列问题

求出n个全排列

排列数字

1. 用path数组记录找到的答案
2. 使用dfs实现
3. dfs的参数是path第k个位置，当k到n时代表前n个位置填完了，就可以输出了
4. 将整个结果看成二叉树的形式，当每次到达叶结点的时候就是输出答案的时候

/*
    深度优先搜索是将一个分支走到头在返回一个节点走另一个分支，直到走完所有分支
    递归过程提供了一个栈的结构，而回复向下走之前的状态，才能往另一个分支前行
*/
#include <iostream>
using namespace std;

const int N = 8;

int path[N], n; // path[N]存放答案的路径
bool st[N];     // 存放没个数是否被用过

void dfs (int k)
{
    if (k == n) // 已经找到了一个答案
    {
        for (int i = 0; i < n; i ++) printf("%d ", path[i]);
        puts("");
        return;
    }

    for (int i = 1; i <= n; i ++)
    {
        if (!st[i])
        {
            path[k] = i;
            st[i] = true;// 向下走的过程中状态的改变回来要复原
            dfs(k + 1); // 递归时是递归下一层体现出深度（向下走的过程），递归结束就是往回走
            st[i] = false;// 出来的时候清空现场是深度优先的特点，这样就需要把所有的分支都走完
        }
    }
}

int main()
{
    cin >> n;
    dfs (0);
    return 0;
}

整数划分问题

问题描述：
将正整数n表示分成一系列正整数之和：
$$n=n_1+n_2+\dots \dots +n_k,其中n1>=n2>=\dots \dots >=nk>=1$$
正整数n的这种表示称为正整数n的划分。求正整数n的划分个数。

整数划分

分治法

我们先将6所有的划分情况求出来
另外还有两种情况是

1. 最外层的三角和括号n=m时，三角就是1括号是q(n, m - 1)
2. 就是n<m的情况，所求划分情况不能超过所求的n
   

TLE了逊呀


不过代码没有问题

动态规划法

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

int dp[N], mod = 1e9 + 7;
int n;

int main()
{
    scanf("%d", &n);
    
    dp[0] = 1;
    for (int i = 1; i <= n; i ++)
        for (int j = i; j <= n; j ++)
                dp[j] = (dp[j] + dp[j - i]) % mod;

        
    printf("%d", dp[n]);
    return 0;
}

---

复习到动态规划在补详解

二分搜索

数的范围

讲解
在区分找左边界还是右边界时是根据check函数决定的
关键点是将定义的mid点保证在需要的范围中

找左边就是 q[mid] <= x
找右边就是 q[mid] >= x 就是q[mid] 符号的范围

寻找的范围是左闭右闭
如果是l = mid 就需要在mid = l + r + 1 >> 1;
如果是r = mid 就不需要

时间复杂度分析

棋盘覆盖问题

问题描述：在正方形方格中，恰有一个方格残缺，要求用L型骨牌覆盖残缺棋盘上的所有方格且任何2个L型骨牌不得重复覆盖

棋盘特点：1）正方形——>分解为左上，右上，左下，右下四
2）残缺块：其中一个有残缺块，但是对这个残缺块外三个加上一个L骨牌后，每个小正方形都有一个残缺块了

递归，直到全部填满

数据结构：
棋盘：a[N][N], size
子棋盘：是棋盘的一部分，但是要给出左上角坐标，以及棋盘大小
特殊方格：a[dr][dc]，dr,dc是特殊方格的下标
L骨牌：将除特殊方格的且未涂色的方格全部标为依次递增的数字

代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int tile = 1; // 定义L形骨牌的最初编号
int a[50][50];//表示棋盘得到的最大程度

void ChessBoard(int tr, int tc, int dr, int dc, int size)//(tr, tc)为棋盘左上角坐标, (dr, dc)为棋盘残缺块的坐标, size为棋盘大小
{
    if (size == 1) return;//已经填完，也可以不return
    
    int s = size >> 1;
    int t = tile ++;// 骨牌标记加加
    //判断残缺块的位置进行相应的递归
    //s可以想象为将棋盘分为小棋盘后的分界线的位置

//--------------------左上------------------------------
    if (dr < tr + s && dc < tc + s)//左上有残缺块的话
        ChessBoard(tr, tc, dr, dc, s);
    else//左上没有填充块就在分界线处填充
    {
        a[tr + s - 1][tc + s - 1] = t;//标记骨牌
        ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
    }
//--------------------右上------------------------------
    if (dr < tr + s && dc >= tc + s)
        ChessBoard(tr, tc + s, dr, dc, s);
    else
    {
        a[tr + s - 1][tc + s] = t;
        ChessBoard(tr, tc + s, tr + s - 1, tc + s, s);
    }
//--------------------左下------------------------------
    if (dr >= tr + s && dc < tc + s)
        ChessBoard(tr + s, tc, dr, dc, s);
    else 
    {
        a[tr + s][tc + s - 1] = t;
        ChessBoard(tr + s, tc, tr + s, tc + s - 1, s);
    }
//--------------------右下------------------------------
    if (dr >= tr + s && dc >= tc + s)
        ChessBoard(tr + s, tc + s, dr, dc, s);
    else 
    {
        a[tr + s][tc + s] = t;
        ChessBoard(tr + s, tc + s, tr + s, tc + s, s);
    }

}

int main()
{
    int size, i, j;
    cout << "棋盘的大小: " << endl;
    cin >> size;
    
    memset(a, 0, sizeof a);//棋盘初始化
    
    int x, y;//残缺块的位置
    cout << "残缺块的位置: "<< endl;
    
    cin >> x >> y;
    ChessBoard(0, 0, x, y, size);//填充函数
    // 输出棋盘
    for (int i = 0; i < size; i ++)
    {
        for (int j = 0; j < size; j ++)
        {
            printf("%d", a[i][j]);
        }
        puts("");
    }
    return 0;
}

下一篇

算法设计与分析复习–递归与分治（二）