2-4基础算法-离散化/贪心/01背包问题

文章目录

  • 一.离散化
  • 二.贪心
  • 01背包问题

一.离散化

离散化是一种将数组的值域压缩，从而更加关注元素的大小关系的算法。
离散化数组要求内部有序（一般去重）
可以通过离散化下标得到值
也可以通过值得到离散化下标
在这里插入图片描述

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{int a[6] = { 0,3,1000,2,99999,2 };//原数组vector<int> L;for (int i = 1; i < 6; i++) {L.push_back(a[i]);}sort(L.begin(), L.end());auto b=unique(L.begin(), L.end());L.erase(b, L.end());for (int i = 0; i < L.size(); i++) {cout << L[i]<<" ";  //2 3 1000 99999}//获取1000在L中的下标.lower_bound返回从左到右第一个大于等于1000 的地址cout << lower_bound(L.begin(), L.end(), 1000) - L.begin();  //2

二.贪心

1.最小化战斗力差距
在这里插入图片描述
在这里插入图片描述
评测系统

分析：先进行排序，从某个位置划分，左侧是a，右侧是b。则max a和min b是相邻的。只需计算相邻两数的差最小值

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
const int N = 1e5 + 5;
int main()
{int n;cin >> n;int a[N] = { 0 };int minnum = INT_MAX;for (int i = 0; i < n; i++) {cin >> a[i];}sort(a, a + n);for (int i = 1; i < n; i++) {minnum = min(minnum, a[i] - a[i - 1]);}cout << minnum;
}

2.谈判
在这里插入图片描述
在这里插入图片描述
评测系统

分析：贪心：每次选择最小的两个部落合并

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e3 + 5;
int main()
{int n;cin >> n;int a[N] = { 0 };for (int i = 0; i < n; i++) {cin >> a[i];}sort(a, a + n);int sum = a[0];int sum2 = 0;int k = 1;while (k<n) {sum = sum + a[k++];sum2+=sum;}cout << sum2;
}

或优先队列

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int main()
{int n;cin >> n;priority_queue<int, vector<int>, greater<int>> queue;//小根堆，最小元素放到前面for (int i = 0; i < n; ++i) {int x;cin >> x;queue.push(x);}int sum = 0;while (queue.size() > 1) {int x = queue.top();queue.pop();int y = queue.top();queue.pop();queue.push(x + y);sum += x + y;}cout << sum;
}

3.纪念品分组
在这里插入图片描述
在这里插入图片描述

评测系统

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{int w, n;cin >> w >> n;vector<int> a(n);for (int i = 0; i < n; i++) {cin >> a[i];}sort(a.begin(), a.end());int i = 0, j = n - 1;int sum = 0;while (i <= j) {if (a[i] + a[j] <= w) {i++;j--;}else {j--;}sum++;}cout << sum;
}

或

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{int w, n;cin >> w >> n;vector<int> a(n);for (int i = 0; i < n; i++) {cin >> a[i];}sort(a.begin(), a.end());int i = 0, j = n - 1;int sum = n;while (i < j) { //注意：这里不能写成i!=j,因为当ij相邻时，若满足if，ij交换，仍可以继续进行，直到越界if (a[i] + a[j] <= w) {i++;j--;sum--;}else {j--;}}cout << sum;
}

4.分糖果
在这里插入图片描述
解读：
①字典序：apple排在banana前面，我们认为apple的字典序更小
②假设我们有6个糖果分给3个学生，可能的分法是：ab、cd、ef，则拿到ef的同学字典序最大
③使得字典序最大的字符串尽可能小：指的是字典序最大的字符串的字典序最小，而不是长度最短（除非只有一个种类的糖果）。一种可能的分法中，字典序最大的是abccd；另一种分法中，字典序最大的是d。我们会选择abccd这种分法作为最终结果

分析：
糖果的种类数可能有三种情况
①只有一个种类的糖果：应使分的字典序最大的（分的糖果数最多的）同学拿到的糖果尽可能少（字符串尽可能小）。也就是尽可能的均分。如我们有7个糖果，分为3个同学。应该是2/2/3的分法
②一共有n个糖果，分给x个同学。我们先将输入序列s排序，现在同种类的糖放在了一起。若第x个糖果的种类和第1个糖果的种类不一样。 我们将前x个糖果依次分给x个同学，则第x个同学拿到了字典序最大的，又由于序列是有序的，x对应的字典序一定是当前最小的。从x+1到n（若有）的糖果我们将其分给第一位同学，因为第一位同学的首字母一定小于第x位同学，所以该操作不会产生影响。
③一共有n个糖果，分给x个同学。我们先将输入序列s排序，现在同种类的糖放在了一起。**若第x个糖果的种类和第1个糖果的种类一样。**这时，第x个糖果的字典序一定是最小的（因为已经排序），我们直接输出[x,n]即为最终序列。如：aaaabbbbcccc，4人，显然最佳分配a/a/a/abbbbcccc>其他分配abbb/a/a/accc

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{int n, x;cin >> n >> x;vector<char> a(n + 1);for (int i = 1; i <= n; i++) {cin >> a[i];}sort(a.begin(), a.end());if (a[n] == a[1]) {if (n % x == 0) {int temp = n / x;while (temp--) {cout << a[1];}}else {int temp = n / x + 1;while (temp--) {cout << a[1];}}}else if (a[x] != a[1]) {cout << a[x];}else {for (int i = x; i <= n; i++) {cout << a[i];}}return 0;
}

5.最大的卡牌价值
在这里插入图片描述

评测系统

注：最多进行k次，并非一定要进行k次

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 1e5 + 5;
struct pro {int a;int b;
};
bool cmp(const pro& x, const pro& y) {return x.b - x.a > y.b - y.a;
}
int main()
{int n, k;pro arr[N];cin >> n >> k;long long sum = 0;for (int i = 0; i < n; i++) {cin >> arr[i].a;sum += arr[i].a;}for (int i = 0; i < n; i++) {cin >> arr[i].b;}sort(arr, arr + n, cmp);for (int i = 0; i < n; i++) {if (k == 0) {break;}if (arr[i].b > arr[i].a) {sum -= arr[i].a;sum += arr[i].b;k--;}}cout << sum;
}
//也可以定义三个数组运算

6.珠宝的最大交替和
在这里插入图片描述
在这里插入图片描述
评测系统

分析：先求和，然后奇数位找最小的，偶数位找最大的，交换。

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
int main()
{int n;cin >> n;vector<int> a(n);long long sum = 0;int ji=INT_MAX, ou=INT_MIN;for (int i = 0; i < n; i++) {cin >> a[i];if ( i % 2 == 0) {sum += abs(a[i]);ji = min(ji, abs(a[i]));}else {sum -= abs(a[i]);ou = max(ou, abs(a[i]));}}if(n>1&&ji<ou)sum = sum - 2 * ji + 2 * ou;cout << sum;
}

7.小蓝的礼物
在这里插入图片描述
在这里插入图片描述
评测系统

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <queue>
using namespace std;
int main()
{priority_queue<int, vector<int>, greater<int>> pq;int n, k;cin >> n >> k;for (int i = 0; i < n; i++) {int x;cin >> x;pq.push(x);}long long sum = 0;int num = 0;while (pq.size() > 0) {int x = pq.top();sum += x;num++;if (sum > k) {sum -= x;if (x % 2 == 0) {if (sum + x/2 > k) {num--;}}else{if (sum + x/2+1 > k) {num--;}}cout << num;return 0;}pq.pop();}cout << num;
}

8.四个瓷瓶的神秘游戏

在这里插入图片描述

评测系统

分析：当一个瓶子为空的时候，我们依然可以继续操作。当两个瓶子都为空的时候，我们无法操作。

在通过sort排序后，满足a[0]<=a[1]<=a[2]<=a[3]。我们先通过操作将a[0]变为空，可操作次数为a[0]内的珍珠数。此时最后一个瓶内珍珠数最多，为a[3]+2*a[0]

在此基础上，对其他瓶进行处理
因为a[2]不小于a[1]，所以能对a[1]进行的操作都可以对a[2]进行操作，我们假设a[2]和a[3]足够大。我们分别假设在a[0]为0时，a[1]分别取1~9，于是有：

在这里插入图片描述

以此类推，我们可以总结出

在这里插入图片描述

可以看出，相差模除为0时，a[1]和a[0]的差值就是a[3]要增加的值；差值模除为其他时，a[3]要增加的值为a[1]和a[0]的差值-1

于是有

#include <iostream>
#include <algorithm>
using namespace std;
int main() { long long x; long long a[4];for (int i = 0; i < 4; i++) {cin >> a[i];}sort(a, a + 4); if ((a[1] - a[0]) % 3 == 0)cout << a[3] + (a[0] * 2) + a[1] - a[0];elsecout << a[3] + (a[0] * 2) + a[1] - a[0]-1;
}

下面考虑a[3]或a[2]非足够大的情况，拥有最多珍珠的瓶子可能就不是a[3]：
在将a[0]变为0的基础上：
当瓶子内珍珠数为0111时，一次操作变为2000，此时瓶内最多珍珠数量为2，但按上述分析前两个瓶01时，a[3]数量不变，也就是1，和2差1
当瓶子内珍珠数为0112时，一次操作变为2001，此时瓶内最多珍珠数2，a[3]数量不变也正好是2，满足上述推理
当瓶子内珍珠数为0113时，一次操作变为2002，此时a[0]=2，a[3]数量不变为3，此时a[3]成为珍珠最多的瓶
当瓶子内珍珠数为0222时，一次操作变为4000，此时瓶内最多珍珠数4，但按上述分析前两个瓶02时，a[3]数量+1，也就是3，和4差1
以此类推
可以看出，当a[3]不是足够大时，或者说，a[3]如果不满足至少比a[2]或a[1]大1时，即a[1]、a[2]、a[3]相等时，a[0]反而成了珍珠最多的瓶
我们据此更新代码，考虑a[1]、a[2]、a[3]相等的情况，要在输出基础上+1

#include <iostream>
#include <algorithm>
using namespace std;
int main() {long long a[4];for (int i = 0; i < 4; i++) {cin >> a[i];}sort(a, a + 4);int x = 0;if (a[3] == a[1]) {x = 1;}if ((a[1] - a[0]) % 3 == 0)cout << a[3] + (a[0] * 2) + a[1] - a[0]+x;elsecout << a[3] + (a[0] * 2) + a[1] - a[0] - 1+x;
}

9.鸡哥的购物挑战
在这里插入图片描述
评测系统

分析：商品价格有正有负，计算过程中可抵消

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int main() {priority_queue<int> pq;//大根堆int n;cin >> n;for (int i = 0; i < n; i++) {int x;cin >> x;pq.push(x);}long long sum = 0;int num = 0;int laste;while (pq.size() > 0&&pq.top()>0) {sum += pq.top();laste = pq.top();//记录while最后一个弹出的元素pq.pop();num++;}if (num < n&& num % 2 != 0) {if (abs(pq.top()) > laste) {sum -= laste;}else {sum += pq.top();}}else if (num == n && num % 2 != 0) {sum -= laste;}cout << sum;
}

10.冒险者公会
在这里插入图片描述
在这里插入图片描述

评测系统

分析：样例说明有一定的误导性，为了更高效的派出冒险者，应该从小到大排序

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 1e3 + 5;
int cmp(const int a, const int b) {return a > b;
}
int main() {int m, n;cin >> m >> n;int x[N] = { 0 }, b[N][N] = { 0 };for (int i = 0; i < m; i++) {cin >> x[i];}sort(x, x + m,cmp);int maxnum = -1;for (int i = 0; i < n; i++) {int k;cin >> k;for (int j = 0; j < k; j++) {cin >> b[i][j];}sort(b[i], b[i] + k,cmp);maxnum = max(maxnum, k);}if (m < maxnum) {cout << "-1";return 0;}int temp[N] = { -1 };//存储每轮的最大值int num = 0;for (int i = 0; i < maxnum; i++) {for (int j = 0; j < n; j++) {temp[num] = max(b[j][i], temp[num]);}num++;}int sum = 0;num = m-1;int num2 = maxnum - 1;while (num!=-1&&num2!=-1) {if (x[num] < temp[num2]) {num--;}else {sum += x[num];num--;num2--;}}if (num2 == -1)cout << sum;elsecout << "-1";
}

11.明日方舟大作战！
在这里插入图片描述
在这里插入图片描述

评测系统

分析：在一轮中所有队员均可上场；对每个队员至多需要一次付费

引入：

01背包问题

对于一系列物品，每个物品有两个属性，价值v[i]和重量w[i]；一个背包，它有一个最大承重限制W。在0-1背包问题中，每个物品只有两种状态：被选中和未被选中，这就是"0-1"的由来。不同于分数背包问题，我们不能选择物品的一部分，而必须决定是否完整地取用每个物品。0-1背包问题通常通过动态规划来解决。基本思想是使用一个二维数组dp[i][j]来表示当考虑到前i个物品，且背包容量为j时所能得到的最大价值。
我们的目标是选择一些物品装入背包，使得这些物品的总价值最大化，同时保证这些物品的总重量不超过背包的承重限制。

在这里插入图片描述
物品(重量w，价值v)
第0行：不考虑任何物品，背包的最大价值为0
第0列：当背包重量为0时，无法放入任何物品，最大价值为0
表格中的每个数字都表示：当考虑前i个物品时，在背包重量j下，能获得的最大价值

在这里插入图片描述
对于[1,1]
背包容量为1，1号物品重量为2，无法放入背包。
即当前物品重量大于背包容量，则背包价值与不放当前物品的价值一致（与只考虑前i-1个物品一致）

if(weight[i]>j){dp[i][j]=dp[i-1][j]
}

在这里插入图片描述

对于[2,3]
当前物品重量为3≤当前背包容量3，允许放入
判断放入后是否能获得更大价值：max(不放入，放入)
若不放入：背包的最大价值=在同样的背包容量j下，能获得的最大价值，即dp[i-1][j]
若放入：背包内物品的总重量一定已经加上了当前物品的重量和价值，我们找到"不考虑当前物品的价值"和“减去当前物品重量”对应的最优值，再加上当前物品的价值，即可得到结果，即dp[i-1][j-weight[i]]+value[i]

if(weight[i]<=j){dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
}

对于另一个例子，我们给出完整的代码（注：weight和value数组下标从1开始存放数据，0号索引填充0）
这里使用vector表示，也可使用数组

#include <iostream>
#include <vector>
using namespace std;
int knapsack(int W, const vector<int> weight, const vector<int> value) {int n = weight.size()-1;//使用vector<vector<int>>创建二维数组//外层(行)有n + 1个元素(向量)//对于每个外层元素都有W+1个内层元素(列),并将它们初始化为0vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));for (int i = 1; i <= n; i++) {for (int j = 1; j <= W; j++) {if (weight[i] <= j) { dp[i][j] = max(dp[i-1][j], dp[i - 1][j - weight[i]] + value[i]);}else {dp[i][j] = dp[i - 1][j];}}}return dp[n][W];
}
int main() {int W = 10;//背包最大容量vector<int> weight = { 0,1,2,4,2,5 };//每个物品的重量vector<int> value = { 0,5,3,5,3,2 };//每个物品的价值cout << knapsack(W, weight, value);//在不超过背包承重限制的条件下，所能选择物品的最大总价值。
}

下面我们再看一个一维dp的例子
一维dp每次迭代只保留上一个物品计算的结果，减少了对空间的需求，空间复杂度有所降低。如果问题只要求最大价值而不需要具体的物品列表，一维DP是更好的选择。如果需要知道具体哪些物品被选中，则可能需要额外的逻辑或记录。二维dp可以具体到每个物品和每种容量下的最大价值。

若背包容量10，共有4件物品，(重量,价值)分别为(2,1),(3,3),(4,5),(7,9)

在这里插入图片描述
在这里插入图片描述

处理第一个物品：从右往左填写。第一个物品重量2＜10，允许放入，直到j=2。检查价值最大化。

for (int j = W; j >= weight[i]; j--) { //逆序保证了在更新时用到的dp仍然是上一轮(没有考虑当前物品)的结果dp[j] = max(dp[j], dp[j - weight[0]] + value[0]);
}

处理第二个物品：j=10前两件物品均可放入

在这里插入图片描述

j=4时
若不放入当前物品，dp[j]=1
若放入当前物品，在减去当前重量的情况下决策dp[j - weight[1]] + value[1]=0+3=3

for (int j = W; j >= weight[i]; j--) {dp[j] = max(dp[j], dp[j - weight[1]] + value[1]);
}

在这里插入图片描述
以此类推，遍历完所有i得到的dp[10]即为结果

对于另一个例子，我们给出完整的代码（注：weight和value数组下标从0开始存放数据），j是逆序的
这里使用vector表示，也可使用数组

#include <iostream>
#include <vector>
using namespace std;int knapsack(int W, const vector<int> weight, const vector<int> value) {int n = weight.size();vector<int> dp(W + 1, 0);for (int i = 0; i < n; i++) {for (int j = W; j >= weight[i]; j--) { //逆序保证了在更新时用到的dp仍然是上一轮(没有考虑当前物品)的结果dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);//max中的dp[j]表示在不加入当前物品i的情况下，物品能达到的最大价值。//类似于在二维的基础上去掉了第一个维度//dp[i][j] = max(dp[i-1][j], dp[i - 1][j - weight[i]] + value[i]);}}return dp[W];
}int main() {int W = 10; vector<int> weight = { 1, 2, 4, 2, 5 };vector<int> value = { 5, 3, 5, 3, 2 };cout << knapsack(W, weight, value);return 0;
}

【回到题目】我们使用01背包一维dp找到最大的攻击力，再找到最多血量的敌人，即可计算最小的回合数

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;
int knapsack(int B, const vector<int> attack, const vector<int> cost) {vector<int> dp(B + 1, 0);//dp数组记录总费用为j时可获得的最大攻击力int n = attack.size();for (int i = 0; i < n; i++) {for (int j = B; j >= cost[i]; j--) {dp[j] = max(dp[j], dp[j - cost[i]] + attack[i]);//是否选择i}}return dp[B];
}
int main() {int n, m, B;cin >> n >> m >> B;vector<int> attack(n), cost(n);for (int i = 0; i < n; i++) {cin >> attack[i] >> cost[i];}int max_attack = knapsack(B,attack,cost);//01背包调用int max_life = 0;//敌人的最大生命值for (int i = 0; i < m; i++) {int life;cin >> life;max_life = max(life, max_life);}if (max_attack == 0) {cout << "-1";return 0;}//使用ceil向上取值，头文件#include <cmath>int rounds = (int)ceil((double)max_life / max_attack);cout << rounds;//也可使用:max_life% max_attack == 0 ? cout << max_life / max_attack : cout << max_life / max_attack + 1;
}

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

DataFunSummit：2023年数据湖架构峰会-核心PPT资料下载

DataFunSummit：2023年数据湖架构峰会-核心PPT资料下载

一、峰会简介 现今&#xff0c;很多企业每天都有PB级的数据注入到大数据平台&#xff0c;经过离线或实时的ETL建模后&#xff0c;提供给下游的分析、推荐及预测等场景使用。面对如此大规模的数据&#xff0c;无论是分析型场景、流批一体、增量数仓都得益于湖仓一体等数据湖技术…
阅读更多...
《微信小程序开发从入门到实战》学习六十七

《微信小程序开发从入门到实战》学习六十七

6.6 网络API 部分小程序服务端不是用云开发技术实现&#xff0c;而是由开发人员使用后端开发语言实现。 在小程序用网络API与&#xff08;开发人员使后端开发语言建设的&#xff09;服务端进行交互&#xff0c;可与服务端交换数据、上传或下载文件。 6.6.1 服务器域名配置 …
阅读更多...
数字资产学习笔记

数字资产学习笔记

附&#xff1a;2023年数据资源入表白皮书下载&#xff1a; 关注WX公众号&#xff1a; commindtech77&#xff0c; 获得数据资产相关白皮书下载地址 1. 回复关键字&#xff1a;数据资源入表白皮书 下载 《2023数据资源入表白皮书》 2. 回复关键字&#xff1a;光大银行 下载 光…
阅读更多...
openGauss学习笔记-179 openGauss 数据库运维-逻辑复制-发布订阅

openGauss学习笔记-179 openGauss 数据库运维-逻辑复制-发布订阅

文章目录 openGauss学习笔记-179 openGauss 数据库运维-逻辑复制-发布订阅179.1 发布179.2 订阅179.3 冲突处理179.4 限制179.5 架构179.6 监控179.7 安全性179.8 配置设置179.9 快速设置 openGauss学习笔记-179 openGauss 数据库运维-逻辑复制-发布订阅 发布和订阅基于逻辑复…
阅读更多...
AJAX: 整理2：学习原生的AJAX，这边借助express框架

AJAX: 整理2：学习原生的AJAX，这边借助express框架

1. npm install express 终端直接安装 2. 测试案例&#xff1a;Hello World&#xff01; 新建一个express.js的文件&#xff0c;写入下方的内容 // 1. 引入express const express require(express)// 2. 创建服务器 const app express()// 3.创建路由规则 // request 是对请…
阅读更多...
C#使用switch语句更改窗体颜色

C#使用switch语句更改窗体颜色

目录 一、示例 二、生成 用switch多路选择语句及窗体的BackColor属性更改窗体的BackColor属性。该属性用于获取或设置控件的背景颜色。 可以使用Color结构的静态属性获取Color对象&#xff0c;如Color.Red&#xff1b;也可以使用Color结构的静态方法Color.FromArgb()&#xf…
阅读更多...
windows 安装multipass

windows 安装multipass

安装说明 Multipass orchestrates virtual Ubuntu instances Launch an instance (by default you get the current Ubuntu LTS) multipass launch --name foo 下载 Multipass orchestrates virtual Ubuntu instances 安装 执行安装exe 前提 需要安装hyper-V 参考链接 …
阅读更多...
goframe v2 模板引擎的用法

goframe v2 模板引擎的用法

这里用的goframe v2框架 提醒&#xff1a;下面的import 引入的控制器和api&#xff0c;根据自己实际项目路径 main函数 import ("context""github.com/gogf/gf/v2/net/ghttp""github.com/gzdzh/dzhgo/modules/dzhCms/controller/web""gith…
阅读更多...
海凌科HLK-V2语音识别模块更新词条

海凌科HLK-V2语音识别模块更新词条

简介 HLK-V20 是海凌科的离线语音识别模块, 中英文不同时支持, 只支持中文/英文, 具体识别看每次的SDK更新设置;资料下载 可以在微信公众包搜索海凌科或HI-LINK, 下载资料 感知模块->HLK-V20 模块限制 中英文被限制, 需要根据你在官网设置的SDK信息进行确定;可以仅设置3…
阅读更多...
JVM知识总结（简单且高效）

JVM知识总结（简单且高效）

1. JVM内存与本地内存 JVM内存&#xff1a;受虚拟机内存大小的参数控制&#xff0c;当大小超过参数设置的大小时会报OOM。本地内存&#xff1a;本地内存不受虚拟机内存参数的限制&#xff0c;只受物理内存容量的限制&#xff1b;虽然不受参数的限制&#xff0c;如果所占内存超过…
阅读更多...
【设计模式】状态模式

【设计模式】状态模式

文章目录 引例状态模式理论状态模式代码优化结合享元模式并发问题解决 策略模式 VS 状态模式 引例 交通信号灯系统的设计与实现 方案一 传统设计方案 定义交通灯颜色的枚举 public enum LightColor { Green,Red,Yellow }交通灯类TrafficLight&#xff0c;处理颜色转换等业务…
阅读更多...
IP地理位置定位技术基本原理

IP地理位置定位技术基本原理

IP地理位置定位技术的基本原理是基于IP地址的特性。每个IP地址在网络中都有一个与之对应的地理位置信息&#xff0c;这是通过IP地址数据库来确定的。这个数据库由ISP&#xff08;Internet Service Provider&#xff09;或其它一些机构维护&#xff0c;其中包含了每个IP地址的地…
阅读更多...
【LeetCode】修炼之路-0001-Two Sum（两数之和）【python】【简单】

【LeetCode】修炼之路-0001-Two Sum（两数之和）【python】【简单】

前言 计算机科学作为一门实践性极强的学科,代码能力的培养尤为重要。当前网络上有非常多优秀的前辈分享了LeetCode的最佳算法题解,这对于我们这些初学者来说提供了莫大的帮助,但对于我这种缺乏编程直觉的学习者而言,这往往难以消化吸收。&#xff08;为什么别人就能想出这么优雅…
阅读更多...
迷宫问题的对比实验研究（代码注释详细、迷宫及路径可视化）

迷宫问题的对比实验研究（代码注释详细、迷宫及路径可视化）

题目描述 对不同的迷宫进行算法问题&#xff0c;广度优先、深度优先、以及人工智能上介绍的一些算法&#xff1a;例如A*算法&#xff0c;蚁群算法等。 基本要求&#xff1a; &#xff08;1&#xff09;从文件读入9*9的迷宫&#xff0c;设置入口和出口&#xff0c;分别采用以上方…
阅读更多...
懒加载的el-tree中没有了子节点之后还是有前面icon箭头的展示，如何取消没有子节点之后的箭头显示

懒加载的el-tree中没有了子节点之后还是有前面icon箭头的展示，如何取消没有子节点之后的箭头显示

没有特别多的数据 <template><el-tree:props"props":load"loadNode"lazyshow-checkbox></el-tree></template><script>export default {data() {return {props: {label: name,children: zones,isLeaf:"leaf",//关…
阅读更多...
华为服务器安装银河麒麟V10操作系统（IBMC安装）

华为服务器安装银河麒麟V10操作系统（IBMC安装）

iBMC是华为面向服务器全生命周期的服务器嵌入式管理系统。提供硬件状态监控、部署、节能、安全等系列管理工具&#xff0c;标准化接口构建服务器管理更加完善的生态系统。 服务器BMC IP&#xff1a;192.168.2.100 一、准备工作 1、确保本机和服务器BMC管理口在同一网络 2、银…
阅读更多...
时序分解 | Matlab实现贝叶斯变化点检测与时间序列分解

时序分解 | Matlab实现贝叶斯变化点检测与时间序列分解

时序分解 | Matlab实现贝叶斯变化点检测与时间序列分解 目录 时序分解 | Matlab实现贝叶斯变化点检测与时间序列分解效果一览基本介绍程序设计参考资料 效果一览 基本介绍 Matlab实现贝叶斯变化点检测与时间序列分解 1.Matlab实现贝叶斯变化点检测与时间序列分解&#xff0c;完…
阅读更多...
Windows下配置GCC（MinGW）环境

Windows下配置GCC（MinGW）环境

一、下载并安装MinGW 步骤1&#xff1a;下载MinGW安装器 前往MinGW的官方下载源&#xff0c;通过以下链接可以获取到最新版的MinGW安装程序&#xff1a; 网页地址&#xff1a;https://sourceforge.net/projects/mingw/files/ [MinGW 下载地址](https://sourceforge.net/proj…
阅读更多...
单点登录的三种模式

单点登录的三种模式

介绍 单点登录存在的意义在于&#xff0c;比如公司里有多个系统&#xff0c;我只想登录一次&#xff0c;便可以访问公司的多个子系统 单点登录有很多模式&#xff0c;目前已知三种模式 1、cookie session模式 2、token模式 3、token refresh_token模式 Cookie Session模式…
阅读更多...
go module本地包导入

go module本地包导入

go module本地包导入 本文目录 go module本地包导入启用go mod主项目工作目录本地module目录发布和使用模块 golang 1.11之后加入了go mod来替代GOPATH 官方文档参考&#xff1a;https://golang.google.cn/doc/tutorial/call-module-code 启用go mod 开启 Go modules # 临时开…
阅读更多...
最新文章

Copyright @ 2022~2023