机试算法模板--DFS/BFS

搜索

DFS

背包问题

//简陋版代码
#include<iostream>
using namespace std;
const int maxn = 30;
int n,V,maxValue = 0; //物品件数n，背包容量V，最大价值maxValue
int w[maxn],v[maxn];

//index为当前处理的物品的编号
//sumW和sumV分别为当前的总重量和总价值
void DFS(int index,int sumW,int sumV){
    if(index==n){ //已经完成对n件物品的选择(死胡同)
        if(sumW <= V&&sumV>maxValue){
            maxValue = sumV;
        }
        return;
    }
    //岔道口
    DFS(index+1,sumW,sumV); //不选第index件物品
    DFS(index+1,sumW+w[index],sumV+v[index]);  //选第index件物品

}
int main(){
    cin>>n>>V;
    for(int i=0;i<n;i++){
        cin>>w[i];
    }
    for(int i=0;i<n;i++){
        cin>>v[i];
    }
    DFS(0,0,0);
    cout<<maxValue<<endl;
    return 0;
}

//岔路口是:对于每个物品都有选择或者不选择两种可能
//死胡同是一旦当前所有物品的总和超过V，就需要返回最近的岔路口

• 每次都把n件物品的选择全部确定之后才去更新最大值，这样效率很低

#include <iostream>
using namespace std;
const int maxn = 30;
int n, V, maxValue = 0; //物品件数n，背包容量V，最大价值maxValue
int w[maxn], v[maxn];

//index为当前处理的物品的编号
//sumW和sumV分别为当前的总重量和总价值
void DFS(int index, int sumW, int sumV)
{
    if (index == n)
    { //已经完成对n件物品的选择(死胡同)
        return;
    }
    //岔道口
    DFS(index + 1, sumW, sumV); //不选第index件物品
    //只有加入第index件物品后未超过容量V，才能继续
    if (sumW + w[index] <= V)
    {
        if (sumV + v[index] > maxValue)
        {
            maxValue = sumV + v[index];
        }
        DFS(index + 1, sumW + w[index], sumV + v[index]); //选择第i件物品
    }
}
int main()
{
    cin >> n >> V;
    for (int i = 0; i < n; i++)
    {
        cin >> w[i];
    }
    for (int i = 0; i < n; i++)
    {
        cin >> v[i];
    }
    DFS(0, 0, 0);
    cout << maxValue << endl;
    return 0;
}

//岔路口是:对于每个物品都有选择或者不选择两种可能
//死胡同是一旦当前所有物品的总和超过V，就需要返回最近的岔路口

#include <bits/stdc++.h>
#include <vector>
using namespace std;

const int maxn = 60;
int n;
int d[maxn];
int p[maxn];
int ans = 1e10; //需要准备的金币个数

//index:当前遇见的怪物
//sum:当前的武力值
//money:当前需要的金币数
void dfs(int index, int sum, int money)
{
    if (index == n)
    {
        ans = min(ans,money);
        return;
    }
    

    //如果当前武力值大于当前怪物武力值，可以选择贿赂或者不贿赂
    if (sum >= d[index])
    {
        dfs(index + 1, sum, money);
        dfs(index + 1, sum + d[index], money + p[index]);
    }
    else //当前的武力值小于怪物武力值，只能贿赂
    {
        dfs(index + 1, sum + d[index], money + p[index]);
    }
}
int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> d[i];
    }
    for (int i = 0; i < n; i++)
    {
        cin >> p[i];
    }
    dfs(0, 0, 0);
    cout<<ans<<endl;
    return 0;
}

BFS

模板1

#include <iostream>
#include <queue>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {-1, 1, 0, 0};
const int maxn = 100;
char maze[maxn][maxn];          //迷宫矩阵
bool vis[maxn][maxn] = {false}; //记录位置(x,y)是否已入过
int n, m;                       //矩阵大小为n*m
struct node
{
    int x;
    int y;
    int step;
} S, T, Node; //开始节点，结束节点，临时节点

bool judge(int x, int y)
{
    if (x >= n || x < 0 || y >= m || y < 0)
    {
        return false;
    }
    else if (vis[x][y] == true || maze[x][y] == '*')
    {
        return false;
    }
    return true;
}
int BFS(int x, int y)
{
    queue<node> q;
    Node.x = x;
    Node.y = y;
    q.push(Node);
    vis[x][y] = true;
    while (!q.empty())
    {
        node top = q.front();
        q.pop();
        if (top.x == T.x && top.y == T.y)
        {
            return top.step;
        }
        for (int i = 0; i < 4; i++)
        {
            int nx = top.x + dx[i];
            int ny = top.y + dy[i];
            if (judge(nx, ny))
            { //如果新位置可以访问
                Node.x = nx;
                Node.y = ny;
                Node.step = top.step + 1;
                q.push(Node);
                vis[nx][ny] = true;
            }
        }
    }
    return -1; //无法到达终点时，返回-1
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> maze[i][j];
        }
    }
    cin >> S.x >> S.y >> T.x >> T.y; //起点和终点的坐标

    cout << BFS(S.x, S.y) << endl;

    return 0;
}