并查集总结

并查集简介

并查集是一种可以动态维护若干个不重叠的结合，并支持合并与查询的数据结构
并查集是一种树状的数据结构，可以用于维护传递关系以及联通性。
并查集有两种操作：

  1. find：查询一个元素属于哪个集合
  2. merge:合并两个集合

模板

  1. find函数
int find(int x)
{
	if(x == fa[x])	return x;
	reutnr fa[x] = find(fa[x]);
}
  1. merge函数
void merge(int x, int y)
{
	int px = find(x), py = find(y);
	if(px != py)	fa[px] = py;
}

模板题

村村通
对于这道题我们只需要求连通块的数量，然后将这几个联通快看成点，联通n个点需要n-1条边

#include <iostream>
#include <cstring>

using namespace std;
const int N = 1010;
int p[N], st[N];

int find(int x)
{
    if(x == p[x])   return x;
    return p[x] = find(p[x]);
}

int main()
{
    // freopen("1.in", "r", stdin);
    while(1)
    {
        memset(st, 0, sizeof st);
        int n, ans = 0;
        scanf("%d", &n);
        if(n == 0)  return 0;
        else
        {
            int m;  scanf("%d", &m);
            for(int i = 1; i <= n; ++ i)    p[i] = i;
            for(int i = 0; i < m; ++ i)
            {
                int x, y;   scanf("%d%d", &x, &y);
                int a = find(x);
                int b = find(y);
                if(a != b)  p[a] = b;
            }
	//统计联通块的数量
            for(int i = 1; i <= n; ++ i)
            {
                int x = find(i);
                if(!st[x])  ans ++, st[x] = 1;;
            }
            cout << ans - 1 << endl;
        }
    }
}

P1551 亲戚
亲戚的亲戚是亲戚，亲戚这种关系具有传递性，如果具有亲戚关系就将合并。

#include <iostream>

using namespace std;

const int N = 5010;

int p[N];
int n, m, t;

int find(int x)
{
    if(x != p[x])   p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m >> t;
    for(int i = 1; i <= n; ++ i)    p[i] = i;
    for(int i = 0; i < m; ++ i)
    {
        int a, b;cin >> a >> b;
        int fa = find(a);
        int fb = find(b);
        p[fa] = fb;
    }
    for(int i = 0; i < t; ++ i)
    {
        int a, b;cin >> a>> b;
        int fa = find(a);
        int fb = find(b);
        if(fa != fb)    puts("No");
        else    puts("Yes");
    }
    return 0;
}

836. 合并集合

#include <iostream>

using namespace std;

const int N = 1e5+10;

int n,m;
int p[N];

int find(int x)
{
    if(p[x] != x )  p[x] = find(p[x]);
    return p[x];
}

int main(int argc, const char * argv[]) {

    scanf("%d%d",&n,&m);
    for(int i = 0; i < n; i ++) p[i] = i;

    while(m--)
    {
        char op[2];int a,b;
        scanf("%s%d%d",op,&a,&b);

        if(op[0] == 'M')    p[find(a)] = find(b);
        else
        {
            if(find(a) == find(b))  cout<<"Yes"<<endl;
            else puts("No");
        }
    }
    return 0;
}

837. 连通块中点的数量
这道题目比前面的几道模板题目需要多维护一个信息，在进行merge时我们需要将更新作为被添加枝的树的cnt
两个bug调了一个小时最后看了下评论区收获颇丰
1、合并两个集合时
如果没有按照下面的写法即省去这一步a=find(a),b=find(b);
则合并根节点的顺序与更新更新集合得顺寻不能互换，
必须要先把原来根节点中元素的数量加到所要合并的
根节点上去再把根节点合并
a=find(a),b=find(b);
cnt[b]+=cnt[a];
p[a]=b;
2、路径压缩
一定不要忘记路径压缩不然会超时！！！

#include"bits/stdc++.h"
using namespace std;
const int N=1e5+10;
int p[N],cnt[N];
int n,m;
int find(int x)
{
     if(p[x] != x)  p[x] = find(p[x]);
     return p[x];
}
int main()
{
    cin.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++)   {p[i]=i;cnt[i]=1;}
    while(m--)
    {
        string str;
        int a,b;
        cin>>str;
        if(str=="C")
        {
            cin>>a>>b;
            if(find(a)!=find(b))   
            {
                a=find(a),b=find(b);
                cnt[b]+=cnt[a];
                p[a]=b;
                
            }
        }
        else if(str=="Q1")
        {
            cin>>a>>b;
            if(find(a)==find(b))    cout<<"Yes"<<endl;
            else                    cout<<"No"<<endl;
        }
        else
        {
            cin>>a;
            cout<<cnt[find(a)]<<endl;
        }
    }
    return 0;
}

边带权并查集

推导部分和
这道题的是带边权并查集的应用，比较难想到的是建图
对于每个区间l, r，k, 我们可以由前缀和s[r] - s[l - 1] = k，我们从r连一条l-1的边
WechatIMG819.png

#include <iostream>

using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
//p[N]数组用来做并查集
int p[N], n, m, q;
//s[N]数组是当前点到根结点的权值和，也是前缀和
LL s[N];

//并查集的查询操作（带路径压缩）
int find(int x)
{
    if(x == p[x])   return x;
    else
    {
        int t = find(p[x]);
        s[x] += s[p[x]];
        p[x] = t;
        return t;
    }
}


int main()
{
    // freopen("1.in", "r", stdin);
    cin >> n >> m >> q;
    for(int i = 1; i <= n; ++ i)    p[i] = i;
    for(int i = 0; i < m; ++ i)
    {
        int l ,r;
        LL k; 
        cin >> l >> r >> k;
        int t1 = find(l - 1), t2 = find(r);
        if(t1 != t2)
        {
            p[t2] = t1;
            s[t2] = s[l - 1] - s[r] + k;
        }
    }
    while(q --)
    {
        int l, r;cin >> l >> r;
        int t1 = find(l - 1), t2 = find(r);
        if(t1 != t2)    puts("UNKNOWN");
        else printf("%lld\n", s[r] - s[l - 1]);
        
    }
    return 0;
}

P1196 [NOI2002] 银河英雄传说
这道题目比较特殊是每个集合是一条链，一条链也是一棵树，不过是树的特殊形态，我们可以把每一列看作一个集合，用并查集去维护，另外题目中需要知道两个点之间的点有多少个，这里我们就还需要额外维护每个点到根节点路径上的权值，因为我们这里的并查集已经进行优化即使用了路径压缩，并且边权都是1，所以在维护每个点到根节点的路径上的权值时，我们还需要用到一个集合中元素的个数，也就是还需要额外维护集合中元素个数。
综上我们需要额外维护两个信息：

  1. d[x]:表示x到根节点的边权求和
  2. size[x]:表示以x为根的子树中节点数量
#include <bits/stdc++.h> 
#define ls p<<1
#define rs p<<1|1
#define PII pair<int, int>
#define ll long long
#define ull unsigned long long
#define endl '\n'
#define db double
using namespace std;

const int N = 30010;
int fa[N], d[N], size[N],t;

void init()
{
	for(int i = 1; i <= N - 1; ++ i)	fa[i] = i, size[i] = 1;
}

int find(int x)
{
	if(x == fa[x])	return x;
	int root = find(fa[x]);
	d[x] += d[fa[x]];
	return fa[x] = root;
}

void merge(int x, int y)
{
	int px = find(x), py = find(y);
	if(px == py)	return;
	fa[px] = py;
	d[px] = size[py];
	size[py] += size[px];
}

void solve()
{
	cin >> t;
	init();
	for(int i = 1; i <= t; ++ i)
	{
		char op;
		int x, y;
		cin >> op >> x >> y;
		if(op == 'M')	merge(x, y);
		else
		{
			int px = find(x), py = find(y);
			if(px != py)	cout << -1 << endl;
			else	cout << abs(d[x] - d[y]) - 1 << endl;		
		} 
	}
}

int main()
{
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
//	freopen("1.in", "r", stdin);
//	cin >> t;
//	while(t --)	
	solve(); 
	return 0;
}

并查集的拓展域

P2024 [NOI2001] 食物链
这是一道并查集的拓展域的题目也可以用带权并查集去做
普通并查集维护的是不相交集合，是一种传递性的关系如亲戚的亲戚是亲戚
天敌的天敌是食物，是一种环形的关系
我们如果用拓展域来解决这道题目的话可以用3个并查集来维护3种关系，第一种是同类关系，第二种是食物关系，第三种是天敌
我们不用真开三个并查集，我们可以将三个并查集开到一个数组里，下标的范围代表不同的集合
WechatIMG824.jpeg

#include <iostream>

using namespace std;
const int N = 5e4 + 10;
int p[N * 3], ans, k, n;

//1--n代表x的同类，n + 1 -- 2n代表x的食物， 2n + 1 -- 3n代表x的天敌
int find(int x)
{
    if(x == p[x])   return x;
    return p[x] = find(p[x]);
}
void merge(int x, int y)
{
    int px = find(x), py = find(y);
    p[py] = px;
}
int main()
{
    cin >> n >> k;
    for(int i = 1; i <= 3 * n; ++ i)    p[i] = i;
    for(int i = 0; i < k; ++ i)
    {
        int d, x, y;scanf("%d%d%d", &d, &x, &y);
        if(x > n || y > n)  ans ++;
        //x、y是同类
        else if(d == 1)
        {
            //如果根据前面的信息，我们可以知道y在x的食物域，
            //或者y在x的天敌域中，说明这句话是假话
            if(find(x + n) == find(y) || find(x + n + n) == find(y))    ans ++;
            //如果根据前面的信息，不能判断这句话是错误的，那么就讲这句话
            //当成对的并且更新x的三个域
            else
            {
                //y在x的同类域中
                merge(x, y);
                //y的食物和x的食物是同类
                merge(x + n, y + n);
                //y的天敌和x的天敌是同类
                merge(x + n + n, y + n + n);
            }
        }
        //如果x吃y
        else
        {
            //若果y在x的同类域或者，y在x的天敌域说明这句话是假话
            if(find(x) == find(y) || find(x + n + n) == find(y))    ans ++;
            //这句话是真话就更新x的三个域
            else
            {
                //y在x的食物域中
                merge(x + n, y);
                //y的食物是x的天敌
                merge(x + n + n, y + n);
                //y的天敌是x的同类
                merge(x, y + n + n);
            }
        }
    }
    cout << ans << endl;
    return 0;
}

例题团伙

#include <iostream>
using namespace std;
const int N = 2010;
int p[N];
bool st[N];
int find(int x)
{
    if(p[x] == x)   return p[x];
    return p[x] = find(p[x]);
}
void merge(int x, int y)
{
    int px = find(x), py = find(y);
    if(px != py)    p[px] = py;
}

int main()
{
    // freopen("1.in", "r", stdin);
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= 2 * n; ++ i)    p[i] = i;
    for(int i = 0; i < m; ++ i)
    {
        char op; int x, y;
        cin >> op >> x >> y;
        if(op == 'F')
        {
            merge(x, y);
            // merge(x + n, y + n);
        }
        else
        {
            merge(x + n, y);
            merge(x, y + n);
        }
    }
    // for(int i = 1; i <= n; ++ i)    cout << i << ' ' << find(i) << endl;    
    int cnt = 0;
    for(int i = 1; i <= n; ++ i)
        if(!st[find(i)])
        {
            cnt ++;
            st[find(i)] = 1;
        }
    cout << cnt << endl;
    return 0;
}

P5937 [CEOI1999] Parity Game

题目的具体思路如下：考虑一段连续区间的1个数的奇偶，可以转化为考虑考虑两个端点前缀和的奇偶性上，分为两种情况，如果[l, r]区间内1的个数为偶数，说明sum[r]和sum[l - 1]包含1的个数的奇偶性相同，反之若为奇数则两个包含1的个数的奇偶性相反，我们知道奇偶性具有传递性，这样我们就可以种类并查集来维护，注意n的范围比较大，但是实际的需要用到的点的个数是比较小的，这里我们需要离散化一下。

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

const int N = 1e4 + 10;
int p[N * 2 + 10], n, m, k;
map<int, int>mp;
int b[N * 2];

struct wy
{
	int l, r, op;	
}q[N];

int find(int x)
{
	if(x != p[x])	p[x] = find(p[x]);
	return p[x];
}

void merge(int x, int y)
{
	int px = find(x), py = find(y);
	p[py] = px;
}

int query(int x)
{
	return lower_bound(b + 1, b + 1 + k, x) - b;
}
void solve()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= m; ++ i)
	{
		int l, r, op;
		char s[5];
		scanf("%d%d%s", &l, &r, s);
		if(s[0] == 'e')	op = 1;
		else op	= 2;
		q[i] = {--l, r, op};
		b[++ k] = l;
		b[++ k] = r;
	} 
	sort(b + 1, b + 1 + k);
	k = unique(b + 1, b + 1 + k) - (b + 1);

	for(int i = 1; i <= 2 * k; ++ i) p[i] = i;
	for(int i = 1; i <= m; ++ i)
	{
		int l = query(q[i].l), r =  query(q[i].r), op = q[i].op;
		if(op == 1) 
		{
			
			if(find(l) == find(r + k) || find(r) == find(l + k))
			{
				printf("%d", i - 1);
				return;
			}
			else
			{
				merge(l, r);
				merge(l + k, r + k);
			}
		
		}
		else
		{
			if(find(l) == find(r) || find(r + k) == find(l + k))
			{
				printf("%d", i - 1);
				return;
			}
			else
			{
				merge(l, r + k);
				merge(r, l + k); 	
			}
		}	
	}
	printf("%d", m);
}
int main()
{
//	freopen("1.in", "r", stdin);
	solve(); 
	return 0;
}

应用

P1955 [NOI2015] 程序自动分析

这道题目是相等关系，相等关系也具有传递性，明显我们可以用并查集来维护。
我们可以先对处理相等，然后去查询不相等的是否在一个集合里面如果在一个集合里面则说明这样的点是不存在的。这道题目的数据的范围很大，但实际用到的很少，我们需要对数据进行离散化。

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

const int N = 1e6 + 10;
int n, m, p[N], a[N], k, tot;
struct wy{
	int x, y, e;
}q[N];

int find(int x)
{
	if(x != p[x])	p[x] = find(p[x]);
	return p[x];
} 

void merge(int x, int y)
{
	int px = find(x), py = find(y);
	p[py] = px;
}

void solve()
{
	scanf("%d", &n);
	for(int i = 1; i <= n; ++ i){
		int x, y, e;
		scanf("%d%d%d", &x, &y, &e);
		a[++ tot] = q[i].x = x;
		a[++ tot] = q[i].y = y;
		q[i].e = e;	
	}
	sort(a + 1, a + 1 + tot);
	tot = unique(a + 1, a + 1 + tot) - a - 1;
	for(int i = 1; i <= tot; ++ i)	p[i] = i;
	for(int i = 1; i <= n; ++ i)
	{
		q[i].x = lower_bound(a + 1, a + tot + 1, q[i].x) - a - 1;
		q[i].y = lower_bound(a + 1, a + tot + 1, q[i].y) - a - 1;
		if(q[i].e == 1){
			merge(q[i].x, q[i].y);
		}
	}

	for(int i = 1; i <= n; ++ i){
		int x = q[i].x;
		int y = q[i].y;
		if(q[i].e == 0 && find(x) == find(y)){
			puts("NO");
			return;
		}
	}
		puts("YES");
}

int main()
{
// 	freopen("1.in", "r", stdin);
	scanf("%d", &k);
	while(k--) solve(); 
	return 0;
}

P1525 [NOIP2010 提高组] 关押罪犯
贪心+并查集，我们优先选择边权最大的罪犯，首先查询他们是否已经在一个集合 如果不在，分别将他们放进不同监狱（集合），如果在则说明我们已经找到了答案

#include <bits/stdc++.h> 
#define ls p<<1
#define rs p<<1|1
#define PII pair<int, int>
#define ll long long
#define ull unsigned long long
#define endl '\n'
#define db double
using namespace std;

const int N = 1e6 + 10, e = 20010;

struct wy
{
	int x, y, val;
	bool operator < (const wy & t) const
	{
		return t.val < val;
	}
}a[N];

int p[N + 1];
int n, m;

void init()
{
	for(int i = 1; i <= N; ++ i)	p[i] = i;
}

int find(int x)
{
	if(x == p[x])	return x;
	return p[x] = find(p[x]);	
}

void merge(int x, int y)
{
	int px = find(x), py = find(y);
	if(px != py)	p[py] = px;
}

void solve()
{
	cin >> n >> m;
	for(int i = 1; i <= m; ++ i)
	{
		int x, y, val; cin >> x >> y >> val;
		a[i] = {x, y, val};
	}
	sort(a + 1, a + 1 + m);
	init();
	for(int i = 1; i <= m; ++ i)
	{
		int x = a[i].x, y = a[i].y, val = a[i].val;
		int px = find(x), py = find(y);
		if(px == py)	
		{
			cout << val << endl;
			return;
		}
		else
		{
			merge(y + n, x);
			merge(x + n, y);
		}
		
	}
	cout << 0 << endl;
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
//	freopen("1.in", "r", stdin);
//	cin >> t;
//	while(t --)	
	solve(); 
	return 0;
}

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

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

相关文章

前端入门（二）Vue2基本语法、样式渲染、数据代理与监测

前端入门（二）Vue2基本语法、样式渲染、数据代理与监测

文章目录 Vue简介Vue的特点Hello, Vue Vue基本语法模板语法数据绑定&#xff08;v-bind、v-model&#xff09;el与data的两种写法 事件处理&#xff08;v-on:click / click&#xff09;事件修饰符键盘事件&#xff08;缺&#xff09; 计算属性与监视&#xff08;computed、watc…
阅读更多...
利用叉积计算向量的旋向及折线段的拐向

利用叉积计算向量的旋向及折线段的拐向

一、向量叉积 两个向量 u u u、 v v v的叉积写作 u v n ∥ u ∥ ∥ v ∥ s i n θ \mathbf{u \times v n \left \| u \right \| \left \| v \right \| sin\theta } uvn∥u∥∥v∥sinθ 式中&#xff0c; n n n: 与 u u u、 v v v均垂直的单位向量&#xff0c;theta是两向量…
阅读更多...
Apache配置文件详解

Apache配置文件详解

引言： Apache是一种功能强大的Web服务器软件，通过配置文件可以对其行为进行高度定制。对于初学者来说，理解和正确配置Apache的配置文件是非常重要的。本文将详细解释Apache配置文件的各个方面，并给出一些入门指南，帮助读者快速上手。 1、主配置文件（httpd.conf）： 主…
阅读更多...
uni-app 使用uni.getLocation获取经纬度配合腾讯地图api获取当前地址

uni-app 使用uni.getLocation获取经纬度配合腾讯地图api获取当前地址

前言 最近在开发中需要根据经纬度获取当前位置信息&#xff0c;传递给后端&#xff0c;用来回显显示当前位置 查阅uni-app文档&#xff0c;发现uni.getLocation () 可以获取到经纬度&#xff0c;但是在小程序环境没有地址信息 思考怎么把经纬度换成地址&#xff0c;如果经纬度…
阅读更多...
10月起个税系统升级，3个月个税零申报将收到提示

10月起个税系统升级，3个月个税零申报将收到提示

近日&#xff0c;自然人电子税务局扣缴端升级了&#xff0c;升级后对于工资薪金收入连续三个月为零的纳税人&#xff0c;系统会自动出现以下提示。这个提示主要为了避免企业长期对已经离职的员工进行零申报&#xff0c;导致数据不准确和资源浪费。HR在申报个税时&#xff0c;一…
阅读更多...
18.天气小案例

18.天气小案例

1►新增带Layout组件的页面 直接在views文件夹下面新增weather.vue。然后随便写一个123&#xff0c;现在先让我们页面能跳过去先。 让页面能跳过去&#xff0c;有好几种方法&#xff1a; 1、在菜单管理自己添加一个菜单&#xff0c;然后把菜单分配给某个角色&#xff0c;再把…
阅读更多...
瑞吉外卖优化

瑞吉外卖优化

1.缓存问题 用户数量多&#xff0c;系统访问量大频繁访问数据库,系统性能下降,用户体验差 2.导入依赖 和配置 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependenc…
阅读更多...
线程安全

线程安全

文章目录 观察线程安全问题线程安全的概念出现线程安全问题的原因共享数据原子性总结 synchronized - 锁synchronized 特性互斥可重入 synchronized 的使用修饰普通方法修饰静态方法修饰代码块 解决线程安全问题两个线程两把锁哲学家就餐问题 - N个线程M把锁解决策略 死锁成因总…
阅读更多...
回归算法优化过程推导

回归算法优化过程推导

假设存在一个数据集&#xff0c;包含工资、年龄及贷款额度三个维度的数据。我们需要根据这个数据集进行建模&#xff0c;从而在给定工资和年龄的情况下&#xff0c;实现对贷款额度的预测。其中&#xff0c;工资和年龄是模型构建时的两个特征&#xff0c;额度是模型输出的目标值…
阅读更多...
【NLP】GPT 模型如何工作

【NLP】GPT 模型如何工作

介绍 2021 年&#xff0c;我使用 GPT 模型编写了最初的几行代码&#xff0c;那时我意识到文本生成已经达到了拐点。我要求 GPT-3 总结一份很长的文档&#xff0c;并尝试了几次提示。我可以看到结果比以前的模型先进得多&#xff0c;这让我对这项技术感到兴奋&#xff0c;并渴望…
阅读更多...
Linux 磁盘/分区/修复 命令

Linux 磁盘/分区/修复 命令

目录 1. lsblk&#xff08;list block devices&#xff09; 2. fdisk&#xff08;fragment disk&#xff09; 3. gdisk 4. mkfs&#xff08;make filesystem&#xff09; 5. df&#xff08;display file-system disk space usage&#xff09; 6. du 7. fsck&#xff08;file-sy…
阅读更多...
千帆Llama 2中文增强技术介绍--SFT，预训练，指令优化

千帆Llama 2中文增强技术介绍--SFT，预训练，指令优化

目录 千帆Llama 2中文增强技术介绍 SFT&#xff0c;预训练&#xff0c;指令优化 千帆Llama 2中文增强技术介绍 SFT&#xff0c;预训练&#xff0c;指令优化
阅读更多...
JavaScript中的继承

JavaScript中的继承

前言 继承 1.借用构造函数继承也叫经典继承 2.原型链继承 3.组合继承 1 2 1.经典继承 借用构造函数实现继承 // 创建父构造函数 function Animal(type,weight,age,length){this.type type;this.weight weight;this.age age;this.length length; }; Animal.prot…
阅读更多...
一个工具让你明白“万丈高楼平地起”，拒绝重复造轮子！

一个工具让你明白“万丈高楼平地起”，拒绝重复造轮子！

大家在公司工作当中是不是很多时间装环境很麻烦&#xff0c;一个项目要上线了&#xff0c;开始网上搜了一边又一遍的环境搭建教程&#xff1f;等到下一个项目要上线了&#xff0c;又上网上搜了一边又一遍的环境搭建教程。关键天花乱坠的互联网&#xff0c;找不到很靠谱的呀。有…
阅读更多...
Python数据分析30w人都在看

Python数据分析30w人都在看

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;公众号&#x1f448;&#xff1a;测试开发自动化【获取源码商业合作】 &#x1f449;荣__誉&#x1f448;&#xff1a;阿里云博客专家博主、5…
阅读更多...
深入了解Performance API：优化网页性能的利器

深入了解Performance API：优化网页性能的利器

在现代Web开发中&#xff0c;优化网页性能是至关重要的。用户对于加载速度和交互性能的要求越来越高&#xff0c;而Performance API作为一组用于测量和监控网页性能的JavaScript接口&#xff0c;为开发者提供了丰富的工具和信息。本文将深入探讨Performance API的各个方面&…
阅读更多...
2021年09月 Scratch（二级）真题解析#中国电子学会#全国青少年软件编程等级考试

2021年09月 Scratch（二级）真题解析#中国电子学会#全国青少年软件编程等级考试

Scratch等级考试（1~4级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 执行下图所示程序，舞台上的角色？ A：在1秒内滑行到随机位置 B：不断地重复滑行到随机位置 C：只有按下空格键的时候，才会滑行到随机位置 D：只有按下空格键以外键的时候，才会滑行…
阅读更多...
SpringMVC问题

SpringMVC问题

文章目录 SpringMVC运行流程MVC的概念与请求在MVC中的执行路径&#xff0c;ResponsBody注解的用途SpringMVC启动流程 SpringMVC运行流程 • 客户端&#xff08;浏览器&#xff09;发送请求&#xff0c;直接请求到 DispatcherServlet 。 • DispatcherServlet 根据请求信息调用 …
阅读更多...
vscode-insiders Remote-SSH XHR failed无法访问远程服务器

vscode-insiders Remote-SSH XHR failed无法访问远程服务器

问题概述&#xff1a; destFolder/home/apple/.vscode-server-insiders > destFolder2/vscode-cli-05cd2640ec8a106a4ee99cb38e6ee34fbec04f11.tar.gz > 194f252f7426:trigger_server_download_end > Waiting for client to transfer server archive... > W…
阅读更多...
C语言好好题（一维数组）

C语言好好题（一维数组）

两天没有更新了&#xff0c;贴纸们&#xff0c;有没有想我呀。&#x1f604;&#x1f604;&#x1f604; 好了&#xff0c;就寒暄到这里吧&#xff0c;下面请看题&#xff1a; 有序序列判断 输入一个整数序列&#xff0c;判断是否是有序序列&#xff0c;有序&#xff0c;指序列…
阅读更多...
最新文章

Copyright @ 2022~2023