Codeforces Round 909 (Div. 3)（A~G）（启发式合并 ， DSU ON TREE）

news2024/11/17 13:18:56

1899A - Game with Integers 

        题意：给定一个数 x , 两个人玩游戏，每人能够执行 +1 / -1操作，若操作完x是3的倍数则获胜，问先手的人能否获胜（若无限循环则先手的人输）。

        思路：假如一个数模3余1或者2，那么第一轮操作先手就能获胜，若余0则后手获胜。

        

// Problem: A. Game with Integers
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/A
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int a[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	if(n % 3 == 0){
		cout << "Second\n";
	}	
	else{
		cout << "First\n";
	}	
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899B - 250 Thousand Tons of TNT 

        题意：给定一个整数n , 表示有 n 个集装箱，接下来给定一个数组a , 代表了第i个集装箱有a_{i}吨重。现要将n个集装箱恰好分成连续的k组。要求这当中所有k的取值下集装箱重量的最大值减去最小值的最大值。

        思路：直接暴力做 ， 假设每一组有1、2、3、4、...n个，看满足题意的情况下最大值减最小值的值。时间复杂度O(NlogN).

        

// Problem: B. 250 Thousand Tons of TNT
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=2e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
LL a[N] , sum[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
		sum[i] = sum[i - 1] + a[i];	
	}
	LL ans = 0;
	for(int i = 1 ; i <= n ; i ++){
		LL maxx = 0 , minn = 1e18;
		if(n % i == 0){
			for(int j = 0 ; j < n ; j += i){
				maxx = max(sum[j + i] - sum[j] , maxx);
				minn = min(minn , sum[j + i] - sum[j]);
			}
			ans = max(ans , maxx - minn);
		}
	}
	cout << ans<<endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899C - Yarik and Array 

        题意：给定一组序列，求连续奇数偶数非空子序列的和的最大值（相邻的奇偶性不能相同）。

        思路：同最大连续子序列差不多的做法，只不过要求前一项和当前的奇偶性不同，且至少要选一项。时间O（N）。

        

// Problem: C. Yarik and Array
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/C
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=2e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
LL a[N];
int dp[N][2];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	int n;
	cin >> n;
	for(int i = 1 ; i <= n ; i ++)
		cin >> a[i];
	LL ans = -1e18;
	LL now = 0;
	for(int i = 1 ; i <= n ; i ++){
		if(now == 0){
			now += a[i];
		}
		else{
			if(abs(a[i]) % 2 == abs(a[i - 1]) % 2 ){
				now = a[i];
			}
			else{
				if(now > 0)
					now += a[i];
				else
					now = a[i];
			}
		}
		ans = max(ans , now);
	//	cout << now << endl;
		if(now < 0)
		 	now = 0;
	}
	cout << ans << endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899D - Yarik and Musical Notes 

        题意：给定一组数，要求数对(i , j)满足(2^{a_i})^{2^{a_{j}}} = (2^{a_j})^{2^{a_{i}}}(i < j)的数量。

        思路：构造辅助哈希nex（范围过大无法构造数组） , nex[i]标记了当前位置之后有多少个数字i。观察后发现 ， 当 i = 1 ,j = 2/i = 2 , j = 1时能够满足，其余均需要i =j才能满足。因此对于1或者2而言，数对的数量为nex[1] +nex[2] ，其余的 i 构成的数对数量都是nex[i]。首先遍历一遍算出nex，然后再遍历一遍求答案，同时不断更新nex即可（unordered_map会被卡(哈希冲突），直接用map即可。

        

// Problem: D. Yarik and Musical Notes
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/D
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=3e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int a[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	map<LL,LL>mp;
	LL ans = 0;
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
		mp[a[i]]++;
	}
	for(int i = 1 ; i <= n ; i ++){
		mp[a[i]]--;
		if(a[i] == 1 || a[i] == 2){
			ans += mp[1] + mp[2];
		}
		else{
			ans += mp[a[i]];
		}
	}
	cout << ans << endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899E - Queue Sort 

        题意：给定一个数组，每次能够进行如下操作：

1、选择第一个数放入数组最后一个。

2、将最后一个数往前交换，直到到达第一位或者比前一个数大为止。

        问将数组变为递增的最少操作数，若无法则输出-1.

        思路：若最小的数为数组第一个，那么一轮操作之后他还是在第一位，这样便会无限循环。因此只需要满足最小的数之后的数全是递增的即可。

        

// Problem: E. Queue Sort
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/E
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=3e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
LL a[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	LL minn = 1e18;
	for(int i = 1 ;i <= n ; i ++){
		cin >> a[i];
		minn = min(a[i] , minn);
	}
/*	for(int i = 1 ; i < n - 1; i++){
		if(a[i] < a[i + 1]){
			break;
		}
		if(i == n - 2){
			cout << 0 << endl;
			return;
		}
	}*/
	for(int i = 1 ; i <= n ; i ++){
		if(a[i] == minn){
			for(int j = i + 1; j <= n ; j ++){
				if(a[j] < a[j - 1]){
					cout << -1 << endl;
					return;
				}
			}
			cout << i - 1 << endl;
			return;
		}
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899F - Alex's whims 

        题意：现有n个顶点，起初你可以任意构造将其形成一棵树。接下来有 d 个数，表示共有d轮。每一轮你可以选择一个已有的边将其删除，然后再连一条边形成一颗新的数。要求每一轮能够满足至少有两个叶子结点的距离恰好为d_{i}。

        思路：首先可以将n个顶点连城一条链。然后每一轮当中，我们固定第一个点和最后一个点的距离为我们要的d_{i}。每次我们可以将与点1相连的边删去，然后新增一条边，使得刚好1到n的距离为d_{i}。由于结点2 ~ n都是一条链，所以2 ~ n - 1 任意一个距离都是可以构造出来的。如此便一定能够满足题意。所以我们只需要记录当前1结点和哪个结点相连，然后需要连到哪个结点即可。

        

// Problem: F. Alex's whims
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/F
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int a[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n >> m;
	for(int i = 2 ; i <= n ; i ++){
		cout << i - 1 << " " << i << endl;
	}
	int pre = 2;
	for(int i = 0 ; i < m ; i ++){
		int x;
		cin >> x;
		int len = (n - pre) + 1;
		if(len == x){
			cout <<"-1 -1 -1\n";
			continue;
		}
		else{
			int to = (n - x + 1);
			cout << 1 << " " << pre << " " << to << endl;
			pre = to; 
		}
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

1899G - Unusual 进入tainment 

        思路：给定一棵树和一个排列p。现有q组询问，每组询问包含了三个数l , r , x。问点x的子树的结点是否在[p_{l} , p_{r}]中出现。

        思路：子树问题，首先想到了用dfs序来解决。对于一颗子树而言，我们可以用set来维护其所有结点在排列p中的位置。然后对于一个询问而言，只需要找到set中大于等于 l 的第一个位置即可，然后判断该位置是否小于等于r。若小于等于r则代表了其子树的结点包含在了[p_{l} , p_{r}]中。共有n个结点，所以我们需要创立n个set，来记录他们的结点在p中的位置。在子树向上合并的过程中，我们可以用启发式合并来实现优化：每一轮虽然是将子树的set合并到父节点的set上，但是可以用swap来交换两个set，确保每次都将小集合合并到大集合上面（swap是O(1)的）。如此总的时间复杂度是O(nlogn + qlogn）的。

        

// Problem: G. Unusual Entertainment
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/G
// Memory Limit: 256 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=2e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}
LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int a[N] , pos[N];
vector<int>tr[N + 5];
vector<array< int , 3 > >que[N];
vector<set<int>> num(N);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0 , tr[i].clear() , que[i].clear();
		num[i].clear();
	}
}
LL ans[N];
void merge(set<int> &a , set<int>&b){
	if(a.size() < b.size()){
		swap(a , b);
	}
	for(auto it : b){
		a.insert(it);
	}
	b.clear();
}
void dfs(int cur , int f){
	num[cur].insert(pos[cur]);
	for(auto it : tr[cur]){
		if(it == f)
			continue;
		dfs(it , cur);
		merge(num[cur] , num[it]);
	}
	for(auto it : que[cur]){
		auto p = num[cur].lower_bound(it[0]);
		ans[it[2]] = p != num[cur].end() && *p <= it[1];
	}
};
void solve() 
{

	cin >> n >> m;
	for(int i = 1 ; i < n ; i++){
		int x , y;
		cin >> x >> y;
		tr[x].pb(y);
		tr[y].pb(x);
	}
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
		pos[a[i]] = i;
	}
	for(int i = 0 ; i < m ; i ++){
		int l , r , x;
		cin >> l >> r >> x;
		que[x].pb({l , r , i});
	}
	dfs(1 , 0);
	for(int i = 0 ; i < m ; i ++){
		if(ans[i]){
			cout <<"YES\n";
		}
		else{
			cout <<"NO\n";
		}
	}
	init(n);
	cout << endl;
	num.clear();
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

更新下新做法：用一个辅助数组vis,其中vis[i] = 1则表示p[i]这个结点存在在子树当中，那么对于一个询问而言，只需要看([vis[l] , vis[r])当中是否有结点存在，即sum(vis[l] , vis[r]) > 0即可。 那么在子树合并的过程之中，可以将轻儿子合并到重儿子上面，然后再将轻儿子的信息删除（DSU on tree）。整个过程的时间复杂度是O（NlogN）的。而要维护区间和，可以用树状数组来实现，每次的复杂度是O（logN）的。而对于每个询问而言，区间和的复杂度也是O（logN）的，因此总体复杂度为O（NlogNlogN + qlogN）。

        

// Problem: G. Unusual Entertainment
// Contest: Codeforces - Codeforces Round 909 (Div. 3)
// URL: https://codeforces.com/contest/1899/problem/G
// Memory Limit: 256 MB
// Time Limit: 3000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N=1e05+10;
const LL mod=1e09+7;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >t;
priority_queue<LL> q;
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}
LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int a[N] , pos[N];
vector<int>tr[N + 5];
vector<array< int , 3 > >que[N];
struct BIT{//Binary indexed Tree(树状数组)
	int n;
	vector<int> tr;
	BIT(int n) : n(n) , tr(n + 1 , 0){
	}
	int lowbit(int x){
		return x & -x;
	}
	void modify(int x , int modify_number){
		for(int i = x ; i <= n ; i += lowbit(i)){
			tr[i] += modify_number;
		}
	}
	void modify(int l , int r , int modify_number){
		modify(l , modify_number);
		modify(r + 1 , -modify_number);
	}
	int query(int x){
		int res = 0;
		for(int i = x ; i ;  i -= lowbit(i))
			res += tr[i];
		return res;
	}
	int query(int x , int y){
		if(x > y)
		swap(x , y);
		return query(y) - query(x);
	}
};
BIT bit(N);
int res[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0 , tr[i].clear() , que[i].clear() , bit.tr[i] = 0 , res[i] = 0;
	}
}
LL l[N] , r[N] , id[N] , sz[N] , hs[N] , tot = 0 , ans[N];
set<int>num;
void dfs(int cur , int f){
	l[cur] = ++ tot;
	id[tot] = cur;
	sz[cur] = 1;
	hs[cur] = -1;
	for(auto it : tr[cur]){
		if(it != f){
			dfs(it , cur);
			sz[cur] += sz[it];
			if(hs[cur] == -1 || sz[it] > sz[hs[cur]]){
				hs[cur] = it;
			}
		}		
	} 
	r[cur] = tot;
}
void dfs2(int cur , int f , int keep){
	vector<int>res(que[cur].size());
	int i = 0;
/*	for(auto it : que[cur]){
		res[i++] = bit.query(it[1] , it[0] - 1);
	}*/
	for(auto it : tr[cur]){
		if(it != f && it != hs[cur]){
			dfs2(it , cur , 0);
		}
	}
	if(hs[cur] != -1){
		dfs2(hs[cur] , cur , 1);
	}
	auto add = [&](int x){
		bit.modify(pos[x] , 1);
	};
	auto del = [&](int x){
		bit.modify(pos[x] , -1);
	};
	for(auto it : tr[cur]){
		if(it != f && it != hs[cur]){
			for(int x = l[it] ; x <= r[it] ; x ++){
					add(id[x]);
			}
		}
	}
	add(cur);
	i = 0;
	for(auto it : que[cur]){
		ans[it[2]] = bit.query(it[1] , it[0] - 1) > 0 ? 1 : 0;
	}
	if(!keep){
		for(int x = l[cur] ; x <= r[cur] ; x ++){
			del(id[x]);
		}
	}
}
void solve() 
{
	cin >> n >> m;
	for(int i = 1 ; i < n ; i++){
		int x , y;
		cin >> x >> y;
		tr[x].pb(y);
		tr[y].pb(x);
	}
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
		pos[a[i]] = i;
	}
	for(int i = 0 ; i < m ; i ++){
		int l , r , x;
		cin >> l >> r >> x;
		que[x].pb({l , r , i});
	}
	dfs(1 , 0);
	dfs2(1 , 0 , 0);
	for(int i = 0 ; i < m ; i ++){
		if(ans[i]){
			cout <<"YES\n";
		}
		else{
			cout <<"NO\n";
		}
	}
	init(n);
	cout << endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

        

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

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

相关文章

【具身智能评估2】具身视觉语言规划（EVLP）数据集基准汇总

【具身智能评估2】具身视觉语言规划（EVLP）数据集基准汇总

参考论文&#xff1a;Core Challenges in Embodied Vision-Language Planning 论文作者&#xff1a;Jonathan Francis, Nariaki Kitamura, Felix Labelle, Xiaopeng Lu, Ingrid Navarro, Jean Oh 论文原文&#xff1a;https://arxiv.org/abs/2106.13948 论文出处&#xff1a;Jo…
阅读更多...
Python PyQt 程序设置图标

Python PyQt 程序设置图标

源码运行时图标 第一步&#xff1a;阿里巴巴是两图标库下载喜欢的图标 iconfont-阿里巴巴矢量图标库 第二步&#xff1a;转化png为ico https://www.aconvert.com/cn/icon/png-to-ico/ 256x256为大图标 默认的32x32很小&#xff08;不建议用) 转化后右键点击文件链接&…
阅读更多...
基于金鹰算法优化概率神经网络PNN的分类预测 - 附代码

基于金鹰算法优化概率神经网络PNN的分类预测 - 附代码

基于金鹰算法优化概率神经网络PNN的分类预测 - 附代码 文章目录 基于金鹰算法优化概率神经网络PNN的分类预测 - 附代码1.PNN网络概述2.变压器故障诊街系统相关背景2.1 模型建立 3.基于金鹰优化的PNN网络5.测试结果6.参考文献7.Matlab代码 摘要&#xff1a;针对PNN神经网络的光滑…
阅读更多...
【Android】Android Framework系列--CarUsbHandler源码分析

【Android】Android Framework系列--CarUsbHandler源码分析

Android Framework系列–CarUsbHandler源码分析 本文基于Android12源码。 CarUsbHandler是Android Car提供的服务之一&#xff0c;其用车载USB连接的场景。 车载USB有其特殊应用场景&#xff0c;比如AndroidAuto、CarLife等。而Android的做法是在其原有的USB服务上&#xff0…
阅读更多...
十七、Linux的组管理

十七、Linux的组管理

1、Linux组基本介绍 在linux中的每个用户必须属于一个组&#xff0c;不能独立于组外。在linux中每个文件所有者、所在组、其它组的概念 1.所有者 2.所在组 3.其他组 4.改变用户所在的组 2、文件/目录 所有者 一般为文件的创建者&#xff0c;谁创建了该文件&#xff0c;就自…
阅读更多...
【图解算法】- 快乐数还能这么解?

【图解算法】- 快乐数还能这么解?

一 - 前言 介绍&#xff1a;大家好啊&#xff0c;我是hitzaki辰。 社区&#xff1a;&#xff08;完全免费、欢迎加入&#xff09;日常打卡、学习交流、资源共享的知识星球。 自媒体&#xff1a;我会在b站/抖音更新视频讲解 或 一些纯技术外的分享&#xff0c;账号同名&#xff…
阅读更多...
MongoDB随记

MongoDB随记

MongoDB 1、简单介绍2、基本术语3、shard分片概述背景架构路由功能chunk&#xff08;数据分片&#xff09;shard key&#xff08;分片键值&#xff09; 4、常用命令 1、简单介绍 MongoDB是一个分布式文件存储的数据库&#xff0c;介于关系数据库和非关系数据库之间&#xff0c…
阅读更多...
第 372 场 LeetCode 周赛题解

第 372 场 LeetCode 周赛题解

A 使三个字符串相等 求三个串的最长公共前缀 class Solution { public:int findMinimumOperations(string s1, string s2, string s3) {int n1 s1.size(), n2 s2.size(), n3 s3.size();int i 0;for (; i < min({n1, n2, n3}); i)if (!(s1[i] s2[i] && s2[i] s…
阅读更多...
【智能家居】5、主流程设计以及外设框架编写与测试

【智能家居】5、主流程设计以及外设框架编写与测试

目录 一、主流程设计 1、工厂模式结构体定义 &#xff08;1&#xff09;指令工厂 inputCmd.h &#xff08;2&#xff09;外设工厂 controlDevices.h 二、外设框架编写 1、创建外设工厂对象bathroomLight 2、编写相关函数框架 3、将浴室灯相关操作插入外设工厂链表等待被调…
阅读更多...
内容运营工具：标签体系

内容运营工具：标签体系

一.分类和标签的区别 ■标签是扁平的&#xff0c;分类是层级的。 ■标签是精确的&#xff0c;分类是粗糙的。 ■标签是多维的&#xff0c;分类是一维的。 二.标签的本质&#xff1a;元数据 事实上&#xff0c;在数据领域&#xff0c;有一个鼎鼎大名的词汇与标签极其雷同&…
阅读更多...
再高级的打工人也只是打工人！

再高级的打工人也只是打工人！

再高级的打工人也只是打工人&#xff01; OpenAI CEO 奥特曼被罢免的事情人尽皆知「虽然&#xff0c;今天又复职了。。」&#xff0c;我们能从中学到什么呢&#xff1f; CEO 也能被裁&#xff0c;这应该是最近几年被裁名单里面&#xff0c;职级最高的一个人了吧。你再也不用担…
阅读更多...
吐血整理，金融银行测试的“火“到底在哪里？银行测试真正实施...

吐血整理，金融银行测试的“火“到底在哪里？银行测试真正实施...

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 银行里的软件测试…
阅读更多...
C#WPF中的实现读取和写入文件的几种方式

C#WPF中的实现读取和写入文件的几种方式

说明&#xff1a;C#中实现读取和写入的类根据需要来选择。 1、File类 File类是用于操作文件的工具类&#xff0c;提供了对文件进行创建、复制、删除、移动和打开单一文件的静态方法。但需要注意的是&#xff0c;WPF中使用File的类&#xff0c;需要先引用System.IO下的命名空间。…
阅读更多...
数据结构【DS】图的遍历

数据结构【DS】图的遍历

BFS 要点 需要一个辅助队列visited数组&#xff0c;防止重复访问 复杂度 时间复杂度&#xff1a;访问结点的时间访问所有的边的时间 广度优先生成树 邻接表存储的图的表示方式不唯一&#xff0c;生成树也不唯一 DFS 复杂度 时间复杂度&#xff1a;访问结点的时间访问所有…
阅读更多...
Java工具包Hutool框架

Java工具包Hutool框架

Hutool是一个Java基础工具类，对文件、流、加密解密、转码、正则、线程、XML 等 JDK 方法进行封装，组成各种 Util 工具类。官网地址：https://www.hutool.cn/。 添加依赖 <dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artif…
阅读更多...
气候更换，气运也会随之变化

气候更换，气运也会随之变化

天人合一&#xff0c;人天相应&#xff0c;人体与宇宙天体的运行互相感应相通&#xff0c;与大自然的万千变化紧密联系。阴阳转换&#xff0c;带来的气场和磁场的变化&#xff0c;对自然界万事万物和人影响很大。 蒹葭苍苍&#xff0c;白露为霜&#xff0c;所谓伊人&#xff0…
阅读更多...
基于未来搜索算法优化概率神经网络PNN的分类预测 - 附代码

基于未来搜索算法优化概率神经网络PNN的分类预测 - 附代码

基于未来搜索算法优化概率神经网络PNN的分类预测 - 附代码 文章目录 基于未来搜索算法优化概率神经网络PNN的分类预测 - 附代码1.PNN网络概述2.变压器故障诊街系统相关背景2.1 模型建立 3.基于未来搜索优化的PNN网络5.测试结果6.参考文献7.Matlab代码 摘要&#xff1a;针对PNN神…
阅读更多...
2023最新最全【Nacos】零基础安装教程

2023最新最全【Nacos】零基础安装教程

一、下载Nacos1.4.1 二、单机版本安装 2.1 将下载的nacos安装包传输到服务器2.2 解压文件2.3 进入bin目录下 单机版本启动2.4 关闭nacos2.5 访问Nacos地址 IP&#xff1a;8848/nacos 三、集群版本的安装 3.1 复制nacos安装包&#xff0c;修改为nacos8849&#xff0c;nacos88…
阅读更多...
HR人才测评，提高招聘效率降低用人风险

HR人才测评，提高招聘效率降低用人风险

随着社会的不断进步&#xff0c;越来越多的企业在人力资源管理中&#xff0c;引入人才测评工具。人才是构成一个企业的基础&#xff0c;是企业不断发展的保障&#xff0c;同时&#xff0c;人才也是一个企业的核心竞争力之一。所以&#xff0c;人才的素质对一个企业至关重要。现…
阅读更多...
[ 一刷完结撒花!! ] Day50 力扣单调栈 : 503.下一个更大元素II ｜42. 接雨水 | 84.柱状图中最大的矩形

[ 一刷完结撒花!! ] Day50 力扣单调栈 : 503.下一个更大元素II ｜42. 接雨水 | 84.柱状图中最大的矩形

Day50 力扣单调栈 : 503.下一个更大元素II &#xff5c;42. 接雨水 | 84.柱状图中最大的矩形 503.下一个更大元素II第一印象看完题解的思路实现中的困难感悟代码 42. 接雨水第一印象看完题解的思路暴力解法单调栈解法 实现中的困难感悟代码 84.柱状图中最大的矩形第一印象看完…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023