24.11.10

news2024/11/14 0:40:43

星期一：

补 23ICPC 合肥 G                                                     cf传送门

思路：由使第 k个最大这种条件易联想到二分，但是如何check是个问题

check使用dp，先想到个比较朴素的状态设定，dp【i】【j】表示考虑到第 i个，已有 j个连续1段长度>=mid，考虑转移，是从dp【i-mid】【j-1】转移还是从dp【i-mid-1】【j-1】进行转移呢？两种转移都有问题，不知道第 i-mid个是否是第 j-1段的末尾1，就有可能出现第 j-1段和第 j段连一起的情况

于是定义状态为dp【i】【j】【0/1】表示考虑到第 i个，共有 j段，第 i个 不是/是 第 j段的末尾1 ，即可进行正常转移

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
ll m,k;
string s;
int sum[N];
int dp[N][6][2];
bool check(int x){
	for(int i=0;i<=n;i++)
		for(int j=0;j<=5;j++) j?dp[i][j][0]=dp[i][j][1]=1e9:dp[i][j][1]=1e9;
	dp[0][0][0]=0;
	for(int i=1;i<=n;i++){
		for(int j=0;j<=k;j++){
			if(j && i-x>=0) dp[i][j][1]=dp[i-x][j-1][0]+sum[i]-sum[i-x];
			if(s[i]=='1') dp[i][j][0]=dp[i-1][j][0];
			else dp[i][j][0]=min(dp[i-1][j][0],dp[i-1][j][1]);
		}
	}
	return min(dp[n][k][0],dp[n][k][1])<=m;
}
void solve(){
	cin >> n >> m >> k;
	cin >> s; s=" "+s;
	for(int i=1;i<=n;i++) sum[i]=sum[i-1]+(s[i]=='0');
	int l=1,r=(n+k-1)/k,res=-1;
	while(l<=r){
		int mid=l+r>>1;
		if(check(mid)) res=mid,l=mid+1;
		else r=mid-1;
	}
	cout << res << "\n";
}

学而时习之，20届东南校赛 J                                      cf传送门

上半年被这题拿下了，现在重做倒没什么难度了

思路：朴素定义 dp【i】【j】表示考虑到第 i个，分了 j段的最小值

复杂度很明显可以接受 n^2 *k，枚举 i，j，再枚举转移的状态，此转移需要知道任何区间中的布尔值总和，简单区间dp处理出sum【l】【r】

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
ll a[3030],sum[3030][3030];
ll dp[3030][22];
void solve(){
	ll k,x; cin >> n >> k >> x;
	for(int i=1;i<=n;i++){
		cin >> a[i];
		a[i]+=a[i-1];
	}
//	for(int i=1;i<=n;i++)
//		for(int j=i;j<=n;j++) sum[i][j]=sum[i+1][j]+sum[i][j-1]-sum[i+1][j-1]+(a[j]-a[i-1]==x);
	for(int len=1;len<=n;len++){       //第一层枚举长度
		for(int l=1;l+len-1<=n;l++){
			int r=l+len-1;
			sum[l][r]=sum[l+1][r]+sum[l][r-1]-sum[l+1][r-1]+(a[r]-a[l-1]==x);
		}
	}
	for(int i=0;i<=n;i++) for(int j=0;j<=k;j++) dp[i][j]=1e18;
	dp[0][0]=0;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=k;j++)
			for(int y=j-1;y<i;y++)
				dp[i][j]=min(dp[y][j-1]+sum[y+1][i],dp[i][j]);
	cout << dp[n][k] << "\n";
//	cout << sum[1][3];
}

星期二：

补 24 辽宁省赛 G                                                     cf传送门

思路：考虑把每个数当作魔力数组的第一个最大值来统计，不重不漏

需要知道左边第一个大于等于ai的值下标，以及右边第一个大于ai值的下标，和以i为第一次，ai值第k次出现的下标，这些信息比较好统计，之后可以直接算出答案

代码如下：

const int N=1e6+10,M=5e5+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
int a[N];
int b[N];
int lm[N],rm[N],lst[N],nxt[N];
void solve(){
	ll k; cin >> n >> k;
	for(int i=1;i<=n;i++){
		cin >> a[i];
		b[i]=0;
	}
	for(int i=1;i<=n;i++){
		if(!b[a[i]]) lst[i]=1;
		else lst[i]=b[a[i]]+1;
		b[a[i]]=i;
	}
	map<int,queue<int>>qu;
	for(int i=n;i;i--){
		qu[a[i]].push(i);
		if((int)qu[a[i]].size()>k) qu[a[i]].pop();
		if((int)qu[a[i]].size()<k) nxt[i]=n+1;
		else nxt[i]=qu[a[i]].front();
	}
	stack<int>sk;
	for(int i=1;i<=n;i++){
		while(!sk.empty() && a[sk.top()]<=a[i]) sk.pop();
		if(sk.empty()) lm[i]=1;
		else lm[i]=sk.top()+1;
		sk.push(i);
	}
	while(!sk.empty()) sk.pop();
	for(int i=n;i;i--){
		while(!sk.empty() && a[sk.top()]<=a[i]) sk.pop();
		if(sk.empty()) rm[i]=n;
		else rm[i]=sk.top()-1;
		sk.push(i);
	}
	ll ans=0;
	for(int i=1;i<=n;i++){
		int l=i-max(lm[i],lst[i])+1,r=rm[i]-nxt[i]+1;
		if(l>0 && r>0) ans+=1ll*l*r;
	}
	cout << ans << "\n";
//	for(int i=1;i<=n;i++) cout << nxt[i] << " ";
}

补 D                                                                           cf传送门

思路：和东南校赛那题有点类似，f【i】【j】表示 i点与 i - j点中组成的最长线段长度

此题不需要处理出 i - j 区间所有线段的信息，n^2枚举足够把所有状态枚举到

代码如下：

const int N=2e5+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
double dis(ll x1,ll y1,ll x2,ll y2){
	return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
ll x[5050],y[5050];
double dp[5050],f[5050][5050];
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++) cin >> x[i] >> y[i];
	for(int i=1;i<=n;i++)
		for(int j=i+1;j<=n;j++)
			f[i][j]=max(dis(x[i],y[i],x[j],y[j]),f[i][j]);
	for(int i=1;i<=n;i++)
		for(int j=i-1;~j;j--)
			dp[i]=max(dp[j]+f[j+1][i],dp[i]);
	cout << fixed << setprecision(8) << dp[n] << "\n";
}

星期四：

补 湖南省赛 E                                                          cf传送门

思路：看数据范围想到状压

f【mask】表示的并不是 mask的长度（也不需要因为长度就是__builtin_popcount(mask)，而是mask的所有合法子集中最长的那个

这是如何处理出来的呢？先遍历 n，每个 i往后枚举找最长子串，最多枚举18位，此时f【mask】若有值则代表存在此合法子串

然后遍历mask，对于每个mask枚举其 1位，1变为0即nmask，即mask的一个子集，f【mask】再与f【nmask】取max，因为nmask此时已表示其所有合法子集，所以mask只需枚举去掉单个1，就能完成和所有子集取max

然后再枚举mask，对 f【mask】+ f【mask^tot】取max

代码如下：

const int N=1e6+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
int a[N];
int f[N];
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++) cin >> a[i],a[i]--;
	for(int i=1;i<=n;i++){
		int mask=0;
		for(int j=0;j<18 && i+j<=n;j++){
			if(mask&1<<a[i+j]) break;
			mask|=1<<a[i+j];
			f[mask]=j+1;
		}
	}
	int tot=(1<<18)-1;
	for(int mask=0;mask<=tot;mask++){
		for(int j=0;j<18;j++) if(mask&1<<j){
			int nmask=mask^(1<<j);
			f[mask]=max(f[nmask],f[mask]);    //mask的最大合法子集
		}
	}
	int ans=0;
	for(int mask=0;mask<=tot;mask++) ans=max(f[mask]+f[mask^tot],ans);
	cout << ans;
}

补 K                                                                           cf传送门

思路：超级源点+分层图

对于超级源点到第一层的每个点建立边权为 ai的边，即可把点权转化为边权处理，然后对于法宝只需建第二层图，建图后跑常规dij即可

取ans时需注意，第二层的点 dis【i+n】只有可能是从非 i点到达i点渡劫的权值，所以缺少了一种可能即在 i点直接渡劫，所以也要考虑第一层点的答案

代码如下：

const int N=2e6+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
vector<PII>ve[N];
ll dis[N];
bool vi[N];
void dij(){
	for(int i=1;i<=n*2;i++) dis[i]=1e18;
	priority_queue<PII,vector<PII>,greater<>>pq;
	pq.push({0,0});
	while(!pq.empty()){
		auto [d,u]=pq.top(); pq.pop();
		if(vi[u]) continue;
		vi[u]=1;
		for(auto [w,v]:ve[u]) if(dis[v]>d+w){
			dis[v]=d+w;
			pq.push({dis[v],v});
		}
	}
}
void solve(){
	ll m; cin >> n >> m;
	for(int i=1;i<=m;i++){
		int u,v,w; cin >> u >> v >> w;
		ve[u].push_back({w,v});
		ve[v].push_back({w,u});
		ve[u+n].push_back({w,v+n});
		ve[v+n].push_back({w,u+n});
		ve[u].push_back({0,v+n});
		ve[v].push_back({0,u+n});
	}
	for(int i=1;i<=n;i++){
		ll a; cin >> a;
		ve[0].push_back({a,i});
	}
	dij();
	ll ans=0;
	for(int i=n+1;i<=n*2;i++) ans=max(min(dis[i],dis[i-n]),ans);dis取min
	cout << ans;
}

星期五:

补 cf round983 div2 E 构造                                           cf传送门

绞尽脑汁差分不如直接上线段树

思路：有意思的构造，通过1 2 1的操作逐步构成其他操作，若对 x+2，x+4...x-1执行1 2 1操作，即等价与对 x和x+1进行 -1操作。若对 x+1，x+3...x-2进行-1 -1操作，即等价于对x进行 +1操作

思路很清新，实现很勾史，最开始想差分试试，结果半天没差分出来，好不容易过了样例 wa6，没办法只能上线段树，虽然线段树的实现也很麻烦但起码很稳定地一发过了

代码如下:

const int N=2e5+10,M=7e5+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
struct seg_Tree{
#define lc p<<1
#define rc p<<1|1
	struct nod{
		int l,r;
		ll mi1,mi2,op1,op2;
		ll tagm1,tagm2,tago1,tago2;
	}t[N<<2];
	ll ql,qr,q1,qv,qop;
	nod merge(nod a,nod b){
		nod res;
		res.l=a.l,res.r=b.r;
		//
		res.tagm1=res.tagm2=res.tago1=res.tago2=0;
		return res;
	}
	void pushup(int p){t[p]=merge(t[lc],t[rc]);}
	void bd(int p,int l,int r){
		t[p]={l,r,0,0,0,0,0,0,0,0};
		if(l==r) return ;
		int mid=l+r>>1;
		bd(lc,l,mid);
		bd(rc,mid+1,r);
	}
	void pushdn(int p){
		if(t[p].tagm1){
			t[lc].mi1+=t[p].tagm1;
			t[rc].mi1+=t[p].tagm1;
			t[lc].tagm1+=t[p].tagm1;
			t[rc].tagm1+=t[p].tagm1;
			t[p].tagm1=0;
		}
		if(t[p].tagm2){
			t[lc].mi2+=t[p].tagm2;
			t[rc].mi2+=t[p].tagm2;
			t[lc].tagm2+=t[p].tagm2;
			t[rc].tagm2+=t[p].tagm2;
			t[p].tagm2=0;
		}
		if(t[p].tago1){
			t[lc].op1+=t[p].tago1;
			t[rc].op1+=t[p].tago1;
			t[lc].tago1+=t[p].tago1;
			t[rc].tago1+=t[p].tago1;
			t[p].tago1=0;
		}
		if(t[p].tago2){
			t[lc].op2+=t[p].tago2;
			t[rc].op2+=t[p].tago2;
			t[lc].tago2+=t[p].tago2;
			t[rc].tago2+=t[p].tago2;
			t[p].tago2=0;
		}
	}
	void update(int p){
		if(ql<=t[p].l && qr>=t[p].r){
			if(qop==1){
				if(q1) t[p].mi1+=qv,t[p].tagm1+=qv;
				else t[p].mi2+=qv,t[p].tagm2+=qv;
			}else{
				if(q1) t[p].op1+=qv,t[p].tago1+=qv;
				else t[p].op2+=qv,t[p].tago2+=qv;
			}
			return ;
		}
		int mid=t[p].l+t[p].r>>1;
		pushdn(p);
		if(ql<=mid) update(lc);
		if(qr>mid) update(rc);
		pushup(p);
	}
	void updt(int l,int r,int op,int if1,ll v){
		ql=l,qr=r;
		qop=op,q1=if1;
		qv=v;
		update(1);
	}
	nod query(int p){
		if(ql<=t[p].l && qr>=t[p].r) return t[p];
		int mid=t[p].l+t[p].r>>1;
		pushdn(p);
		if(ql<=mid) return query(lc);
		if(qr>mid) return query(rc);
	}
	ll ask(int x,int op){
		ql=qr=x;
		qop=op;
		nod res=query(1);
		if(op==1) return x&1?res.mi1:res.mi2;
		else return x&1?res.op1:res.op2;
	}
}tr;
ll a[N];
void solve(){
	cin >> n;
	tr.bd(1,1,n);
	ll ma=0;
	for(int i=1;i<=n;i++){
		cin >> a[i];
		ma=max(a[i],ma);
	}
	for(int i=1;i<=n;i++) if(a[i]!=ma){
		if(i<n) tr.updt(i+1,n,1,!(i&1),ma-a[i]);
		if(i>1) tr.updt(1,i-1,1,i&1,ma-a[i]);
	}
	for(int i=1;i<=n;i++){
		ll mi=tr.ask(i,1);
//		cout << mi << " \n"[i==n];
		if(i<n) tr.updt(i+1,n,2,i&1,mi);
		if(i>1) tr.updt(1,i-1,2,!(i&1),mi);
	}
	for(int i=1;i<=n;i++) cout << tr.ask(i,2) << " \n"[i==n];
//	cout << tr.t[8].mi1 << " ";
}

星期六：

vp了21年沈阳ICPC，B题常数卡了很久，也算一个经验

晚上cf round985，预测的掉分场，但因为C的dp出的够快，又给+了2分

周日：

补 cf round985 D 构造                                                    cf传送门

又是一道有意思的构造

思路：每次操作对于边的数量有4种结果，+3,-3,+1,-1。考虑先把图拆成森林，让每个连通块的点数小于等于2，最多m次操作，若无边则直接结束，若有边考虑再构造成一颗树，事实上对于此操作和森林的情况下，构造成树很轻松，对于边 u，v，若要合并单点 w，直接进行操作u v w，操作边变为 u w，若合并边 p q，进行操作 v p q，p q即成为了v的子节点，此步骤操作次数也小于n

代码如下：

const int N=2e6+10,M=1e4+10;
const int INF=0x3f3f3f3f;
const int mod=998244353;
ll n;
vector<int>ve[N];
struct nod{
	ll a,b,c;
};
vector<nod>ans;
void solve(){
	ans.clear();
	ll m; cin >> n >> m;
	for(int i=1;i<=n;i++) ve[i].clear();
	for(int i=1;i<=m;i++){
		int u,v; cin >> u >> v;
		ve[u].push_back(v);
		ve[v].push_back(u);
	}
	for(int i=1;i<=n;i++) sort(ve[i].begin(),ve[i].end());
	for(int i=1;i<=n;i++) if(ve[i].size()>1){
		sort(ve[i].begin(),ve[i].end());//
		while(ve[i].size()>1){
			int u=ve[i].back(); ve[i].pop_back();
			int v=ve[i].back(); ve[i].pop_back();
			ans.push_back({i,u,v});
			sort(ve[u].begin(),ve[u].end());
			sort(ve[v].begin(),ve[v].end());
			ve[u].erase(find(ve[u].begin(),ve[u].end(),i));
			ve[v].erase(find(ve[v].begin(),ve[v].end(),i));
			if(find(ve[u].begin(),ve[u].end(),v)==ve[u].end()){
				ve[u].push_back(v);
				ve[v].push_back(u);
			}else{
				ve[u].erase(find(ve[u].begin(),ve[u].end(),v));
				ve[v].erase(find(ve[v].begin(),ve[v].end(),u));
			}
		}
	}
	int u=0,v=0;
	for(int i=1;i<=n;i++) if(!ve[i].empty()){
		u=i,v=ve[i].back();
		break;
	}
	map<int,bool>vi;
//	cout << u << " " << v << "\n";
	vi[v]=vi[u]=1;
	if(u){
		for(int i=1;i<=n;i++) if(!vi.count(i)){
//			cout << i << "\n";
			if(ve[i].empty()){
				ans.push_back({i,u,v});
				v=i;
			}else{
				int b=ve[i].back(); ve[i].pop_back();
				ve[b].pop_back();
				ans.push_back({v,i,b});
				vi[b]=1;
			}
		}
	}
	cout << ans.size() << "\n";
	for(auto i:ans) cout << i.a << " " << i.b << " " << i.c << "\n";
}

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

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

相关文章

JavaSE：初识Java（学习笔记）

JavaSE：初识Java（学习笔记）

java是高级语言的面向对象语言 .[最贴近生活.最快速分析和设计程序] 一&#xff0c;计算机语言发展历史 二&#xff0c;Java体系结构 1&#xff0c;JavaSE&#xff08;Java Standard Edition&#xff09; 标准版&#xff0c;定位在个人计算机上的应用 这个版本是Jav…
阅读更多...
SQL 专项练习题（合集）

SQL 专项练习题（合集）

1&#xff0c;第一题 1&#xff09;表名&#xff1a;t_patent_detail &#xff08;专利明细表&#xff09; 2&#xff09;表字段&#xff1a;专利号(patent_id)、专利名称(patent_name)、专利类型(patent_type)、申请时间 (aplly_date)、授权时间(authorize_date)、申请人(a…
阅读更多...
使用ffmpeg播放rtsp视频流

使用ffmpeg播放rtsp视频流

获取IPC摄像机视频流一般使用GB28181或者RTSP协议&#xff0c;这两款协议是比较常见的&#xff1b;两者都有开源的库&#xff0c;下面介绍如何使用RTSP获取进行IPC视频流&#xff1b; 准备库 ffmepg是个开源的库,该库集成了rtsp协议&#xff0c;可以直接使用&#xff1b;首先…
阅读更多...
【Linux探索学习】第十二弹——初识进程：进程的定义、描述和一些简单的相关操作

【Linux探索学习】第十二弹——初识进程：进程的定义、描述和一些简单的相关操作

Linux学习笔记&#xff1a; https://blog.csdn.net/2301_80220607/category_12805278.html?spm1001.2014.3001.5482 前言&#xff1a; 在前面经过那么多篇的铺垫后&#xff0c;今天我们正式进入Linux学习的第一个重难点——进程&#xff0c;理解进程对于我们学习操作系统的其…
阅读更多...
AI教育革命：个性化学习的新篇章

AI教育革命：个性化学习的新篇章

内容概要 在 教育 领域&#xff0c;人工智能 的崭露头角带来了前所未有的变化。如今&#xff0c;个性化学习 已不再是一个遥不可及的梦想&#xff0c;而是通过 AI 技术真正实现的可能。借助先进的数据分析能力&#xff0c;教师可以实时跟踪和评估每位学生的学习进度&#xff0…
阅读更多...
ASMR助眠声音视频素材去哪找 吃播助眠素材网站分享

ASMR助眠声音视频素材去哪找 吃播助眠素材网站分享

在快节奏的现代生活中&#xff0c;越来越多的人感到压力山大&#xff0c;许多人开始寻求助眠和放松的方式。而ASMR&#xff08;自发性知觉经络反应&#xff09;助眠声音视频&#xff0c;凭借其独特的声音刺激和放松效果&#xff0c;成为了睡前的“神器”。如果你是一位内容创作…
阅读更多...
项目管理中不可或缺的能力

项目管理中不可或缺的能力

在现代企业中&#xff0c;项目管理是一项至关重要的能力。项目管理需要具备的能力包括&#xff1a;有效的沟通能力、团队协作能力、时间管理能力、风险管理能力、以及问题解决能力。 其中&#xff0c;有效的沟通能力尤为重要&#xff0c;它不仅涉及到信息的传递&#xff0c;还包…
阅读更多...
蓝桥杯备考——算法

蓝桥杯备考——算法

一、排序 冒泡排序、选择排序、插入排序、 快速排序、归并排序、桶排序 二、枚举 三、二分查找与二分答案 四、搜索&#xff08;DFS&#xff09; DFS&#xff08;DFS基础、回溯、剪枝、记忆化&#xff09; 1.DFS算法&#xff08;深度优先搜索算法&#xff09; 深度优先搜…
阅读更多...
【Vue】Vue3.0（十九）Vue 3.0 中一种组件间通信方式-自定义事件

【Vue】Vue3.0（十九）Vue 3.0 中一种组件间通信方式-自定义事件

文章目录 一、自定义事件概念及使用场景二、代码解释三、新的示例 一、自定义事件概念及使用场景 概念 在 Vue 3.0 中&#xff0c;自定义事件是一种组件间通信的机制&#xff0c;允许子组件向父组件传递数据或触发父组件中的操作。子组件通过defineEmits函数定义可以触发的事件…
阅读更多...
成功解决WSL2上的Ubuntu22.04执行sudo apt-get update指令报错问题

成功解决WSL2上的Ubuntu22.04执行sudo apt-get update指令报错问题

问题&#xff1a;输入sudo apt-get update指令会显示如下报错 问题所在&#xff1a;Temporary failure in name resolution 显然是系统无法解析域名。这可能是 DNS 配置问题。 解决方案&#xff1a; 临时修改 DNS 配置 尝试手动修改 /etc/resolv.conf 文件来使用公共 DNS 服务…
阅读更多...
L1G3000 提示工程(Prompt Engineering)

L1G3000 提示工程(Prompt Engineering)

什么是Prompt(提示词)? Prompt是一种灵活、多样化的输入方式&#xff0c;可以用于指导大语言模型生成各种类型的内容。什么是提示工程? 提示工程是一种通过设计和调整输入(Prompts)来改善模型性能或控制其输出结果的技术。 六大基本原则: 指令要清晰提供参考内容复杂的任务拆…
阅读更多...
探索Python的Shell力量：Plumbum库揭秘

探索Python的Shell力量：Plumbum库揭秘

文章目录 探索Python的Shell力量&#xff1a;Plumbum库揭秘第一部分&#xff1a;背景介绍第二部分&#xff1a;Plumbum是什么&#xff1f;第三部分&#xff1a;如何安装Plumbum&#xff1f;2. 创建管道3. 重定向4. 工作目录操作5. 前台和后台执行 第五部分&#xff1a;场景应用…
阅读更多...
点击文本将内容填入tinymce-vue 富文本编辑器的光标处

点击文本将内容填入tinymce-vue 富文本编辑器的光标处

富文本编辑器组件 <template><div ref"tinymceBox" class"tinymce-box"><Editor id"myEditor" v-model"contentValue" :init"init" :disabled"disabled" blur"inputBlur" click"o…
阅读更多...
星海智算：风月ComfyUI_SD3.5

星海智算：风月ComfyUI_SD3.5

&#xff08;一&#xff09;镜像介绍 1、风月ComfyUI_SD3.5​ 占用69.71G磁盘&#xff0c;为用户预留了近30个G使用。 2、SD3.5​ SD3.5&#xff0c;即Stable Diffusion 3.5&#xff0c;是Stability AI推出的最新图像生成模型&#xff0c;是Stable Diffusion 3.0版本的升级版…
阅读更多...
在模方置平建筑失败的原因是什么？

在模方置平建筑失败的原因是什么？

在模方置平建筑失败的原因是什么&#xff1f; 可能是obj拓扑不连续&#xff0c;可以在网格大师使用osgb转obj功能&#xff0c;选择拓扑或者重建。 网格大师是一款能够解决实景三维模型空间参考、原点、瓦块大小不统一&#xff0c;重叠区域处理问题的工具“百宝箱”&#xff0c…
阅读更多...
python 语言入门

python 语言入门

目录 1.发展历程 2.优缺点 3.环境搭建 3.1.Anaconda 3.2.VSCode 3.3.重装自己的独立环境 4.第一个 python 程序 4.1.创建一个 .py 的文件 4.2.编写 python 代码 ​4.3.运行 python 代码 5.注释 5.1.单行注释 5.2.多行注释 6.转义字符 7.变量 7.1.变量类型 7.2…
阅读更多...
C++11 --- 智能指针详解

C++11 --- 智能指针详解

C11 智能指针 一、智能指针的使用场景分析二、RAII和智能指针的设计思路三、智能指针的本质及衍生的问题四、C标准库的智能指针的使用五、智能指针的原理&#xff08;模拟实现&#xff09;1. auto_ptr的模拟实现2. unique_ptr的模拟实现3. shared_ptr的模拟实现&#xff08;简单…
阅读更多...
（实战）WebApi第13讲：怎么把不同表里的东西，包括同一个表里面不同的列设置成不同的实体，所有的给整合到一起？【前端+后端】、前端中点击标签后在界面中显示

（实战）WebApi第13讲：怎么把不同表里的东西，包括同一个表里面不同的列设置成不同的实体，所有的给整合到一起？【前端+后端】、前端中点击标签后在界面中显示

一、实现全局跨域&#xff1a;新建一个Controller&#xff0c;其它的controller都继承它 1、新建BaseController 2、在后端配置&#xff0c;此处省略【详情见第12讲四、3、】 3、其它的控制器继承BaseController&#xff0c;这个时候就能够完成全局的跨域 【向后台传cookie和…
阅读更多...
【C++】map和set的介绍及使用

【C++】map和set的介绍及使用

前言&#xff1a; map和 set 是 C STL&#xff08;标准模板库&#xff09;中的两种非常重要的容器&#xff0c;它们基于一种叫做平衡二叉搜索树&#xff08;通常是红黑树&#xff09;的数据结构来实现。在 C 中&#xff0c;map 是一个键值对容器&#xff0c;set 只存储唯一的键…
阅读更多...
Python的函数（补充浅拷贝和深拷贝）

Python的函数（补充浅拷贝和深拷贝）

一、定义 函数的定义&#xff1a;实现【特定功能】的代码块。 形参&#xff1a;函数定义时的参数&#xff0c;没有实际意义 实参&#xff1a;函数调用/使用时的参数&#xff0c;有实际意义 函数的作用&#xff1a; 简化代码提高代码重用性便于维护和修改提高代码的可扩展性…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023