【算法】王晓东期末考题总结（一）

文章目录

  • 分治
  • 动态规划
  • 贪心算法

分治

实现思路可参考：【算法】分治算法
之前写的Java版有思路。

  1. 二分搜索
#include <iostream>
#include <vector>using namespace std;// 二分搜索函数
int binarySearch(const vector<int>& array, int target) {int left = 0;int right = array.size() - 1;while (left <= right) {int mid = left + (right - left) / 2;// 如果找到目标元素，返回其索引if (array[mid] == target) {return mid;}// 如果目标元素在数组的左半部分，缩小搜索范围到左半部分if (array[mid] > target) {right = mid - 1;}// 如果目标元素在数组的右半部分，缩小搜索范围到右半部分else {left = mid + 1;}}// 如果数组中没有找到目标元素，返回-1表示未找到return -1;
}int main() {vector<int> array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};int target = 6;// 调用二分搜索函数int result = binarySearch(array, target);// 输出结果if (result != -1) {cout << "元素 " << target << " 在数组中的索引为 " << result << endl;} else {cout << "未找到元素 " << target << endl;}return 0;
}
  1. 合并排序
#include <iostream>
#include <vector>using namespace std;// 合并两个有序数组
void merge(vector<int>& array, int left, int mid, int right) {int n1 = mid - left + 1;int n2 = right - mid;// 创建临时数组存储左右两个子数组vector<int> leftArray(n1);vector<int> rightArray(n2);// 复制数据到临时数组 leftArray 和 rightArrayfor (int i = 0; i < n1; i++) {leftArray[i] = array[left + i];}for (int j = 0; j < n2; j++) {rightArray[j] = array[mid + 1 + j];}// 合并左右子数组int i = 0; // 初始化左子数组的索引int j = 0; // 初始化右子数组的索引int k = left; // 初始化合并后的数组的索引while (i < n1 && j < n2) {if (leftArray[i] <= rightArray[j]) {array[k] = leftArray[i];i++;} else {array[k] = rightArray[j];j++;}k++;}// 将左子数组的剩余部分复制到合并后的数组while (i < n1) {array[k] = leftArray[i];i++;k++;}// 将右子数组的剩余部分复制到合并后的数组while (j < n2) {array[k] = rightArray[j];j++;k++;}
}// 归并排序
void mergeSort(vector<int>& array, int left, int right) {if (left < right) {// 找到数组的中间位置int mid = left + (right - left) / 2;// 递归地对左右两部分进行排序mergeSort(array, left, mid);mergeSort(array, mid + 1, right);// 合并已排序的两部分merge(array, left, mid, right);}
}int main() {vector<int> array = {12, 11, 13, 5, 6, 7};cout << "原始数组: ";for (int num : array) {cout << num << " ";}cout << endl;// 调用归并排序函数mergeSort(array, 0, array.size() - 1);cout << "排序后的数组: ";for (int num : array) {cout << num << " ";}cout << endl;return 0;
}
  1. 快速排序
#include <iostream>
#include <vector>using namespace std;// 交换数组中两个元素的位置
void swap(vector<int>& array, int i, int j) {int temp = array[i];array[i] = array[j];array[j] = temp;
}// 根据选定的基准元素将数组划分为两部分，并返回基准元素的索引
int partition(vector<int>& array, int low, int high) {// 选择最右侧元素作为基准int pivot = array[high];int i = low - 1;  // i是小于等于基准元素的子数组的最后一个元素的索引// 遍历数组，将小于等于基准元素的元素放在左侧，大于基准元素的元素放在右侧for (int j = low; j < high; j++) {if (array[j] <= pivot) {i++;swap(array, i, j);}}// 将基准元素放在正确的位置swap(array, i + 1, high);return i + 1;
}// 快速排序的递归函数
void quickSort(vector<int>& array, int low, int high) {if (low < high) {// 划分数组，获取基准元素的索引int pivotIndex = partition(array, low, high);// 递归排序左侧子数组quickSort(array, low, pivotIndex - 1);// 递归排序右侧子数组quickSort(array, pivotIndex + 1, high);}
}int main() {vector<int> array = {12, 4, 5, 6, 7, 3, 1, 15};cout << "Original array: ";for (int num : array) {cout << num << " ";}// 调用快速排序算法quickSort(array, 0, array.size() -1);cout << "\nSorted array: ";for (int num : array) {cout << num << " ";}return 0;
}
  1. 最接近点对问题

最接近点对问题是一个经典的计算几何问题，目标是找到平面上一组点中距离最近的两个点。分治算法是解决这个问题的一种有效方法。下面是最接近点对问题的分治算法实现思路：

  • 按照 x 坐标将点集排序：
    将点集按照 x 坐标的顺序进行排序。这可以通过常见的排序算法（如快速排序）实现。
  • 分治：
    将排序后的点集平均分成两部分，分别递归求解左右两部分的最接近点对。
  • 查找跨越中间的最接近点对：
    在左右两部分的边界附近，找到距离中间线最近的两个点。这一步的时间复杂度是线性的。
  • 合并：
    比较左右两部分的最接近点对，选择其中的最小值作为候选。
  • 找到最终的最接近点对：
    在之前的步骤中，我们找到了两个候选点对，分别来自左右两部分。最终的最接近点对要么在其中一个部分，要么跨越两个部分。
  • 计算最终的最接近点对：
    在考虑跨越边界的情况时，需要检查距离边界线距离小于当前最小距离的点。如果找到更小的距离，更新最小距离。
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <limits>using namespace std;struct Point {double x, y;
};// 按照 x 坐标升序排序
bool compareX(const Point& a, const Point& b) {return a.x < b.x;
}// 按照 y 坐标升序排序
bool compareY(const Point& a, const Point& b) {return a.y < b.y;
}// 计算两点之间的距离
double distance(const Point& a, const Point& b) {return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
}// 暴力解法，计算所有点对之间的距离，找到最小值
pair<Point, Point> bruteForceClosestPair(const vector<Point>& points, int left, int right) {double minDist = numeric_limits<double>::max();pair<Point, Point> closestPair;for (int i = left; i <= right; ++i) {for (int j = i + 1; j <= right; ++j) {double dist = distance(points[i], points[j]);if (dist < minDist) {minDist = dist;closestPair = {points[i], points[j]};}}}return closestPair;
}// 在给定的点集中找到最接近的点对
pair<Point, Point> closestPairUtil(const vector<Point>& points, int left, int right) {if (right - left <= 3) {// 对于小规模问题，使用暴力解法return bruteForceClosestPair(points, left, right);}int mid = (left + right) / 2;// 分别递归求解左右两边的最近点对pair<Point, Point> leftClosest = closestPairUtil(points, left, mid);pair<Point, Point> rightClosest = closestPairUtil(points, mid + 1, right);// 取左右两边的最近点对中的最小距离double minDist = min(distance(leftClosest.first, leftClosest.second),distance(rightClosest.first, rightClosest.second));// 在距离中间线小于minDist的点集中查找可能更小的距离vector<Point> strip;for (int i = left; i <= right; ++i) {if (abs(points[i].x - points[mid].x) < minDist) {strip.push_back(points[i]);}}// 按照 y 坐标升序排序 stripsort(strip.begin(), strip.end(), compareY);// 在 strip 中查找可能更小的距离for (int i = 0; i < strip.size(); ++i) {for (int j = i + 1; j < strip.size() && (strip[j].y - strip[i].y) < minDist; ++j) {double dist = distance(strip[i], strip[j]);if (dist < minDist) {minDist = dist;leftClosest = {strip[i], strip[j]};}}}// 返回最终的最近点对return leftClosest;
}// 最接近点对算法的入口函数
pair<Point, Point> closestPair(const vector<Point>& points) {// 按照 x 坐标升序排序点集vector<Point> sortedPoints = points;sort(sortedPoints.begin(), sortedPoints.end(), compareX);return closestPairUtil(sortedPoints, 0, sortedPoints.size() - 1);
}int main() {vector<Point> points = {{0, 0}, {1, 1}, {2, 2}, {3, 3}, {5, 5}, {7, 7}, {8, 8}};// 调用最接近点对算法pair<Point, Point> closestPairPoints = closestPair(points);// 输出结果cout << "最接近点对: (" << closestPairPoints.first.x << ", " << closestPairPoints.first.y << ") and ("<< closestPairPoints.second.x << ", " << closestPairPoints.second.y << ")" << endl;return 0;
}

动态规划

实现思路可参考：【算法】动态规划（Dynamic Programming）

  1. 矩阵连乘
#include<iostream>
using namespace std;#define N 7  //N为7，实际表示有6个矩阵
/*
*矩阵链构造函数：构造m[][]和s[][]
*m中存储的值是计算出来的最小乘法次数，比如m[1][5]就是A1A2A3A4A5的最小乘法次数
*s中存储的是获取最小乘法次数时的断链点，s[1][5]对应的就是如何拆分A1A2A3A4A5,
*比如S[1][5]=3可表示：(A1A2A3)(A4A5)，当然内部断链还会继续划分A1A2A3
*/
int MatrixChain(int *p, int n, int m[][N], int s[][N]){for(int i=1;i<=n;i++){     //矩阵链中只有一个矩阵时，次数为0，注意m[0][X]时未使用的m[i][i]=0;}for(int r=2;r <= n;r++){    //矩阵链长度,从长度为2开始for(int i=1;i <= n-r+1;i++){    //根据链长度，控制链最大的可起始点int j = i+(r-1);  //矩阵链的末尾矩阵，注意r-1，因为矩阵链为2时，实际是往右+1m[i][j] = m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];   //先设置最好的划分方法就是直接右边开刀，后续改正，也可合并到下面的for循环中s[i][j]=i;for(int k=i+1;k < j;k++){   //这里面将断链点从i+1开始，可以断链的点直到j-1为止int t = m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];if(t<m[i][j]){m[i][j] = t;s[i][j] = k;}}}}return m[1][n];
}
/*
*追踪函数：根据输入的i,j限定需要获取的矩阵链的始末位置，s存储断链点
*/
void Traceback(int i,int j, int s[][N]){if(i==j)       //回归条件{cout<<"A"<<i;}else       //按照最佳断点一分为二，接着继续递归{cout<<"(";Traceback(i,s[i][j],s);Traceback(s[i][j]+1,j,s);cout<<")";}
}
int main(){int p[N]={30,35,15,5,10,20,25};int m[N][N],s[N][N];int minCost = MatrixChain(p,N-1,m,s);//N-1因为只有六个矩阵Traceback(1,6,s);cout << "最小计算代价为: " << minCost << endl;return 0;
}
  1. 流水作业调度

流水作业调度问题（Flow Shop Scheduling Problem）是一个经典的调度问题，通常涉及到多个作业（jobs）需要在多台机器上执行。每个作业都有一系列的任务（tasks），并且每个任务需要在不同的机器上执行。流水作业调度的目标是找到一个调度方案，使得完成所有作业的时间最短。

参考：法设计与分析】流水作业调度问题 动态规划算法与代码实现 超详细

#include<iostream>
#include<algorithm>
#include<math.h>
#define NUM 5		//工件总数
#define POWNUM 32	//2^NUM 状态总数using namespace std;//2 5 7 3 6 2 4 7 6 9 8 2
//答案：35//2 5 4 2 3 3 6 1 1 7
//答案：19class JiHe
{
public:int a[NUM];			//1:被加工 0:不被加工int num;			//当前状态下 被加工的工件个数int minTime[100];	//数组下标是等待时间t
};class GongJian
{
public:int t1;				//该工件在 M1 上加工需要的时间int t2;				//该工件在 M2 上加工需要的时间
};GongJian gongjian[NUM];
JiHe jihe[POWNUM];//寻找最小时间的递归函数
int findMinTime(JiHe jihe, int t)
{if (jihe.num == 0)			//集合中无元素时 等待时间就是加工时间{return t;}int i;int curMinTime;int mintime = 1000;			//初始化巨大值JiHe withoutI = jihe;for (i = 0; i < NUM; i++)	//i放在第一个加工 循环找到最小值情况下的i 但是i没有被记录{withoutI = jihe;if (jihe.a[i] == 1){withoutI.a[i] = 0;withoutI.num = jihe.num - 1;curMinTime = gongjian[i].t1 + findMinTime(withoutI, gongjian[i].t2 + max(t - gongjian[i].t1, 0));if (curMinTime < mintime){mintime = curMinTime;}}}return mintime;
}int main()
{//每个工件的时间状况cout << "请输入工件在机器M1 M2上的加工时间：\n";for (int i = 0; i < NUM; i++){cout << "工件序号" << i << "的加工时间\n";cout << "t1 = ";cin >> gongjian[i].t1;cout << "t2 = ";cin >> gongjian[i].t2;}//填写每个工件在与不在的状态 32个int i;int x[NUM];for (int i = 0; i < NUM; i++)//用于二进制计数{x[i] = 1;}int num;int t, p;for (i = 0; i < POWNUM; i++){//二进制计数 罗列所有工件组合for (t = NUM - 1, p = 0; t >= 0; t--, p++){if ((i % (int)pow(2, t)) == 0){x[p] = -x[p];}}/*if (i % 32 == 0)x[0] = -x[0];if (i % 16 == 0)x[1] = -x[1];if (i % 8 == 0)x[2] = -x[2];if (i % 4 == 0)x[3] = -x[3];if (i % 2 == 0)x[4] = -x[4];if (i % 1 == 0)x[5] = -x[5];*/for (t = 0; t < NUM; t++)//把-1改成0{jihe[i].a[t] = (x[t] > 0 ? x[t] : 0);}/*jihe[i].a[0] = (x[0] > 0 ? x[0] : 0);jihe[i].a[1] = (x[1] > 0 ? x[1] : 0);jihe[i].a[2] = (x[2] > 0 ? x[2] : 0);jihe[i].a[3] = (x[3] > 0 ? x[3] : 0);jihe[i].a[4] = (x[4] > 0 ? x[4] : 0);jihe[i].a[5] = (x[5] > 0 ? x[5] : 0);*///填写当前状态下有几个工件被加工 numnum = 0;for (int j = 0; j < NUM; j++){if (jihe[i].a[j] == 1)num++;}jihe[i].num = num;}//自底向上 计算每个状态的最短时间int k;int workNum;for (workNum = 0; workNum <= NUM; workNum++){// 0,1,2,...,workNum 个工件被加工for (i = 0; i < POWNUM; i++){if (jihe[i].num == workNum){//等待时间kfor (k = 0; k < 100; k++){jihe[i].minTime[k] = findMinTime(jihe[i], k);}}}}cout << "最短时间:" << jihe[POWNUM - 1].minTime[0] << endl;system("pause");
}
  1. 背包问题
#include <iostream>
#include <vector>
#include <algorithm>using namespace std;// 物品结构体
struct Item {int weight; // 物品重量int value;  // 物品价值
};// 动态规划解决0/1背包问题
int knapsack(const vector<Item>& items, int capacity) {int numItems = items.size();// 创建二维数组存储最大价值vector<vector<int>> dp(numItems + 1, vector<int>(capacity + 1, 0));// 填充动态规划表for (int i = 1; i <= numItems; i++) {for (int w = 1; w <= capacity; w++) {if (items[i - 1].weight <= w) {// 当前物品可以放入背包dp[i][w] = max(dp[i - 1][w], items[i - 1].value + dp[i - 1][w - items[i - 1].weight]);} else {// 当前物品不能放入背包dp[i][w] = dp[i - 1][w];}}}// 返回最终的最大价值return dp[numItems][capacity];
}int main() {// 定义一组物品vector<Item> items = {{2, 3}, {3, 4}, {4, 5}, {5, 6}};// 背包容量int capacity = 8;// 调用0/1背包问题算法int maxValue = knapsack(items, capacity);// 输出结果cout << "背包中物品的最大总价值为: " << maxValue << endl;return 0;
}

贪心算法

实现思路可参考：【算法】贪心算法

  1. 最优装载问题（首次适用）
#include <iostream>
#include <vector>using namespace std;// 最优装载问题的首次适应算法
int firstFit(const vector<int>& items, int binCapacity) {int numBins = 0;vector<int> binSpace; // 每个容器的剩余空间for (int item : items) {bool binFound = false;// 在现有的容器中找到第一个可以装下当前物品的容器for (int i = 0; i < numBins; i++) {if (binSpace[i] >= item) {binSpace[i] -= item;binFound = true;break;}}// 如果没有找到合适的容器，则开启一个新的容器if (!binFound) {binSpace.push_back(binCapacity - item);numBins++;}}return numBins;
}int main() {// 定义一组物品vector<int> items = {4, 8, 1, 4, 2, 1, 8, 5};// 容器的容量int binCapacity = 10;// 调用首次适应算法解决最优装载问题int numBins = firstFit(items, binCapacity);// 输出结果 4cout << "最优装载问题的最小容器数量（首次适应算法）为: " << numBins << endl;return 0;
}
  1. 单源最短路径

贪心算法解决单源最短路径问题的经典算法是Dijkstra算法。Dijkstra算法通过贪心策略逐步确定从源节点到各个其他节点的最短路径，具体实现思路如下：

  • 初始化：
    将源节点到自身的距离设为0，将源节点到其他所有节点的距离设为无穷大（或一个较大的数）。
  • 选择最短路径节点：
    从未确定最短路径的节点中选择一个节点，该节点到源节点的距离最短。一开始选择源节点。
  • 更新距离：
    对于选定的节点，更新它的邻居节点到源节点的距离。如果通过选定节点到某个邻居节点的路径比当前已知的最短路径更短，则更新邻居节点的距离。
  • 标记节点：
    将选定的节点标记为已确定最短路径。
  • 重复步骤2~4：
    重复步骤2~4，直到所有节点都被标记为已确定最短路径或者没有可选的节点。
#include <iostream>
#include <vector>
#include <set>
#include <limits>using namespace std;const int INF = numeric_limits<int>::max();// 图的邻接矩阵表示
using Graph = vector<vector<int>>;// Dijkstra算法实现
void dijkstra(const Graph& graph, int source, vector<int>& distances) {int n = graph.size();set<pair<int, int>> pq;  // 优先队列，用于选择当前距离最短的节点distances.resize(n, INF);distances[source] = 0;pq.insert({0, source});while (!pq.empty()) {int u = pq.begin()->second;pq.erase(pq.begin());for (int v = 0; v < n; ++v) {if (graph[u][v] != INF && distances[u] + graph[u][v] < distances[v]) {// 更新距离pq.erase({distances[v], v});distances[v] = distances[u] + graph[u][v];pq.insert({distances[v], v});}}}
}int main() {// 例子：有向图的邻接矩阵表示Graph graph = {{0, 1, 4, INF, INF},{INF, 0, 2, 5, INF},{INF, INF, 0, INF, 1},{INF, INF, INF, 0, 3},{INF, INF, INF, INF, 0}};int source = 0;  // 源节点vector<int> distances;  // 存储最短路径长度dijkstra(graph, source, distances);// 输出结果cout << "从节点 " << source << " 出发到各节点的最短路径长度：" << endl;for (int i = 0; i < distances.size(); ++i) {cout << "到节点 " << i << " 的最短路径长度为: " << distances[i] << endl;}return 0;
}

graph是一个有向图的邻接矩阵表示，source 是源节点的编号。dijkstra 函数实现了Dijkstra算法，其中使用了一个优先队列来选择当前距离最短的节点。最终，distances 向量存储了从源节点到各个节点的最短路径长度。
3. 最小生成树

贪心算法解决最小生成树问题的一个经典算法是Prim算法。Prim算法基于贪心策略，逐步构建最小生成树。以下是Prim算法的实现思路：

  • 选择起始节点：
    从图中选择一个起始节点作为最小生成树的起点。
  • 初始化集合：
    将起始节点加入一个集合，表示已经包含在最小生成树中的节点。
  • 选择最短边：
    从已选择的节点集合中，选择一条连接到未选择节点的最短边。
  • 将节点加入集合：
    将该边连接的未选择节点加入节点集合。
  • 重复步骤3~4：
    重复步骤3和4，直到所有节点都包含在最小生成树中。
#include <iostream>
#include <vector>
#include <set>
#include <limits>using namespace std;const int INF = numeric_limits<int>::max();// 图的邻接矩阵表示
using Graph = vector<vector<int>>;// Prim算法实现
void prim(const Graph& graph, int start) {int n = graph.size();// 使用集合存储已选择的节点set<int> selectedNodes;// 初始化起始节点selectedNodes.insert(start);// 重复选择最短边，直到所有节点都被选择while (selectedNodes.size() < n) {int minWeight = INF;int minNode = -1;// 在已选择的节点集合中，找到一条连接到未选择节点的最短边for (int node : selectedNodes) {for (int neighbor = 0; neighbor < n; ++neighbor) {if (graph[node][neighbor] < minWeight && selectedNodes.find(neighbor) == selectedNodes.end()) {minWeight = graph[node][neighbor];minNode = neighbor;}}}// 输出最短边的信息cout << "Edge: (" << minNode << ", " << minWeight << ")" << endl;// 将连接的未选择节点加入集合selectedNodes.insert(minNode);}
}int main() {// 例子：无向图的邻接矩阵表示Graph graph = {{0, 2, INF, 6, INF},{2, 0, 3, 8, 5},{INF, 3, 0, INF, 7},{6, 8, INF, 0, 9},{INF, 5, 7, 9, 0}};int startNode = 0;  // 起始节点cout << "最小生成树的边：" << endl;prim(graph, startNode);return 0;
}

graph 是一个无向图的邻接矩阵表示，startNode 是起始节点的编号。prim 函数实现了Prim算法，它使用一个集合 selectedNodes 来存储已选择的节点。算法通过在已选择的节点中找到一条连接到未选择节点的最短边，将未选择节点加入集合，并输出最短边的信息。最终，算法输出了构建最小生成树的边。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/583558.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Flask笔记四之异常处理

Flask笔记四之异常处理

本文首发于公众号&#xff1a;Hunter后端 原文链接&#xff1a;Flask笔记四之异常处理 在系统运行中&#xff0c;有时候需要处理报错异常。 异常的来源可能是系统在运行中的报错&#xff0c;比如错误的运算的有 1/0 这种等&#xff0c;还有的是访问了不存在接口&#xff0c;又…
阅读更多...
docker 部署mysql

docker 部署mysql

docker pull mysql:5.7.25 docker run \ --name mysql \ -e MYSQL_ROOT_PASSWORD123456 \ -p 3306:3306 \ -v /soft/mysql/conf:/etc/mysql \ -v /soft/mysql/data:/var/lib/mysql \-d \mysql:5.7.25安装好之后可以用命令行进入查看 docker exec -it mysql mysql -u root -p密…
阅读更多...
解决ROS含动态参数的Config文件无法正确识别的错误

解决ROS含动态参数的Config文件无法正确识别的错误

问题描述 功能包名为paddle_detection 在工作空间下, 通过catkin_make可以正常通过编译且执行无异常, 可以通过bloom-generate rosdebian生成依赖 但是在将其打包成deb包的过程中fakeroot debian/rules binary报错 fatal error: paddle_detection/paddle_detectionConfig.…
阅读更多...
116基于matlab的盲源信号分离

116基于matlab的盲源信号分离

基于matlab的盲源信号分离。FASTICA方法&#xff0c;能够很好的将信号解混&#xff0c;可以替换数据进行分析。具有GUI界面&#xff0c;可以很好的进行操作。程序已调通&#xff0c;可直接运行。 116matlab盲源信号分离FASTICA (xiaohongshu.com)
阅读更多...
IDEA搜索指定某个类的方法的引用位置

IDEA搜索指定某个类的方法的引用位置

搜索方法引用位置的时候&#xff0c;如果该方法是接口定义出来的&#xff0c;则结果里会包含其他实现类的该方法的引用位置&#xff0c;但是像Object定义的Equals方法这种&#xff0c;搜索出来的结果是超级多的&#xff0c;根据没法看&#xff0c;因此想要只看该类的方法引用位…
阅读更多...
python的WebSocket编程详解，案例群聊系统实现

python的WebSocket编程详解，案例群聊系统实现

1.websocket相关 1.1为什么要用websocket 如果有需求要实现服务端向客户端主动推送消息时&#xff08;比如聊天室&#xff0c;群聊室&#xff09;有哪几种方案 轮训&#xff1a;让浏览器每隔两秒发送一次请求&#xff0c;缺点&#xff1a;有延时&#xff0c;请求太多网站压力…
阅读更多...
扭蛋机小程序搭建：打造互联网“流量池”

扭蛋机小程序搭建：打造互联网“流量池”

随着互联网科技的发展&#xff0c;扭蛋机小程序成为了市场发展的重要力量。 扭蛋机市从日本发展流行起来的&#xff0c;玩法就是根据设置的概率&#xff0c;让玩家体验扭蛋机的乐趣。扭蛋机中有隐藏款和稀有款&#xff0c;为了获得稀有款商品&#xff0c;玩家便会进行扭蛋&…
阅读更多...
Zabbix图形显示乱码修复

Zabbix图形显示乱码修复

2023年12月29日&#xff0c;星期五&#xff0c;2023年最后一个工作日了&#xff0c;明天就开始放假元旦了&#xff0c;去年水了31篇&#xff0c;今年到目前为止才水了30篇&#xff0c;所以这篇也水一下来充个数。祝大家元旦快乐&#xff0c;新的一年里越来越好。 被监控主机指…
阅读更多...
Vue3-26-路由-useRouter 和 useRoute 两个API 的作用介绍

Vue3-26-路由-useRouter 和 useRoute 两个API 的作用介绍

先来说说两个API 的作用 useRouter() : 返回的是项目中的 路由实例的对象 可以通过这个实例对象进行路由的逻辑跳转 useRoute() : 返回的是当前的 路由对象&#xff0c; 可以在当前路由对象中获取到路由名称、路由参数、路由路径等玩完整的路由信息。 写个案例看一下具体是什么…
阅读更多...
二、类与对象（三）

二、类与对象（三）

17 初始化列表 17.1 初始化列表的引入 之前我们给成员进行初始化时&#xff0c;采用的是下面的这种方式&#xff1a; class Date { public:Date(int year, int month, int day)//构造函数{_year year;_month month;_day day;} private:int _year;int _month;int _day; };…
阅读更多...
【数据结构和算法】独一无二的出现次数

【数据结构和算法】独一无二的出现次数

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 哈希类算法题注意事项 2.2 方法一&#xff1a;判断长度 2.3 方法二&#xff1a; set 判断 2.4 方法…
阅读更多...
《Linux系统与网络管理》---题库---简答题

《Linux系统与网络管理》---题库---简答题

1、简述这些分区的名字以及各自的作用。 答&#xff1a; /boot 存放内核镜像的地方&#xff0c;这个文件夹独立分区的意义在于降低不能开机的风险。 /根目录&#xff0c;一般采用 etx3 文件系统&#xff0c;分区的容量一定要大于安装软件包的容量。 /usr 多数软件的默认安装的地…
阅读更多...
HTTP 是哪⼀层的协议？简述它的作⽤？

HTTP 是哪⼀层的协议？简述它的作⽤？

theme: channing-cyan http协议是应用层的协议&#xff0c;主要用于web浏览器和服务器两点之间传输超文本的协议&#xff0c;它是一种⽆状态的协议&#xff0c;即服务器不 会保存关于客户端的任何信息&#xff0c;每次客户端发送请求&#xff0c;服务器都会返回响应。HTTP 协议…
阅读更多...
举个栗子~位操作到底有什么用【库仑计芯片MAX17043】

举个栗子~位操作到底有什么用【库仑计芯片MAX17043】

首先吐槽各个平台在卖的五花八门的库仑计芯片EV board&#xff0c;前后试了估计有4家不同的货&#xff0c;终于DFRobot给出最稳定也是最符合MAX17043说明书描述的效果。 本篇继续水&#xff0c;描述一下位操作的一个普遍用法&#xff0c;就是读写各类测量芯片。此处就拿MAX170…
阅读更多...
springboot(ssm交通管理在线服务系统 交通管理平台 Java系统

springboot(ssm交通管理在线服务系统 交通管理平台 Java系统

springboot(ssm交通管理在线服务系统 交通管理平台 Java系统 开发语言&#xff1a;Java 框架&#xff1a;ssm/springboot vue JDK版本&#xff1a;JDK1.8&#xff08;或11&#xff09; 服务器&#xff1a;tomcat 数据库&#xff1a;mysql 5.7&#xff08;或8.0&#xff09…
阅读更多...
AUTOSAR从入门到精通-可变速率 CAN 总线控制器设计与实现

AUTOSAR从入门到精通-可变速率 CAN 总线控制器设计与实现

目录 前言 研究现状 2通信协议及产品特性研究 2.1总线概述 2.2通信协议研究
阅读更多...
【资源分享】免费好用的API接口汇总

【资源分享】免费好用的API接口汇总

IP归属地-IPv4城市级&#xff1a;根据IP地址查询归属地信息&#xff0c;支持到城市级&#xff0c;包含国家、省、市、和运营商等信息。IP归属地-IPv6城市级&#xff1a;根据IP地址&#xff08;IPv6版本&#xff09;查询归属地信息&#xff0c;支持到中国大陆地区&#xff08;不…
阅读更多...
1317：【例5.2】组合的输出

1317：【例5.2】组合的输出

1317&#xff1a;【例5.2】组合的输出 时间限制: 1000 ms 内存限制: 65536 KB 【题目描述】 排列与组合是常用的数学方法&#xff0c;其中组合就是从n个元素中抽出r个元素(不分顺序且r≤n)&#xff0c;我们可以简单地将n个元素理解为自然数1&#xff0c;2&#xff0c;…&#…
阅读更多...
基于ssm食用菌菌棒溯源系统的开发与设计论文

基于ssm食用菌菌棒溯源系统的开发与设计论文

食用菌菌棒溯源系统 摘要 随着信息互联网购物的飞速发展&#xff0c;一般企业都去创建属于自己的管理系统。本文介绍了食用菌菌棒溯源系统的开发全过程。通过分析企业对于食用菌菌棒溯源系统的需求&#xff0c;创建了一个计算机管理食用菌菌棒溯源系统的方案。文章介绍了食用菌…
阅读更多...
深入理解Mysql MHA高可用集群搭建：从实验到实战

深入理解Mysql MHA高可用集群搭建：从实验到实战

1. 简介 MHA&#xff08;Master High Availability&#xff09;是一个高效的开源MySQL高可用性解决方案。由日本开发者yoshinorim&#xff08;前DeNA员工&#xff0c;现在Facebook&#xff09;创建&#xff0c;MHA支持MySQL的主从复制架构&#xff0c;自动化主节点故障转移。当…
阅读更多...
最新文章

Copyright @ 2022~2023