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

news2024/11/19 20:46:47

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即可。

        

// 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;
	unordered_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;
}

        另外为何我这个会超时

// 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];
int vis[N];
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0 , tr[i].clear() , que[i].clear() , vis[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){
	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){
		vis[x] = 1;
		num.insert(pos[x]);
	};
	auto del = [&](int x){
		vis[x] = 0;
		num.erase(pos[x]);
	};
	for(auto it : tr[cur]){
		if(it != f && it != hs[cur]){//轻儿子加入到重儿子当中
			for(int x = l[it] ; x <= r[it] ; x ++){
				if(!vis[id[x]])
					add(id[x]);
			}
		}
	}
	add(cur);
	for(auto it : que[cur]){//QLOGN
		auto  p = lower_bound(num.begin() , num.end() , it[0]);
		int x = *p;
	//	cout << cur <<" " << it[0] <<" "<< x << endl;
		if(x > it[1] || x < it[0]){
			ans[it[2]] = 0;
		}
		else{
			ans[it[2]] = 1;
		}
	}
	if(!keep){
		for(int x = l[cur] ; x <= r[cur] ; x ++){//NlogN
			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;
	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;
}

 

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

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

相关文章

248: vue+openlayers 以静态图片作为底图，并在上面绘制矢量多边形

248: vue+openlayers 以静态图片作为底图，并在上面绘制矢量多边形

第248个 点击查看专栏目录 本示例是演示如何在vue+openlayers项目中以静态图片作为底图，并在上面绘制矢量多边形。这里主要通过pixels的坐标作为投射，将静态图片作为底图，然后通过正常的方式在地图上显示多边形。注意的是左下角为[0,0]。 直接复制下面的 vue+openlayers源代…
阅读更多...
基于SSM的设备配件管理和设备检修系统

基于SSM的设备配件管理和设备检修系统

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
Python----图像的手绘效果

Python----图像的手绘效果

图像的数组表示 图像是有规则的二维数据&#xff0c;可以用numpy 库将图像转换成数组对象 : from PIL import Image import numpy as np imnp.array(Image.open("D://np.jpg")) print(im.shape,im.dtype)结果&#xff1a; 图像转换对应的ndarray 类型是3 维数据&am…
阅读更多...
剑指offer --- 用两个栈实现队列的先进先出特性

剑指offer --- 用两个栈实现队列的先进先出特性

目录 前言 一、读懂题目 二、思路分析 三、代码呈现 总结 前言 当我们需要实现队列的先进先出特性时&#xff0c;可以使用栈来模拟队列的行为。本文将介绍如何使用两个栈来实现队列&#xff0c;并给出具体的思路和代码实现。 一、读懂题目 题目&#xff1a;用两个栈实现一…
阅读更多...
ClickHouse的分片和副本

ClickHouse的分片和副本

1.副本 副本的目的主要是保障数据的高可用性&#xff0c;即使一台ClickHouse节点宕机&#xff0c;那么也可以从其他服务器获得相同的数据。 Data Replication | ClickHouse Docs 1.1 副本写入流程 1.2 配置步骤 &#xff08;1&#xff09;启动zookeeper集群 &#xff08;2&…
阅读更多...
openfeign整合sentinel出现异常

openfeign整合sentinel出现异常

版本兼容的解决办法&#xff1a;在为userClient注入feign的接口类型时&#xff0c;添加Lazy注解。 Lazy注解是Spring Framework中的一个注解&#xff0c;它通常用于标记Bean的延迟初始化。当一个Bean被标记为Lazy时&#xff0c;Spring容器在启动时不会立即初始化这个Bean&…
阅读更多...
SpringMVC 进阶

SpringMVC 进阶

SpringMVC 进阶 一、拦截器 SpringMVC 中 Interceptor 拦截器的主要作⽤是拦截⽤⼾的请求并进⾏相应的处理。⽐如通过它来进⾏权限验证&#xff0c;或者是来判断⽤⼾是否登陆等操作。对于 SpringMVC 拦截器的定义⽅式有两种&#xff1a; 实现接⼝&#xff1a;org.springfram…
阅读更多...
无线物理层安全大作业

无线物理层安全大作业

这个标题很帅 Beamforming Optimization for Physical Layer Security in MISO Wireless NetworksProblem Stateme![在这里插入图片描述](https://img-blog.csdnimg.cn/58ebb0df787c4e23b0c7be4189ebc322.png) Beamforming Optimization for Physical Layer Security in MISO W…
阅读更多...
websocket详解

websocket详解

一、什么是Websocket WebSocket 是一种在单个 TCP 连接上进行 全双工 通信的协议&#xff0c;它可以让客户端和服务器之间进行实时的双向通信。 WebSocket 使用一个长连接&#xff0c;在客户端和服务器之间保持持久的连接&#xff0c;从而可以实时地发送和接收数据。 在 Web…
阅读更多...
【Mysql学习笔记】1 - Mysql入门

【Mysql学习笔记】1 - Mysql入门

一、Mysql5.7安装配置 下载后会得到zip 安装文件解压的路径最好不要有中文和空格这里我解压到 D:\hspmysql\mysql-5.7.19-winx64 目录下 【根据自己的情况来指定目录,尽量选择空间大的盘】 添加环境变量 : 电脑-属性-高级系统设置-环境变量&#xff0c;在Path 环境变量增加mysq…
阅读更多...
js-webApi笔记1

js-webApi笔记1

目录 前言 Web API的概念 什么是DOM DOM树 1、查找元素 2、其他查找元素方法 3、操作元素 4、操作元素属性 5、 操作元素样式 style 6、操作自定义属性 7、 操作表单元素属性 8、事件 9、事件绑定 10、常用鼠标事件 11、定时器 12、定时器案例 前言 Web API的概念…
阅读更多...
京东推出数据平台云海 API接口将达700个

京东推出数据平台云海 API接口将达700个

1月16日消息&#xff0c;继上周面对企业用户发布京东电商云解决方案后&#xff0c;日前&#xff0c;京东云平台又发布了全新的数据开放平台——“云海”&#xff0c;以开放商家、商品、点击流等相关数据。 在京东主办&#xff0c;思路网协办的京东开放云服务合作伙伴2014峰会&…
阅读更多...
leetcode刷题日志-151反转字符串中的单词

leetcode刷题日志-151反转字符串中的单词

给你一个字符串 s &#xff0c;请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意&#xff1a;输入字符串 s中可能会存在前导空格、尾随…
阅读更多...
加密数字货币：机遇与风险并存

加密数字货币：机遇与风险并存

随着区块链技术的发展和普及&#xff0c;加密数字货币逐渐走入人们的视线。作为一种以数字形式存在的资产&#xff0c;加密数字货币具有去中心化、匿名性和安全性高等特点&#xff0c;为人们提供了一种全新的支付方式和投资选择。然而&#xff0c;加密数字货币市场也存在着较高…
阅读更多...
实在智能携手中国电信翼支付，全球首款Agent智能体亮相2023数字科技生态大会

实在智能携手中国电信翼支付，全球首款Agent智能体亮相2023数字科技生态大会

11月10日-13日&#xff0c;中国电信与广东省人民政府联合主办的“2023数字科技生态大会”在广州隆重举行。本届大会以“数字科技焕新启航”为主题&#xff0c;邀请众多生态合作伙伴全方位展示数字科技新成果&#xff0c;包括数字新消费、产业数字化、智能电子、人工智能大模型等…
阅读更多...
Vite Vue3+Element Plus框架布局

Vite Vue3+Element Plus框架布局

App根组件&#xff1a;框架布局 <template><el-container class"layout-container-demo" style"height: 98vh"><!-- 菜单栏 --><el-aside width"200px"><el-scrollbar><!-- router:是否启用 vue-router 模式。…
阅读更多...
springcloud整合nacos实现服务注册

springcloud整合nacos实现服务注册

Nacos是一个开源的分布式系统服务和基础设施解决方案&#xff0c;用于实现动态服务发现、配置管理和服务治理。它可以帮助开发人员和运维团队更好地管理微服务架构中的服务实例、配置信息和服务调用。 Nacos提供了服务注册与发现、动态配置管理、服务路由和负载均衡等功能&…
阅读更多...
02-3解析BeautifulSoup

02-3解析BeautifulSoup

一、基本简介 BeautifulSoup简称&#xff1a;bs4什么是BeatifulSoup&#xff1f;  BeautifulSoup&#xff0c;和lxml一样&#xff0c;是一个html的解析器&#xff0c;主要功能也是解析和提取数据优缺点&#xff1f;  缺点&#xff1a;效率没有lxml的效率高  优点&#xff1…
阅读更多...
小游戏：贪吃蛇和俄罗斯方块（Java简单版）

小游戏：贪吃蛇和俄罗斯方块（Java简单版）

贪吃蛇 package z; import java.awt.Color; import java.awt.EventQueue; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; import java.awt.Image; import java.util.ArrayList; import java.util.List; import java.util.Random;import javax.swin…
阅读更多...
畅捷通+数环通iPaaS，实现无代码集成上千款应用

畅捷通+数环通iPaaS，实现无代码集成上千款应用

01 关于畅捷通 畅捷通信息化服务专家,为用户提供在线财务软件,云进销存管理软件,移动办公软件,帮助小微企业人、财、货、客的管理,全面服务小微企业并提供社交化、个性化、服务化、小量化的生意管理支持。 企业除了畅捷通&#xff0c;还有大大小小其他的系统&#xff0c;面临着…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023