BFS&DFS

宽度优先搜索

思想：从搜索的起点开始,不断地优先访问当前结点的邻接结点，对树而言就是其孩子结点。
数据结构：队列

类似层次遍历

题目：
初始值为N，目标值为K，0<=N<=100000,0<=K<=100000
每次操作可以执行:N+1,N-1,N*2
问最少多少次操作可以达到目标值K

分析:
定义状态(n,t)
可拓展为(n+1,t+1),(n-1,t+1),(n*2,t+1)

typedef pair<int, int> Status;//位置,时间

bool visit[MAXN];

int BFS(int n, int k)
{
    queue<Status> myQueue;
    myQueue.push(Status(n, 0)); //初始状态压入栈
    visit[n] = true;            //初始点已经访问
    while (!myQueue.empty())
    {
        Status current_status = myQueue.front();
        myQueue.pop();
        //判断当前结果是否满足要求
        if (current_status.first == k)
            return current_status.second;
        //拓展新的状态,并压入队列中
        for (int i = 0; i < 3; i++)
        {
            //拓展当前状态,判断next是否合法
            Status next = Status(current_status.first, current_status.second + 1);
            switch (i)
            {
            case 0:
                next.first = current_status.first + 1;
                break;
            case 1:
                next.first = current_status.first - 1;
                break;
            case 2:
                next.first = current_status.first * 2;
                break;
            }
            if (next.first < 0 || next.first >= MAXN || visit[next.first])
            {
                continue;
            }
            myQueue.push(next);
            visit[next.first] = true;
        }
    }
}

总结

1. 状态。将问题中的解转化为状态。通过状态的拓展，遍历所有状态。
2. 状态拓展方式。
3. 有效状态。对有效状态进行拓展，拓展所得的状态无效则舍弃。
4. 队列。先得出的状态先拓展——先进先出
5. 标记。判断状态是否有效，可用作存储是否遍历过，防止重复陷入死循环。
6. 有效状态数。在搜索之前估计算法的复杂度是否在可接受范围内。
7. 最优。宽度优先搜索常被用来求解最优问题，因为其搜索到的状态总是按照某个关键字递增的，这个特性非常适用求解最优值问题。

深度优先搜索（DFS）

思想：先获取该结点的一个邻居结点，但不访问除该点外的其他邻接结点而是访问该邻接结点的邻接结点。对树而言就是访问其孩子结点后，再访问其孙结点
数据结构：栈

步骤

1. 为G中的每个节点设置STATUS = 1(就绪状态)
2. 将起始节点A推入堆栈并设置其STATUS = 2(等待状态)
3. 重复第4步和第5步，直到STACK为空
4. 弹出顶部节点N.处理它并设置其STATUS = 3(处理状态)
5. 将处于就绪状态(其STATUS = 1)的N的所有邻居推入堆栈并设置它们
   STATUS = 2(等待状态)
   [循环结束]

例题

题目
给定一堆棍子,问是否能通过首尾相接形成一个正方形

分析
先提取状态(sum，number，position),分别为当前边所用细棍的长度和、所处第x根细棍，细棍数组的下标
新的状态有以下几种

1. (sum+edge[i],number,i+1)
   其中i为数组下标,该状态为当前所处边添加第i根细棍后长度没有达到边长的标准,继续寻找下一根边长
2. (0,number+1,0)
   该状态为所用细棍刚好满足边长的要求,进入下一条边的搜索,sum和position都置为0

除此之外,还可以通过一些方法来剪枝提高程序效率

1. 总长不是4的倍数
2. 最长的细棍超过边长
3. 记录拼接失败的长度,在同一条边中,如果还有相同长度的进行拼接,可以直接跳过

vector<int> edges;
bool visit[MAX];

int side;
//状态元组（sum，number，position）
bool Judge(int sum, int number, int position)
{
    if (number == 3)
        return true;
    int sample = 0;//用于剪枝 记录失败的棍子
    for (int i = position; i < edges.size(); i++)
    {
        if (visit[i] || sum + edges[i] > side || edges[i] == sample)
            continue;
        visit[i] = true;
        if (sum + edges[i] == side)
        {
            if (Judge(0, number + 1, 0))
                return true;
            else
                sample = edges[i];
        }
        else
        {
            if (Judge(sum + edges[i], number, i + 1))
                return true;
            else
                sample = edges[i];
        }
        visit[i] = false;
    }
    return false;
}

int main(int argc, char const *argv[])
{
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        int m = 0, sum = 0;
        scanf("%d", &m);
        edges.clear();
        for (int j = 0; j < m; j++)
        {
            int e;
            scanf("%d", &e);
            sum += e;
            edges.push_back(e);
        }
        sort(edges.begin(), edges.end());
        //剪枝
        if (sum % 4 != 0 || edges.size() < 4 || edges[edges.size() - 1] > sum / 4)
        {
            printf("no\n");
            continue;
        }
        side = sum / 4;
        printf("%s\n", Judge(0, 0, 0) ? "yes" : "no");
    }
    return 0;
}