qq_44791484的博客

题面题解代码/* 对#进行编号 0 1 2 34 5 6 7 8 9 10 11 1213 14 15 16 17 18 19 20 21 22 23*/#include<bits/stdc++.h>using namespace std;const int N = 24;int q[N];int path[100];//八种操作方式int op[8][

题面题解(IDA*)IDA*与A*算法思想相似，就是在迭代加深的基础上进行优化，当遍历当前节点时，如果当前深度 +预估正解深度 > 设定的最大深度 ，则提前退出分析正解枚举放到哪个位置：本质其实就是交换两个相邻两段（将区间lr插入到k之后的位置，相当于交换区间[l,r]和[r+1,k]）代码#include<bits/stdc++.h>using namespace std;const int N = 15;int n;int q[N], w

题面题解(双向DFS)看给定数据范围，如果用01背包来做，时间复杂度是O(nv) ,v是231,肯定超时，我们考虑DFS来做，但是直接搜索状态就会有246,还是超时，正解采用双向DFS大体思想：我们先预处理出前n/2个物品所能组成的所有状态(选或不选)，然后再DFS后n/2个物品，找出最大然后二分前面状态找出一个不超过m的最大值1.将所有物品按重量从小到大排序2.先将前k件物品能凑出的所有重量打表，然后排序并判重3.搜索剩下的N-k件物品的选择方式，然后在表中二分出不超过W的最大值

题面题解(迭代加深)迭代加深使用场景：当存在较长的分支时，而答案却在很短的分支。我们在搜索较长 的分支时会浪费大量的时间大体思想：设定一个最大的搜索层数，如果可以搜索到答案，直接退出， 如果无解，则增大最大的搜索层数分析我们可以确定的是第一个位置一定是1，第二个位置一定是2，然后开始搜索第三个位置可以是3，4…我们可以发现，可能存在一个序列1，2，3，4，5，6，…题中数据范围是n<=100,那么存在搜索分支达到100层，我们再估算正解，因为要求最小长度，

题面题解蛋糕从下往上搜索，上表面积就是最底层的圆面积，求解过程注重 侧面积和体积即可代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>#include<cmath>using namespace std;const int N=25,INF=1e9;int n

题面题解代码#include<iostream>#include<cstdio>#include<cstring>#include<string>#include<algorithm>using namespace std;const int N=70;int n;int w[N],sum,length;bool st[N];bool dfs(int u,int s,int strat){ if(u*lengt

题面题解通过位运算表示描绘出当前的局面，某一行某一列某一某一宫格均用1个长度是9为的二进制数表示，若当前位置是1表示该行该列或者该宫格可填入在选择当前需要填数的位置时，选择分支最少的格子state = row[x] & col[y] & cell[x / 3][y / 3]表示当前位置(x,y)可填数的状态，某二进制为是1表示可填该数代码#include<iostream>#include<cstdio>#include<strin

题面题解剪枝分类dfs优化主要分成5类1、优化搜索顺序(大部分情况下，我们应该优先搜索分支较少的结点)2、排除等效冗余3、可行性剪枝4、最优性剪枝5、记忆化搜索做法依次遍历所有的猫，通过第u只猫往现有的第k个辆车中放来遍历所有情况，（可以放入第 i 辆车，也可以新开一辆车放入）优化优先放重的猫，优化搜索顺序，因为先放重的，可以减少接下来的分支，使遍历情况减少当前猫放入已经超出最大限制，就不再进行遍历，可行性剪枝新开车的数量大于答案的值，接下来肯定不是答案，最优

题面题解枚举组，开始将第一个数放入第一组，然后判断下一个数能否放到这个组，如果能就继续dfs下一个数，如果不能就新开一个组，从头开始扫描没有被放的数能否放到新的组代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;const int N=11;int n;

题面题解(DFS搜索顺序)两个字符串拼接，重合部分越短，拼接起来的字符串就越长，因此我们处理出所有单词两两拼接起来重合部分最短且符合条件的最小重合长度 , g[i][j]表示第i个单词和第j个单词重合的最小长度我们从给定的字母符合的单词开始做dfs，因为是外部搜索，所以要状态还原代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include&

题面题解因为是每个状态的顺序搜索，所以dfs之后要记得还原代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;const int N=10;int t,n,m,sx,sy;bool st[N][N];int res;int dx[8] = {-2,

题面题解Flood Fill 模型，用dfs来求连通块，因为是图内部，不需要还远状态代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;const int N=25;int n,m;char g[N][N];bool st[N][N];int dx

题面题解（A*）对于第一次出队的为最短路，第K次出队的就是第K短路，我们采用反向建边，dijkstra预处理终点到每个点的距离，将每个点到终点的距离作为估计值代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>#include<queue>using namespace std;typ

题面题解(A*)A*算法在最小步数模型中，当状态数较多时，不能直接用BFS来做，我们就可以考虑A*算法来减少一些没必要的搜索状态引入一个估值函数，用来估计某个点到达终点的距离。记f是估值函数，g是真实值，那么f(state) <= g(state)，越接近越好 , 记dist是从起点到state状态的步数；利用的是优先队列，排序依据是dist[state] + f(state),当终点状态第一次出队时，就是最小步数。本题对于八数码问题，我们知道最终状态是序列12345678x

题面题解双向BFS一般用于最小步数模型，当我们变化的状态较多时，直接用BFS搜索会TLE或MLE做法我们开两个队列，分别将起始状态和终点状态加入队列，每次取队列元素少的拓展，如果有解，那么首尾拓展的状态一定会在中间相遇代码#include <cstring>#include <iostream>#include <algorithm>#include <unordered_map>#include <queue>

题面题解和八数码问题类似，都是将初始状态变化成最终状态所花费的最小步数，我们可以将每个状态看成一个点进行更新即可代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>#include<queue>#include<unordered_map>using namespace s

题面题解(双端队列广搜)双端队列双端队列主要解决图中边的权值只有0或者1的最短路问题操作每次从队头取出元素，并进行拓展其他元素时若拓展某一元素的边权是0，则将该元素插入到队头若拓展某一元素的边权是1，则将该元素插入到队尾只有在最后出队时，才能确定这个点的最小值(没有出队时，其他点可能还会更新这个点的距离)代码解释我们可以将直接能走的点的步数看作是0，需要变化的步数看作是1，这样问题就转化成了从起点开始到终点最小的步数，因为起点是(0,0)，我们移动每次都是按照方格的斜

题面题解这道题让我们找到每一个点到多个起点(这里指1)的最近距离，用一般的做法就是用每一个起点去更新其他点的距离，然后更新的距离去一个最小值，O(n3),会超时我们可以给多个起点建立一个虚拟的节点，虚拟节点到每个起点的距离都是0，那么我们就可以转化成这个虚拟节点到所有点的最小距离，在写代码时，我们只开始将所有起点入队即可代码#include<bits/stdc++.h>using namespace std;typedef pair<int, int> PI

题面题解我们可以将坐标轴看成一个图，从起点n开始，可以到达n+1,n-1,n*2的点，要求n到k的最短距离，那么我们可以设到达每个点的距离是1，然后用bfs进行搜索，搜索到k时，dist[k]就是n到k的最短距离代码#include<bits/stdc++.h>using namespace std;const int N = 1e5 + 10;int n, k;int q[N];int dist[N];int bfs() { memset(dist, -

题面题解从起点开始，步数为0，然后BFS能走到’日’的方向，更新距离即可代码#include<bits/stdc++.h>using namespace std;typedef pair<int, int> PII;const int N = 160;int n, m;char g[N][N];PII q[N * N];int dist[N][N];int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};int dy[]

题面题解(最短路模型)迷宫问题+输出路径，因为每个点之间的距离都是1，所以用BFS搜索出来的结果就是最短的距离，我们新开一个数组，然后我们从终点开始最终搜索到起点，记录每个点的前一个点是从哪转移过来的，最后从(0,0)点遍历一遍即可代码#include<bits/stdc++.h>using namespace std;typedef pair<int, int> PII;const int N = 1010;int n;int g[N][N];PII

题面题解对于一个联通的格子，周围没有比它高的称为山峰，周围没有比它矮的称为山谷，如果周围没有，全图都是联通的，它就是山峰又是山谷。我们依次遍历没有被标记过的点，用bfs求联通块的同时，判断这个联通块周围是否有这个联通块高度高的/低的并且记录，然后累加答案即可代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorith

题面题解(Flood Fill 模型)用bfs遍历每一个房间，每次遍历返回房间的大小，同时标记这些房间已经被访问过，时间复杂度O(nm) ，每个房间的墙壁信息可以提前用坐标表示，我们设坐标为int dx[4] = {0, -1, 0, 1} ; int dy[4] = {-1, 0, 1, 0};这样就可以使每次访问的和坐标的方向一一对应，比如 d[x][y] >> i &1 表示的就是向坐标{dx[i],dy[i]}的方向走代码#include<iostream&

题面题解(Flood Fill 模型)本题是八联通形式，我们直接枚举每一个格子，如果有水并且是没有被标记过的，那么就开始做Flood Fill ，将所有联通的水源标记，联通的数量+1，代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;typedef pai

题面题解判断B是不是A的子结构，其实可以对比字符串的匹配，我们从B的根节点开始，，然后匹配A的根节点，如果失败，再从B的左儿子和右儿子匹配A的根节点（类似字符串）匹配过程： 如果A节点为空，说明匹配完成，返回true，如果B节点为空或者B的值和A的值不相同，返回false，否则，继续判断AB的左右儿子（递归即可）代码/** * Definition for a binary tree node. * struct TreeNode { * int val; * T

题面题解代码class Solution {public: //求横纵坐标各位数之和 int get_sum(int x, int y) { int sum = 0; while (x) { sum += x % 10; x /= 10; } while (y) { sum += y % 10; y /

题面题解DFS搜索简单题，我们以二维矩阵的每一个点为起点，然后开始dfs，只要有一种情况满足就可以返回true代码class Solution {public: bool dfs(vector<vector<char>> &matrix, string &str, int len, int x, int y) { if (matrix[x][y] != str[len]) return false; if (len == str

题面题解BFS经典八数码问题 ：抽象成图，每一个状态都是都与上一个点相连，且距离为1，最终状态就是终点，转化成了从开始点到最终点的距离最小，因为每个点之间的距离都是1，所以直接用BFS来做即可代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>#include<unordered_map>

题面题解我们可以将这个问题抽象成一个图。设原始状态为起点，结尾状态为终点，变化的状态为中间点，每次都可以将x位置与它相邻的四个方向交换（4中状态，符合条件下），这四个方向的状态就是新的点，而且是这个状态能到达的点，我们设点之间的距离是1，那么要求的变换最少次数就是求起始点到终点的最短距离我们将起始点放入BFS的队列，每次通过取出队头来遍历四个方向，如果状态符合，就更新距离，并将新的点放入队列小技巧：我们这里的点其实就是字符串，那么由x转化的四个状态，可以先将字符串转化成二维的表

题面题解1（逐一搜索）对于n皇后问题，我们知道不能有两个皇后在同一行同一列和同一对角线上，那么我们就可以按顺搜索每一个位置，然后这个位置有两种放置方式（放皇后或者不放皇后）对于不放皇后的情况，直接搜索到下一个位置；对于放皇后，我们就需要判断这个位置能否放置皇后，就是看行列和对角线都没有放的情况下才能放对于行列我们可以直接用一维的x,y代表哪行哪列，但是对角线我们怎样转化呢，我们可以知道数学中，对角线是y=x+b,y=-x+b,那么我们就可以用截距b来表示对角线，将二维转化成一维

题面题解DFS 从开始填数字，标记出已经放入的数字，然后回溯，每次搜索到第三层输出答案即可代码#include<bits/stdc++.h>using namespace std;const int N = 10;int n;int path[N];bool st[N];void dfs(int u) { if (u == n) { for (int i = 0; i < n; i++) cout << path[

原题链接思路1.dfs经典题N-皇后问题的变形，用全排列的方式来枚举，记录结果即可2.我们可以发现，对于N*N的棋盘，正好放N个，每行一个，然后枚举每行放置的位置并记录3.满足什么条件就可以放，就是列，两条斜对角线都没有棋子的情况，就可以放4.因为要求所有的情况，所以每次记得还原AC代码#include <iostream>using namespace std;const int N = 15;int n;bool col[N], d[N * 2], ud[

原题链接给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。题目描述无输入格式第一行N、M和T，N为行，M为列，T为障碍总数。第二行起点坐标SX,SY，终点坐标FX,FY。接下来T行，每行为障碍点的坐标。输出格式给定起点坐标和终点坐标，问每个方格最多经过1次，从起点坐标到终点坐标的方案总数。输入输出样例输入 #1复制

题面题解代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;const int N = 110;typedef pair<int, int> PII;int n, m;int g[N][N], d[N][N];int dx[4] = {1, -

题面题解如图，树的重心就是一个节点，如果将这个节点删除，剩余连通块中点数最大的最小值，样例中树的重心是4，要知道，树的重心是不唯一的，但是值是唯一的我们可以用树的深搜，dfs记录以u为根节点子树的大小（包括自己），然后就可以求出删除这个点以后所有的连通块（以这个点为根节点的所有子树，整棵树删除以这个点为根节点的树），在这些中去一个最大，然后在最后更新一下最大的最小就是答案代码#include<iostream>#include<cstdio>#i

题面题解求图中点到点的最短距离，因为所有点的距离都是1，我们就可以用bfs来做，每次逐层搜索，从1到n一定是距离最短的，用宽搜的模板即可代码#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<algorithm>using namespace std;const int N = 1e5 + 10;int n, m;i