1.31学习总结

最新推荐文章于 2024-07-12 22:49:10 发布
最新推荐文章于 2024-07-12 22:49:10 发布
阅读量726 收藏 21
点赞数 14
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80489323/article/details/135960342
版权

1.31
1.线段树
2.Bad Hair Day S（单调栈）
3.01迷宫(BFS连通块问题+剪枝)（连通性问题的并查集解法）
4.健康的荷斯坦奶牛 Healthy Holsteins（DFS）

线段树与树状数组

线段树和树状数组的功能相似，但是线段树的功能要更加强大一些，但是线段树的构造比树状数组更加复杂。

在动态区间和的问题上，朴素暴力的算法复杂度达到了O（n^2）效率很低，在前缀和中，计算出所有的前缀和的复杂度是O（n），而查询只要O（1），所以总复杂度只有O（n），但如果面对的是动态的区间和问题，计算量就会大大增加，如果涉及到区间修改，就会更加棘手，因为修改其中的一个值，会导致后面的前缀和发生改变，所以就需要O（n）的复杂度，那么如果改变m次元素的值，复杂度就达到了O（mn），和暴力的方法是一样的，所以就需要用到树状数组或者是线段树这样的结构，由于这样的结构存储是非线性的，所以在修改元素上的时间是O（logn），同理查询某个元素的复杂度也是O（logn），由于初始化数组的时候，需要逐个读取数值所以初始化的复杂度是O（nlogn）所以总复杂度是O（nlogn），线段树的复杂度和树状数组是相当的，线段树和树状数组的区别就在于树状数组在面对区间查询，区间修改问题时非常棘手，而线段树可以很轻松的解决区间问题

树状数组主要就只有三个函数，lowbit（），更新函数：update（），求和函数：sum（）

#define lowbit(x) (x& (-x))
void update(int x,int k)
{
	while(x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);//子节点+k，父节点都要+k 
	}
}
int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);//求的是1---x的区间和 
	}
	return res;
}

这三个函数构成了树状数组的主要部分

初始化数组

for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		update(i,a[i]);
	}

全部代码（单点修改+区间查询）https://www.luogu.com.cn/problem/P3374

#include <bits/stdc++.h>
using namespace std;
#define int long long 
const int N=5e5+5;
#define lowbit(x) (x& (-x))
int tree[N],a[N];
int n;
void update(int x,int k)
{
	while(x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);//子节点+k，父节点都要+k 
	}
}
int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);//求的是1---x的区间和 
	}
	return res;
}
signed main()
{
	int q;
	cin>>n>>q;
	for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		update(i,a[i]);
	}
	for (int i=0;i<q;++i)
	{
		int a,b,c;
		cin>>a>>b>>c;
		if (a==1)
		{
			update(b,c);
		}
		else if (a==2)
		{
			int ans=0;
			ans=sum(c)-sum(b-1);
			cout<<ans<<endl;
		}
	}
}

（区间修改+单点查询）需要用到差分数组的性质https://www.luogu.com.cn/problem/P3368

#include <bits/stdc++.h>
using namespace std;
#define int long long 
const int N=5e5+5;
#define lowbit(x) (x& (-x))
int tree[N],a[N],d[N];
int n,q;
void update(int x,int k)
{
	while (x<=n)
	{
		tree[x]+=k;
		x+=lowbit(x);
	}
}
int sum(int x)
{
	int res=0;
	while (x>0)
	{
		res+=tree[x];
		x-=lowbit(x);
	}
	return res;
}
signed main()
{
	cin>>n>>q;
	for (int i=1;i<=n;++i)
	{
		cin>>a[i];
		d[i]=a[i]-a[i-1];
		update(i,d[i]);//放的是差分数组的值，这样树状数组保存的就是差分数组的前缀和 
	}
	for (int i=0;i<q;++i)
	{
		int op;
		cin>>op;
		if (op==1)
		{
			int a,b,c;
			cin>>a>>b>>c;
			update(a,c);
			update(b+1,-c);
		}
		if (op==2)
		{
			int a;
			cin>>a;
			int res=sum(a);
			cout<<res<<endl;
		}
	}
	
}

运用线段树会麻烦很多

它需要向上更新函数push_up，向下更新函数push_down，建树函数build，更新函数update和查询函数query

同时树上的节点都是以结构体的形式出现，这样方便找到当前节点的区间

struct node{
	int sum;
	int l;
	int r;
	int add;
}tree[4*N];
int a[N];
inline void push_up(int p){
	tree[p].sum=tree[lc].sum+tree[rc].sum;
}
inline void push_down(int p){
	if (tree[p].add){
		tree[lc].sum+=tree[p].add*(tree[lc].r-tree[lc].l+1);
		tree[lc].add+=tree[p].add;
		tree[rc].sum+=tree[p].add*(tree[rc].r-tree[rc].l+1);
		tree[rc].add+=tree[p].add;
		tree[p].add=0;
	}
	return ;
}
inline void build(int p,int l,int r){
	tree[p]={a[l],l,r,0};
	if (l==r) return ;
	int mid=tree[p].l+tree[p].r>>1;
	build(lc,l,mid);
	build(rc,mid+1,r);
	push_up(p);
}
inline void update(int p,int l,int r,int k){
	if (tree[p].l>=l && tree[p].r<=r){
		tree[p].sum+=k*(tree[p].r-tree[p].l+1);
		tree[p].add+=k;
		return ;
	}
	push_down(p);
	int mid=tree[p].r+tree[p].l>>1;
	if (mid>=l) update(lc,l,r,k);
	if (mid<r)	update(rc,l,r,k);
	push_up(p);
}
inline int query(int p,int l,int r){
	if (tree[p].l>=l && tree[p].r<=r){
		return tree[p].sum;
	}
	push_down(p);
	int mid=tree[p].l+tree[p].r>>1;
	int s=0;
	if (mid>=l)	s+=query(lc,l,r);
	if (mid<r)	s+=query(rc,l,r);
	return s; 
}

但是打好框架之后解决问题就很简单。只需要改改数值就好了

单点修改+区间查询：https://www.luogu.com.cn/problem/P3374

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

#define int long long
#define lc p<<1
#define rc p<<1|1

const int N=1e6+10;
struct node{
	int sum;
	int l;
	int r;
	int add;
}tree[4*N];
int a[N];
inline void push_up(int p){
	tree[p].sum=tree[lc].sum+tree[rc].sum;
}
inline void push_down(int p){
	if (tree[p].add){
		tree[lc].sum+=tree[p].add*(tree[lc].r-tree[lc].l+1);
		tree[lc].add+=tree[p].add;
		tree[rc].sum+=tree[p].add*(tree[rc].r-tree[rc].l+1);
		tree[rc].add+=tree[p].add;
		tree[p].add=0;
	}
	return ;
}
inline void build(int p,int l,int r){
	tree[p]={a[l],l,r,0};
	if (l==r) return ;
	int mid=tree[p].l+tree[p].r>>1;
	build(lc,l,mid);
	build(rc,mid+1,r);
	push_up(p);
}
inline void update(int p,int l,int r,int k){
	if (tree[p].l>=l && tree[p].r<=r){
		tree[p].sum+=k*(tree[p].r-tree[p].l+1);
		tree[p].add+=k;
		return ;
	}
	push_down(p);
	int mid=tree[p].r+tree[p].l>>1;
	if (mid>=l) update(lc,l,r,k);
	if (mid<r)	update(rc,l,r,k);
	push_up(p);
}
inline int query(int p,int l,int r){
	if (tree[p].l>=l && tree[p].r<=r){
		return tree[p].sum;
	}
	push_down(p);
	int mid=tree[p].l+tree[p].r>>1;
	int s=0;
	if (mid>=l)	s+=query(lc,l,r);
	if (mid<r)	s+=query(rc,l,r);
	return s; 
}
signed main(){
	int n,m;
	cin>>n>>m;
	for (int i=1;i<=n;++i)	cin>>a[i];
	build(1,1,n);
	for (int i=0;i<m;++i){
		int op;
		cin>>op;
		if (op==1){
			int a,b;
			cin>>a>>b;
			update(1,a,a,b);
		}else if (op==2){
			int a,b;
			cin>>a>>b;
			int sum1=query(1,a,b);
			cout<<sum1<<endl;
		}
	}
}

区间修改+单点查询：https://www.luogu.com.cn/problem/P3368

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

#define int long long
#define lc p<<1
#define rc p<<1|1

const int N=1e6+10;
struct node{
	int sum;
	int l;
	int r;
	int add;
}tree[4*N];
int a[N];
inline void push_up(int p){
	tree[p].sum=tree[lc].sum+tree[rc].sum;
}
inline void push_down(int p){
	if (tree[p].add){
		tree[lc].sum+=tree[p].add*(tree[lc].r-tree[lc].l+1);
		tree[lc].add+=tree[p].add;
		tree[rc].sum+=tree[p].add*(tree[rc].r-tree[rc].l+1);
		tree[rc].add+=tree[p].add;
		tree[p].add=0;
	}
	return ;
}
inline void build(int p,int l,int r){
	tree[p]={a[l],l,r,0};
	if (l==r) return ;
	int mid=tree[p].l+tree[p].r>>1;
	build(lc,l,mid);
	build(rc,mid+1,r);
	push_up(p);
}
inline void update(int p,int l,int r,int k){
	if (tree[p].l>=l && tree[p].r<=r){
		tree[p].sum+=k*(tree[p].r-tree[p].l+1);
		tree[p].add+=k;
		return ;
	}
	push_down(p);
	int mid=tree[p].r+tree[p].l>>1;
	if (mid>=l) update(lc,l,r,k);
	if (mid<r)	update(rc,l,r,k);
	push_up(p);
}
inline int query(int p,int l,int r){
	if (tree[p].l>=l && tree[p].r<=r){
		return tree[p].sum;
	}
	push_down(p);
	int mid=tree[p].l+tree[p].r>>1;
	int s=0;
	if (mid>=l)	s+=query(lc,l,r);
	if (mid<r)	s+=query(rc,l,r);
	return s; 
}
signed main(){
	int n,m;
	cin>>n>>m;
	for (int i=1;i<=n;++i)	cin>>a[i];
	build(1,1,n);
	for (int i=0;i<m;++i){
		int op;
		cin>>op;
		if (op==1){
			int a,b,c;
			cin>>a>>b>>c;
			update(1,a,b,c);
		}else if (op==2){
			int a;
			cin>>a;
			int sum1=query(1,a,a);
			cout<<sum1<<endl;
		}
	}
}

区间修改，区间查询https://www.luogu.com.cn/problem/P3372

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

#define int long long
#define lc p<<1
#define rc p<<1|1

const int N=1e6+10;
struct node{
	int sum;
	int l;
	int r;
	int add;
}tree[4*N];
int a[N];
inline void push_up(int p){
	tree[p].sum=tree[lc].sum+tree[rc].sum;
}
inline void push_down(int p){
	if (tree[p].add){
		tree[lc].sum+=tree[p].add*(tree[lc].r-tree[lc].l+1);
		tree[lc].add+=tree[p].add;
		tree[rc].sum+=tree[p].add*(tree[rc].r-tree[rc].l+1);
		tree[rc].add+=tree[p].add;
		tree[p].add=0;
	}
	return ;
}
inline void build(int p,int l,int r){
	tree[p]={a[l],l,r,0};
	if (l==r) return ;
	int mid=tree[p].l+tree[p].r>>1;
	build(lc,l,mid);
	build(rc,mid+1,r);
	push_up(p);
}
inline void update(int p,int l,int r,int k){
	if (tree[p].l>=l && tree[p].r<=r){
		tree[p].sum+=k*(tree[p].r-tree[p].l+1);
		tree[p].add+=k;
		return ;
	}
	push_down(p);
	int mid=tree[p].r+tree[p].l>>1;
	if (mid>=l) update(lc,l,r,k);
	if (mid<r)	update(rc,l,r,k);
	push_up(p);
}
inline int query(int p,int l,int r){
	if (tree[p].l>=l && tree[p].r<=r){
		return tree[p].sum;
	}
	push_down(p);
	int mid=tree[p].l+tree[p].r>>1;
	int s=0;
	if (mid>=l)	s+=query(lc,l,r);
	if (mid<r)	s+=query(rc,l,r);
	return s; 
}
signed main(){
	int n,m;
	cin>>n>>m;
	for (int i=1;i<=n;++i)	cin>>a[i];
	build(1,1,n);
	for (int i=0;i<m;++i){
		int op;
		cin>>op;
		if (op==1){
			int a,b,c;
			cin>>a>>b>>c;
			update(1,a,b,c);
		}else if (op==2){
			int a,b;
			cin>>a>>b;
			int sum1=query(1,a,b);
			cout<<sum1<<endl;
		}
	}
}

Bad Hair Day Shttps://www.luogu.com.cn/problem/P2866

题目描述

农夫约翰有 �N 头奶牛正在过乱头发节。

每一头牛都站在同一排面朝右，它们被从左到右依次编号为 1,2,⋯ ,�1,2,⋯,N。编号为 �i 的牛身高为 ℎ�hi​。第 �N 头牛在最前面，而第 11 头牛在最后面。

对于第 �i 头牛前面的第 �j 头牛，如果 ℎ�>ℎ�+1,ℎ�>ℎ�+2,⋯ ,ℎ�>ℎ�hi​>hi+1​,hi​>hi+2​,⋯,hi​>hj​，那么认为第 �i 头牛可以看到第 �+1i+1 到第 �j 头牛。

定义 ��Ci​ 为第 �i 头牛所能看到的牛的数量。请帮助农夫约翰求出 �1+�2+⋯+��C1​+C2​+⋯+CN​。

输入格式

输入共 �+1N+1 行。

第一行为一个整数 �N，代表牛的个数。
接下来 �N 行，每行一个整数 ��ai​，分别代表第 1,2,⋯ ,�1,2,⋯,N 头牛的身高。

输出格式

输出共一行一个整数，代表 �1+�2+⋯+��C1​+C2​+⋯+CN​。

输入输出样例

输入 #1复制

6
10
3
7
4
12
2

输出 #1复制

5

说明/提示

数据规模与约定

对于 100%100% 的数据，保证 1≤�≤8×1041≤N≤8×104，1≤ℎ�≤1091≤hi​≤109。

思路：单调栈，单调减的栈，栈空时入栈，遇到比栈顶大的元素时出栈直到栈空或者栈顶栈顶元素更大，10入栈前，栈内没有元素，所以计数器+0，入栈，3比10小，入栈前计数器+1（栈的长度）由于7的长度大于3，所以3出栈，计数器+1,7入栈，4比7小，计数器+2，4入栈......

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long 
const int N=8e4+5;
int h[N];
stack<int>st;
signed main(){
	int n;
	cin>>n;
	int sum=0;
	for (int i=1;i<=n;++i)cin>>h[i];
	for (int i=1;i<=n;++i){
		while (!st.empty() && h[st.top()]<=h[i]){
			st.pop();
		}
		sum+=st.size();
		st.push(i);
	}
	cout<<sum;
}

01迷宫

 

题目描述

有一个仅由数字 00 与 11 组成的 �×�n×n 格迷宫。若你位于一格 00 上，那么你可以移动到相邻 44 格中的某一格 11 上，同样若你位于一格 11 上，那么你可以移动到相邻 44 格中的某一格 00 上。

你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。

输入格式

第一行为两个正整数 �,�n,m。

下面 �n 行，每行 �n 个字符，字符只可能是 00 或者 11，字符之间没有空格。

接下来 �m 行，每行两个用空格分隔的正整数 �,�i,j，对应了迷宫中第 �i 行第 �j 列的一个格子，询问从这一格开始能移动到多少格。

输出格式

�m 行，对于每个询问输出相应答案。

输入输出样例

输入 #1复制

2 2
01
10
1 1
2 2

输出 #1复制

4
4

说明/提示

对于样例，所有格子互相可达。

  • 对于 20%20% 的数据，�≤10n≤10；
  • 对于 40%40% 的数据，�≤50n≤50；
  • 对于 50%50% 的数据，�≤5m≤5；
  • 对于 60%60% 的数据，�,�≤100n,m≤100；
  • 对于 100%100% 的数据，1≤�≤10001≤n≤1000，1≤�≤1000001≤m≤100000。

思路：连通块问题，用搜索和并查集都可以

用 BFS的时候记得判重，不然会TLE

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long 
#define check(tx,ty) (tx>=1 && ty >=1 && tx<=n && ty<= n)	
const int N=1005;
int vis[N][N],a[N][N];
struct node{
	int x;
	int y;
}q[1000001];
int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int step[N][N];
signed main(){
	int n,m;
	cin>>n>>m;
	for (int i=1;i<=n;++i){
		for (int j=1;j<=n;++j){
			scanf("%1d",&a[i][j]);
		}
	}
	for (int i=0;i<m;++i){
		int sx,sy,tail=0,head=0;
		int cnt=1;
		cin>>sx>>sy;
		if (step[sx][sy]!=0){
			cout<<step[sx][sy]<<endl;
			continue;
		}
		q[tail].x=sx,q[tail].y=sy;
		step[sx][sy]=1;
		tail++;
		while (head<tail){
			int x=q[head].x,y=q[head].y;
			for (int i=0;i<4;++i){
				int tx=x+dir[i][0],ty=y+dir[i][1];
				if (check(tx,ty) && step[tx][ty]==0 && a[tx][ty]!=a[x][y]){
					q[tail].x=tx,q[tail].y=ty;
					step[tx][ty]=1;
					tail++;
					cnt++;
				}
			}
			head++;
		}
		for (int i=0;i<tail;++i){
			step[q[i].x][q[i].y]=cnt;
		}
		printf("%d\n",cnt);
	}
}

下面是并查集做法

遍历所有的点，如果两个点连通但未合并，那就合并

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long 
#define check(tx,ty) (tx>=1 && ty >=1 && tx<=n && ty<= n)	
const int N=1005;
int f[N*N];
int cnt[N*N];
int aa[N][N];
int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int find(int x){
	if (f[x]==x)return x;
	else{
		f[x]=find(f[x]);
		return f[x];
	}
}
void unionn(int i,int j){
	f[find(i)]=find(j);
}
signed main(){
	int m,n;
	cin>>n>>m;
	//初始化并查集
	for (int i=1;i<=n*n;++i){
		f[i]=i;
		cnt[i]=1;
	}
	for (int i=1;i<=n;++i){
		for (int j=1;j<=n;++j){
			scanf("%1d",&aa[i][j]);
		}
	}
	for (int i=1;i<=n;++i){
		for (int j=1;j<=n;++j){
			for (int k=0;k<4;++k){
				int a=i+dir[k][0],b=j+dir[k][1];
				if (a>=1 && a<=n && b>=1 && b<=n){
					if (aa[i][j]!=aa[a][b]){
						int x=find((i-1)*n+j);
						int y=find((a-1)*n+b);
						if (x!=y){
							unionn(x,y);
							cnt[y]+=cnt[x];	
						}
					}
				}
			}
		}
	}
	while (m--){
		int sx,sy;
		cin>>sx>>sy;
		cout<<cnt[find((sx-1)*n+sy)]<<endl;
	}
}

健康的荷斯坦奶牛 Healthy Holsteinshttps://www.luogu.com.cn/problem/P1460

题目描述

农民 John 以拥有世界上最健康的奶牛为傲。他知道每种饲料中所包含的牛所需的最低的维他命量是多少。请你帮助农夫喂养他的牛，以保持它们的健康，使喂给牛的饲料的种数最少。

给出牛所需的最低的维他命量，输出喂给牛需要哪些种类的饲料，且所需的饲料剂量最少。

维他命量以整数表示，每种饲料最多只能对牛使用一次，数据保证存在解。

输入格式

第一行一个整数 �v，表示需要的维他命的种类数。
第二行 �v 个整数，表示牛每天需要的每种维他命的最小量。

第三行一个整数 �g，表示可用来喂牛的饲料的种数。
下面 �g 行，第 �n 行表示编号为 �n 饲料包含的各种维他命的量的多少。

输出格式

输出文件只有一行，包括牛必需的最小的饲料种数 �p；后面有 �p 个数，表示所选择的饲料编号（按从小到大排列）。

如果有多个解，输出饲料序号最小的（即字典序最小）。

输入输出样例

输入 #1复制

4
100 200 300 400
3
50  50  50  50
200 300 200 300
900 150 389 399

输出 #1复制

2 1 3

说明/提示

【数据范围】
对于 100%100% 的数据，1≤�≤251≤v≤25，1≤�≤151≤g≤15。
输入的所有整数在 [1,1000][1,1000] 范围内。

思路：DFS排列问题

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long 
const int N=1000;
int v[N],g[N][N],ans[N],c[N];
int m,n,minx=100000000;
bool check(int x){
	for (int i=1;i<=n;++i){
		int sum=0;
		for (int j=1;j<=x;++j){
			sum+=g[c[j]][i];
		}
		if (sum<v[i])return false;
	}
	return true;
}
void dfs(int t , int s){
	if (s>minx) return ;
	if (t>m){	
		if (check(s)){
			if (s<minx){
				minx=s;
				for (int i=1;i<=minx;++i){
					ans[i]=c[i];
				}
   			}
		}
		return ;
	}
	c[s+1]=t;
	dfs(t+1,s+1);
	c[s+1]=0;
	dfs(t+1,s);
}
signed main(){
	cin>>n;
	for (int i=1;i<=n;++i)	cin>>v[i];
	cin>>m;
	for (int i=1;i<=m;++i){
		for (int j=1;j<=n;++j){
			cin>>g[i][j];
		}
	}
	dfs(1,0);
	cout<<minx<<" ";
	for (int i=1;i<=minx;++i){
		cout<<ans[i]<<" ";
	}
}

啊这泪目了
关注
  • 14
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
品优购_day05_服务器FastDFS_V1.31
08-08
总结来说，这个课程涵盖了电商系统中商品分类的实现、关键概念的理解以及前端和后端技术的运用，旨在构建一个功能完善的商品录入系统。通过学习这些内容，开发者可以提升自己在电商领域的专业技能。
品优购_day04_Spring Security_V1.31
08-08
总结来说，Spring Security 是一款强大且灵活的安全框架，能够帮助开发者快速实现复杂的安全控制逻辑，同时提供了丰富的扩展性和定制性，适应各种企业级应用场景。在品优购电商系统的开发中，通过学习和运用 Spring ...
1.31学习总结6
2302_80892730的博客
01-31 1006
M 海运公司最近要对旗下仓库的货物进出情况进行统计。目前他们所拥有的唯一记录就是一个记录集装箱进出情况的日志。该日志记录了两类操作：第一类操作为集装箱入库操作，以及该次入库的集装箱重量；第二类操作为集装箱的出库操作。这些记录都严格按时间顺序排列。集装箱入库和出库的规则为先进后出，即每次出库操作出库的集装箱为当前在仓库里所有集装箱中最晚入库的集装箱。出于分析目的，分析人员在日志中随机插入了若干第三类操作――查询操作。分析日志时，每遇到一次查询操作，都要报告出当前仓库中最大集装箱的重量。输入格式。
1.31学习总结（3.30再次复习）
weixin_74789176的博客
01-31 91
再次复习一下最短路径，最新复习时间2023.3.30
1.31训练总结
qq_40859951的博客
01-31 128
对于有的题别人能A自己A不了的，第一点：自己对于题目的一些细节没有把握好，例如有的一些题目需要一些特判，自己没有考虑到。第二：有的一些洗的知识点自己不知道，通过几次牛客网的比赛可以看出，有的就是一些结论比如数论上的一些结论自己不知道。第三：自己对于所学的一些知识点自己不能灵活地运用，有时候看了题解自己才知道考的是哪一方面的知识。第四：题目有时涉及到多个知识点，只知道用到了一部分知识点，这就导致要么...
学习总结——1.31
2301_81263955的博客
01-31 394
二叉树
智慧校园-排课系统解决方案-V1.31-20210511.pdf
11-04
本方案——"智慧校园-排课系统解决方案-V1.31-20210511"，充分利用了物联网和云计算等先进技术，旨在打造一个高效、智能的校园环境。 物联网技术在智慧校园中的应用主要体现在对校园环境的全面感知和实时监控。通过...
hnust 2022年光纤通信考点总结.docx
07-05
湖南科技大学的数据通信技术课程中，光纤通信是重要的学习内容。本篇总结涵盖了光纤通信的基本概念、光纤的结构与分类、优缺点、传输特性以及相关器件的介绍。 1. 光纤通信系统由光发射机、光纤和光接收机组成。光...
PAT考试中的一些习题，大概做了100道甲级，需要自取
06-03
3. `2.13`、`3.02`、`1.17`、`2.4`、`2.25`、`1.06`、`1.31`：这些可能是PAT甲级试题的编号。每个数字可能代表一道具体的题目，例如“2.13”可能表示第二部分第13题。文件可能是文本文件，里面记录了题目描述、数据...
爬虫学习日记
wuhu_czy的博客
07-12 239
爬虫python code
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 651
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 530
ROS运行管理。
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 285
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
【安卓学习】文本切换器
m0_73241073的博客
07-08 622
文本切换器的使用
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 451
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 287
Qt/QML学习-动画元素
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
最新发布
2301_80220607的博客
07-12 987
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
NPDP含金量高吗？什么人适合学习NPDP？
PMP项目管理的博客
07-09 905
开始报名后先提交报名资料，通过审核后缴纳考试费用，即算报名成功；如果报名成功后被抽中审核了的话，则须提交相关资料进行资格审查，通过审查即可参加考试，未通过审核则会将考试费用退还给您；
SRA2021-G03-项目开发计划1.31
08-08
背景在产品研发的过程中，我们发现其实身边的每个人、每个团队、每个组织都有很多知识。随着人与人之间的交流越来越频繁，大部分的经验和知识却只能停留在少数人的脑海中，

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值