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

news2024/11/13 9:48:32

比赛链接

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

这把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;
}

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

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

相关文章

Vivado Lab Edition

Vivado Lab Edition

Vivado Lab Edition 是完整版 Vivado Design Suite 的独立安装版本 &#xff0c; 包含在生成比特流后对赛灵思 FPGA 进行编程和 调试所需的所有功能。通常适用于在如下实验室环境内进行编程和调试&#xff1a; 实验室环境中的机器所含磁盘空间、内存和连 接资源较少。Vivad…
阅读更多...
B2902A是德科技B2902A精密型电源

B2902A是德科技B2902A精密型电源

181/2461/8938产品概述&#xff1a; Agilent B2902A 精密源/测量单元 (SMU) 是一款 2 通道、紧凑且经济高效的台式 SMU&#xff0c;能够源和测量电压和电流。它用途广泛&#xff0c;可以轻松、高精度地执行 I/V&#xff08;电流与电压&#xff09;测量。4 象限源和测量功能的集…
阅读更多...
Android room 在dao中不能使用挂起suspend 否则会报错

Android room 在dao中不能使用挂起suspend 否则会报错

错误&#xff1a; Type of the parameter must be a class annotated with Entity or a collection/array of it. kotlin.coroutines.Continuation<? super kotlin.Unit> $completion); 首先大家检查一下几个点 一、kotlin-kapt 二、 是否引入了 room-ktx 我是2024年…
阅读更多...
JAVA的NIO和BIO底层原理分析

JAVA的NIO和BIO底层原理分析

文章目录 一、操作系统底层IO原理1. 简介2. 操作系统进行IO的流程 二、BIO底层原理1. 什么是Socket2. JDK原生编程的BIO 三、Java原生编程的NIO1. 简介2. NIO和BIO的主要区别3. Reactor模式4. NIO的三大核心组件5. NIO核心源码分析 一、操作系统底层IO原理 1. 简介 IO&#x…
阅读更多...
Untiy 布局控制器Aspect Ratio Fitter

Untiy 布局控制器Aspect Ratio Fitter

Aspect Ratio Fitter是Unity中的一种布局控制器组件&#xff0c;用于根据指定的宽高比来调整包含它的UI元素的大小。实际开发中&#xff0c;它可以确保UI元素保持特定的宽高比&#xff0c;无论UI元素的内容或父容器的大小如何变化。 如图为Aspect Ratio Fitter组件的基本属性&…
阅读更多...
驾照自助机体检色盲检测第六版

驾照自助机体检色盲检测第六版

相关文章&#xff1a; 驾驶证自助机换证流程 色弱如何识别色盲检测图 数字类 1-3张原图 题目&#xff1a;请根据图片&#xff0c;从左至右&#xff0c;填写出3位正确的数字 题目&#xff1a;请根据图片&#xff0c;从左至右&#xff0c;填写出2位正确的数字 题目&#…
阅读更多...
|行业洞察·汽车|《新能源汽车行业发展及营销策略分析-35页》

|行业洞察·汽车|《新能源汽车行业发展及营销策略分析-35页》

报告的主要内容解读&#xff1a; 行业环境&#xff1a;报告指出&#xff0c;海外车企的电动化进程遇到阻碍&#xff0c;而中国新能源汽车市场持续增长&#xff0c;2023年销量占全球新能源汽车的63.5%&#xff0c;市占率达到31.6%。 市场政策&#xff1a;中国政府通过减免税收、…
阅读更多...
机器学习优化算法（深度学习）

机器学习优化算法（深度学习）

目录 预备知识 梯度 Hessian 矩阵&#xff08;海森矩阵&#xff0c;或者黑塞矩阵&#xff09; 拉格朗日中值定理 柯西中值定理 泰勒公式 黑塞矩阵&#xff08;Hessian矩阵&#xff09; Jacobi 矩阵 优化方法 梯度下降法&#xff08;Gradient Descent&#xff09; 随机…
阅读更多...
腾讯云4核8G服务器多少钱？12M带宽646元15个月，买1年送3月

腾讯云4核8G服务器多少钱？12M带宽646元15个月，买1年送3月

2024年腾讯云4核8G服务器租用优惠价格&#xff1a;轻量应用服务器4核8G12M带宽646元15个月&#xff0c;CVM云服务器S5实例优惠价格1437.24元买一年送3个月&#xff0c;腾讯云4核8G服务器活动页面 txybk.com/go/txy 活动链接打开如下图&#xff1a; 腾讯云4核8G服务器优惠价格 轻…
阅读更多...
离线Linux/openEuler服务器指定本地yum仓库

离线Linux/openEuler服务器指定本地yum仓库

1、前提准备一个预装坏境比较完整的linux镜像文件&#xff0c;本文服务器使用的是openEuler 官网&#xff1a;openEuler下载 | 欧拉系统ISO镜像 | openEuler社区官网 2、上传镜像文件至服务器 如果是集群服务器&#xff0c;上传其中一台服务器之后&#xff0c;使用scp指令将镜…
阅读更多...
PowerBI加权计算权重

PowerBI加权计算权重

1.打开主页&#xff0c;点击快速度量值 2.计算里面 选择计算&#xff1a;每个类别的加权平均值 3.就是添加数据&#xff0c;基值&#xff08;就是你要计算的值&#xff09;粗细&#xff08;就是你要用那个值计算权重&#xff09;类别&#xff08;就是你是要乘以那个类别&#x…
阅读更多...
黑群晖基于docker配置frp内网穿透

黑群晖基于docker配置frp内网穿透

前言 我的黑群晖需要设置一下内网穿透来外地访问&#xff0c;虽然zerotier的p2p组网已经很不错了&#xff0c;但是这个毕竟有一定的局限性&#xff0c;比如我是ios的国区id就下载不了zerotier的app&#xff0c;组网不了 1.下载镜像 选择第一个镜像 2.映射文件 配置frpc.ini&a…
阅读更多...
Flutter 拦截系统键盘，显示自定义键盘

Flutter 拦截系统键盘，显示自定义键盘

一、这里记录下在开发过程中&#xff0c;下单的时候输入金额需要使用自定义的数字键盘 参考链接: https://juejin.cn/post/7166046328609308685 效果图 二、屏蔽系统键盘 怎样才能够在输入框获取焦点的时候&#xff0c;不让系统键盘弹出呢&#xff1f;同时又显示我们自定义的…
阅读更多...
拉里·埃里森 (Larry Ellison) 概述了 Oracle 的生成式 AI 战略

拉里·埃里森 (Larry Ellison) 概述了 Oracle 的生成式 AI 战略

翻译自&#xff1a;拉里埃里森 (Larry Ellison) 概述了 Oracle 的生成式 AI 战略 甲骨文董事长兼首席技术官拉里埃里森概述了该公司如何将生成式人工智能 (GenAI) 嵌入其庞大的云服务组合中&#xff0c;旨在帮助客户和整个社会解决最棘手的问题。 在 Oracle CloudWorld 的主题…
阅读更多...
Collection集合 --java学习笔记

Collection集合 --java学习笔记

Collection Collection是单列集合的祖宗&#xff0c;它规定的方法&#xff08;功能&#xff09;是全部单列集合都会继承的 List系列集合&#xff1a;List系列集合&#xff1a;ArrayList、LinkedList --java学习笔记-CSDN博客 Set系列集合&#xff1a;Set系列集合&#xff1a;…
阅读更多...
08_会话技术

08_会话技术

文章目录 前置知识点会话技术Conversation客户端技术CookieCookie的格式Cookie的优缺点构造Cookie信息通过浏览器构造Cookie通过Postman构造Cookie通过服务器构造Cookie 获取Cookie信息Cookie中的信息PathDomainMaxAge 案例&#xff08;cookie相关&#xff09; 服务器技术Sessi…
阅读更多...
MD5 计算 (加密辅助类, Win32, C++)

MD5 计算 (加密辅助类, Win32, C++)

CCryptHelper.h #pragma once #include <string> #include <tchar.h> #include <windows.h>#ifdef _UNICODE using _tstring std::wstring; #else using _tstring std::string; #endif// 加密辅助类 // 客户端: Windows XP 及以上系统可用 // 服务器: Win…
阅读更多...
VESTA模拟计算XRD标准卡片

VESTA模拟计算XRD标准卡片

先上Crystallography Open Database网站下载标准CIF卡片&#xff08;以PbI2为例&#xff09; 1.直接进网站搜元素就行 2.点CIF直接下载 3.打开VESTA&#xff0c;导入刚刚下载的CIF 4.导入成功就是这样的 5.按照我这个操作来计算 6.点Calculation 7.已经计算出来了&#xff…
阅读更多...
政安晨：专栏目录【TensorFlow与Keras实战演绎机器学习】

政安晨：专栏目录【TensorFlow与Keras实战演绎机器学习】

政安晨的个人主页&#xff1a;政安晨 欢迎 &#x1f44d;点赞✍评论⭐收藏 收录专栏: TensorFlow与Keras实战演绎机器学习 希望政安晨的博客能够对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff01; 本篇是作者政安晨的专栏《TensorFlow与Keras…
阅读更多...
cf937Div4E题F题

cf937Div4E题F题

题目要找到一个长为k的子串,使得x个相同的k相连长度和s相同且对应字符中只能有一个地方对应的字符不同, 那是不是说明s也能分成x段,且最多有一段中的一个字符不同,否则就不满足要求,那我们现在要讨论这个不同的字符在哪,如果在第一段比如sabaa aaaa aaaa aaaa,如果我们取了abaa…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023