牛客小白月赛89（A,B,C,D,E,F）

比赛链接

官方视频讲解（个人觉得讲的还是不错的）

这把BC偏难，差点就不想做了在这里插入图片描述，对小白杀伤力比较大。后面的题还算正常点。

A 伊甸之花

思路：

发现如果这个序列中最大值不为 k k k，我们可以把序列所有数都加 1 1 1，这样所有数一定不会超出范围，也就得到了一种可行解。同理，若序列中最小值不为 1 1 1，就可以给序列所有数减 1 1 1。

但是如果序列最小值顶到了 1 1 1，最大值顶到了 k k k，那么序列就完全无法整体上下移动，也就无解。

code：

#include <iostream>
#include <cstdio>
using namespace std;
const int inf=1e9;

int n,m,minn=inf,maxx=-inf;

int main(){
	cin>>n>>m;
	for(int i=1,t;i<=n;i++){
		cin>>t;
		minn=min(minn,t);
		maxx=max(maxx,t);
	}
	if(minn==1 && maxx==m)puts("No");
	else puts("Yes");
	return 0;
}

B 显生之宙

思路：

手玩一下，其实不难发现操作的顺序是固定的：先操作当前剩余序列的最小的负数，给其他所有数加上这个负数，操作完负数后，正数加起来就是答案。

因为我们处理元素是从小到大，所以先排个序。最后一个数一定留着不操作，所以我们把正数都累加到 a n a_n an​ 上，最后的答案就是 a n a_n an​ 了。

但是这里元素值是在时刻变化的，而且处理负数的时候是区间操作。考虑我们设置一个累加变量，给后面加上的数我们先存放在这个变量里，到后面处理到某个元素的时候，再把影响附加到这个元素上。

或者你也可以直接上线段树。赛时调到红温差点就用了。

code：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn=5e5+5;

ll T,n,a[maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n;
		for(int i=1,t;i<=n;i++)cin>>a[i];
		sort(a+1,a+n+1);
		
		ll add=0;
		for(int i=1;i<=n;i++){
			a[i]+=add;
			if(i==n){
				cout<<a[n]<<endl;
				break;
			}
			
			if(a[i]<0)add+=a[i];
			else a[n]+=a[i];
		}
		
	}
	return 0;
}

C 太阳之华

思路：

手玩一会其实会发现一个规律，就是如果某一方无法一次就决定胜局，那么这一方一定不会赢。

因为如果你一次操作后，若对方还有剩的格子，对方任选一个操作一下，这个格子周围就会出现一圈 “护盾”，你下次操作后只能剥离这个 “护盾”，而内部的格子不会受到影响。因此就会无限循环起来，这时候就会平局。

而进一步研究发现，除非蓝方赢在了起跑线上——地图上全是蓝格子。就只有红方有可能会赢，因为红方先手操作就会导致被操作的红格子周围出现 “护盾”，之后蓝方肯定不可能赢。所以我们暴力枚举红方操作的哪一个连通块，模拟一下涂色过程，看看红方能不能一局定胜负，不能就是平局。

不过检查图是否被涂满红色不能暴力来验证，最坏情况下每个连通块都验证一下，需要 O ( n 2 m 2 ) O(n^2m^2) O(n2m2)。考虑预先统计一下蓝色点的个数，之后涂色的时候记录一下涂了几个点，涂色结束后看一下个数对不对的上就行了，为了不重复可以用set存储被涂色的点。

code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
const int maxn=2005;

int T,n,m,cnt;
string mp[maxn];

int fx[]={1,-1,0,0},fy[]={0,0,1,-1};

bool vis[maxn][maxn];
set<pair<int,int> > S;
void dfs(int ux,int uy){
//	cout<<ux<<" "<<uy<<endl;
	vis[ux][uy]=true;
	for(int i=0,x,y;i<4;i++){
		x=ux+fx[i];
		y=uy+fy[i];
		if(x<1 || x>n || y<1 || y>m)continue;
		
		if(mp[x][y]=='#'){
			if(!vis[x][y]){
				dfs(x,y);
			}
		}
		else S.insert(make_pair(x,y));
	}
}
void solve(){
	if(cnt==n*m){
		puts("Blue");
		return;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			vis[i][j]=false;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(!vis[i][j] && mp[i][j]=='#'){
				S.clear();
				dfs(i,j);
				if(S.size()==cnt){
					puts("Red");
					return;
				}
			}
		}
	}
	puts("Draw");
}

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		cnt=0;
		for(int i=1;i<=n;i++){
			cin>>mp[i];
			for(auto x:mp[i])
				if(x=='.')
					cnt++;
			mp[i]=" "+mp[i];
		}
		solve();
	}
	return 0;
}

D 冥古之潮

思路：

题面虽然规定了选出点后的顺序必须从小到大，但是实际上这可以看作是一种选点的集合。因为选点集合和从小到大的排列是可以一一对应的。所以这个题其实就是在问：选择 k k k 个到点 x x x 的距离不同的结点的方案数。

我们预处理出到点 x x x 距离为 i i i 的点的个数 c o u n t [ i ] count[i] count[i]。然后就可以先枚举 k k k，对每个 k k k，去计算选择方案数。

不过这样复杂度是爆炸的，考虑如何优化。考虑对每种距离的点，我们可以选或不选，所以考虑动态规划。设 d p [ i ] [ j ] dp[i][j] dp[i][j] 为考虑了距离小于等于 i i i 的所有点，从中选取 j j j 个的方法数。状态转移方程也好想： d p [ i ] [ j ] = d p [ i − 1 ] [ j ] + c o u n t [ i ] ∗ d p [ i − 1 ] [ j ] dp[i][j]=dp[i-1][j]+count[i]*dp[i-1][j] dp[i][j]=dp[i−1][j]+count[i]∗dp[i−1][j]

实际上发现 d p i dp_{i} dpi​ 只和 d p i − 1 dp_{i-1} dpi−1​ 有关，所以第一维可以优化掉，类似于 01 01 01 背包的优化方式。

code：

#include <iostream>
#include <cstdio>
#include <queue>
#define pii pair<int,int>
using namespace std;
typedef long long ll;
const int maxn=1e6+5;
const int maxk=5e5+5;
const ll inf=1e9;
const ll linf=1e18;
const ll mod=1e9+7;

int n,m,q,x;

int head[maxn],cnt;
struct edge{
	int v,nxt;
}e[maxn<<1];
void add(int u,int v){
	e[++cnt].v=v;
	e[cnt].nxt=head[u];
	head[u]=cnt;
}

int d[maxn],count[maxk];
void dijkstra(){
	for(int i=1;i<=n;i++)d[i]=inf;
	queue<int> q;//假dij，因为边权都是1，直接bfs就行了
	q.push(x);
	d[x]=0;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u],v;i;i=e[i].nxt){
			v=e[i].v;
			if(d[v]==inf){
				d[v]=d[u]+1;
				count[d[v]]++;
				q.push(v);
			}
		}
	}
}

ll dp[maxk];//dp[i] 选择i个数的方法数 

int main(){
	cin>>n>>m>>q>>x;
	for(int i=1,u,v;i<=m;i++){
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	
	dijkstra();
	
	dp[0]=1;
	for(int i=1;i<=5000;i++){
		if(count[i]){
			for(int j=5000;j>=1;j--)
				dp[j]=(dp[j]+count[i]*dp[j-1])%mod;
		}
	}
	while(q--){
		int k;
		cin>>k;
		cout<<dp[k]<<endl;
	}
	
	return 0;
}

其实还有别的理解方式，比如生成函数，详细讲解可以看这个大佬的。

多项式某一项的系数就表示方法数，指数表示选择个数。比如选择 k k k 个点的方法数就是 x k x^k xk 的系数。

这个题的生成函数其实就是 ∏ i = 1 5000 ( 1 + c o u n t i ∗ x 1 ) \prod_{i=1}^{5000}(1+count_i*x^{1}) i=1∏5000​(1+counti​∗x1)上面的 d p dp dp 递推过程其实相当于在算这个式子的展开式。

E 神性之陨

思路：

发现一个竖条旁边接另一个竖条的话，两个相邻的竖条只能有一个格子是相邻的，这样在前面竖条走到后面竖条的路径一定是唯一的。否则在这上面就会出现多条路径。

因此后一个竖条的上端点要接在前一个竖条的下端点，或者后一个竖条的下端点要接在前一个竖条的上端点。不过有个特殊情况就是如果后一个竖条的宽度就是 1 1 1 的话，那么它放在前一个竖条的哪里都可以。

一个比较明显的想法就是保存第 i i i 列所有可以放竖条的位置，然后枚举每个可能的情况，算出第 i + 1 i+1 i+1 列的情况，一直算到最后一列即可。代码如下：

#include <iostream>
#include <cstdio>
#include <set>
using namespace std;
const int maxn=5005;

int T,n,m,a[maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		for(int i=1;i<=m;i++)cin>>a[i];
		
		set<int> S,t;
		for(int i=1;i<=n;i++)S.insert(i);
		for(int i=2,l,r;i<=m;i++){
			t.clear();
			if(a[i]==1){
				int tl=0,l,r;
				for(auto x:S){
					l=x;
					r=x+a[i-1]-1;
					for(int j=max(tl,l);j<=r;j++)t.insert(j);
					tl=r+1;
				}
			}
			else {
				for(auto x:S){
					l=x;
					r=x+a[i-1]-1;
					if(l-a[i]+1>=1)t.insert(l-a[i]+1);
					if(r+a[i]-1<=n)t.insert(r);
				}
			}
			
			S=t;
		}
		
		cout<<S.size()<<endl;
	}
	return 0;
}

结果T了， n ∗ m ∗ l o g m n*m*logm n∗m∗logm 会被卡。考虑到可以用桶的思想来存储，我们用 v i s [ i ] [ j ] vis[i][j] vis[i][j] 表示第 i i i 行第 j j j 列是否可以作为第 j j j 列竖条的上端点。我们用第 j − 1 j-1 j−1 列的竖条可能在的位置的信息就可以算出第 j j j 列的信息，这样就可以优化掉一个 l o g log log。

code：

实际上 v i s vis vis 可以再加一维，变成 v i s [ i ] [ j ] [ 0 / 1 ] vis[i][j][0/1] vis[i][j][0/1] 表示第 i i i 行第 j j j 列是否可以作为第 j j j 列竖条的 上/下 端点，递推的时候可能会比较好推。

#include <iostream>
#include <cstdio>
#include <set>
using namespace std;
const int maxn=5005;

int T,n,m,a[maxn];
bool vis[maxn][maxn];

int main(){
	cin>>T;
	while(T--){
		cin>>n>>m;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++)
				vis[i][j]=false;
		for(int i=1;i<=m;i++)cin>>a[i];
		
		for(int i=1;i<=n;i++)vis[i][1]=true;
		for(int col=2,l,r;col<=m;col++){
			if(a[col]==1){
				for(int l,r,x=0,i=1;i<=n;i++){
					if(!vis[i][col-1])continue;
					l=i;
					r=i+a[col-1]-1;
					for(int j=max(l,x);j<=r;j++)vis[j][col]=true;
					x=r+1;
				}
			}
			else {
				for(int i=1;i<=n;i++){
					if(!vis[i][col-1])continue;
					l=i;
					r=i+a[col-1]-1;
					if(l-a[col]+1>=1)vis[l-a[col]+1][col]=true;
					if(r+a[col]-1<=n)vis[r][col]=true;
				}
			}
		}
		
		int ans=0;
		for(int i=1;i<=n;i++)ans+=vis[i][m];
		cout<<ans<<endl;
	}
	return 0;
}

F 无垢之土

思路：

考虑树上答案的两个生物怎么相遇：应该是走树上的路径然后相遇，这个路径最短就是一个点先到它们的最近公共祖先（LCA，Least Common Ancestor），再到另一个点。

一对生物想要尽可能快地相遇，它们一定是这样跑：某个生物从一个点出生，并沿着这个最短路径向另一边跑，另一个点上的生物同理，然后两个生物在路上的某个位置相遇了。而这个用时我们可以在它们的最近公共祖先上算出来，也就是这两个生物一定是先后到达这个祖先的，先到达的生物向另一个生物所在的子树跑，于是两个生物总用时的一半就是答案用时。

因为我们只需要知道最快相遇的那对生物，所以我们一个祖先就不需要存储每个子树的点到这个根的用时，只用知道每个子树最快到这个根的时间即可。我们设 d p [ i ] dp[i] dp[i] 表示 i i i 的子树的点到达根 i i i 的最快的生物的用时。

我们保存一下这个点出生的生物的时间，每个子树跑过来的最快生物的时间（子树的 d p dp dp 值），从中选出时间最小和次小的生物，它们的平均值就是以这个点为 L C A LCA LCA 的最快相遇时间。然后 d p [ i ] dp[i] dp[i] 就等于其中的最小值。

不过这样是有 b u g bug bug 的，有的生物用时比较长并不是离 L C A LCA LCA 远，而是出生晚，这样一个生物跑到另一边即使跑到了另一个生物的出生地，也无法相遇，只能等待，直接取平均值就会出错，hack数据：

3 2
1 2
1 3
2 1
3 10

正确答案是：20
不考虑出生时间答案是：13

发现一对生物相遇的最快用时是 用时 = m a x { 通过 L C A 跑出的最短时间 , 生物 1 的出生时间，生物 2 的出生时间 } 用时=max\{通过 LCA 跑出的最短时间,生物1的出生时间，生物2的出生时间\} 用时=max{通过LCA跑出的最短时间,生物1的出生时间，生物2的出生时间}
这样验证一个时间是比较方便的（也就是验证在这个时刻上有没有生物已经相遇了）。首先需要这个时间能保证两个生物都能出生，在此基础上 通过 L C A LCA LCA 跑出的最短时间 小于等于这个时间即可。这样就能验证这两个生物一定是在验证时间之前就相遇了。

所以考虑二分答案，当出生时间比要验证的答案要晚的话，就不再将他出生在点上，这样就能保证两个生物在这个时间点上都出生了。如果跑出来的最短时间小于等于这个时刻，就说明在这个时刻上有生物已经相遇了。

不过中间算时间时有可能会出现 ∼ . 5 \sim.5 ∼.5 的情况，搞浮点魔法也不好搞。所以我们一开始就对所有跟时间有关的东西都乘上 2 2 2：出生时间乘以 2 2 2，从子节点移动到父节点的用时变成 2 2 2 即可。

code：

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn=1e5+5;
const int inf=1e9;

int n,m;
vector<int> tm[maxn];

int head[maxn],counter;
struct edge{
	int v,nxt;
}e[maxn<<1];
void add(int u,int v){
	e[++counter].v=v;
	e[counter].nxt=head[u];
	head[u]=counter;
}

int dp[maxn];//子树点最小时间到达i的时间 
int ans;
void dfs(int u,int fa,int bd){
	int m1=inf,m2=inf;
	for(int i=head[u],v;i;i=e[i].nxt){
		v=e[i].v;
		if(v==fa)continue;
		
		dfs(v,u,bd);
		m2=min(m2,dp[v]+2);
		if(m1>m2)swap(m1,m2);
	}
	
	for(auto x:tm[u]){
		if(x>bd)continue;
		 
		m2=min(m2,x);
		if(m1>m2)swap(m1,m2);
	}
	dp[u]=m1;
	ans=min(ans,(m1+m2)/2);
}
bool check(int bd){
	ans=inf;
	dfs(1,-1,bd);
	return ans<=bd;
}

int main(){
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		add(u,v);
		add(v,u);
	}
	for(int i=1,nd,t;i<=m;i++){
		cin>>nd>>t;
		tm[nd].push_back(2*t);
	}
	
	int l=0,r=1e7,mid;
	while(l<r){
		mid=(l+r)>>1;
		for(int i=1;i<=n;i++)dp[i]=inf;
		if(check(mid))r=mid;
		else l=mid+1;
	}
	cout<<l<<endl;
	return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2024年道路运输企业主要负责人证模拟考试题库及道路运输企业主要负责人理论考试试题

2024年道路运输企业主要负责人证模拟考试题库及道路运输企业主要负责人理论考试试题

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 2024年道路运输企业主要负责人证模拟考试题库及道路运输企业主要负责人理论考试试题是由安全生产模拟考试一点通提供&#xff0c;道路运输企业主要负责人证模拟考试题库是根据道路运输企业主要负责人最新版教材&#…
阅读更多...
数据结构进阶篇 之 【二叉树】详细概念讲解（带你认识何为二叉树及其性质）

数据结构进阶篇 之 【二叉树】详细概念讲解（带你认识何为二叉树及其性质）

有朋自远方来&#xff0c;必先苦其心志&#xff0c;劳其筋骨&#xff0c;饿其体肤&#xff0c;空乏其身&#xff0c;鞭数十&#xff0c;驱之别院 一、二叉树 1、二叉树的概念 1.1 二叉树中组分构成名词概念 1.2 二叉树的结构概念 1.3 特殊的二叉树 2、二叉树的存储结构 …
阅读更多...
沪漂8年回郑州三年如何走上创业之路

沪漂8年回郑州三年如何走上创业之路

大家好&#xff0c;我是大牛&#xff0c;目前人在郑州。 现在标签是&#xff1a; 创业者&#x1f697;&#x1f438; (注册有自己的公司&#xff0c;主要是为了自己的产品和接外包项目)独立开发者&#x1f468;&#x1f3fb;&#x1f4bb; (有自己的小项目)数字游民&…
阅读更多...
SpringDoc 注解

SpringDoc 注解

列举几个常用的 1. Tag 用于说明或定义的标签。一般作用于控制层 2.Operation(summary "这是新增方法") 描述 API 操作的元数据信息。常用于 controller 层的方法上 ​ 3.Parameter 用于描述 API 操作中的参数 ​ 4.Operation Parameters ​ 5.Schema用于…
阅读更多...
IPV6协议之RIPNG

IPV6协议之RIPNG

目录 前言&#xff1a; 一、RIPNG与RIP的区别 二、如何配置RIPNG 如何解决RIPNG环路问题呢&#xff1f; 控制RIPNG的选路 1、修改RIPNG默认优先级 2.配置接口附加开销值从而干涉RIPNG的选路 RIPNG拓展配置 1.RIPNG的认证 配置RIPNG进程下的IPsec认证&#xff1a; 配…
阅读更多...
麒麟系统安装JDK、OpenGauss

麒麟系统安装JDK、OpenGauss

Linux安装openjdk1.8 1. 执行命令yum list |grep jdk查看可安装jdk版本 2. 选择一个java版本进行安装 这里我们希望安装java1.8&#xff0c;因为我们的机器是64位的&#xff0c;所以选择安装java-1.8.0-openjdk-devel.x86_64。 这里有个地方要注意&#xff0c;上图中我用红框圈…
阅读更多...
LLaVA: Large Language and Vision Assistant 图片解析 图生文

LLaVA: Large Language and Vision Assistant 图片解析 图生文

LLaVA: Large Language and Vision Assistant 图片解析 图生文 目录 介绍 效果 ​编辑项目 测试代码 Form1.cs Helper.cs 下载 介绍 LLaVA&#xff0c;一种新的大型多模态模型&#xff0c;称为“大型语言和视觉助手”&#xff0c;旨在开发一种通用视觉助手&#xf…
阅读更多...
110 Tried to send an out-of-range integer as a 2-byte value: 40003

110 Tried to send an out-of-range integer as a 2-byte value: 40003

前言 呵呵 这个也是一个之前碰到的一个问题, 主要的问题是 发送给数据库的 sql 参数太多了, 呵呵 超过了 postgres 客户端, 服务器 交互的参数的数量的上限了 之前记录了一个 todo, 最近的时候 看了一下 这部分的代码, 以及 涉及到的相关的协议 另外 例子中会有一个对比, …
阅读更多...
【Lazy ORM 框架学习】

【Lazy ORM 框架学习】

Gitee 点赞关注不迷路 项目地址 快速入门 模块所属层级描述快照版本正式版本wu-database-lazy-lambdalambda针对不同数据源wu-database-lazy-orm-coreorm 核心orm核心处理wu-database-lazy-sqlsql核心处理成处理sql解析、sql执行、sql映射wu-elasticsearch-starterESESwu-hb…
阅读更多...
JAVA 8 新特性Stream API

JAVA 8 新特性Stream API

一、Stream API 概念 Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这 是目前为止对Java类库最好的补充&#xff0c;因为Stream API可以极大提供Java程序员的生产力&#xff0c;让程序员写出高效率、干净、简洁的代码。 Stream 是 Java8 中处理集合…
阅读更多...
docker搭建zabbixx ，智能服务器监控运维平台（运维工程师必备）

docker搭建zabbixx ，智能服务器监控运维平台（运维工程师必备）

安装阿里的docker源 yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo sudo yum makecache fast 安装系统需要的工具 yum install -y bind-utils net-tools wget unzip yum install -y yum-utils device-mapper-persisten…
阅读更多...
学习笔记Day17：转录组上游分析-1

学习笔记Day17：转录组上游分析-1

转录组上游分析-1 作业&#xff1a; 取出fastq文件中的所有序列ID&#xff08;第一行&#xff09; less SRR1039510_1.fastq.gz | awk {if(NR%41){print $0}}less SRR1039510_1.fastq.gz | paste - - - - | cut -f 1 取出fastq文件中的所有序列&#xff08;第二行&#xff09;…
阅读更多...
鸿蒙OS应用示例：【数字滚动计时】

鸿蒙OS应用示例：【数字滚动计时】

实现效果&#xff1a; 代码示例&#xff1a; RollingText.ets 组件封装 RollingText.ets 组件封装 /*** 滚动文字特效*/ Component export default struct RollingText {private num:numberprivate timerId: number -1State counter: number 0aboutToAppear() {this.timerId…
阅读更多...
【蓝桥杯】填空题技巧|巧用编译器|用Python处理大数和字符|心算手数|思维题

【蓝桥杯】填空题技巧|巧用编译器|用Python处理大数和字符|心算手数|思维题

目录 一、填空题 1.巧用编译器 2.巧用Excel 3. 用Python处理大数 4.用Python处理字符 5.心算手数 二、思维题 推荐 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。【点击跳转到网站】 一、填空题 …
阅读更多...
做功能测试多年，想进阶自动化技术 ，该如何学习自动化测试呢 ？

做功能测试多年，想进阶自动化技术 ，该如何学习自动化测试呢 ？

1.什么是自动化测试 &#xff1f; 即三个自动化 &#xff1a; 代码修改自动触发自动化运行 、自动执行测试用例 、自动生成测试结果并发送团队 。 对技术的要求就是&#xff1a;自动化测试框架 持续集成工具 2. 企业为什么要做自动化 &#xff1f; 从企业的需求来看 &…
阅读更多...
速看！2024广州国际服务机器人产业博览会

速看！2024广州国际服务机器人产业博览会

2024广州国际服务机器人产业博览会 时间&#xff1a;2024年12月19-21日 地点&#xff1a;中国进出口商品交易会琶洲展馆 近年来我国服务机器人智能化、个性化水平快速提升&#xff0c;使其需求领域不断扩展&#xff0c;销售额不断增长。尤其是疫情带动服务机器人需求增长&am…
阅读更多...
MCGS学习——弹框报警

MCGS学习——弹框报警

弹框报警的制作流程 先绘制一个弹框窗口&#xff0c;在弹框窗口里绘制弹框标志&#xff0c;记得绘制完成之后点击合成单元&#xff0c;此外&#xff0c;打开报警信息按钮中是打开报警界面 绘制好之后&#xff0c;如果我们想让弹窗出现在我们想让他出现的位置&#xff0c;那我…
阅读更多...
Stata 15 for Mac：数据统计分析新标杆，让研究更高效！

Stata 15 for Mac：数据统计分析新标杆，让研究更高效！

Stata 是一种统计分析软件&#xff0c;适用于数据管理、数据分析和绘图。Stata 15 for Mac 具有以下功能&#xff1a; 数据管理&#xff1a;Stata 提供强大的数据管理功能&#xff0c;用户可以轻松导入、清洗、整理和管理数据集。 统计分析&#xff1a;Stata 提供了广泛的统计…
阅读更多...
常见端口及对应服务

常见端口及对应服务

6379 redis未授权 7001、7002 weblogic默认弱口令、反序列化 9200、9300 elasticsearch 参考乌云&#xff1a;多玩某服务器ElasticSearch命令执行漏洞 11211 memcache未授权访问 50000 SAP命令执行 50070、50030 hadoop默认端口未授权访问
阅读更多...
C/C++ 语言中的 ​if...else if...else 语句

C/C++ 语言中的 ​if...else if...else 语句

C/C 语言中的 ​if...else if...else 语句 1. if statement2. if...else statement3. if...else if...else statementReferences 1. if statement The syntax of the if statement is: if (condition) {// body of if statement }The code inside { } is the body of the if …
阅读更多...
最新文章

Copyright @ 2022~2023