各种常见算法 & 数据结构模板

1. 最长不下降子序列（LIS）

1.1 \(O(n^2)\) 做法

点击查看代码 
  1. for (int i = 1;i <= n;i++) {
  2. 		cin >> a[i];
  3. 		dp[i] = 1;
  4. 	}
  5. 	for (int i = 1;i <= n;i++) {
  6. 		for (int j = 1;j < i;j++) {
  7. 			if (a[i] > a[j]) {
  8. 				dp[i] = max(dp[i],dp[j] + 1);
  9. 			}
  10. 		}
  11. 		ans = max(ans,dp[i]);
  12. 	}

1.2 \(O(n \log n)\) 做法

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int dp[N], n, x, k = 1;
  7. int main() {
  8.     cin >> n >> x;
  9.     dp[1] = x;
  10.     for (int i = 2; i <= n; i++) {
  11.         scanf("%d",&x);
  12.         if (x > dp[k]) {
  13.             dp[++k] = x;
  14.         } else {
  15.             int p = lower_bound(dp + 1, dp + k + 1, x) - dp;
  16.             dp[p] = x;
  17.         }
  18.     }
  19.     cout << k;
  20.     return 0;
  21. }

2. 背包问题

2.1 01背包-二维数组

点击查看代码 
  1. 	cin >> maxw >> n;
  2. 	for (int i = 1;i <= n;i++) {
  3. 		cin >> w >> v;
  4. 		for (int j = 1;j <= maxw;j++) {
  5. 			if (w > j) {
  6. 				dp[i][j] = dp[i - 1][j];
  7. 			} else {
  8. 				dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - w] + v);
  9. 			}
  10. 		}
  11. 	}
  12. 	cout << dp[n][maxw];

2.2 01背包-一维数组优化

点击查看代码 
  1. 	cin >> maxv >> n; // maxv: 价值
  2. 	for (int i = 1;i <= n;i++) {
  3. 		cin >> v;
  4. 		for (int j = maxv;j >= v;j--) {
  5. 			dp[j] = max(dp[j],dp[j - v] + v);
  6. 		}
  7. 	}
  8. 	cout << dp[maxv];

2.3 完全背包-一维数组优化

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. typedef long long ll;
  6. const int N = 1e4 + 10, S = 1e7 + 10;
  7. ll dp[S], vi, wi, maxw, n;
  8. int main() {
  9.     scanf("%lld%lld", &maxw, &n);
  10.     for (int i = 1; i <= n; i++) {
  11.         scanf("%lld%lld", &wi, &vi);
  12.         for (int j = wi; j <= maxw; j++) {
  13.             dp[j] = max(dp[j], dp[j - wi] + vi);
  14.         }
  15.     }
  16.     printf("%lld", dp[maxw]);
  17.     return 0;
  18. }

2.4 多重背包-普通版本

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 110;
  6. int dp[N], v, s, w;
  7. int n, maxw;
  8. int main() {
  9.     scanf("%d%d", &n, &maxw);
  10.     for (int i = 1; i <= n; i++) {
  11.         scanf("%d%d%d", &w, &v, &s);
  12.         for (int k = 1; k <= s; k++) {
  13.             for (int j = maxw; j >= w; j--) {
  14.                 dp[j] = max(dp[j], dp[j - w] + v);
  15.             }
  16.         }
  17.     }
  18.     printf("%d", dp[maxw]);
  19.     return 0;
  20. }

2.5 多重背包-二进制优化版

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 2e4 + 10;
  6. int dp[2010], v[N], w[N];
  7. int n, wi, vi, si, maxw, k;
  8. int main() {
  9.     scanf("%d%d", &n, &maxw);
  10.     for (int i = 1; i <= n; i++) {
  11.         scanf("%d%d%d", &wi, &vi, &si);
  12.         for (int t = 1; t <= si; t *= 2) {
  13.             k++;
  14.             v[k] = t * vi;
  15.             w[k] = t * wi;
  16.             si -= t;
  17.         }
  18.         if (si > 0) {
  19.             k++;
  20.             v[k] = si * vi;
  21.             w[k] = si * wi;
  22.         }
  23.     }
  24.     for (int i = 1; i <= k; i++) {
  25.         for (int j = maxw; j >= w[i]; j--) {
  26.             dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
  27.         }
  28.     }
  29.     printf("%d", dp[maxw]);
  30.     return 0;
  31. }

2.6 分组背包

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 110;
  6. int dp[N], v[N][N], w[N][N], s[N];
  7. int n, maxw;
  8. int main() {
  9.     scanf("%d%d", &n, &maxw);
  10.     for (int i = 1; i <= n; i++) {
  11.         scanf("%d", &s[i]);
  12.         for (int j = 1; j <= s[i]; j++) {
  13.             scanf("%d%d", &w[i][j], &v[i][j]);
  14.         }
  15.     }
  16.     for (int i = 1; i <= n; i++) {
  17.         for (int j = maxw; j >= 1; j--) {
  18.             for (int k = 1; k <= s[i]; k++) {
  19.                 if (w[i][k] <= j)
  20.                     dp[j] = max(dp[j], dp[j - w[i][k]] + v[i][k]);
  22.             }
  23.         }
  24.     }
  25.     printf("%d", dp[maxw]);
  26.     return 0;
  27. }

2.7 二维费用背包

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 410;
  6. int dp[N][N], maxw, maxv, vi, wi, c;
  7. int n;
  8. int main() {
  9.     scanf("%d%d", &maxw, &maxv);
  10.     cin >> n;
  11.     for (int i = 1; i <= n; i++) {
  12.         cin >> wi >> vi >> c;
  13.         for (int j = maxw; j >= wi; j--) {
  14.             for (int k = maxv; k >= vi; k--) {
  15.                 dp[j][k] = max(dp[j][k], dp[j - wi][k - vi] + c);
  16.             }
  17.         }
  18.     }
  19.     cout << dp[maxw][maxv];
  21.     return 0;
  22. }

3. 图论最短路

3.1 朴素Dijkstra

时间复杂度：\(O(n^2)\)

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 60;
  6. int a[N][N];
  7. int d[N];
  8. bool f[N];
  9. int n,s;
  10. int main() {
  11. 	cin >> n >> s;
  12. 	for (int i = 1;i <= n;i++) {
  13. 		for (int j = 1;j <= n;j++) {
  14. 			cin >> a[i][j];
  15. 		}
  16. 	}
  17. 	memset(d,0x3f,sizeof(d)); // 初始化为INF
  18. 	d[s] = 0; // 走到起点的最短路为0
  19. 	for (int i = 1;i <= n;i++) {
  20. 		int mi = -1;
  21.       		// 找到最小数下标
  22. 		for (int j = 1;j <= n;j++) {
  23. 			if (!f[j] && (mi == -1 || d[j] < d[mi])) {
  24. 				mi = j;
  25. 			}
  26. 		}
  27. 		f[mi] = true;
  28.       		// 从最短路的点开始更新最短路
  29. 		for (int j = 1;j <= n;j++) {
  30. 			if (!f[j] && a[mi][j] && a[mi][j] + d[mi] < d[j]) {
  31. 				d[j] = a[mi][j] + d[mi];
  32. 			}
  33. 		}
  35. 	}
  36. 	for (int i = 1;i <= n;i++) {
  37. 		if (i != s) {
  38.           		//走不到 -> 0x3f3f3f3f
  39. 			if (d[i] == 0x3f3f3f3f) cout << -1 << " ";
  40. 			else cout << d[i] << " ";
  41. 		}
  42. 	}
  43. 	return 0;
  44. }

3.2 优先队列BFS优化 Dijkstra

时间复杂度：\(O(m \times logm)\)

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. typedef pair<int,int> PII;
  7. struct node{
  8.     int to,next,len;
  9. }a[N];
  10. int pre[N],k = 0;
  11. int n,m,x,y,len;
  12. priority_queue<PII,vector<PII>,greater<PII>> q; // 优先队列
  13. void add(int x,int y,int len) { // 建边
  14.     a[++k] = {y,pre[x],len};
  15.     pre[x] = k;
  16. }
  17. bool f[N];
  18. int d[N];
  19. int main() {
  20.     scanf("%d%d",&n,&m);
  21.     for (int i = 1;i <= m;i++) {
  22.         scanf("%d%d%d",&x,&y,&len);
  23.         add(x,y,len);
  24.     }
  25.     // 初始化
  26.     q.push({0,1});
  27.     memset(d,0x3f,sizeof(d));
  28.     d[1] = 0;
  30.     while (!q.empty()) {
  31.         PII h = q.top();
  32.         int dis = h.first,p = h.second;
  33.         q.pop();
  34.         if (f[p]) continue;
  35.         f[p] = true;
  36.         if (p == n) { // 走到终点
  37.             cout << dis;
  38.             return 0;
  39.         }
  40.         for (int i = pre[p];i;i = a[i].next) { // 更新最短路
  41.             int to = a[i].to;
  42.             if (a[i].len + dis < d[to]) {
  43.                 d[to] = a[i].len + dis;
  44.                 q.push({a[i].len + dis,to});
  45.             }
  46.         }
  47.     }
  48.     cout << -1;
  49.     return 0;
  50. }

3.3 Floyd

时间复杂度：\(O(n^3)\)

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 110,INF = 0x3f3f3f3f;
  6. int d[N][N];
  7. int n,m,x,y,l;
  8. int main() {
  9. 	cin >> n >> m;
  10. 	memset(d,0x3f,sizeof(d));
  11. 	for (int i = 1;i <= n;i++) d[i][i] = 0;
  13. 	for (int i = 1;i <= m;i++) {
  14. 		cin >> x >> y >> l;
  15. 		d[x][y] = l;
  16. 	}
  17. 	for (int k = 1;k <= n;k++) {
  18. 		for (int i = 1;i <= n;i++) {
  19. 			for (int j = 1;j <= n;j++) {
  20. 				if (d[i][k] != INF && d[k][j] != INF) {
  21. 					d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
  22. 				}
  23. 			}
  24. 		}
  25. 	}
  26. 	for (int i = 1;i <= n;i++) {
  27. 		for (int j = 1;j <= n;j++) {
  28. 			if (d[i][j] == INF) cout << "N ";
  29. 			else cout << d[i][j] << " ";
  30. 		}
  31. 		cout << endl;
  32. 	}
  33. 	return 0;
  34. }

4.树

4.1 树的直径

两次深搜求直径：

  1. 从树上任意找一个点 \(x\) 搜索离 \(x\) 最远的点 \(u\) ，\(u\) 一定是直径的一个端点；

  2. 从直径的一个端点 \(u\) 开始搜索，搜索出离 \(u\) 最远的点 \(v\) ，\(v\) 一定是直径的另一个端点，因此 \(uv\) 一定是直径。

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 110;
  6. int n,x,y;
  7. struct node{
  8. 	int to,next;
  9. }a[N * 2];
  10. int pre[N];
  11. int k = 0;
  12. int dep[N];
  13. void add(int x,int y) {
  14. 	a[++k] = {y,pre[x]};
  15. 	pre[x] = k;
  16. }
  18. void dfs(int x,int fath) {
  19. 	dep[x] = dep[fath] + 1;
  20. 	for (int i = pre[x];i;i = a[i].next) {
  21. 		if (a[i].to != fath) {
  22. 			dfs(a[i].to,x);
  23. 		}
  24. 	}
  25. }
  27. int main() {
  28. 	cin >> n;
  29. 	for (int i = 1;i <= n - 1;i++) {
  30. 		scanf("%d%d",&x,&y);
  31. 		add(x,y);
  32. 		add(y,x);
  33. 	}
  34. 	dfs(1,0);
  35. 	int x = 1;
  36.   	// 求出离1号点最远的那个点
  37. 	for (int i = 2;i <= n;i++) {
  38. 		if (dep[i] > dep[x]) x = i;
  39. 	}
  40. 	dfs(x,0);
  41. 	int y = 1;
  42.   	// 找出离x号点最远的点y
  43. 	for (int i = 1;i <= n;i++) {
  44. 		if (dep[i] > dep[y]) y = i;
  45. 	}
  46. 	printf("%d",dep[y] - 1);

4.2 树的中心

树的中心指的是，该结点离树中的其他结点，最远距离最近。

树的中心满足如下性质：

（1）它一定在某条树的直径上，且到直径的两端的距离差不超过1。

（2）即使树有多条直径，但树的中心至多有2个，且均为直径的中点。

求树的中心：由于树的中心一定在直径上，求出直径的两个端点 \(u v\)，加深 \(v\) 深度更深。

(1) 如果 \(dep[v]\) 是奇数，爬树 \(dep[v]/2\) 次；

(2) 如果 \(dep[v]\) 是偶数，爬树 \(dep[v]/2-1\) 次，得到两个中心的靠下的一个点，另一个点就是该点的父；

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int n,x,y;
  7. struct node{
  8. 	int to,next;
  9. }a[N * 2];
  10. int pre[N];
  11. int k = 0;
  12. int dep[N],fa[N];
  13. void add(int x,int y) {
  14. 	a[++k] = {y,pre[x]};
  15. 	pre[x] = k;
  16. }
  18. void dfs(int x,int fath) {
  19. 	dep[x] = dep[fath] + 1;
  20. 	fa[x] = fath;
  21. 	for (int i = pre[x];i;i = a[i].next) {
  22. 		if (a[i].to != fath) {
  23. 			dfs(a[i].to,x);
  24. 		}
  25. 	}
  26. }
  28. int main() {
  29. 	cin >> n;
  30. 	for (int i = 1;i <= n - 1;i++) {
  31. 		scanf("%d%d",&x,&y);
  32. 		add(x,y);
  33. 		add(y,x);
  34. 	}
  35. 	dfs(1,0);
  36. 	int x = 1;
  37. 	for (int i = 2;i <= n;i++) {
  38. 		if (dep[i] > dep[x]) x = i;
  39. 	}
  40. 	dfs(x,0);
  41. 	int y = 1;
  42. 	for (int i = 1;i <= n;i++) {
  43. 		if (dep[i] > dep[y]) y = i;
  44. 	}
  45. 	if (dep[y] % 2 == 1) {
  46. 		int d = dep[y] / 2;
  47. 		for (int i = 1;i <= d;i++) {
  48. 			y = fa[y];
  49. 		}
  50. 		printf("%d",y);
  51. 	} else {
  52. 		int d = dep[y] / 2 - 1;
  53. 		for (int i = 1;i <= d;i++) {
  54. 			y = fa[y];
  55. 		}
  56. 		if (y < fa[y]) cout << y << " " << fa[y];
  57. 		else cout << fa[y] << " " << y;
  58. 	}
  59. 	return 0;
  60. }

4.3 树的公共祖先(LCA)

解法一：染色法

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int n,x,y;
  7. struct node{
  8. 	int to,next;
  9. }a[N * 2];
  10. int pre[N];
  11. int k = 0;
  12. int dep[N],fa[N];
  13. void add(int x,int y) {
  14. 	a[++k] = {y,pre[x]};
  15. 	pre[x] = k;
  16. }
  17. bool vis[N];
  19. void dfs(int x,int fath) {
  20. 	dep[x] = dep[fath] + 1;
  21. 	fa[x] = fath;
  22. 	for (int i = pre[x];i;i = a[i].next) {
  23. 		if (a[i].to != fath) {
  24. 			dfs(a[i].to,x);
  25. 		}
  26. 	}
  27. }
  29. int main() {
  30. 	cin >> n;
  31. 	int u,v;
  32. 	cin >> u >> v;
  33. 	for (int i = 1;i <= n - 1;i++) {
  34. 		scanf("%d%d",&x,&y);
  35. 		add(x,y);
  36. 		add(y,x);
  37. 	}
  38. 	dfs(1,0);
  39. 	vis[u] = true;
  40. 	while (fa[u] != 0) {
  41. 		u = fa[u];
  42. 		vis[u] = true;
  43. 	}
  44. 	while (!vis[v]) {
  45. 		v = fa[v];
  46. 	}
  47. 	cout << v;
  48. 	return 0;
  49. }

解法二：两个结点同时向上移动

思路：

（1）求出每个结点的深度；

（2）如果两个结点重叠，那么得知公共祖先；

（3）如果不重叠，选择深度更大的结点，向父元素移动，重复上述过程，直到重叠。

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int n,x,y;
  7. struct node{
  8. 	int to,next;
  9. }a[N * 2];
  10. int pre[N];
  11. int k = 0;
  12. int dep[N],fa[N];
  13. void add(int x,int y) {
  14. 	a[++k] = {y,pre[x]};
  15. 	pre[x] = k;
  16. }
  17. bool vis[N];
  19. void dfs(int x,int fath) {
  20. 	dep[x] = dep[fath] + 1;
  21. 	fa[x] = fath;
  22. 	for (int i = pre[x];i;i = a[i].next) {
  23. 		if (a[i].to != fath) {
  24. 			dfs(a[i].to,x);
  25. 		}
  26. 	}
  27. }
  29. int main() {
  30. 	cin >> n;
  31. 	int u,v;
  32. 	cin >> u >> v;
  33. 	for (int i = 1;i <= n - 1;i++) {
  34. 		scanf("%d%d",&x,&y);
  35. 		add(x,y);
  36. 		add(y,x);
  37. 	}
  38. 	dfs(1,0);
  39. 	while (u != v) {
  40. 		if (dep[u] > dep[v]) {
  41. 			u = fa[u];
  42. 		} else {
  43. 			v = fa[v];
  44. 		}
  45. 	}
  46. 	cout << u;
  48. 	return 0;

4.4 树的重心

求出每个结点删除后的最大子树的大小，并求出该值的最小值，最后循环看哪些树删除后子树大小==所求的最小值，哪些结点就是重心。

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int n,x,y;
  7. struct node{
  8. 	int to,next;
  9. }a[N * 2];
  10. int pre[N];
  11. int k = 0;
  12. int dep[N],fa[N],si[N];
  13. int ma[N];
  14. int mi = INT_MAX;
  15. void add(int x,int y) {
  16. 	a[++k] = {y,pre[x]};
  17. 	pre[x] = k;
  18. }
  19. bool vis[N];
  21. int dfs(int x,int fath) {
  22. 	dep[x] = dep[fath] + 1;
  23. 	fa[x] = fath;
  24. 	si[x] = 1;
  25. 	for (int i = pre[x];i;i = a[i].next) {
  26. 		if (a[i].to != fath) {
  27. 			si[x] += dfs(a[i].to,x);
  28. 		}
  29. 	}
  30. 	return si[x];
  31. }
  33. int main() {
  34. 	cin >> n;
  35. 	for (int i = 1;i <= n - 1;i++) {
  36. 		scanf("%d%d",&x,&y);
  37. 		add(x,y);
  38. 		add(y,x);
  39. 	}
  40. 	dfs(1,0);
  41. 	for (int i = 1;i <= n;i++) {
  42. 		ma[i] = n - si[i];
  43. 		for (int j = pre[i];j;j = a[j].next) {
  44. 			if (a[j].to != fa[i]) {
  45. 				ma[i] = max(ma[i],si[a[j].to]);
  46. 			}
  47. 		}
  48. 		mi = min(ma[i],mi);
  49. 	}
  50. 	for (int i = 1;i <= n;i++) {
  51. 		if (ma[i] == mi) {
  52. 			cout << i << " ";
  53. 		}
  54. 	}
  55. 	return 0;
  56. }

5.最长公共子序列（LCS）

5.1 \(O(n^2)\) 做法

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 1010;
  6. int n, dp[N][N], a[N], b[N];
  7. int main() {
  8.     cin >> n;
  9.     for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
  10.     for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
  11.     for (int i = 1; i <= n; i++) {
  12.         for (int j = 1; j <= n; j++) {
  13.             if (a[i] == b[j]) {
  14.                 dp[i][j] = dp[i - 1][j - 1] + 1;
  15.             } else {
  16.                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
  17.             }
  18.         }
  19.     }
  20.     printf("%d", dp[n][n]);
  21.     return 0;
  22. }

5.2 \(O(n \log n)\) 做法

点击查看代码 
  1. #include <iostream>
  3. using namespace std;
  5. const int N = 1e5 + 10;
  6. int dp[N], a[N], b[N], n, c[N];
  7. int main() {
  8.     cin >> n;
  9.     for (int i = 1; i <= n; i++) {
  10.         cin >> a[i];
  11.         c[a[i]] = i;
  12.     }
  13.     for (int i = 1; i <= n; i++) {
  14.         cin >> b[i];
  15.     }
  16.     dp[1] = c[b[1]];
  17.     int k = 1;
  18.     for (int i = 2; i <= n; i++) {
  19.         if (c[b[i]] > dp[k]) {
  20.             dp[++k] = c[b[i]];
  21.         } else {
  22.             int p = lower_bound(dp + 1, dp + k + 1, c[b[i]]) - dp;
  23.             dp[p] = c[b[i]];
  24.         }
  25.     }
  26.     printf("%d", k);
  27.     return 0;
  28. }

6. 并查集

6.1 朴素并查集

点击查看代码 
  1. int find(int x) {
  2. 	if (x == fa[x]) return x;
  3. 	return find(fa[x]);
  4. }
点击查看代码 
  1. void merge(int x, int y) {
  2. 	int rx = find(x), ry = find(y);
  3. 	if (rx != ry) fa[rx] = ry;
  4. }

6.2 路径压缩

点击查看代码 
  1. int find(int x) {
  2. 	if (x == fa[x]) return x;
  3. 	return fa[x] = find(fa[x]);
  4. }

7. 最小生成树

7.1 \(Kustral\) 算法

点击查看代码 
  1. for (int i = 1;i <= k;i++) {
  2. 		if (find(a[i].x) != find(a[i].y)) {
  3. 			merge(a[i].x, a[i].y);
  4. 			sum += a[i].len;
  5. 			c++;
  7. 			if (c == n - 1) {
  8. 				printf("%d", sum);
  9. 				return 0;
  10. 			}
  11. 		}
  12. 	}

8. 素数筛法

8.1 埃氏筛法

点击查看代码 
  1. #include <bits/stdc++.h>
  3. using namespace std;
  5. const int N = 1e6 + 10;
  6. bool f[N];
  7. int n, ans;
  8. int main() {
  9. 	scanf("%d", &n);
  10. 	f[0] = f[1] = true;
  11. 	for (int i = 2;i <= sqrt(n);i++) {
  12. 		if (!f[i]) {
  13. 			for (int j = i * 2;j <= n;j += i) {
  14. 				if (!f[j]) {
  15. 					f[j] = true;
  16. 				}
  17. 			}
  18. 		}
  19. 	}
  20. 	for (int i = 1; i <= n; i++) {
  21. 		if (!f[i]) ans++;
  22. 	}
  23. 	printf("%d", ans);
  24. 	return 0;
  25. }

8.2 欧拉筛法

点击查看代码 
  1. f[0] = f[1] = true;
  2. 	for (int i = 2;i <= e;i++) {
  3. 		if (!f[i]) primes[++k] = i;
  4. 		for (int j = 1;i * primes[j] <= e;j++) {
  5. 			f[i * primes[j]] = true;
  6. 			if (i % primes[j] == 0) break;
  7. 		}
  8. 	}

C++常见算法&数据结构模版的更多相关文章

  1. acm常见算法及例题

    转自:http://blog.csdn.net/hengjie2009/article/details/7540135 acm常见算法及例题  初期:一.基本算法:     (1)枚举. (poj17 ...

  2. 经典面试题（二）附答案 算法+数据结构+代码 微软Microsoft、谷歌Google、百度、腾讯

    1.正整数序列Q中的每个元素都至少能被正整数a和b中的一个整除,现给定a和b,需要计算出Q中的前几项, 例如,当a=3,b=5,N=6时,序列为3,5,6,9,10,12 (1).设计一个函数void ...

  3. 算法数据结构 | 只要30行代码，实现快速匹配字符串的KMP算法

    本文始发于个人公众号:TechFlow,原创不易,求个关注 今天是算法数据结构专题的第29篇文章,我们来聊一个新的字符串匹配算法--KMP. KMP这个名字不是视频播放器,更不是看毛片,它其实是由Kn ...

  4. Hadoop学习笔记—12.MapReduce中的常见算法

    一.MapReduce中有哪些常见算法 (1)经典之王:单词计数 这个是MapReduce的经典案例,经典的不能再经典了! (2)数据去重 "数据去重"主要是为了掌握和利用并行化思 ...

  5. [Machine Learning] 机器学习常见算法分类汇总

    声明:本篇博文根据http://www.ctocio.com/hotnews/15919.html整理,原作者张萌,尊重原创. 机器学习无疑是当前数据分析领域的一个热点内容.很多人在平时的工作中都或多 ...

  6. 常见算法是js实现汇总（转载）

    常见算法是js实现汇总 /*去重*/ <script> function delRepeat(arr){ var newArray=new Array(); var len=arr.len ...

  7. paper 12：机器学习常见算法分类汇总

    机器学习无疑是当前数据分析领域的一个热点内容.很多人在平时的工作中都或多或少会用到机器学习的算法.这里南君先生为您总结一下常见的机器学习算法,以供您在工作和学习中参考. 机器学习的算法很多.很多时候困 ...

  8. AI - 机器学习常见算法简介（Common Algorithms）

    机器学习常见算法简介 - 原文链接:http://usblogs.pwc.com/emerging-technology/machine-learning-methods-infographic/ 应 ...

  9. 前端常见算法的JS实现

    1.冒泡排序 function bubbleSort(arr){ var i = 0, j = 0; for(i=1; i<arr.length; i++){ for(j=0; j<=ar ...

  10. Java 中常见的数据结构

    1.数据结构有什么作用? 当使用 Java 里面的容器类时,你有没有想过,怎么 ArrayList 就像一个无限扩充的数组,也好像链表之类的.很好使用,这就是数据结构的用处,只不过你在不知不觉中使用了 ...

随机推荐

  1. Tauri-Admin通用后台管理系统|tauri+vue3+pinia桌面端后台EXE

    基于tauri+vite4+pinia2跨端后台管理系统应用实例TauriAdmin. tauri-admin 基于最新跨端技术 Tauri Rust webview2 整合 Vite4 构建桌面端通 ...

  2. 现代C++（Modern C++）基本用法实践：四、模板

    概述 C++的模板是泛型编程思想的一种实现.C++是强类型语言,处处强调类型.同样的加法运算,int和float的加法运算需定义两个函数(重载),而使用模板则可以只用一个函数(见下面示例). 这类似我 ...

  3. C# 12新预览功能介绍

    Visual Studio 17.7 Preview 3和.NET 8 Preview 6延续了C# 12的发展.该预览版包含的功能旨在为未来的性能增强奠定基础.对内联数组的轻松访问将允许库在更多地方 ...

  4. PDF书签的编辑器，基于（python、Tkinter）

    使用 脚本 在github下载源码. 安装python3 安装必要的python包 pip install numpy pip install pandas pip install PyMuPDF p ...

  5. ranger2.1.0源码编译以及安装

    ranger2.1.0源码编译以及安装 编译环境准备 环境需求 示例版本 JDK8 Java(TM) SE Runtime Environment (build 1.8.0_231-b11) mave ...

  6. 探索Java通信面试的奥秘：揭秘IO模型、选择器和网络协议，了解面试中的必备知识点！

    了解常见的TCP/UDP TCP(Transmission Control Protocol)是一种面向连接的可靠的传输协议.类似于打电话,它通过建立一个连接和保证数据的可靠传输来提高通信的可靠性.然 ...

  7. Module build failed: TypeError: this.getOptions is not a function at Object.loader

    这个问题主要是因为node-loader版本过高导致的问题 解决方案 css-loader降为3.6.0版本即可 npm install css-loader@2.0.2 --save-dev npm ...

  8. CF1601 题解

    偶然看这一场的题目,忽然很有感觉,于是写了一下 A 题面 考虑每一位可以单独分开考虑 考虑单独的一位,每次要选 \(m\) 个位置,可能产生贡献的位置就是这位为 1 的数,设数量为 \(x\),则 \ ...

  9. cesium 绑定dom弹窗（跟随模型）

    https://blog.csdn.net/qq_36266612/article/details/109648367?utm_term=cesium%E6%80%8E%E4%B9%88%E6%B7% ...

  10. 部署安装maven和mvnd

    前言 maven是常见的java构建工具,优点是稳定可靠,缺点是构建太慢,maven-mvnd是maven的强化版,致力于提高构建速度,默认情况下,mvnd 使用多核CPU并行构建. 常见的java构 ...