qq_45437180的博客

第二个例子没选好…将就用5.5凑合一下把#include<iostream>using namespace std;typedef struct ElemType { int key;}ElemType;typedef struct BSTNode { ElemType data; BSTNode* lchild, * rchild;}BSTNode, * BSTree;void DeleteBST(BSTree& T, char key) { BSTree.

#include<iostream>using namespace std;int a;typedef struct Node { int data;//数据域 Node* next;//指针域}Node;typedef Node* List;//定义线性表void tailinsert(List& h) { //尾插法建立线性表 List tail;//建立一个尾指针 h = new Node;//给链表创建一个空的头 h->next = NULL;/

初学数据结构、、书上的在线算法 感觉有点像dp、、当然简单求lis的话dp能过 不过没试过这个用dp怎么样、、 有机会补上#include<iostream>#include<stdio.h>using namespace std;#pragma warning(disable:4996)const int N = 1e5 + 10;int a[N];int k;int main() { scanf("%d", &k); for (int i = ..

区间dp常见套路：枚举区间长度枚举左端点（同时得到右端点枚举分割点 构造状态转移方程注意和 贪心的合并果子 区别这个每次只能合并 相邻 的两堆 贪心可以任意题目设有 N 堆石子排成一排，其编号为 1，2，3，…，N。每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。例如有 4 堆石子分别

给定两个字符串 A 和 B，现在要将 A 经过若干操作变为 B，可进行的操作有：删除–将字符串 A 中的某个字符删除。插入–在字符串 A 的某个位置插入某个字符。替换–将字符串 A 中的某个字符替换为另一个字符。现在请你求出，将 A 变为 B 至少需要进行多少次操作。输入格式第一行包含整数 n，表示字符串 A 的长度。第二行包含一个长度为 n 的字符串 A。第三行包含整数 m，表示字符串 B 的长度。第四行包含一个长度为 m 的字符串 B。字符串中均只包含大写字母。输出格式输出一个整

分组背包实际上可以看作是限制了的多重背包每组只能取一个 那就枚举所有的策略#include<iostream>#include<algorithm>using namespace std;const int N = 110;int s[N], v[N], w[N];int n, m;int dp[N];int main() { cin >> n >> m; int s; for (int i = 0; i < n; i++) {

转化成01背包问题s件物品总能用二进制数想办法±得到#include<iostream>#include<cstring>#include<algorithm>#include<vector>using namespace std;const int N = 2010;int n, m;int dp[N];struct Good { int v, w;};int main() { cin >> n >>

先放01背包和完全背包的状态转移方程：Q:为什么完全背包的表达式第二个是f[i][j-v]+w ?从这也可以看出和01背包的代码差别Q: 为什么是01从大到小枚举 ？A: 因为01背包每次用到的是i-1层的f值如果从小到大枚举 j-v<j 那么此时的j-v在第i轮会被计算出不满足用的i-1层但如果从大到小 那么第i轮中j-v并没有被计算得出 会在i-1中才被计算因此 要从大到小枚举对于完全背包问题从小到大枚举同样分析可得...

acwing891 nim游戏#include<iostream>using namespace std;const int N = 100010;int main() { int n; cin >> n; int res = 0; for (int i = 0; i < n; i++) { int x; cin >> x; res ^= x; } if (res)puts("Yes"); else puts("No");

题解建议看这个：https://www.acwing.com/solution/content/29702/#include<iostream>using namespace std;typedef long long LL;const int N = 20;int p[N];int main() { int n, m; cin >> n >> m; int res = 0; for (int i = 0; i < m; i++)cin &gt

给定 n 个 0 和 n 个 1，它们将按照某种顺序排成长度为 2n 的序列，求它们能排列成的所有序列中，能够满足任意前缀序列中 0 的个数都不少于 1 的个数的序列有多少个。输出的答案对 1e9+7 取模。输入格式共一行，包含整数 n。输出格式共一行，包含一个整数，表示答案。数据范围1≤n≤1e5输入样例：3输出样例：5由于直接求排列比较困难 因此转化为求路径 假设0是向右走一格 1是向上走一格 则问题转化为卡特兰数问题卡特兰数如下：#include<iostr

高精度加法#include<iostream>#include<stdio.h>#include<vector>using namespace std;vector<int>C;vector<int>add(vector<int>& A, vector<int>& B) { int t = 0; int i = 0; while (i < A.size() || i < B.s

情况1 询问组数比较多 但是b<=a<=2000 比较小递推公式法#include<iostream>#include<algorithm>using namespace std;const int N = 2010, mod = 1e9 + 7;int c[N][N];//从i里面取出j个的方案数void init() { for (int i = 0; i < N; i++) for (int j = 0; j <= i; j++)

#include<iostream>#include<algorithm>#include<cmath>#include<cstring>using namespace std;#pragma warning(disable:4996)const int N = 110;const double eps = 1e-8;double a[N][N];int n;int gauss() { int r , c ; for (r = 0,

哈夫曼树 每次让在最底下的达到最小 那么总和一定最小#include<iostream>#include<queue>#include<stdio.h>using namespace std;int main() { int n; cin >> n; priority_queue<int, vector<int>, greater<int>>heap; for (int i = 0; i < n;

给定 N 个闭区间 [ai,bi] 以及一个线段区间 [s,t]，请你选择尽量少的区间，将指定线段区间完全覆盖。输出最少区间数，如果无法完全覆盖则输出 −1。输入格式第一行包含两个整数 s 和 t，表示给定线段区间的两个端点。第二行包含整数 N，表示给定区间数。接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。输出格式输出一个整数，表示所需最少区间数。如果无解，则输出 −1。数据范围1≤N≤1e5,−1e9≤ai≤bi≤1e9,−1e9≤s≤t≤1e9输入样例：

实在受不了数论的折磨于是感觉贪心友好多了but不严谨证明多少带点运气成分（（题目：给定 N 个闭区间 [ai,bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。输出最小组数。输入格式第一行包含整数 N，表示区间数。接下来 N 行，每行包含两个整数 ai,bi，表示一个区间的两个端点。输出格式输出一个整数，表示最小组数。数据范围1≤N≤1e5,−1e9≤ai≤bi≤1e9输入样例：3-1 12 43 5输出样例：2#i

题解建议看这个：https://www.acwing.com/solution/content/3539/#include<iostream>#include<stdio.h>#include<math.h>using namespace std;typedef long long LL;LL exgcd(LL a, LL b, LL & x, LL & y) { if (!b) { x = 1, y = 0; return a;

就是说是怎么才能让尽可能多的人找到对象法（（给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。数据保证任意一条边的两个端点都不可能在同一部分中。请你求出二分图的最大匹配数。二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。输入格式第一

#include<iostream>#include<algorithm>#include<cstring>using namespace std;const int N = 100010, M = 200010;int h[N], e[M], ne[M], idx;int color[N];int n, m;void add(int a,int b) { e[idx] = b; ne[idx] = h[a]; h[a] = idx++;}

#include<iostream>#include<algorithm>using namespace std;const int N = 2e5 + 10;int n, m;int p[N];struct edge { int a, b, w; bool operator< (const edge& W)const { return w < W.w; }};edge edges[N];int find(int x) { if

输入一个 n 行 m 列的整数矩阵，再输入 q 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。每个操作都要将选中的子矩阵中的每个元素的值加上 c。请你将进行完所有操作后的矩阵输出。输入格式第一行包含整数 n,m,q。接下来 n 行，每行包含 m 个整数，表示整数矩阵。接下来 q 行，每行包含 5 个整数 x1,y1,x2,y2,c，表示一个操作。输出格式共 n 行，每行 m 个整数，表示所有操作

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。输入格式第一行包含两个整数 n 和 m。接下来 m 行，每行包含三个整数

Dijkstra-朴素O(n^2)初始化距离数组, dist[1] = 0, dist[i] = inf;for n次循环 每次循环确定一个min加入S集合中，n次之后就得出所有的最短距离将不在S中dist_min的点->tt->S加入最短路集合用t更新到其他点的距离Dijkstra-堆优化O(mlogm)利用邻接表，优先队列在priority_queue[HTML_REMOVED], greater[HTML_REMOVED] > heap;中将返回堆顶利用堆顶来更新其

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。数据保证图中不存在负权回路。输入格式第一行包含三个整数 n,m,k。接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。输出格式共 k 行，每行输出一

#include <cstring>#include <iostream>#include <queue>using namespace std;const int N = 2e3 + 10, M = 1e4 + 10;int n, m;int h[N], e[M], ne[M], w[M], idx;bool st[N];int dist[N];int cnt[N]; //cnt[x] 表示 当前从1-x的最短路的边数void add(int

#include<iostream>#include<queue>#include<cstring>using namespace std;const int N = 1e5 + 10;int h[N], e[N], w[N], ne[N], idx = 0;int dist[N];//各点到源点的距离bool st[N];int n, m;void add(int a, int b, int c) { e[idx] = b; w[idx] = c;

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。注意：图中可能 存在负权回路 。输入格式第一行包含三个整数 n,m,k。接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。输出格式输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。如果不存在满足条件的路径，则输出

#include<iostream>#include<algorithm>#include<queue>#include<cstring>using namespace std;typedef pair<int, int> PII;const int N = 1e6 + 10;int h[N], e[N], ne[N], idx;int w[N];//存储权重bool st[N];//标记这个点的最短路是否已经被找到int di

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。输入格式第一行包含整数 n 和 m。接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。输出格式输出一个整数，表示 1 号点到 n 号点的最短距离。如果路径不存在，则输出 −1。数据范围1≤n≤500,1≤m≤1e5,图中涉及边长均不超过10000。输入样例：3 3

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。所有边的长度都是 1，点的编号为 1∼n。请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。输入格式第一行包含两个整数 n 和 m。接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。输出格式输出一个整数，表示 1 号点到 n 号点的最短距离。数据范围1≤n,m≤1e5输入样例：4 51 22 33 41 31 4输出样例：1

给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。输入格式第一行包含整数 n，表示树的结点数。接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。输出格式输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。数据范围1≤n≤1e6输入样例

在一个 3×3 的网格中，1∼8 这 8 个数字和一个 x 恰好不重不漏地分布在这 3×3 的网格中。例如：1 2 3x 4 67 5 8在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：1 2 34 5 67 8 x例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。交换过程如下：1 2 3 1 2 3 1 2 3 1 2 3x 4 6 4

初学bfs貌似通常和队列一起结合？题目：给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。输入格式第一行包含两个整数 n 和 m。接下来 n 行，每行包含 m 个整数（

n−皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。现在给定整数 n，请你输出所有的满足条件的棋子摆法。输入格式共一行，包含整数 n。输出格式每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。每个方案输出完成后，输出一个空行。注意：行末不能有多余空格。输出方案的顺序任意，只要不重复且没有遗漏即可。

#include<iostream>using namespace std;#pragma warning(disable:4996)int exgcd(int a, int b, int& x, int& y) { if (b == 0) { x = 1, y = 0;//此时只有唯一解 return a; } else { int x1, y1, gcd; gcd = exgcd(b, a % b, x1, y1); x = y1, y ...

和快速幂差不多 等于就是求a的p-2次%p的结果注意特判无解情况#include <iostream>using namespace std;typedef long long LL;LL qmi(int a, int b, int p){ LL res = 1; while(b){ if(b & 1) res = res * a % p; a = (LL)a * a % p; b >>= 1;..

#include<iostream>using namespace std;typedef long long LL;#pragma warning(disable:4996)int qni(int a, int k, int p) { //返回a^k%p的结果 LL res = 1; while (k) { if(k&1) res = res * a % p;//如果k的末尾是1 k = k >> 1; a = (LL)a * a % p; }

给定一个正整数 n，求 1∼n 中每个数的欧拉函数之和。输入格式共一行，包含一个整数 n。输出格式共一行，包含一个整数，表示 1∼n 中每个数的欧拉函数之和。数据范围1≤n≤106输入样例：6输出样例：12#include<iostream>#include<algorithm>using namespace std;const int N = 100010;int primes[N], cnt;int phi[N];bool st[N];//st表

#include<iostream>using namespace std;int main() { int n; cin >> n; while (n--) { int a; cin >> a; int res = a; for (int i = 2; i <= a / i; i++) { if (a % i == 0) { res = res / i * (i - 1); while (a % i == 0)a.