7.30 模拟赛总结 [神奇性质]+[线段树二分]

news2024/9/22 21:15:21

复盘

7:40 成功开题，艾教场

看 T1，感觉很神奇，但看数据范围没有开到 1 e 9 1e9 1e9 之类的，应该是得怎么搜一下；T2 发现做过原题，秒了；T3 第一眼没看懂题，推样例始终不理解其中的一句话；T4 听说是 arc 原，看起来应该可做

尝试 T1，爆搜给了 45pts，想了想可以把一段操作打包做，不以操作为阶段，而以每次往桶里倒水为阶段，这样可以在 O ( x y z ) O(xyz) O(xyz) 的复杂度内把所有边搜出来，最后再跑最短路

感觉很对，遂开写，20min 写的暴力跑出来了大样例，准备优化 (噩梦开始)

首先想到的操作是 ( z − y − . . . ) , ( z − x − . . . ) , ( y − x − . . . ) (z-y-...),(z-x-...),(y-x-...) (z−y−...),(z−x−...),(y−x−...)，然后这会有个问题，比如说先灌满 z z z，然后不停往 x x x 里倒，最后得到 z − k x z-kx z−kx 的一个东西，再倒进桶里。问题在于 最后一次 z z z 可以不清空 ，就是说可能留着 z z z 为满的情况下只使用 x , y x,y x,y 把桶灌到合适为止？那这样图得分层， f [ i ] [ 0 / 1 / 2 / 3 / 4 ] f[i][0/1/2/3/4] f[i][0/1/2/3/4] 表示能用 x y z / x y / x z / y z / z xyz/xy/xz/yz/z xyz/xy/xz/yz/z 的情况下的最小值

写写写，一顿分讨后代码长度来到 250 行，已经 1h 过去，但心想 T2 已经 100 了，不慌

发现样例没过，推了一下感觉样例错了？？？但爆搜跑出来的没问题啊？？？直接懵逼了

静态查错了大概 20min，未果…已经 10:15

决定先把 T2 写了，Kruskal 重构树+经典结论维护 dfn 最小最大的 LCA，十分顺利，样例一遍过，10:40 交了，发现这题没卡 l o g 2 log^2 log2 做法，可惜

回看 T1，仍觉得样例不对

看 T3，发现题根本看不懂？不懂样例解释里说 “1、4不能” 通信是什么意思，明明可以选 4 4 4 啊？无奈只能跳过

先看 T4 吧，想 q n qn qn 做法瞪出一个性质：必定选一段长度为 1 1 1，很快把暴力写完了，只剩 40min 了！

再看 T1 ，发现那个样例是因为我看错了，滑动条拉到最右边导致我看的是后面几个答案…

难蚌，经过手玩已经找到之前的问题了，不仅可以 z − x − x − . . . z-x-x-... z−x−x−... 还可以 x + . . + x − z x+..+x-z x+..+x−z 得到新的，这样讨论完全是 2 3 = 8 2^3=8 23=8 种状态！

决定把之前的删掉重构一遍，在过程中算复杂度发现 8 ∗ 1 e 5 ∗ 300 ∗ l o g 8*1e5*300*log 8∗1e5∗300∗log…心态有点崩

最后也是不出意料地没写完

35+100+0+40=175 , rk_ O ( n ! ) O(n!) O(n!)

懂了，艾教场一定要放弃 T1

T1 离正解很近了… 考虑把上面那种难处理地操作直接换到最后做，就可以直接背包了。推出来离谱做法后应该再尝试优化一下的…

T3 70pts 的主席树几乎是送的…(甚至实现好可以拿100)，而我样例都没推懂…

结论：要学会放弃艾教的 T1

题解

T1

在这里插入图片描述
我们理想的状态当然是 每次往桶里倒水的操作互不影响，这样就可以 O ( x y z ) O(xyz) O(xyz) 处理后直接背包

可以证明，一定存在一种最优方案，会影响后面的操作只会在最后做一次

有影响指的是 “某个杯子不清空，在之后的操作中不再用到” ，不妨设为是 x x x 杯，由于操作顺序不固定，那么之后 y , z y,z y,z 的清空操作不妨直接放到前面完成

唯一的问题是如果在接下来又在 y , z y,z y,z 中执行了一次 “对后面有影响” 的操作呢？手玩后发现，这样的情况一定可以被另一种上文所说的方式代替掉！

那么做法就很简单：处理 b t [ x ] bt[x] bt[x] 表示往桶里倒 x x x 的水，且清空，最小操作次数； b t 2 [ x ] bt2[x] bt2[x] 表示不清空，最小次数

对于前者做完全背包，对于后者做分组背包

#include<bits/stdc++.h>
using namespace std ;

typedef long long LL ;
const int N = 1e5+10 ;

int X , Y , Z , n ;
namespace Part1
{
	// 操作顺序可以随便交换，不妨就把填满某个不再动的操作放到最后 
	struct nn
	{
		int x , y , z , d ;
	};
	int D[101][101][101] , f[N] , bt[301] , bt2[301] ;// 最后一次操作 
	queue<nn> q ;
	void solve()
	{
		memset( D , -1 , sizeof D ) ;
		memset( bt , 0x3f , sizeof bt ) ;
		memset( bt2 , 0x3f , sizeof bt2 ) ;
		q.push({0,0,0,0}) ;
		D[0][0][0] = 0 ;
		while( !q.empty() ) {
			int x=q.front().x,y=q.front().y,z=q.front().z,d=q.front().d;
			q.pop() ;
			bt[x+y+z] = min( bt[x+y+z] , d+(x!=0)+(y!=0)+(z!=0) ) ;
			bt2[x] = min(bt2[x],d+(x!=0)); bt2[y] = min(bt2[y],d+(y!=0)); bt2[z] = min(bt2[z],d+(z!=0)) ;
			bt2[x+y]=min(bt2[x+y],d+(x!=0)+(y!=0)),bt2[x+z]=min(bt2[x+z],d+(x!=0)+(z!=0)),bt2[y+z]=min(bt2[y+z],d+(y!=0)+(z!=0)) ;
			if( D[X][y][z] == -1 ) D[X][y][z] = d+1 , q.push({X,y,z,d+1}) ;
			if( D[x][Y][z] == -1 ) D[x][Y][z] = d+1 , q.push({x,Y,z,d+1}) ;
			if( D[x][y][Z] == -1 ) D[x][y][Z] = d+1 , q.push({x,y,Z,d+1}) ;
			if( D[0][y][z] == -1 ) D[0][y][z] = d+1 , q.push({0,y,z,d+1}) ;
			if( D[x][0][z] == -1 ) D[x][0][z] = d+1 , q.push({x,0,z,d+1}) ;
			if( D[x][y][0] == -1 ) D[x][y][0] = d+1 , q.push({x,y,0,d+1}) ;
			//x->y 
			int tim=min(x,Y-y); if( D[x-tim][y+tim][z]==-1 ) D[x-tim][y+tim][z]=d+1 , q.push({x-tim,y+tim,z,d+1}) ;
			tim = min(x,Z-z); if( D[x-tim][y][z+tim]==-1 ) D[x-tim][y][z+tim]=d+1 , q.push({x-tim,y,z+tim,d+1}) ;
			tim = min(y,X-x); if( D[x+tim][y-tim][z]==-1 ) D[x+tim][y-tim][z]=d+1 , q.push({x+tim,y-tim,z,d+1}) ;
			tim = min(y,Z-z); if( D[x][y-tim][z+tim]==-1 ) D[x][y-tim][z+tim]=d+1 , q.push({x,y-tim,z+tim,d+1}) ;
			tim = min(z,X-x); if( D[x+tim][y][z-tim]==-1 ) D[x+tim][y][z-tim]=d+1 , q.push({x+tim,y,z-tim,d+1}) ;
			tim = min(z,Y-y); if( D[x][y+tim][z-tim]==-1 ) D[x][y+tim][z-tim]=d+1 , q.push({x,y+tim,z-tim,d+1}) ;
		}
		memset( f , 0x3f , sizeof f ) ;
		f[0] = 0 ;
		for(int i = 1 ; i <= X+Y+Z ; i ++ ) {
			if( bt[i]>1000 ) continue ;
			for(int j = i ; j <= n ; j ++ ) { // 完全背包 
				f[j] = min( f[j] , f[j-i]+bt[i] ) ;
			}
		}
		for(int j = n ; j >= 1 ; j -- ) {
			for(int i = 1 ; i <= min(j,X+Y+Z) ; i ++ ) {
				if( bt2[i] > 1000 ) continue ;
				f[j] = min( f[j] , f[j-i]+bt2[i] ) ; 
			}
		}
		for(int i = 1 ; i <= n ; i ++ ) printf("%d " , f[i]>1e8?-1:f[i] ) ;
	}
}

int main()
{
	scanf("%d%d%d%d" , &X , &Y , &Z , &n ) ;
	if( X > Y ) swap( X , Y ) ;
	if( Y > Z ) swap( Y , Z ) ;
	if( X > Y ) swap( X , Y ) ;
	Part1::solve() ;
	return 0 ; 
}

 

T2

在这里插入图片描述
典题

 

T3

在这里插入图片描述
考虑确定 P P P 后，每个节点 z z z 的负载是多少，等价于查以它为根的各个子树中的 s i z siz siz

那么二分答案后 check ，check 方法很多，已知的：线段树合并/主席树 在原序列上做；按 w i w_i wi​ 排序后离线树状数组做

但这样不可避免二分答案的 l o g log log + 检验的 l o g log log

我们之前遇到这个问题是在 区间第 K 大，当时利用了线段树二分来解决，我们考虑同样编一个线段树二分的做法

首先对于每个节点还是要维护子树中 w i w_i wi​ 的值域，通过 d f n dfn dfn 序转化到序列上 前缀主席树实现

接下来直接在查询的过程中二分，取出若干个主席树的根节点，每次计算左子树的答案，判断后 整体 往左/右儿子走

口胡很简单，细节不少

#include<bits/stdc++.h>
using namespace std ;

typedef long long LL ;
const int N = 3e5+10 , INF = 1e6 ;

int n , w[N] ;
LL K ;
vector<int> E[N] ;
int dfn[N] , tim , ed[N] , nam[N] ;
void dfs( int x , int fa )
{
	dfn[x] = ++tim ; nam[tim] = x ;
	for(int t : E[x] ) {
		if( t == fa ) continue ;
		dfs( t , x ) ; 
	}
	ed[x] = tim ;
}
struct Segtree
{
	int ls , rs , sum ;
}t[32*N] ;
int tot , rt[N] ;
inline int build() { return ++tot ; }
int Insert( int p , int l , int r , int x )
{
	int nw = build() ;
	t[nw] = t[p] ;
	if( l == r ) {
		t[nw].sum ++ ;
		return nw ;
	}
	int mid = (l+r)>>1 ;
	if( x <= mid ) t[nw].ls = Insert( t[p].ls , l , mid , x ) ;
	else t[nw].rs = Insert( t[p].rs , mid+1 , r , x ) ;
	t[nw].sum = t[t[nw].ls].sum + t[t[nw].rs].sum ;
	return nw ;
}
int p[N] , q[N] , Sum[N] , len , X , S , R ;//q-p
LL calc( int mid )
{
	int siz = 0 ; LL sum = 0 ;
	if( w[X] <= mid ) siz = 1 ;
	for(int i = 1 ; i <= len ; i ++ ) { 
		int v = t[q[i]].sum - t[p[i]].sum + Sum[i] ;
		sum += 1LL*siz*v ;
		siz += v ;
	}
	int v = t[R].sum-siz+S ;
	sum += 1LL*siz*v ;
	siz += v ; 
	return sum ;
}
int ask( int l , int r )
{
	if( l == r ) {
		if( calc(l) < K ) return l ;// 需要再算一次，不然边界会错
		return l-1 ;
	}
	int mid = (l+r)>>1 ;
	// 选左子树答案 
	int siz = 0 ; LL sum = 0 ;
	if( w[X] <= mid ) siz = 1 ;
	for(int i = 1 ; i <= len ; i ++ ) { 
		int v = t[t[q[i]].ls].sum - t[t[p[i]].ls].sum + Sum[i] ;
		sum += 1LL*siz*v ;
		siz += v ;
	}
	int v = t[t[R].ls].sum-siz+S ;
	sum += 1LL*siz*v ;
	siz += v ; 
	if( sum < K ) { //可以更大，往右儿子走 
		for(int i = 1 ; i <= len ; i ++ ) {
			Sum[i] += t[t[q[i]].ls].sum-t[t[p[i]].ls].sum ;// 需要补前缀
			q[i] = t[q[i]].rs ; p[i] = t[p[i]].rs ;
		}
		S += t[t[R].ls].sum ;
		R = t[R].rs ;
		return ask( mid+1 , r ) ;
	}
	else { // 往左儿子走 
		for(int i = 1 ; i <= len ; i ++ ) {
			q[i] = t[q[i]].ls ; p[i] = t[p[i]].ls ;
		}
		R = t[R].ls ;
		return ask( l , mid ) ;
	}
}
void solve()//把二分放到主席树上 
{
	int Min = 1e6 ;
	for(int x = 1 ; x <= n ; x ++ ) {
		X = x ; S = 0 ; R = rt[n] ; len = 0 ; 
		for(int t : E[x] ) {
			if( dfn[t] < dfn[x] ) continue ;
			len ++ ;
			p[len] = rt[dfn[t]-1] ; q[len] = rt[ed[t]] ; Sum[len] = 0 ;//这一层的根全存起来，整体走
		}
		Min = min( Min , ask(0,INF)-w[x] ) ;
	}
	printf("%d\n" , Min ) ;
}

int main()
{
	scanf("%d%lld" , &n , &K ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%d" , &w[i] ) ;
	}
	int x , y ;
	for(int i = 1 ; i < n ; i ++ ) {
		scanf("%d%d" , &x , &y ) ;
		E[x].push_back( y ) ;
		E[y].push_back( x ) ;
	}
	dfs( 1 , 0 ) ; // 需要子树信息，除了线段树合并之外，还可以通过 dfn 搞成前缀主席树 
	rt[0] = build() ;
	for(int i = 1 ; i <= n ; i ++ ) {
		rt[i] = Insert( rt[i-1] , 0 , INF , w[nam[i]] ) ;
	}
	solve() ;
	return 0 ; 
}

类似于 树套树求区间第 K K K 大时，整体往下走的思路
 

T4


好题，不过似乎比较套路

枚举 其中一段后 后，只有两种情况

在这里插入图片描述
这是由于，后边的两段中 有一段内部最大值更大，把这一段尽可能延申一定不差

( bb几句：好吧赛场上没有继续推下去，所以遇到这种情况我们要最大限度利用贪心简化条件

那么同理对于左边的两段，我们在比较二者内部的最大值后也可以进行延申

总之，最后只会存在两种情况：

[ L , L ] , [ L + 1 , R − 1 ] , [ R , R ] [L,L],[L+1,R-1],[R,R] [L,L],[L+1,R−1],[R,R]

[ L , t − 1 ] , [ t , t ] , [ t + 1 , R ] [L,t-1],[t,t],[t+1,R] [L,t−1],[t,t],[t+1,R]

第一种直接算就行，对于第二种情况：

首先它有三个变量，不好搞

对于区间 M a x Max Max 可以有一种想法：由于一定有一段能够取到整个区间的 M a x Max Max， 我们考虑它的位置，通过 下标在某一区间内 把某个变量给定下来

具体来说，假设区间最大值的位置为 p o s pos pos：（有多个取最左边)

不妨认为 t < p o s t<pos t<pos，那么第三段的答案就是固定的 M a x Max Max，接下来只需要求 m a x ( a L , . . . , a t − 1 ) + a t max(a_L,...,a_{t-1})+a_t max(aL​,...,at−1​)+at​ 的最大值

与下标有关，我们按 L L L 扫描线，线段树下标 t t t 位置维护的就是 t t t 的答案

当 L − − L-- L−−，对线段树的影响是修改了某一段的区间最大值，通过 单调栈找到影响的范围 + 线段树区间修改 解决；然后新插入 L L L 位置的答案也是好做的

对于一个询问，只需查 [ L + 1 , p o s − 1 ] [L+1,pos-1] [L+1,pos−1] 内部的答案即可， p o s pos pos 是区间最大值位置

对于 t > p o s t>pos t>pos 只需要把序列翻转后做一遍即可

#include<bits/stdc++.h>
using namespace std ;

typedef long long LL ;
const int N = 3e5+100 ;

int n , Q , a[N] , st[20][N] , id[20][N] , Lg2[N] ;
void make_st()
{
	for(int i = 2 ; i <= n ; i ++ ) Lg2[i] = Lg2[i/2]+1 ;
	for(int i = 0 ; i <= 18 ; i ++ ) {
		if( i == 0 ) {
			for(int j = 1 ; j <= n ; j ++ ) st[i][j] = a[j] , id[i][j] = j ;
		}
		else {
			for(int j = 1 ; j <= n-(1<<i)+1 ; j ++ ) {
				if( st[i-1][j] >= st[i-1][j+(1<<(i-1))] ) { // 多个 Max，取最靠左 
					st[i][j] = st[i-1][j] ;
					id[i][j] = id[i-1][j] ;
				}
				else {
					st[i][j] = st[i-1][j+(1<<(i-1))] ;
					id[i][j] = id[i-1][j+(1<<(i-1))] ;
				}
			}
		}
	}
}
typedef pair<int,int> PII ;
PII ask( int l , int r )
{
	int k = Lg2[r-l+1] ;
	if( st[k][l] >= st[k][r-(1<<k)+1] ) {
		return {st[k][l],id[k][l]} ;
	}
	return {st[k][r-(1<<k)+1],id[k][r-(1<<k)+1]} ;
}
// 推性质，简化条件
// 对于 Max，很常见的处理是考虑最大值位置，转化成某一段区间内某个值是一定的,减少变量 
struct nn
{
	int l , r , id , Mx , pos ;
}q[N] ;
bool cmp( nn x , nn y )
{
	return x.l > y.l ;
}
int ans[N] , stk[N] , top ;
struct Segtree
{
	int l , r , Max , Val , Mx ;//单点最小值/区间最大值/和的最小值 
	int tag ; 
}t[4*N] ;
inline void update( int p )
{
	t[p].Mx = min( t[p<<1].Mx , t[p<<1|1].Mx ) ;
	t[p].Max = min( t[p<<1].Max , t[p<<1|1].Max ) ;
}
void build( int p , int l , int r )
{
	t[p].l = l , t[p].r = r , t[p].Max = t[p].Val = t[p].Mx = t[p].tag = 0 ;
	if( l == r )  {
		t[p].Max = a[l] ;
		t[p].Mx = a[l] ;
		return ;
	}
	int mid = (t[p].l+t[p].r)>>1 ;
	build( p<<1 , l , mid ) ; build( p<<1|1 , mid+1 , r ) ;
	update( p ) ;
}
inline void spread( int p )
{
	if( t[p].tag ) { // 强行让后来的覆盖前面的 
		int d = t[p].tag ; t[p].tag = 0 ;
		t[p<<1].Val = d ; t[p<<1].tag = d ; t[p<<1].Mx = t[p<<1].Max+t[p<<1].Val ;
		t[p<<1|1].Val = d ; t[p<<1|1].tag = d ; t[p<<1|1].Mx = t[p<<1|1].Max+t[p<<1|1].Val ;
	}
}
void change( int p , int l , int r , int x ) //[l,r]内的区间最大值更改为 x 
{
	if( l <= t[p].l && t[p].r <= r ) {
		t[p].Val = x ; t[p].tag = x ;
		t[p].Mx = t[p].Max+t[p].Val ;
		return ;
	}
	spread(p) ;
	int mid = (t[p].l+t[p].r)>>1 ;
	if( l <= mid ) change( p<<1 , l , r , x ) ;
	if( r > mid ) change( p<<1|1 , l , r , x ) ;
	update( p ) ;
}
int query( int p , int l , int r ) // [l,r] 内和的最大值 
{
	if( l <= t[p].l && t[p].r <= r ) {
		return t[p].Mx ;
	}
	spread(p) ;
	int mid = (t[p].l+t[p].r)>>1 , res = 1e9 ;
	if( l <= mid ) res = min( res , query(p<<1,l,r) ) ;
	if( r > mid ) res = min( res , query(p<<1|1,l,r) ) ;
	return res ; 
}
void solve()
{
	sort( q+1 , q+Q+1 , cmp ) ;
	build( 1 , 1 , n ) ;
	stk[0] = n ;
	for(int i = n , j = 1 ; i >= 1 ; i -- ) {
		while( top && a[i]>a[stk[top]] ) top -- ;
		int R = stk[top] ;
		stk[++top] = i ;
		if( i+1 <= R ) {
			change( 1 , i+1 , R , a[i] ) ;
		}
		while( j <= Q && q[j].l == i ) {
			if( i+1<=q[j].pos-1 ) {
				ans[q[j].id]=min(ans[q[j].id],query(1,i+1,q[j].pos-1)+q[j].Mx ) ;
			}
			j ++ ;
		}
	}
}

int main()
{
	scanf("%d%d" , &n , &Q ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%d" , &a[i] ) ;
	}
	make_st() ;
	for(int i = 1 ; i <= Q ; i ++ ) {
		scanf("%d%d" , &q[i].l , &q[i].r ) ;
		q[i].id = i ;
		PII x = ask(q[i].l,q[i].r) ;
		q[i].Mx = x.first , q[i].pos = x.second ;
		ans[i] = a[q[i].l]+a[q[i].r]+ask(q[i].l+1,q[i].r-1).first ;
	}
	solve() ;
	reverse( a+1 , a+n+1 ) ;
	for(int i = 1 ; i <= Q ; i ++ ) {
		q[i].l = n-q[i].l+1 , q[i].r = n-q[i].r+1 ;
		swap( q[i].l , q[i].r ) ;
		q[i].pos = n-q[i].pos+1 ;
	}
	solve() ;
	for(int i = 1 ; i <= Q ; i ++ ) {
		printf("%d\n" , ans[i] ) ;
	}
	return 0 ; 
}

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

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

相关文章

使用Leaflet GeoMan结合天地图进行自由标绘实战

使用Leaflet GeoMan结合天地图进行自由标绘实战

目录 前言 一、Leaflet GeoMan是什么 1、关于Leaflet GeoMan 2、关于开源版和企业版 3、相关的方法介绍 二、使用Geoman来进行自由标绘实战 1、相关资源准备 2、新建html网页 3、初始化地图及绑定Geoman控件 三、自由标绘的成果 1、整体效果 2、添加空间对象 3、开…
阅读更多...
语音交互、AI问答，等你来体验！

语音交互、AI问答，等你来体验！

功能背景 在实际大屏应用中&#xff0c;用户向大屏直接下达语音指令显的越来越便捷&#xff0c;其中体现的交互感也比通过动作指令来的更加强烈&#xff0c;给用户带来更高效的服务体验。目前EasyV平台开发的自定义事件交互已经很完善&#xff0c;组件之间可以进行触发联动。 …
阅读更多...
python 装饰器及使用场景

python 装饰器及使用场景

1. 装饰器的理解 上面这种用装饰器的效果和下面这种是一样的&#xff0c;两个圈起来的是等价的&#xff0c;只是写法不一样&#xff0c;用装饰器函数 更简洁一些。 总的来说&#xff0c;装饰器的作用是&#xff1a;当定义一个函数的时候&#xff0c;通过在其上面加上装饰器&…
阅读更多...
C:关于位操作符：、|、^、~的一些应用

C:关于位操作符：、|、^、~的一些应用

一些用来熟悉位操作符的应用 一、按位异或&#xff1a;^ 异或运算&#xff1a;相同为0&#xff0c;相异为1 应用&#xff1a;在不引入临时变量&#xff08;第三变量&#xff09;的情况下&#xff0c;实现两个整数的交换。 关于两个整数交换&#xff0c;我们有一些方法&…
阅读更多...
Docker Compose部署项目+使用

Docker Compose部署项目+使用

目录结构 - suggestion/- backend/ # 我的后端项目- app.py- other_files/- docker-compose.yml- Dockerfile- requirements.txt获得requirements.txt 命令行输入&#xff1a;pip list --formatfreeze > requirements.txt 因为使用 pip freeze > requirements.txt 导出…
阅读更多...
创建了Vue项目,需要导入什么插件以及怎么导入

创建了Vue项目,需要导入什么插件以及怎么导入

如果你不知道怎么创建Vue项目,建议可以看一看这篇文章 怎么安装Vue的环境和搭建Vue的项目-CSDN博客 1.在idea中打开目标文件 2.系在一个插件Vue.js 3.下载ELement UI 在Terminal中输入 # 切换到项目根目录 cd vueadmin-vue # 或者直接在idea中执行下面命令 # 安装element-u…
阅读更多...
漏洞打靶-tomato

漏洞打靶-tomato

这是一个很有意思的靶场&#xff0c;靶机的安装过程请参考我的文章“漏洞打靶-hackme”&#xff0c;进入靶场后&#xff0c;迎面而来的就是一个大tomato&#xff0c;然后就无从下手了&#xff0c;查目录查不出来&#xff0c;sql注入也没地方注入 这时候我们可以用kali的nmap去查…
阅读更多...
ARM学习（29）NXP 双coreMCU MCXN94学习

ARM学习（29）NXP 双coreMCU MCXN94学习

笔者来介绍一下NXP 双core板子 &#xff0c;新系列的mcxn94 1、MCX 新系列介绍 恩智浦 MCU 系列产品包括 Kinetis 、LPC 系列&#xff0c;以及 i.MX RT 系列&#xff0c;现在又推出新系列产品 MCX 产品&#xff0c;包括四个系列&#xff0c;目前已经发布产品的是 MCX N 系列。…
阅读更多...
学习打卡第30天

学习打卡第30天

阅读更多...
第十四天7.25（git）

第十四天7.25（git）

1.git 1.git功能特性 1.克隆数据库版本&#xff1a;从服务器上克隆数据库本机上 2.提交代码&#xff1a;在本机上自己创建的分支上提交代码 3.合并分支&#xff1a;在本机上合并分支 4.拉取合并分支&#xff1a;新建一个分支&#xff0c;把服务器上最新的代码Fetch下来&…
阅读更多...
微软工具合集 | Microsoft PowerToys v0.83.0

微软工具合集 | Microsoft PowerToys v0.83.0

PowerToys是由微软开发的一款免费系统工具集&#xff0c;专为Windows 10和Windows 11系统设计。它提供了一系列高效实用的工具&#xff0c;旨在帮助用户提升操作系统的使用效率和个性化程度。PowerToys工具集深受系统管理员和高级用户的喜爱&#xff0c;通过集成多种工具&#…
阅读更多...
XXE -靶机

XXE -靶机

XXE靶机 一.扫描端口 进入xxe靶机 1.1然后进入到kali里 使用namp 扫描一下靶机开放端口等信息 1.2扫描他的目录 二 利用获取的信息 进入到 robots.txt 按他给出的信息 去访问xss 是一个登陆界面 admin.php 也是一个登陆界面 我们访问xss登陆界面 随便输 打开burpsuite抓包 发…
阅读更多...
《深入浅出WPF》学习笔记二.为对象属性赋值的三种方式

《深入浅出WPF》学习笔记二.为对象属性赋值的三种方式

《深入浅出WPF》学习笔记二.为对象属性赋值的三种方式 WPF用户图形界面是树状结构 &#x1f446;wpf文档大纲 &#x1f446;winform文档大纲 wpf的用户图形界面是树状结构&#xff0c;与winform不同点在于&#xff0c;winform同样存在树状结构的控件(比如panel、gridcontrol等…
阅读更多...
Wi-Fi、WLAN、Bluetooth、zigbee、蜂窝网络、4g5g、MQTT

Wi-Fi、WLAN、Bluetooth、zigbee、蜂窝网络、4g5g、MQTT

为什么打开手机的WiFi连接&#xff0c;显示的是WLAN&#xff1f; 分清Wi-Fi、WLAN、Bluetooth、zigbee、蜂窝网络、4g5g、MQTT这些概念. 一、WLAN、WIFI、WAPI WLAN是利用无线通信技术在局部区域内构建的网络&#xff0c;家庭/办公室里的网络就是一个WLAN&#xff0c;WLAN是一…
阅读更多...
【数据结构】Java实现二叉搜索树

【数据结构】Java实现二叉搜索树

二叉搜索树的基本性质 二叉搜索树&#xff08;Binary Search Tree, BST&#xff09;是一种特殊的二叉树&#xff0c;它具有以下特征&#xff1a; 1. 节点结构&#xff1a;每个节点包含一个键&#xff08;key&#xff09;和值&#xff08;value&#xff09;&#xff0c;以及指…
阅读更多...
大语言模型中的提示隐私保护

大语言模型中的提示隐私保护

大语言模型中的提示隐私保护 一、简介&#xff1a; 大语言模型&#xff08;LLM&#xff09; 拥有庞大的规模、预先训练的知识和卓越的性能&#xff0c;被广泛应用于各种任务。提示学习(prompt learning)和指令微调(instruction tuning) 是两种重要的使得大模型能理解具体任务…
阅读更多...
决策树基础

决策树基础

概述 决策树是一种树型结构&#xff0c;其中每个内部结点表示在一个属性上的测试&#xff0c;每个分支代表一 个测试输出&#xff0c;每个叶结点代表一种类别。决策树学习采用的是自顶向下的递归方法&#xff0c;其基本思想是以信息熵为度量构造一棵熵值下降最快的树&#xff…
阅读更多...
自学Java第16Day

自学Java第16Day

学习目标&#xff1a;面向对象进阶 学习内容&#xff1a;Object、Objects、BigInteger、BigDecimal、正则表达式 学习时间&#xff1a;下午 3 点-下午 6 点 学习产出&#xff1a; 1. Object类 1.1 概述 查看API文档&#xff0c;我们可以看到API文档中关于Object类的定义如下&…
阅读更多...
【SpringBoot3】场景整合（实战）

【SpringBoot3】场景整合（实战）

0 环境准备 0.0 云服务器 阿里云、腾讯云、华为云 服务器开通&#xff1b; 按量付费&#xff0c;省钱省心 安装以下组件&#xff1a;docker、redis、kafka、prometheus、grafana 下载windterm&#xff1a; https://github.com/kingToolbox/WindTerm/releases/download/2.5…
阅读更多...
React-Native 宝藏库大揭秘：精选开源项目与实战代码解析

React-Native 宝藏库大揭秘：精选开源项目与实战代码解析

1. 引言 1.1 React-Native 简介 React-Native 是由 Facebook 开发的一个开源框架&#xff0c;它允许开发者使用 JavaScript 和 React 的编程模型来构建跨平台的移动应用。React-Native 的核心理念是“Learn Once, Write Anywhere”&#xff0c;即学习一次 React 的编程模型&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023