算法提高之搜索：剪枝与与优化

0、剪枝的方法

1、小猫爬山

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

using namespace std;

const int N = 20;

int n, m;
int w[N];
int sum[N];
int ans = N;

void dfs(int u, int k)
{
    // 最优性剪枝
    if (k >= ans) return;
    if (u == n)
    {
        ans = k;
        return;
    }

    for (int i = 0; i < k; i ++ )
        if (sum[i] + w[u] <= m) // 可行性剪枝
        {
            sum[i] += w[u];
            dfs(u + 1, k);
            sum[i] -= w[u]; // 恢复现场
        }

    // 新开一辆车
    sum[k] = w[u];
    dfs(u + 1, k + 1);
    sum[k] = 0; // 恢复现场
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i ++ ) cin >> w[i];

    // 优化搜索顺序
    sort(w, w + n);
    reverse(w, w + n);

    dfs(0, 0);

    cout << ans << endl;

    return 0;
}

2、数独

/*
81个字符的字符串->在计算中变向转换成9*9的矩阵。
将变向的9*9矩阵转换到，每一行、列和九宫格的9位的01串（int） draw实现
9位的01串从右向左依次表示123456789是否存在。0表示存在，1表示不存在可填。
预处理 0~1<<8 01串中1的个数。
log2(0) log2(1) log2(8) 中的n 目的是当某个01串，首位是1，其他位是0.得到1的位置。
init->将行、列、九宫格的01串全部置成1。
draw：最初将变向的9*9矩阵转换到，每一行、列和九宫格的9位的01串。
      在dfs中设置01串中1的位置为0，以及将0的位置变成1。
lowbit：返回一个01串中，最后一个1，以及它后边的0.
*/

/*
预处理 one map为二进制优化做准备
初始化 将所有行、列、九宫格的01串全部变成1.
draw 将字符串中还有数字的地方修改到01串中。计算空格数。
dfs以空格为0试截止。先找到所有空格中分支最少的空格。
对分支最少的空格优先dfs。
*/
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 9, M = 1 << N;

//one快速求出一个状态有多少个1
//map求出1og2（n）中的n
int ones[M], map[M];
int row[N], col[N], cell[3][3];
char str[100];

//预处理行 列 九宫格 全部置为1
void init()
{
    for (int i = 0; i < N; i ++ )
        row[i] = col[i] = (1 << N) - 1;

    for (int i = 0; i < 3; i ++ )
        for (int j = 0; j < 3; j ++ )
            cell[i][j] = (1 << N) - 1;
}

//在x，y处填上t bool表示在当前位置填上一个数，还是删掉。
//填的时候是dfs的过程，删的时候是恢复现场的过程。
void draw(int x, int y, int t, bool is_set)
{
//t是0~8 变成1~9 填
    if (is_set) str[x * N + y] = '1' + t;
//删
    else str[x * N + y] = '.';

    int v = 1 << t;
    //清空
    if (!is_set) v = -v;

    row[x] -= v;
    col[y] -= v;
    cell[x / 3][y / 3] -= v;
}

int lowbit(int x)
{
    return x & -x;
}
//求x，y这个格子上能填哪些数
int get(int x, int y)
{
    return row[x] & col[y] & cell[x / 3][y / 3];
}

bool dfs(int cnt)
{
//没有空格 表示找到合法方案
    if (!cnt) return true;
//找一个分支数最小的空格 最多有9个分支，写10
    int minv = 10;
    int x, y;
    //循环结束后 xy存的是分支数量最小的节点
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j < N; j ++ )
        	//当前位置是空格应该枚举
            if (str[i * N + j] == '.')
            {
            //格子上能填的数字交集
                int state = get(i, j);
                if (ones[state] < minv)
                {
                    minv = ones[state];
                    x = i, y = j;
                }
            }

    int state = get(x, y);
    //枚举这个状态上的所有1
    for (int i = state; i; i -= lowbit(i))
    {
        int t = map[lowbit(i)];
        draw(x, y, t, true);
        if (dfs(cnt - 1)) return true;
        draw(x, y, t, false);
    }

    return false;
}

int main()
{
    for (int i = 0; i < N; i ++ ) map[1 << i] = i;
    for (int i = 0; i < 1 << N; i ++ )
        for (int j = 0; j < N; j ++ )
            ones[i] += i >> j & 1;

    while (cin >> str, str[0] != 'e')
    {
        init();
		//有多少个空位
        int cnt = 0;
        for (int i = 0, k = 0; i < N; i ++ )
            for (int j = 0; j < N; j ++, k ++ )
            //是一个数字
                if (str[k] != '.')
                {
                    int t = str[k] - '1';
                    draw(i, j, t, true);
                }
                else cnt ++ ;

        dfs(cnt);

        puts(str);
    }

    return 0;
}

3、 木棒

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

using namespace std;

const int N = 70;

int n;
//每个木棍的长度
int w[N];
//所有木棍的总和 
//每根木棒的长度
int sum, length;
//小棍是否被用过
bool st[N];

//当前枚举到哪根木棒，当前木棒的长度，开始的位置
bool dfs(int u, int cur, int start)
{
    if (u * length == sum) return true;
  //木棒的长度等于枚举的长度，开一个新的木棒
    if (cur == length) return dfs(u + 1, 0, 0);
//当前木棒中枚举每一根小棍 剪枝3-1
    for (int i = start; i < n; i ++ )
    {
    //当前木棍被用过，或者当前木棒的长度>假定木棒长度，跳过。
    //可行性剪枝
        if (st[i] || cur + w[i] > length) continue;

        st[i] = true;
        //枚举成功，找到答案，返回true
        if (dfs(u, cur + w[i], i + 1)) return true;
        st[i] = false;
		//剪枝3-3 3-4
        if (!cur || cur + w[i] == length) return false;
		//剪枝3-2
        int j = i;
        while (j < n && w[j] == w[i]) j ++ ;
        i = j - 1;
    }

    return false;
}

int main()
{
    while (cin >> n, n)
    {
        memset(st, 0, sizeof st);
        sum = 0;
		//读入所有木棍的长度
		//并计算所有木棍的总和
        for (int i = 0; i < n; i ++ )
        {
            cin >> w[i];
            sum += w[i];
        }
		//将小棍从大到小排序 剪枝2
        sort(w, w + n);
        reverse(w, w + n);
		//从小到大枚举木棒的长度
        length = 1;
        while (true)
        {
  //当木棒的长度整除总和，才按照此长度枚举 剪枝1
            if (sum % length == 0 && dfs(0, 0, 0))
            {
                cout << length << endl;
                break;
            }
            length ++ ;
        }
    }

    return 0;
}

4、 生日蛋糕

从第一层到第u层的最小体积和最小面积



ans是当前最小的表面积

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

using namespace std;

const int N = 25, INF = 1e9;

int n, m;
//前n层的体积最小值和面积最小值
int minv[N], mins[N];
//每一层的半径和高度
int R[N], H[N];

int ans = INF;
//从u层开始，已经消耗的体积是v，涂抹的表面积是s
void dfs(int u, int v, int s)
{
//可行性剪枝：当前的体积（m层~u+1层）+（1~u层）的体积>n
    if (v + minv[u] > n) return;
//最优性剪枝
    if (s + mins[u] >= ans) return;
//最优性剪枝
    if (s + 2 * (n - v) / R[u + 1] >= ans) return;
//u=0 表示收完了所有层
    if (!u)
    {
    //体积全部用完 是合法解
        if (v == n) ans = s;
        return;
    }
//枚举当前这层的半径和高度
    for (int r = min(R[u + 1] - 1, (int)sqrt(n - v)); r >= u; r -- )
        for (int h = min(H[u + 1] - 1, (n - v) / r / r); h >= u; h -- )
        {
        //是否为最底层 最底层需要加上俯视圆的面积
            int t = 0;
            if (u == m) t = r * r;
            R[u] = r, H[u] = h;
            dfs(u - 1, v + r * r * h, s + 2 * r * h + t);
        }
}

int main()
{
    cin >> n >> m;
	//计算从1层到n层的最小体积和面积
    for (int i = 1; i <= m; i ++ )
    {
        minv[i] = minv[i - 1] + i * i * i;
        mins[i] = mins[i - 1] + 2 * i * i;
    }
	//哨兵  由于r[m]<=r[m+1]-1。 为这个做准备
    R[m + 1] = H[m + 1] = INF;
	//从m层开始，当前的体积和表面积都是0 
    dfs(m, 0, 0);

    if (ans == INF) ans = 0;
    cout << ans << endl;

    return 0;
}