HNU-算法设计与分析-实验2

算法设计与分析
实验2

计科210X 甘晴void 202108010XXX
在这里插入图片描述

目录

文章目录

  • 算法设计与分析<br>实验2
    • 1 用动态规划法实现0-1背包
      • 问题重述
      • 想法
      • 代码
      • 验证
      • 算法分析
    • 2 用贪心算法求解背包问题
      • 问题重述
      • 想法
      • 代码
      • 验证
      • 算法分析
    • 3 半数集问题(实现题2-3)
      • 问题重述
      • 想法
      • 代码
      • 验证
      • 算法分析
    • 3.5 关于此题的进一步探索(半数单集问题,实现题2-4)
      • 为什么会产生重复
      • 如何消除重复
      • 代码
      • 验证
      • 算法分析
    • 4 集合划分问题(实现题2-7)
      • 问题重述
      • 验证方式
      • ★基础知识补充
      • 想法
        • 算法1(贝尔数自身递推):
          • 想法
          • 代码
          • 验证
          • 算法分析
        • 算法2(第二类斯特林数加和):
          • 想法
          • 代码
          • 验证
          • 算法分析
        • 算法3(贝尔三角形):
          • 想法
          • 代码
          • 验证
          • 算法分析
        • 继续深入
    • 实验感悟

1 用动态规划法实现0-1背包

问题重述

一共有N件物品,第i(i从0开始)件物品的重量为weight[i],价值为value[i]。在总重量不超过背包承载上限maxw的情况下,求能够装入背包的最大价值是多少

想法

经典问题,假设我们现在手上有一个空的背包,然后从0个物品开始按照序号从小到大拿可供选择的物品,对于每个物品我们只有“选择”或者“不选择”两种策略。

状态dp[i][j]表示选择到第i个物品后,背包容量为j时所拿所有物品的最大价值。对于每一个物品而言,我们只有“拿”与“不拿”这两种处置方法。首先看看在当前状态下,如果腾空背包,能不能拿下它,如果即使背包空了都没法拿下它,那只能选择“不拿”,继承拿到前一个物品时这个大小的背包的状态;如果可能拿下它,那么我们可以选择“不拿”,跟前面一样处理,或者“拿”,这就要求腾出这个空间,但加上这个价格。

最优子结构易证:

假设(y1,y2,y3,……,yn)为所给01背包问题的一个最优解,则照理(y2,y3,……,yn)应该是其子问题的最优解。我们假设(y2,y3,……,yn)并不是其最优解,另存在(z2,z3,……,zn)为其子问题的最优解,那么一定有(y1,z2,z3,……,zn)为该问题的最优解,而非(y1,y2,y3,……,yn)是该问题的最优解,这与我们一开始的假设矛盾,故这是不成立的。所以该问题一定有最优子结构。

重叠子问题:

显然在计算i和j较大时的dp[i][j]必然会用到较小的dp[i][j]的值,故有重叠子问题。

这样,我们有状态转移方程如下:

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

有了状态转移方程就可以写代码了。

代码

#include <stdio.h>
using namespace std;int max(int a, int b)
{return a > b ? a : b;
}int solve(int n, int maxw, int weight[], int value[])
{// weight[]重量// value[]价值int dp[n][maxw + 1];for (int i = 0; i < n; i++){for (int j = 0; j < maxw + 1; j++){dp[i][j] = 0;}}for (int k = 0; k < maxw + 1; k++){if (weight[0] <= k)dp[0][k] = value[0];}for (int i = 1; i < n; i++){for (int j = 0; j < maxw + 1; j++){if (j - weight[i] < 0)dp[i][j] = dp[i - 1][j];elsedp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);}}return dp[n - 1][maxw];
}int main()
{int n, maxw;scanf("%d %d", &maxw, &n);int w[n], v[n];for (int i = 0; i < n; i++){scanf("%d %d", &w[i], &v[i]);}printf("%d\n", solve(n, maxw, w, v));
}

验证

洛谷P1048 [NOIP2005 普及组] 采药(https://www.luogu.com.cn/problem/P1048)与这道题较为类似。

在这里插入图片描述

基本上是一模一样的,我们可以测试一下,结果如下:

在这里插入图片描述

可见算法正确。

算法分析

时间复杂度O(nm),n为物品个数,m为最大背包容量。

空间复杂度O(nm),开了个这个数组。

2 用贪心算法求解背包问题

问题重述

有n个物品,每个物品的重量weight[i]和价格value[i],物品可以被分割,背包容量maxw,求最多拿走价值为多少。

想法

贪心背包和01背包,区别就在于“可以分割”,那么贪心策略就变为了优先取走“性价比”较高的物品,并按照这样的策略尽可能多的取走物品,如果能取走就尽可能取走,最后一个物品如果取不走,就分割取走可以取走的部分。

代码

#include <algorithm>
#include <stdio.h>
using namespace std;struct object
{int weight;int value;double vpw; // value per weight
};bool cmp(struct object a, struct object b)
{return a.vpw > b.vpw;
}double solve_greedy(int n, int maxw, int weight[], int value[])
{// weight[]重量// value[]价值struct object x[n];for (int i = 0; i < n; i++){x[i].weight = weight[i];x[i].value = value[i];x[i].vpw = (double)x[i].value / x[i].weight;}sort(x, x + n, cmp);int total = 0;  // 已放入背包的重量double ans = 0; // 放入背包的价值for (int i = 0; i < n; i++){if (total + x[i].weight <= maxw){ans += x[i].value;total += x[i].weight;}else{ans += (((double)(maxw - total) / x[i].weight) * x[i].value);break;}}return ans;
}int main()
{int n, maxw;scanf("%d %d", &n, &maxw);int w[n], v[n];for (int i = 0; i < n; i++){scanf("%d %d", &w[i], &v[i]);}printf("%.2lf\n", solve_greedy(n, maxw, w, v));
}

验证

洛谷 P2240 【深基12.例1】部分背包问题(https://www.luogu.com.cn/problem/P2240)就是这个问题

在这里插入图片描述

测试,结果如下。

在这里插入图片描述

通过了测试点。

算法分析

主要瓶颈在于排序,调用sort函数,按快速排序计,时间复杂度O(nlogn)。

空间复杂度考虑开了个数组,和结构体数组,是一维的,O(n)。

3 半数集问题(实现题2-3)

问题重述

给定一个自然数 n,由 n 开始可以依次产生半数集 set(n)中的数如下。

  • (1) n∈set(n);

  • (2) 在 n 的左边加上一个自然数,但该自然数不能超过最近添加的数的一半;

  • (3) 按此规则进行处理,直到不能再添加自然数为止。

例如,set(6)={6,16,26,126,36,136}。半数集 set(6)中有 6 个元素。
注意半数集是多重集。

编程任务:

  • 对于给定的自然数 n,编程计算半数集 set(n)中的元素个数。

数据输入:

  • 输入数据由文件名为 input.txt 的文本文件提供。
  • 每个文件只有 1 行,给出整数 n。(0<n<1000)

结果输出:

  • 程序运行结束时,将计算结果输出到文件 output.txt 中。输出文件只有 1 行,给出半数集 set(n)中的元素个数。

想法

问题有些复杂的时候可以先举例子。

例如.set(6) 6,16,26,126,36,136。半数集set(6)中有6个元素。

例如.set(10) 10,510,2510,12510,1510,410,2410,12410,1410,310,1310,210,1210,110,半数集set(10)中有14个元素。

设set(n)中的元素个数为f(n)。如:6的前面可以加上1、2、3,而2、3的前面又都可以加上1,也就是f(6)=1+f(3)+f(2)+f(1)。

则显然有递归表达式:f(n)=1+∑f(i),i=1,2……n/2。

可以先写一个递归函数如下

int f(int n)
{
int temp=1;
if(n>1)
for (int  i=1;i < = n/2;i ++)temp+=f(i);
return temp;
}

时间复杂度:n/2个相加,每一个需要计算1+…+i/2,因此时间复杂度为O(n^2)缺点:这样会有很多的重复子问题计算。

这个问题显然存在重叠子问题:例如,当n=4时,f(4)=1+f(1)+f(2),而f(2)=1+f(1),在计算f(2)的时候又要重复计算一次f(1)。如果这样的话时间复杂度会很大,我们要想办法简化重叠部分的计算。

可以采用“备忘录”的方法,来避免重叠部分的计算。

代码

#include <algorithm>
#include <stdio.h>
using namespace std;int solve(int f[], int n)
{if (n == 1)return 1;if (f[n] != 0)return f[n];int sum = 1;for (int i = 1; i <= n / 2; i++)sum += solve(f, i);f[n] = sum;return sum;
}int main()
{int n;scanf("%d", &n);int f[n + 1];for (int i = 1; i <= n; i++)f[i] = 0;printf("%d\n", solve(f, n));
}

验证

P1028 [NOIP2001 普及组] 数的计算(https://www.luogu.com.cn/problem/P1028)

在这里插入图片描述

测试结果如下:

在这里插入图片描述

算法分析

使用到记忆化剪枝,本质上仍然是对每个f[i]都去遍历了f[0]到f[n/2],所以时间复杂度应该是O(n^2)。

由于开了备忘录数组,空间复杂度O(n)。

3.5 关于此题的进一步探索(半数单集问题,实现题2-4)

为什么会产生重复

2-3和2-4的唯一区别就在这个地方。2-4需要剔除重复的部分。

先来看看重复的部分是怎么产生的:

考虑n=26时的set(n)因为n/2=13,所以13 26∈set(n)但是我们想,1326真的只能这样产生嘛?

考虑26->3 26->1 3 26,也就是说26直接产生3再产生1,这是不是也可以。

这就造成了重复:[1][3][26][13][26] 都会产生 1326

现在我们要解决这个问题

如何消除重复

如果这道题仍然对n限定很高,那么是不好做的。

但是这里题目限定(0<n<201)这意味着0<n/2<=100,所以可能造成问题的必定是两位数。

我们再看刚刚的例子1326,如果是1226还会发生这样的事情嘛?如果是1126呢?

在这里插入图片描述

其实我们很好理解为什么【x/10 <= (x%10) /2】会出现重复的情况

因为这会导致(x%10)这一项仍然有能力分出它前面的那个

也就是1326的3,依旧具备产生1的能力,

而1126的右边的1,已经不具备再产生左边的1的能力了。

所以也就是说只有【x/10 <= (x%10) /2】这个情况会出现额外计数的分支,

那我们只需要再这个情况发生的时候,去剪掉由这个产生的分支就可以。

体现在算法上就是在算这一层的答案的时候减掉f[i/10]就好(当i/10*2<=i%10的时候)

代码

#include <algorithm>
#include <stdio.h>
using namespace std;int solve(int f[], int n)
{if (n == 1)return 1;if (f[n] != 0)return f[n];int sum = 1;for (int i = 1; i <= n / 2; i++){sum += solve(f, i);if ((i > 10) && (2 * (i / 10) <= (i % 10))){sum -= f[i / 10];}}f[n] = sum;return sum;
}int main()
{int n;scanf("%d", &n);int f[n + 1];for (int i = 1; i <= n; i++)f[i] = 0;f[1] = 1;printf("%d\n", solve(f, n));
}

验证

在这里插入图片描述

可以看到,对于我们刚刚给出的例子,[13][26][12][26]被删去了,效果实现了。

算法分析

由于本题只是进行了一句判断并剪枝,故与上一题一样

使用到记忆化剪枝,本质上仍然是对每个f[i]都去遍历了f[0]到f[n/2],所以时间复杂度应该是O(n^2)。

由于开了备忘录数组,空间复杂度O(n)。

4 集合划分问题(实现题2-7)

问题重述

n 个元素的集合{1,2,……, n }可以划分为若干个非空子集。例如,当 n=4 时,集合{1,2,3,4}可以划分为 15 个不同的非空子集如下:

{{1},{2},{3},{4}},
{{1,2},{3},{4}},
{{1,3},{2},{4}},
{{1,4},{2},{3}},
{{2,3},{1},{4}},
{{2,4},{1},{3}},
{{3,4},{1},{2}},
{{1,2},{3,4}},
{{1,3},{2,4}},
{{1,4},{2,3}},
{{1,2,3},{4}},
{{1,2,4},{3}},
{{1,3,4},{2}},
{{2,3,4},{1}},
{{1,2,3,4}}

编程任务:
给定正整数 n,计算出 n 个元素的集合{1,2,……, n }可以划分为多少个不同的非空子集。

数据输入:
由文件 input.txt 提供输入数据。文件的第 1 行是元素个数 n。

结果输出:
程序运行结束时,将计算出的不同的非空子集数输出到文件 output.txt 中。

验证方式

本题的验证由在线评测进行

洛谷P5748 集合划分计数(https://www.luogu.com.cn/problem/P5748)

在这里插入图片描述

注意与课本题面区别:

  • 由于数据很大,题目要求取模
  • 有多组数据

★基础知识补充

【贝尔数】

B[n]的含义是基数为 n的集合划分成非空集合的划分数。

贝尔数自身递推关系: B[n+1] = ∑ C(n,k) B[k] ,其中k从0到n。

其中定义B[0] = 1

【第二类斯特林数】

第二类斯特林数实际上是集合的一个拆分,表示将 n个不同的元素拆分成m个集合间有序(可以理解为集合上有编号且集合不能为空)的方案数,记为 S(n,m) (这里是大写的)或者 {n m} (n在上m在下) 。

和第一类斯特林数不同的是,这里的集合内部是不考虑次序的,而圆排列圆的内部是有序的。常常用于解决组合数学中的几类放球模型。描述为:将n个不同的球放入m个无差别的盒子中,要求盒子非空,有几种方案。

S(n,k)的值可以递归的表示为:S(n+1, k) = kS(n, k) + S(n, k-1)。

递推边界条件:

S(n,n) = 1, n>=0

S(n,0) = 0, n>=1

为什么会这样表示呢?当我们将第(n + 1)个元素添加到k个划分集合时,有两种可能性。

  • 第n + 1个元素作为一个单独的集合参与到划分成k个集合,有S(n,k-1)个。
  • 将第n + 1个元素添加到已经划分的k个集合中,一共有k*S(n,k)种。

【贝尔数与第二类斯特林数的关系】

B[n]=∑S(n,k) 其中k从0到n

参考资料:

【详细讲解第一二三类斯特林数】https://zhuanlan.zhihu.com/p/350774728

【详细讲解贝尔数和贝尔三角形】https://www.cnblogs.com/lfri/p/11549652.html

想法

这是一道数论模板题,相关的知识是【贝尔数】,本题只要根据给定的n求出贝尔数B[n]即可。

结合我们上面给出的基础知识,这里至少有以下几种求贝尔数的方法:

  • 算法1:利用贝尔数自身递推关系,循环计算贝尔数
  • 算法2:利用贝尔数与第二类斯特林数的关系,k从0到n计算S(n,k)并且累加求和。
  • 算法3:使用贝尔三角形(后面讲)

下面逐个分析这些想法:

算法1(贝尔数自身递推):
想法

主要需要解决的是组合数的计算,数据量较小的时候可以用杨辉三角来计算组合数,数据量较大的时候可能会超时。

可以使用动态规划来计算组合数。

// 计算组合数的代码
#include <iostream>
#include<bits/stdc++.h>
#define ll long long
const int N = 55;
using namespace std;ll ans[N][N];void Combinations()  //处理组合数
{ans[0][0]=1;for(int i=1;i<=40;i++){ans[i][0]=1;for(int j=1;j<=i;j++){ans[i][j]=ans[i-1][j]+ans[i-1][j-1];}}
}int main()
{ll t;cin>>t;Combinations();  //记忆化搜索ll a,b;cin>>a>>b;cout<<ans[a][b]<<endl;return 0;
}

解决了组合数的计算之后,就可以再利用递推关系,把贝尔数求出来。用到如下关系:

  • 贝尔数自身递推关系: B[n+1] = ∑ C(n,k) B[k] ,其中k从0到n。

  • 其中定义B[0] = 1

代码
#include <bits/stdc++.h>
#define ll long long
const int N = 1000;
const int mod = 998244353;
using namespace std;ll C[N][N];
ll B[N];void Combinations() // 处理组合数
{C[0][0] = 1;for (int i = 1; i <= N - 1; i++){C[i][0] = 1;for (int j = 1; j <= i; j++){C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;}}
}long long Bell(int n)
{if (n == 0)return 1;ll ans = 0;for (int k = 0; k <= n - 1; k++){if (B[k] == 0)B[k] = Bell(k);ans += (C[n - 1][k] * B[k] % mod);}return ans % mod;
}
int main()
{Combinations(); // 记忆化搜索求所有C(n,m)for (int i = 0; i < N; i++)B[i] = 0;B[0] = 1;int n, T;scanf("%d", &T);for (int i = 0; i < T; i++){scanf("%d", &n);printf("ans = %lld\n", Bell(n));}return 0;
}
验证

案例数据是可以过的。

在这里插入图片描述

但是无法通过在线评测,这是因为我们要求的空间太大了。

在这里插入图片描述

但是数据确实要求到了这么大,如果我们开小数据,会出现运行时错误(要求的位置越界了)

在这里插入图片描述

说明这种O(n^2)的方法无法通过。

算法分析

时间复杂度O(n^2)

空间复杂度O(n^2),但是递归消耗的栈空间实在太大了。

不可接受。

(时间足够多,空间足够大的时候可以考虑)

算法2(第二类斯特林数加和):
想法

主要的问题在于使用递推关系求出第二类斯特林数,再把第二类斯特林数加和得到贝尔数。

// 计算第二类斯特林数
typedef long long ll;
typedef int itn;
const int N = 5007, mod = 1e9 + 7;
int n, m, k;
int S[N][N];
int main()
{scanf("%d%d", &n, &k);S[0][0] = 1;S[n][0] = 0;for(int i = 1; i <= n; ++ i) {for(int j = 1; j <= k; ++ j) {S[i][j] = (S[i- 1][j - 1] + 1ll * j * S[i - 1][j]) % mod;//公式中的 k 是当前的 k}}cout << S[n][k] << endl;return 0;
}

计算出第二类斯特林数之后,通过这个关系:

  • B[n]=∑S(n,k) 其中k从0到n

求解出B[n]

代码
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
typedef int itn;
const int N = 5000;
const int mod = 998244353;
int n, m, k;
ll S[N][N];
ll B[N];int solve_S(int n, int k)
{S[0][0] = 1;S[n][0] = 0;for (int i = 1; i <= n; ++i){for (int j = 1; j <= k; ++j){S[i][j] = (S[i - 1][j - 1] + 1ll * j * S[i - 1][j]) % mod; // 公式中的 k 是当前的 k}}return 0;
}ll Bell(int n)
{if (n == 0)return 1;ll ans = 0;for (int k = 0; k <= n; k++){if (!S[n][k])solve_S(n, k);ans += S[n][k];ans = ans % mod;}return ans;
}
int main()
{for (int i = 0; i < N; i++)B[i] = 0;B[0] = 1;int n, T;scanf("%d", &T);for (int i = 0; i < T; i++){scanf("%d", &n);// printf("ans = %lld\n", Bell(n));printf("%lld\n", Bell(n));}return 0;
}
验证

验证可得,案例同样可以过,空间不会超,但是还是TLE。

在这里插入图片描述

时间消耗太久了,不可接受。

算法分析

时间复杂度O(n^3)

空间复杂度O(n^2)

算法3(贝尔三角形):
想法

在这里插入图片描述

为什么贝尔三角形可以解决这个计算问题:

在这里插入图片描述

代码
#include <bits/stdc++.h>
using namespace std;const int maxn = 100001;
const int mod = 998244353;
long long int bell[maxn], T[maxn];void Bell(int n, int mod) // 求前n项Bell数
{bell[0] = bell[1] = 1;T[0] = 1;T[1] = 2;for (int i = 2; i <= n; i++){T[i - 1] = bell[i - 1];for (int j = i - 2; j >= 0; j--) // 滚动数组T[j] = (T[j] + T[j + 1]) % mod;bell[i] = T[0];}
}int main()
{int n, t;scanf("%d", &t);Bell(maxn, mod);for (int i = 0; i < t; i++){scanf("%d", &n);printf("%lld\n", bell[n]);}// for (int i = 0; i < 100; i++) printf("%d%c", bell[i], (i + 1) % 13 == 0 ? '\n' : ' ');
}
验证

较小的数据是可以通过的,

在这里插入图片描述

但是对于较大的数据,仍然未通过评测,显示TLE,O(n^2)的时间复杂度应该是没法通过评测的。

算法分析

时间复杂度应该是O(n^2)

空间复杂度O(n^2)

继续深入

对于一道按点得分的题而言,它的数据点是所有数据点。

洛谷的题解涉及到了FFT(快速傅里叶变换),将时间复杂度降到O(nlogn)之后,就可以通过。但是对于有限的课程实验时间,再结合自身能力而言,我决定暂时做到这里了。这是一个遗憾,后续如果有时间我会继续研究。

实验感悟

对于有一些数论的知识,没有能够掌握,这是一个遗憾。如果有足够的时间,还是要多理解多掌握一些。

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

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

相关文章

Ubuntu 22.04 安装Fail2Ban

Fail2Ban是一种用来防止暴力破解的工具&#xff0c;一般要和iptables配合使用。其原理是读取系统日志&#xff0c;并通过正则表达式匹配&#xff0c;监控IP在一段时间内的登录尝试、身份验证失败日志等并进行计数。超过阈值则进行IP封禁&#xff0c;过一段时间后再解封。 总的…

k8s 检测node节点内存使用率平衡调度脚本 —— 筑梦之路

直接上脚本&#xff1a; #! /bin/bash#对实际使用内存大于85%的机器停止调度&#xff0c;对实际使用内存小于70%的 关闭调度# 获取实际内存小于或等于70%的机器 memory_lt_70kubectl top nodes |awk NR>1{if($50<70) print $1} # 获取实际内存大于或等于85%的机器 memor…

ant design vue Tree组件叶子节点横向排列

antdesignvue的树形组件要实现组件叶子节点横向排列有点坑&#xff0c;没有 配置属性&#xff0c;需要自己想办法。 要实现的效果 看tree组件的dom结构&#xff0c;父元素flex竖向布局&#xff0c;子项不论节点层级都在同一层&#xff01;&#xff01;&#xff01; 难点在于想…

框架基础-网络编程+Tomcat服务器+XML

一. 网络编程 - 理论 1.项目架构 【Client】/S【Server - Service】 - 放在这个程序的用客户端 用户需要单独安装客户端&#xff0c;客户端升级了用于需要重新更新不能跨平台&#xff1a;不同的操作系统都需要相应版本的程序 性能和安全性&#xff1a;客户端与服务器直接交互…

golang --gin+websocket实现指定的数据点推送

这里提到的endpointId是一个负载了数据的逻辑点&#xff0c;就像一根水管的出口&#xff0c;有新数据来就会根据后端记录的endpointId推送到用户正在查看的endpointId。用户没有正在查看的endpoint就不会有新数据推送。这里如果如果对endpoint加上权限就相当于实现对实时数据的…

8个 Python 开发者必备的 PyCharm 插件

这8个顶级插件保证了更快、更轻松、更愉悦的开发过程。 在 PyCharm 插件列表中&#xff0c;我们发现了几个瑰宝插件&#xff0c;它们各自以独特的方式帮助开发者快速、简便、愉悦地开发。 今天我就给大家逐个介绍它们。 1. Key Promoter X 【下载链接】&#xff1a;https://…

01-15网络编程-XML

网络编程Web服务器XML 网络编程 项目架构&#xff1a; C[Client] /S[Server- Service] -访问这个程序时用客户端 缺点&#xff1a; 1.用户需要单独安装客户端&#xff0c; 2.客户端升级了用于需要重新更新不能跨平台: 3.不同的操作系统都需要相应版本的程序 优点&#xff1a;…

AtCoder abc336 A~D题解

A. 题目翻译&#xff1a; 对于正整数 X X X 级别的龙串&#xff0c; X X X 是长度为 ( X 3 ) (X3) (X3) 的字符串&#xff0c;由按此顺序排列的 o、n 和 g 的一次L、 X X X次出现形成。 你得到一个正整数 N N N。打印 N N N 级的龙串。 分析 按题目要求做即可……&am…

Openlayer【四】—— 控件

控件 控件是一个可见的小部件&#xff0c;其 DOM 元素位于 屏幕。它们可以涉及用户输入&#xff08;按钮&#xff09;&#xff0c;也可以仅供参考; 位置是使用 CSS 确定的。默认情况下&#xff0c;它们位于 容器&#xff0c;但可以使用 任何外部 DOM 元素。 其中ol/control是…

GO基础进阶篇 (十二)、反射

什么是反射 Go语言中的反射是指在程序运行时检查程序的结构&#xff0c;比如变量的类型、方法的签名等。Go语言的反射包是reflect。通过反射&#xff0c;你可以动态地检查类型信息、获取字段和方法、调用方法等。 反射可以在运行时动态获取变量的各种信息&#xff0c;比如变量…

linux系统nginx工具的一些应用

nginx高级应用 虚拟目录监控模块配置文件创建用户名密码客户端访问 限制传输速度&#xff08;服务层&#xff09; nginx配置文件中的每个语句要以 ; 结尾 虚拟目录 配置文件中的server块中编辑&#xff1a;location /test {alias /usr/share/nginx/html; //映射的是/usr…

定时器中断控制的独立式键盘扫描实验

#include<reg51.h> //包含51单片机寄存器定义的头文件 sbit S1P1^4; //将S1位定义为P1.4引脚 sbit S2P1^5; //将S2位定义为P1.5引脚 sbit S3P1^6; //将S3位定义为P1.6引脚 sbit S4P1^7; //将S4位定义为P1.7引脚 unsigned char keyval; /…

知识笔记(八十)———链式语句中join用法

join通常有下面几种类型&#xff0c;不同类型的join操作会影响返回的数据结果。 INNER JOIN: 等同于 JOIN&#xff08;默认的JOIN类型&#xff09;,如果表中有至少一个匹配&#xff0c;则返回行LEFT JOIN: 即使右表中没有匹配&#xff0c;也从左表返回所有的行RIGHT JOIN: 即使…

50天精通Golang(第18天)

web开发介绍、iris框架安装、HTTP请求和返回、Iris路由处理 一 Web项目开发介绍及实战项目介绍 1.1 引言 本系列课程我们将学些Golang语言中的Web开发框架Iris的相关知识和用法。通过本系列视频课程&#xff0c;大家能够从零到一经历一个完整项目的开发&#xff0c;并在课程…

[树莓派]给树莓派装pyinstaller环境

安装&#xff1a; sudo pip3 install pyinstaller 但是打包后会发现报错&#xff1a; Fatal error: PyInstaller does not include a pre-compiled bootloader for your platform. For more details and instructions how to build the bootloader see https://pyinstaller.…

Golang语言switch case

Golang语言使用switch语句可方便地对大量的值进行条件判断。 练习&#xff1a;判断文件类型,如果后缀名是.html输入text/html, 如果后缀名.css 输出text/css ,如果后缀名是.js 输出text/javascript Go语言规定每个switch只能有一个default分支。 extname : ".a"swit…

【栈】Leetcode 496 下一个更大元素I

【栈】Leetcode 496 下一个更大元素I 解法1 两个单调栈解法2 ---------------&#x1f388;&#x1f388;题目链接&#x1f388;&#x1f388;------------------- 解法1 两个单调栈 两个栈进行操作&#xff0c;一个栈用来遍历寻找&#xff0c;一个栈用来保留 将nums2中的元素…

NLP论文阅读记录 - 2021 | WOS 利用 ParsBERT 和预训练 mT5 进行波斯语抽象文本摘要

文章目录 前言0、论文摘要一、Introduction1.1目标问题1.2相关的尝试1.3本文贡献 二.前提三.本文方法A. 序列到序列 ParsBERTB、mT5 四 实验效果4.1数据集4.2 对比模型4.3实施细节4.4评估指标4.5 实验结果4.6 细粒度分析 五 总结思考 前言 Leveraging ParsBERT and Pretrained …

1.6 面试经典150题 - 买卖股票的最佳时机

买卖股票的最佳时机 给定一个数组 prices &#xff0c;它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票&#xff0c;并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易…

鸿蒙开发之组合手势

当我们需要支持多个手势的时候&#xff0c;可以通过GestureGroup来实现&#xff0c;如下实现了同时支持Tap和Pan手势 import Prompt from system.prompt Entry Component struct OfficialGestureGroupPage {State message: string Hello Worldbuild() {Column() {Column() {T…