第二章 搜索（迭代加深 双向DFS IDA*）

加成序列（迭代加深）

问题描述

解题思路

迭代加深的模板题，相较于普通的dfs，迭代加深在每次搜索时给定了一个范围上限，若每次在搜索时超出了这个范围上限，那么就会返回false然后允许搜索的深度加1

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 105;

int res[N];
int n;

bool dfs(int u, int k) // u表示当前正在处理第u层，k表示当前迭代加深的深度
{
    //如果目前到达了k+1层，那么判断在第k层上答案是否为目标值
    if (u == k + 1)
        return res[u - 1] == n;

    bool st[N] = {0};

    //从大到小枚举前缀的组合数，将其作为本层的答案
    for (int i = u - 1; i > 0; i--)
        for (int j = i; j > 0; j--)
        {
            int s = res[i] + res[j];
            //剪枝
            if (st[s] || s > n || s <= res[u - 1])
                continue;
            //在当前状态下排除等效冗余
            st[s] = true;
            res[u] = s;
            if (dfs(u + 1, k))
                return true;
        }
    return false;
}

int main()
{
    res[1] = 1;
    while (cin >> n, n)
    {
        int depth = 1;
        //由于第一层已经确定，从第二层开始搜索，每次搜索失败则进行迭代加深
        while (!dfs(2, depth))
            depth++;
        for (int i = 1; i <= depth; i++)
            cout << res[i] << " ";
        cout << endl;
    }
    return 0;
}

送礼物（双向DFS）

问题描述

解题思路

双向dfs的思路在于将要搜索的区域一分为二，前一部分暴力枚举将每一种情况存储下来，后一部分对于枚举出的每一个值，通过二分的方式将其与第一部分的dfs相匹配，若满足题意，则更新最大值

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 50;
typedef long long LL;

int n, w, k;     //注意，k是我们划定的双向dfs的搜索范围，1~k-1为前半段dfs,k~n为后半段dfs
int wg[1 << 26]; // wg数组用于存储前半段dfs搜出来的所有的物品重量和
int g[N];
int cnt = 0;

int res = 0;

void dfs(int u, int s)
{
    if (u == k) //当搜索完第k-1个数时，将新的s填入到wg中
    {
        wg[++cnt] = s;
        return;
    }

    dfs(u + 1, s); //不选择当前物品

    if ((LL)s + g[u] <= w) //选择当前物品
        dfs(u + 1, s + g[u]);
}

void rdfs(int u, int s)
{
    if (u == n + 1) //如果n个数已经被全部枚举完了
    {               //那么我们需要在这里去二分wg数组中的答案寻找最大的且符合条件的值
        int l = 1, r = cnt;
        while (l < r)
        {
            int mid = (l + r + 1) >> 1;
            // s是后半段搜索出来的值，wg数组存的是前半段的值
            //找出符合条件的不大于最大值w的在wg数组中的最大值
            if (wg[mid] <= w - s)
                l = mid;
            else
                r = mid - 1;
        }
        res = max(res, wg[l] + s); //更新答案
        return;
    }

    rdfs(u + 1, s); //不选择当前物品

    if ((LL)s + g[u] <= w) //选择当前物品
        rdfs(u + 1, s + g[u]);
}

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

    sort(g + 1, g + n + 1, greater<int>()); //优化搜索顺序，从大到小搜索

    k = (n >> 1) + 1; //将搜索范围划分为（1~k-1）和（k~n）

    dfs(1, 0); //从下标为1的数开始搜索

    sort(wg + 1, wg + cnt + 1);

    //对wg数组进行去重
    int t = 1;
    for (int i = 2; i <= cnt; i++)
        if (wg[i] != wg[i - 1])
            wg[++t] = wg[i];
    //从第k个数开始进行反向深搜
    rdfs(k, 0);
    cout << res;
    return 0;
}

排书（IDA*）

问题描述

解题思路

IDA算法是迭代加深和A算法的结合版：一方面使用估价函数得出当前状态到达终点状态需要的最小操作数，另一方面每次限制搜索的深度。
在本道题中：估价函数是每次移动一段序列所能修复节点的最小操作数，每次最多可以修复三个节点，所以需要进行的操作数=待修复节点/ 3上取整

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 20;

int n;
int a[N], w[6][N]; // w数组用于备份当前深度下的a数组

//估价函数用于启发式搜索，估价函数的值等于当前要修的节点数的最小操作次数
int f()
{
    int res = 0;
    for (int i = 1; i < n; i++)
    {
        if (a[i] != a[i + 1] - 1)
            res++;
    }
    return (res + 2) / 3;
}

bool dfs(int depth, int max_depth) // depth表示当前搜索到的深度，max_depth表示当前允许搜索的最大深度
{
    if (depth + f() > max_depth)
        return false; //如果最终返回值大于等于当前允许的最大深度，那么直接剪枝
    if (f() == 0)
        return true; //如果最终不存在要修的节点，说明已经满足相应结果了，直接返回true

    //枚举交换的区间的长度
    for (int len = 1; len <= n; len++)
        for (int l = 1; l + len - 1 <= n; l++)
        {
            int r = l + len - 1;
            //枚举被交换区间的长度
            for (int k = r + 1; k <= n; k++)
            {
                //先备份一下a数组到w数组中去
                memcpy(w[depth], a, sizeof a);
                //接下来让y从l开始，向k走，重新调整原数组
                int y = l;
                for (int x = r + 1; x <= k; x++, y++)
                    a[y] = w[depth][x];
                for (int x = l; x <= r; x++, y++)
                    a[y] = w[depth][x];

                if (dfs(depth + 1, max_depth))
                    return true;
                memcpy(a, w[depth], sizeof a);
            }
        }
    return false;
}

void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];

    int depth = 0;
    while (depth < 5 && !dfs(0, depth))
        depth++; //每次搜索失败一次，都要迭代加深一次
    if (depth >= 5)
        puts("5 or more");
    else
        cout << depth << endl;
}

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

回转游戏（IDA*）

问题描述

解题思路

见代码

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 24;

int op[8][7] = {
    {0, 2, 6, 11, 15, 20, 22},//A
    {1, 3, 8, 12, 17, 21, 23},//B
    {10, 9, 8, 7, 6, 5, 4}//C
    {19, 18, 17, 16, 15, 14, 13},//D
    {23, 21, 17, 12, 8, 3, 1},//E
    {22, 20, 15, 11, 6, 2, 0},//F
    {13, 14, 15, 16, 17, 18, 19},//G
    {4, 5, 6, 7, 8, 9, 10}};//H

int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2};//表示对应操作的

int center[8] = {6, 7, 8, 12, 17, 16, 15, 11};
int seq[N];
int path[100];

//估价函数用于求解当前中心圈内，8-数字最大值的个数
int f()
{
    int sum[4];
    memset(sum, 0, sizeof sum);
    for (int i = 0; i < 8; i++)
        ++sum[seq[center[i]]];

    int x = 0;
    for (int i = 1; i <= 3; i++)
        x = max(x, sum[i]);

    return 8 - x;
}

// operate操作表示进行操作x，将操作x上的序列更新一遍
void operate(int x)
{
    int t = seq[op[x][0]];
    for (int i = 0; i < 6; i++)
        seq[op[x][i]] = seq[op[x][i + 1]];
    seq[op[x][6]] = t;
}

bool dfs(int depth, int max_depth, int last)
{
    if (depth + f() > max_depth)
        return false;
    if (f() == 0)
        return true;

    for (int i = 0; i < 8; i++)
    {
        //剪枝，如果反向拉，明显不是最优解
        if (opposite[i] == last)
            continue;
        operate(i);
        path[depth] = i;
        if (dfs(depth + 1, max_depth, i))
            return true;
        operate(opposite[i]);
    }
    return false;
}

int main()
{
    while (cin >> seq[0], seq[0])
    {
        for (int i = 1; i < 24; i++)
            cin >> seq[i];

        //初始时，深度为0
        int depth = 0;
        while (!dfs(0, depth, -1))
            ++depth; //若当前深度不满足要求，则迭代加深一次

        if (!depth)
            cout << "No moves needed";
        else
        {
            for (int i = 0; i < depth; i++)
                printf("%c", 'A' + path[i]);
        }
        cout << endl
             << seq[6] << endl;
    }
    return 0;
}