DFS和BFS算法总结

1.DFS

以走迷宫为例子，DFS（深度优先搜索），碰到岔道时候，选择其中一条，直到碰到死路再回头，重新选择。 //可用堆栈实现

const int maxn=1000;
int w[maxn],v[maxn];
int maxW,maxV;

void DFS(int index,int sumW,int sumV)
{
    if(index==n)
        return;
    
    DFS(index+1,sumW,sumV);
    
    if(sumW+w[index]<=maxW)
    {
        if(sumV+v[index]>manV)
            maxV=sumV+v[index];
        DFS(index+1,sumW+w[index],sumV+v[index]);
    }
} 

选择K个数，使这几个数的和为X，并且其平方和最大
int K,X;  //选择K个数  恰好为X
int maxsumSqu=-1;
vector<int> temp,ans;
void DFS(int index,int nowK,int sum,int sumSqu)
{
    if(nowK==K&&sum==X)
    {
        if(sumSqu>maxsumSqu)
        {
            maxsumSqu=sumSqu;
            ans=temp;
        }
        return ;
    }
    
    if(index==n||nowK>K||sum>x)
        return;
    
    temp.push_back(A[index]);
    DFS(index+1,nowK+1,sum+A[index],sumSqu+A[index]*A[index]);
    
    temp.pop_back();
    DFS(index+1,nowK,sum,sumSqu);

}

2.BFS

BFS可对比于波纹，一层一层的访问，先访问根节点，再访问根结点能达到的所有结点，直至到达终点。 //可用队列实现

可解决连接块数问题，有几个连通块
1 1 1 1 0 0 1
0 0 0 0 1 1 0
1 1 1 0 1 1 0
1 1 1 1 0 0 0
1 0 0 0 1 1 1
0 1 1 1 0 0 0

void BFS(Node s)
{
    queue<Node> q;
    q.push(s)
    while(!q.empty())
    {
        Node temp=q.front();
        q.pop();
        将结点temp能到达的结点入列
        设置为已经入队列
    }
}