双向搜索(bfs,dfs)

双向搜索的基本思路：

双向搜索

从状态图上的起点和终点同时开始进行广搜或深搜，如果发现搜索的两端相遇了，那么可以认为是获得了可行解

BFS例题：

字串变换

代码：

#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <queue>
#define  SI unordered_map<string, int>
using namespace std;

const int N = 6;

int n;
string a[N], b[N];

int extend(queue<string>& q, SI& da, SI& db, string a[], string b[]){
	//一次遍历一层,大小为q.size()
    for (int k = 0, sk = q.size(); k < sk; k ++ ){
        string t = q.front(); q.pop();

        for (int i = 0; i < t.size(); i ++ )
            for (int j = 0; j < n; j ++ )
                if (t.substr(i, a[j].size()) == a[j]){//可替换
                    string state = t.substr(0, i) + b[j] + t.substr(i + a[j].size());
                    if (da.count(state)) continue;
                    //两个方向会师,一定是最小步数,直接返回即可
                    if (db.count(state)) return da[t] + 1 + db[state];
                    da[state] = da[t] + 1;
                    q.push(state);
                }
    }
    return 11;
}

int bfs(string A, string B){
    queue<string> qa, qb;//分别从起点,终点开始的队列
    SI da, db;//每个状态到起点的距离da(哈希表),每个状态到终点的距离db(哈希表)
    qa.push(A), da[A] = 0;
    qb.push(B), db[B] = 0;

    while (qa.size() && qb.size()) {
        int t;
		//看从上到下还是从下到上好
        if (qa.size() <= qb.size()) t = extend(qa, da, db, a, b);
        else t= extend(qb, db, da, b, a);
		//找到了
        if (t <= 10) return t;
    }
	//找不到
    return 11;
}

int main(){
    string A, B;
    cin >> A >> B;
    while (cin >> a[n] >> b[n]) n ++ ;

    int step = bfs(A, B);
    if (step > 10) puts("NO ANSWER!");
    else printf("%d\n", step);

    return 0;
}

DFS例题：

送礼物

思路：

双向搜索，先将一部分的礼物能出现的组合打表，对于后一部分，搜索到一种组合后，再在前一部分的组合中找合适的组合，两个组合加起来重量<=w，取max就是答案

代码：

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

using namespace std;

typedef long long LL;

const int N = 46;

int n, m, k;
int w[N];
int weights[1 << 25], cnt = 1;
int ans;

void dfs1(int u, int s){//第一次爆搜
    if (u == k){
        weights[cnt ++ ] = s;
        return;
    }
    dfs1(u + 1, s);//不放
    if ((LL)s + w[u] <= m) dfs1(u + 1, s + w[u]);//放进去(带剪枝)
}

void dfs2(int u, int s){
    if (u == n){
        int l = 0, r = cnt - 1;
        while (l < r){
            int mid = l + r + 1 >> 1;
            if ((LL)s + weights[mid] <= m) l = mid;
            else r = mid - 1;
        }
        ans = max(ans, s + weights[l]);
        return;
    }
    dfs2(u + 1, s);//不放
    if ((LL)s + w[u] <= m) dfs2(u + 1, s + w[u]);//放进去(带剪枝)
}

int main(){
    cin >> m >> n;
    for (int i = 0; i < n; i ++ ) cin >> w[i];
    sort(w, w + n);
    reverse(w, w + n);
    //实践出真理,用n/2+2代替n/2竟然可以快500+ ms
    k = n / 2 + 2;
    dfs1(0, 0);
    sort(weights, weights + cnt);
	//去重+得到数量(unique返回类似指针的迭代器)
    cnt = unique(weights, weights + cnt) - weights;
    dfs2(k, 0);
    cout << ans << endl;
    return 0;
}