蓝桥杯第三场双周赛（AK）

news2024/11/17 11:54:11

题目非常典型，很适合学算法。

1111 第 3 场算法双周赛 - 蓝桥云课

双十一的祈祷

        题意：求11^{1111}的个位数。

        思路：只需要求个位数，因此此题等效于求11^{1111} mod 10 ,可用快速幂或者直接看出为1。

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod = 10;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
LL qpow(LL a , LL b)//快速幂
{
	LL sum=1;
	while(b){
		if(b&1){
			sum=sum*a%mod;
		}
		a=a*a%mod;
		b>>=1;
	}
	return sum;
}
void solve() 
{
	cout<<qpow(11,1111);
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
//	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

疯狂的促销

        题意：三个电商平台优惠不同，现有若干商品，每个商品可以任选平台，求购买所有商品的最低价格。

        思路：直接模拟。

        

#include <iostream>
using namespace std;
int algo(int cost){
  int cost1 , cost2 , cost3;
  cost1 = cost >= 500 ? cost - cost / 10 : cost;
  cost2 = cost >= 1000 ? cost - 150 : cost;
  cost3 = cost == 1111 ? 0 : cost - cost / 20;
  return min(cost1 , min(cost2 , cost3));
}
int main()
{
  // 请在此输入您的代码
  int n;
  cin>>n;
  long long sum = 0;
  for(int i = 0 ; i < n ; i ++){
    int num;
    cin>>num;
    sum += algo(num);
  }
  cout<<sum;
  return 0;
}

被替换的身份证

        题意：两个人有两张牌，根据规则谁先出完牌谁赢。

        思路：还是模拟，考虑先手获胜情况：1、有对子/王炸。2、自己最大的牌比对面能打的最大的牌要大。其余都是后手赢。

        

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
  // 请在此输入您的代码
  int n;
  cin>>n;
  map<char , int>mp;
  string mask = "3456789XJQKA2MF";
  for(int i = 0 ; i < mask.size() ; i ++){
    mp[mask[i]] = i;
  }
  while(n--){
    string s1 , s2;
    cin >> s1 >> s2;
    int sd_1 , sd_2 , j_1 , j_2;
    sd_1 = mp[s1[0]];
    sd_2 = mp[s1[1]];
    j_1 = mp[s2[0]];
    j_2 = mp[s2[1]];
    if(sd_1 > sd_2){
      swap(sd_1 , sd_2);
    }
    if(j_1 > j_2){
      swap(j_1,j_2);
    }
    if(sd_1 == 13 && sd_2 == 14){
      cout<<"ShallowDream";
    }
    else if(sd_1 == sd_2){
      cout<<"ShallowDream";      
    }
    else if(j_1 == 13 && j_2 == 14){
      cout<<"Joker";
    }
    else if(sd_2 >= j_2){
      cout<<"ShallowDream";
    }
    else{
      cout<<"Joker";
    }
    cout<<endl;
  }
  return 0;
}

迷宫逃脱

        题意：迷宫问题，从左上角走到右下角，只能往右或者往下走，每个格子中含有一个数字，若从 a 走到 b 的两个格子中的数字互质，则需要一把钥匙才能走。现在共有 k 把钥匙。求从左上角走到右下角的路径上数字之和的最大值。

        思路：观察到迷宫格子数（1e6）, 钥匙数（3）因此考虑 dp 来做。定义dp[i][j][k]为走到第i行的第j列，消耗了k把钥匙的路径之和最大值。状态转移方程：dp[i][j][k] = max(dp[i][j][k] , dp[i - 1][j][k - 1] + a[i][j])\\ dp[i][j][k] = max(dp[i][j][k] , dp[i][j - 1][k - 1] + a[i][j])(互质情况）

dp[i][j][k] = max(dp[i][j][k] , dp[i - 1][j][k] + a[i][j])\\ dp[i][j][k] = max(dp[i][j][k] , dp[i][j - 1][k] + a[i][j])（非互质情况）

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}         
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	int  n , m  , q;
	cin >> n >> m >> q;
	LL a[n + 5][m + 5];
	LL dp[n + 5][m + 5][q + 5];
	memset(dp , -0x3f3f, sizeof dp);
	for(int i = 1; i <= n ; i ++)
		for(int j = 1 ; j <= m ; j ++)
			cin >> a[i][j];
	dp[1][1][0] = a[1][1];
	for(int i = 1 ; i <= n ; i ++){
		for(int j = 1 ; j <= m ; j ++){
			for(int k = 0 ; k <= q; k ++){
				//从上方转移
				if(i > 1){
					if(gcd(a[i - 1][j] , a[i][j]) == 1){
						if(k > 0){
							dp[i][j][k] = max(dp[i][j][k] , dp[i - 1][j][k - 1] + a[i][j]);
						}
					}
					else{
						dp[i][j][k] = max(dp[i][j][k] , dp[i - 1][j][k] + a[i][j]);
					}
				}
				//从左侧转移
				if(j > 1){
					if(gcd(a[i][j - 1] , a[i][j]) == 1){
						if(k > 0){
							dp[i][j][k] = max(dp[i][j][k] , dp[i][j - 1][k - 1] + a[i][j]);
						}
					}
					else{
							dp[i][j][k] = max(dp[i][j][k] , dp[i][j - 1][k] + a[i][j]);						
					}
				}
			}
		}
	}
	LL maxx = -1e18;
	for(int i = 0 ; i <= q; i ++){
		maxx = max(maxx , dp[n][m][i]);
	}
	if(maxx > 0)
		cout<<maxx;
	else
		cout<<-1;
    return 0;
}

深秋的苹果

        题意：给定一个数组，要求分成m段连续子序列，定义一段子序列的价值为\sum _{i = l}^{r}\sum _{j = l + 1}^{r}A_{i}*A_{j}，求分成m段连续子序列中子序列价值的最大值的最小值。

        思路：最值问题考虑二分来解答，二分子序列价值的最大值即可。

#include <iostream>
using namespace std;
const int N = 2e5 + 10;
int n , m;
int a[N];
bool check(long long c){
  long long cnt = 1;
  long long sum = 0;
  long long tt = 0;
  for(int i = 0 ; i < n ; i ++){
      if(tt + sum * a[i] > c){
        cnt ++;
        tt = 0;
        sum = a[i];
      }
      else{
        tt += sum * a[i];
        sum += a[i];
      }
  }
  if(cnt <= m){
    return true;
  }
  else{
    return false;
  }
}
int main()
{
  // 请在此输入您的代码
  cin >> n >> m;
  for(int i = 0 ; i < n ; i ++)
    cin>>a[i];
  long long l = 0 , r = 3e18;
  while(l < r){
    long long mid = (l + r) / 2;
    if(check(mid)){
      r = mid;
    }
    else{
      l = mid + 1;
    }
  }
  cout<<l;
  return 0;
}

 鲜花之海

在一个幻想的王国中，有一个美丽的花园，花园里开满了各种不同颜色的鲜花。现在花园里一共有 N^2 朵鲜花，这些鲜花都有一个独特且 唯一 的编号，编号由 (a , b)(1 \leq a,b\leq N)两个数字组成。

这些鲜花按如下规则摆放在花坛中（花坛可以视作一条直线）：

  1. 如果第 X 朵鲜花的编号之和 X_a + X_b小于第 Y 朵鲜花编号之和 Y_a + Y_b，则 XX 朵鲜花放在 YY 朵鲜花前面。
  2. 如果第 X 朵鲜花的编号之和 X_a + X_b 等于第Y 朵鲜花编号之和 Y_a + Y_b ，则哪一朵鲜花的编号 a 更小，哪一朵鲜花就摆在前面。

现在小蓝需要找到花园中的第 K朵鲜花，但鲜花实在是太多了，他不想一朵朵的去找，你可以快速的告诉他第 K 朵鲜花的编号吗。

        思路：参考曼哈顿距离，将原正方形顺时针旋转90°之后再镜像一下得到一个菱形，其中第一行只有一个元素(1,1) , 第二行有两个元素(1 , 2)(2,1)....共有2 * n - 1行，且上面一行的两坐标之和必然小于下面一行。由于N很大，因此无法通过遍历N来找出第K朵花。对于整个菱形而言，前x行的总数是能够快速得到的，因此考虑二分第K朵花所在的行，然后再快速求出其坐标。

        

#include <iostream>
using namespace std;
long long n , k;
long long cnt(long long r){
  long long res = 0;
  if(r > n){
    res += (n + 1) * n / 2;
    res += (n - 1 + (n - (r - n))) * (r - n) / 2; 
  }
  else{
    res += (1 + r) * r / 2;
  }	
  return res;
}
bool check(long long r){
  long long res = cnt(r);
  if(res >= k){
    return true;
  }
  else{
    return false;
  }
}
int main()
{
  // 请在此输入您的代
  int t;
  cin >> t;
  while(t--){
	  cin >> n >> k;
	  long long l = 0 , r = 2 * n - 1;
	  while(l < r){
	    long long mid = (l + r) / 2;
	    if(check(mid)){
	      r = mid;
	    }
	    else{
	      l = mid + 1;
	    }
	  }
	  k -= cnt(l - 1);
	  if(l <= n){
	  	int sum = l + 1;
	  	int x = k;
	  	int y = sum - k;
	  	cout << x << " " << y << endl;
	  }
	  else{
	  	int sum = l + 1;
	  	int x = k + (r - n);
	  	int y = sum - x;
	  	cout << x << " " << y << endl;
	  }
  }
  return 0;
}

斐波拉契跳跃

        题意：博弈游戏，小蓝和小桥在玩一个数学游戏，游戏规则如下：有一个长度为 n 的 排列  a 和一个棋子，两个人轮流按照游戏规则在排列上移动这个棋子，由小蓝先手，最先不能移动棋子的人判为输。对于某一次移动，设棋子的移动起点为 i，移动的终点为 j，两人移动棋子均需要满足以下游戏规则：

        1、a_{i} < a_{j}。

        2、abs(j - i)是一个斐波那契数。且跳跃的距离要严格大于上一次所跳跃的距离。

        思路：建立sg函数，定义sg[i][j]为第i个点，上一步已经跳了第j个斐波那契数的距离之后是否能走出最后一步，若移动之后无法再移动了，则sg[i][j] = 1（代表了必胜）, 反之sg[i][j] = 0（代表必输）.。其中sg[i][0]表示自身状态，若sg[i][0] == 0 , 则该点必输。由于每个点所能跳跃的点十分有限，因此考虑dfs+记忆化搜索来遍历所有可能情况。

        

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
    return b > 0 ? gcd(b , a % b) : a;
}
LL lcm(LL a , LL b){
    return a / gcd(a , b) * b;
}
int n;
int fib[30];
int sg[N][30];
int a[N];
int dfs(int x , int l){
	if(sg[x][l] != -1)
		return sg[x][l];	
	int vis[2] = {0};
	for(int i = l + 1 ; i < 30 ; i ++){
		int v = fib[i];
		if(x - v >= 0 && a[x] < a[x - v]){
			dfs(x - v , i);
			vis[sg[x - v][i]] = 1;
		}
		if(x + v < n && a[x] < a[x + v]){
			dfs(x + v , i);
			vis[sg[x + v][i]] = 1;
		}
	}
	if(vis[0])
		return sg[x][l] = 1;
	else
		return sg[x][l] = 0;
}
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	fib[0] = 0;
	fib[1] = 1;
	fib[2] = 2;
	for(int i = 3 ; i < 30 ; i ++){
		fib[i] = fib[i - 1] + fib[i - 2];
	}
	cin>>n;
	for(int i = 0 ; i < n ; i ++){
		cin >> a[i];
	}
	memset(sg , -1 , sizeof sg);
	for(int i = 0;i < n;i++)
	{
	if(dfs(i,0) == 0)
		cout<<"Little Qiao"<<endl;
	else 
		cout<<"Little Lan"<<endl;
	}	
    return 0;
}

星石传送阵

       

        思路：首先答案显然是建完图之后BFS。对于求f(x),需要求出所有的质因子之和（由于要求价值之和最小，假设有一个能量为x * x的星石，那么将其拆为x + x 两块星石的总价值会更小）。需要先把1 ~ 1e4上所有的素数都找出来。然后再对 x 分解质因子。 接下来考虑如何去建图，对于规则2而言，编号为 x 和编号为f(x)的相连，那么总共只会有最多n条边（每个编号一条边）。但是对于规则1而言，若每个能量阵的f(x)都相同，那么需要建n * (n - 1)条边，这是无法接受的。因此不能用操作1来建边。因为其边权值都为1，那么无需存边，只需要将f(x)相等的点放一起即可。在BFS的过程中，对于能量值为 x 的传送阵而言，下一步只需要将f(x)相等的所有的点全部放进去即可，然后又因为此次操作做完以后所有f(x') = f(x)的点全都放进去了，下次再碰到f(y) = f(x)时无需再遍历f(x)相等的所有的点，如此便能无需建边且不重复的BFS。

        

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 2e05+10;
const LL NN = 1e4;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}
LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
vector<LL>prime;//存储素数
bool vis[N+5];
vector<int>mp[N];
int depth[N];
int vi[N];//x是否进去
int v[N];//f[i]是否进去
int n , A , B;
struct Node{
	int x;
	int fx;
}a[N];
vector<int>f[N];
void su() 
{
	for(int i = 2;i <= NN;i++)
	{
		if(!vis[i])
		  prime.pb(i);
		for(int j=0;j < prime.size() && prime[j] * i <= NN;j ++)
		{
			vis[prime[j]*i]=1;
			if(i % prime[j]==0)
			break;
		}
	}
}  
int fun(int a){
	int len = prime.size();
	int sum = 0;
	for(int i = 0 ; i < len ; i++){
		int x = prime[i];
		if(a < x){
			break;
		}
		while(a % x == 0){
			sum += x;
			a /= x;
		}
	}
	if(a > 1){
		sum += a;
	}
	return (sum % n) + 1;
}
void dfs(){
	queue<int>q;
	q.push(A);
	vi[A] = 1;
	depth[A] = 0;
	while(!q.empty()){
		int x = q.front();
		q.pop();
		for(auto it : mp[x]){
			if(!vi[it]){
				depth[it] = depth[x] + 1;
				q.push(it);
				vi[it] = 1;
			}
		}
		int F = a[x].fx;
		if(v[F] == 0){
			for(auto it : f[F]){
				if(!vi[it]){
					depth[it] = depth[x] + 1;
					q.push(it);
					vi[it] = 1;
				}				
			}
			v[F] = 1;
		}
	}
}
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	su();
	cin >> n >> A >> B;
	for(int i = 0 ; i <= n ; i ++){
		depth[i] = -1;
	}
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i].x;
		a[i].fx = fun(a[i].x);
		mp[i].pb(a[i].fx);
		mp[a[i].fx].pb(i);
		f[a[i].fx].pb(i);
	}
	dfs();
	cout<<depth[B];
    return 0;
}

        

        

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

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

相关文章

矩阵置零00

矩阵置零00

题目链接 矩阵置零 题目描述 注意点 使用 原地 算法 解答思路 思路是需要存储每一行以及每一列是否有0&#xff0c;因为要尽可能使用更少的空间&#xff0c;且新设置为0的格子不能对后续的判断产生影响&#xff0c;所以要在原有矩阵上存储该信息先用两个参数存储第一行和第…
阅读更多...
关于反弹Shell个人的一些理解与学习收获

关于反弹Shell个人的一些理解与学习收获

反弹Shell 概念&#xff1a; 反弹shell(reverse shell)&#xff0c;就是控制端(攻击者所有)监听某TCP/UDP端口&#xff0c;被控端发起请求到该端口&#xff0c;并将其命令行的输入输出转发到控制端。reverse shell与telnet&#xff0c;ssh等标准shell对应&#xff0c;本质上是…
阅读更多...
Linux 本地zabbix结合内网穿透工具实现安全远程访问浏览器

Linux 本地zabbix结合内网穿透工具实现安全远程访问浏览器

前言 Zabbix是一个基于WEB界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。能监视各种网络参数&#xff0c;保证服务器系统的安全运营&#xff1b;并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。 本地zabbix web管理界面限制在只能局域…
阅读更多...
OpenMMlab导出yolov3模型并用onnxruntime和tensorrt推理

OpenMMlab导出yolov3模型并用onnxruntime和tensorrt推理

导出onnx文件 直接使用脚本 import torch from mmdet.apis import init_detector, inference_detectorconfig_file ./configs/yolo/yolov3_mobilenetv2_8xb24-ms-416-300e_coco.py checkpoint_file yolov3_mobilenetv2_mstrain-416_300e_coco_20210718_010823-f68a07b3.pth…
阅读更多...
计算机网络期末复习-Part5

计算机网络期末复习-Part5

1、CRC计算 看例题&#xff1a;待发送序列为101110&#xff0c;生成多项式为X31&#xff0c;计算CRC校验码 先在待发送序列末尾添加与生成多项式次数相同的零&#xff0c;在上述例子中&#xff0c;生成多项式是X^3 1&#xff0c;所以需要添加3个零&#xff0c;待发送序列变成…
阅读更多...
面试官问 Spring AOP 中两种代理模式的区别?很多面试者被问懵了

面试官问 Spring AOP 中两种代理模式的区别?很多面试者被问懵了

面试官问 Spring AOP 中两种代理模式的区别?很多初学者栽了跟头&#xff0c;快来一起学习吧&#xff01; 代理模式是一种结构性设计模式。为对象提供一个替身&#xff0c;以控制对这个对象的访问。即通过代理对象访问目标对象&#xff0c;并允许在将请求提交给对象前后进行一…
阅读更多...
11.9乘法器实验总结（流水线，for移位）

11.9乘法器实验总结（流水线，for移位）

for循环乘法器 流水线乘法器 仿真的时候&#xff0c;注意把clk设置一个初始值 分析报告 电路图分析: 比对两种实现方式的RTL级电路图可以发现&#xff0c;for循环的乘法器本质为转为不断的循环累加&#xff0c;故最终电路长度很长&#xff0c;取决于循环&#xff0c;即累加的…
阅读更多...
CSS特效008：鼠标悬浮文字跳动动画效果

CSS特效008：鼠标悬浮文字跳动动画效果

总第 010 篇文章&#xff0c; 查看专栏目录 本专栏记录的是经常使用的CSS示例与技巧&#xff0c;主要包含CSS布局&#xff0c;CSS特效&#xff0c;CSS花边信息三部分内容。其中CSS布局主要是列出一些常用的CSS布局信息点&#xff0c;CSS特效主要是一些动画示例&#xff0c;CSS花…
阅读更多...
VB.NET三层之用户查询窗体

VB.NET三层之用户查询窗体

目录 前言: 过程: UI层代码展示: BLL层代码展示: DAL层代码展示: 查询用户效果图:​ 总结: 前言: 想要对用户进行查询&#xff0c;需要用到控件DataGrideView&#xff0c;通过代码的形式将数据库表中的数据显示在DataGrideview控件中&#xff0c;不用对DatGridView控件…
阅读更多...
关于财税体制什么是扁平化？三级财政西方的龙骑兵FIBW 10道练习题第五题

关于财税体制什么是扁平化？三级财政西方的龙骑兵FIBW 10道练习题第五题

目录 关于财税体制什么是扁平化&#xff1f; 三级财政 西方的龙骑兵 FIBW 10道练习题 第五题 关于财税体制什么是扁平化&#xff1f; 在财税领域&#xff0c;"扁平化"&#xff08;Flattening&#xff09;通常指的是简化税收结构&#xff0c;减少税种和税率的层…
阅读更多...
深度学习 YOLO 实现车牌识别算法 计算机竞赛

深度学习 YOLO 实现车牌识别算法 计算机竞赛

文章目录 0 前言1 课题介绍2 算法简介2.1网络架构 3 数据准备4 模型训练5 实现效果5.1 图片识别效果5.2视频识别效果 6 部分关键代码7 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 基于yolov5的深度学习车牌识别系统实现 该项目较…
阅读更多...
【Liunx】DHCP服务

【Liunx】DHCP服务

【Liunx】DHCP服务 DHCP概述A.安装dhcpB.查看配置文件C.修改配置文件 DHCP概述 DHCP(Dynamic Host Configuration Protocol)i动态主机配置协议 DHCP是由Internet工作任务小组设计开发的&#xff0c;专门用于为TCP/IP网络中的计算机自动分配TCP/IP参数的协议。 口使用DHCP服务的…
阅读更多...
YOLOv5算法进阶改进（3）— 引入深度可分离卷积C3模块 | 轻量化网络

YOLOv5算法进阶改进（3）— 引入深度可分离卷积C3模块 | 轻量化网络

前言：Hello大家好，我是小哥谈。深度可分离卷积是一种卷积神经网络中的卷积操作，它可以将标准卷积分解为两个较小的卷积操作：深度卷积和逐点卷积。深度卷积是在每个输入通道上分别执行卷积，而逐点卷积是在所有通道上执行卷积。这种分解可以大大减少计算量和参数数量，从而提…
阅读更多...
在 HarmonyOS 上实现 ArkTS 与 H5 的交互

在 HarmonyOS 上实现 ArkTS 与 H5 的交互

介绍 本篇 Codelab 主要介绍 H5 如何调用原生侧相关功能&#xff0c;并在回调中获取执行结果。以“获取通讯录”为示例分步讲解 JSBridge 桥接的实现。 相关概念 Web组件&#xff1a;提供具有网页显示能力的 Web 组件。 ohos.web.webview&#xff1a;提供 web 控制能力。 …
阅读更多...
【vue实战项目】通用管理系统：封装token操作和网络请求

【vue实战项目】通用管理系统：封装token操作和网络请求

目录 1.概述 2.封装对token的操作 3.封装axios 1.概述 前文我们已经完成了登录页&#xff1a; 【vue实战项目】通用管理系统&#xff1a;登录页-CSDN博客 接下来我们要封装一下对token的操作和网络请求操作。之所以要封装这部分内容是因为token我们登陆后的所有请求都要携…
阅读更多...
lamp环境搭建（kali，docker，ubuntu）

lamp环境搭建（kali，docker，ubuntu）

学了微专业，然后第一节课是学的搭建自己的环境，这里记录一下吧。 搭建一个lamp环境 (因为本人使用的是kali而且还带有集成环境的xampp，本身就自带了apache2，mysql和php。）后面有用ubuntu从0开始搭建的。 在kali环境下： 1.首先查看apache2和mysql和php 查看apache2 where…
阅读更多...
二、Linux用户管理

二、Linux用户管理

Linux是一个多用户多任务的操作系统&#xff0c;任何一个要使用系统资源的用户&#xff0c;都必须向系统管理员申请一个账户&#xff0c;然后用这个账户进入系统。 每个Linux用户至少属于一个用户组。 用户家目录home下&#xff0c;有各个用户分别创建的家目录&#xf…
阅读更多...
全域全自主建设，亚信科技AntDB数据库助力广电5G业务上线运行

全域全自主建设，亚信科技AntDB数据库助力广电5G业务上线运行

自2019年6月&#xff0c;中国广电成功获得5G牌照以来&#xff0c;迅速推进网络建设目标&#xff0c;成为5G网络覆盖广、应用场景多、用户体验出色的第四大运营商。其依托全球独有的700MHz频谱资源&#xff0c;具备覆盖能力强、容量足、速率高的优势。通过不断深化和中国移动的共…
阅读更多...
进行 “最佳价格查询器” 的开发（多种并行方式的性能比较）

进行 “最佳价格查询器” 的开发（多种并行方式的性能比较）

前置条件 public class Shop {private final String name;private final Random random;public Shop(String name) {this.name name;random new Random(name.charAt(0) * name.charAt(1) * name.charAt(2));}public double getPrice(String product) {return calculatePrice…
阅读更多...
让AI拥有人类的价值观，和让AI拥有人类智能同样重要

让AI拥有人类的价值观，和让AI拥有人类智能同样重要

编者按&#xff1a;2023年是微软亚洲研究院建院25周年。25年来&#xff0c;微软亚洲研究院探索并实践了一种独特且有效的企业研究院的新模式&#xff0c;并以此为基础产出了诸多对微软公司和全球社会都有积极影响的创新成果。一直以来&#xff0c;微软亚洲研究院致力于创造具有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023