Codeforces Round 913 (Div. 3)（A~G）

news2024/11/24 10:45:55

1、编程模拟

2、栈模拟

3、找规律？（从终止状态思考）

4、二分

5、找规律，数学题

6、贪心（思维题）

7、基环树

A - Rook 

        题意：

        直接模拟

// Problem: A. Rook
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/0
// 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	string s;
	cin >> s;
	char c = s[0];
	int k = s[1] - '0';
	for(int i = 0 ; i < 8 ; i++){
		char t = i + 'a';
		if(t == c){
			continue;
		}
		else{
			cout << t <<k<<endl;
		}
	}
	for(int i = 1 ; i < 9 ; i ++){
		if(i == k)
			continue;
		else{
			cout << c << i <<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;
}

B - YetnotherrokenKeoard 

        题意：给定键入顺序，但是其中‘B’和‘b’不再代表字母，‘B’代表删除前面第一个大写字母，‘b’代表删除前面第一个小写字母，求最终键入的字符串结果。

        思路：‘第一个’自然想到了栈的后进后出原则，‘B’‘b’操作即是出栈操作。先不考虑最终结果，而是将其字母的键入时间放入栈当中。最后将栈中键入时间全部取出，再根据键入时间输出结果。

        

// Problem: B. YetnotherrokenKeoard
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/B
// 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	string s;
	cin >> s;
	stack<int>big , small;
	int len = s.size();
	for(int i = 0 ; i < len ; i ++){
		if(s[i] >= 'a' && s[i] <= 'z'){
			if(s[i] == 'b'){
				if(!small.empty()){
					small.pop();
				}
			}				
			else{
				small.push(i);
			}
		}
		else{
			if(s[i] == 'B'){
				if(!big.empty()){
					big.pop();
				}
			}
			else{
				big.push(i);
			}
		}
	}
	vector<int>ans;
	while(!big.empty()){
		ans.pb(big.top());
		big.pop();
	}
	while(!small.empty()){
		ans.pb(small.top());
		small.pop();
	}
	sort(ans.begin() , ans.end());
	len = ans.size();
	for(int i = 0 ; i < len ; i ++){
		cout <<s[ans[i]];
	}
	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;
}

C - Removal of Unattractive Pairs 

        题意：给定字符串，能够删除相邻两个不相同字符，求最终字符最短能为多少。

        思路：考虑最终状态：一定不存在字符或者只存在一种字符。因此考虑将其余字符全部删除，能将字符串变为多短。

// Problem: C. Removal of Unattractive Pairs
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	vector<int>cnt(26 , 0);
	string s;
	cin >>s;
	for(int i = 0;  i < n ; i ++){
		cnt[s[i] - 'a']++;
	}
	int maxx = 0;
	for(int i = 0 ; i < 26 ; i ++){
		maxx = max(maxx , cnt[i]);
	}
	cout << max( n & 1 ? 1 : 0 , n - 2 * (n - maxx)) << 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;
}

 D - Jumping Through Segments 

        题意：

        思路：直接二分求答案，每一轮的范围是[上一轮左端点 - k ， 上一轮右端点 + k ] ,然后和当前线段合并，若不相交则false。

        

// Problem: D. Jumping Through Segments
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/D
// Memory Limit: 256 MB
// Time Limit: 5000 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
vector<pair<int,int>>range;
bool check(int len){
	pair<int,int> ran = {0 , 0};
	int t = range.size();
	for(auto to : range){
//		cout << ran.x << " " << ran.y << endl;
		int l = to.x;
		int r = to.y;
		ran.x -= len;
		ran.y += len;
		if(ran.x > r || ran.y < l)
			return false;
		ran.x = max(ran.x , l);
		ran.y = min(ran.y , r);
	}
	return true;
}
void solve() 
{
	cin >> n;
	for(int i = 0 ; i < n ; i ++){
		pair<int,int>tmp;
		cin >> tmp.x >> tmp.y;
		range.pb(tmp);
	}
	int l = 0 , r = 1e9;
	while(l < r){
		int mid = (l + r) / 2;
		if(check(mid)){
			r = mid;
		} 
		else{
			l = mid + 1;
		}
	}
	cout << l << endl;
	range.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;
}

E - Good Triples 

题意：

思路:可以发现，若要满足条件，那么三个数是不能进位的，因此本题中数据的每一位是不会影响的。满足乘法原则，将每一位所能带来的贡献相乘即可。

// Problem: E. Good Triples
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/E
// 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
int dig(int s){
	int cnt = 0;
	while(s){
		cnt += s % 10;
		s/=10;
	}
	return cnt;
}
void solve() 
{
	// 0 == 1 
	// 1 == 3
	// 2 == 6
	// 3 == 10
	// 4 == 15
	// 5 == 21
	// 6 == 28
	// 7 == 36
	// 8 == 45
	// 9 == 55
	// 3141 = 3 * 15 * 3 * 10
	LL mask[10] = {1 , 3 , 6 , 10 , 15 , 21 , 28 , 36 , 45 , 55};
	string s;
	cin >> s;
	int len = s.size();
	LL ans = 1;
	for(int i = 0 ; i < len ; i ++){
		ans *= mask[s[i] - '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;
}

F - Shift and Reverse 

思路：将数组放到环上考虑， 假设环起初按顺时针排 ， 且有一个指针指向了环的第一位。现考虑操作变成了什么：

移位操作：将指针往前移动一格。

反转：将环变成逆时针（将非递减转化为非递增）。

因此，若要满足非递减排序，必然存在从环上某一点出发，顺时针是非递减顺序/非递增的。如何去模拟环，只需要将整个数组复制一遍到尾端即可模拟。然后就是找非递减序列和非递增序列即可。然后判断一下需要多少操作。

        

// Problem: F. Shift and Reverse
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/F
// 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	for(int i = 0 ; i < n ; i ++)
		cin >> a[i];
	vector<int>v(2 * n , 0);
	for(int i = 0 ; i < n ; i ++){
		v[i] = a[i];
		v[i + n] = a[i];
	}
	int ans = -1;
	//递减
	for(int i = 0 ; i < n ; ){
		int st = i;
		int cnt = 1;
		while(i < 2 * n - 1 && v[i] >= v[i + 1]){
			cnt++;
			i++;
		}
		if(cnt >= n){
			ans = min(1 + st, 1 + (n - st));
		}
		i ++;
	}
	//递增
	for(int i = 0 ; i < n ; ){
		int st = i;
		int cnt = 1;
		while(i < 2 * n - 1 && v[i] <= v[i + 1]){
			cnt++;
			i++;
		}
		if(cnt >= n){
			if(ans == -1){
				ans = min(n - st , st + 2);
			}
			else{
				ans = min(ans ,min(n - st , st + 2) );
			}
			if(st == 0)
			ans = 0;
		}
		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;
}

G - Lights 

        题意：

思路：将相关联的灯建边，每次操作都对边两端处理。可以发现这是一颗基环树，也就是说：在非环上的点可以按照拓扑序来唯一的去处理（要么1变0，同时另一端也变化，要么不变）。现在就只剩下环上的一部分了，可以发现若环上剩余亮着的灯是奇数的话那么就不能全部熄灭了。

        接下来考虑输出最小操作：若环上某一条边的操作已经确定下来了（变或者不变），那么其余所有边操作都确定了，因此可以考虑类似于环形dp的思想。将所有边操作分为两类表示对一类中的每一条边操作后整个环都能变成0。最后比较两类边集大小考虑输出哪一类即可。

        

// Problem: G. Lights
// Contest: Codeforces - Codeforces Round 913 (Div. 3)
// URL: https://codeforces.com/contest/1907/problem/G
// 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 = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
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;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;	
	vector<int>in(n + 5 , 0);
	vector<int>vis(n + 5 , 0);
	vector<int>e(n + 5 , 0) ;
	string s;
	cin >> s;
	s = " " + s;
	for(int i = 1 ; i <= n ; i ++){
		int u = i , v;
		cin >> v;
		e[u] = v;
		in[v]++;
	}	
	queue<int>q;
	for(int i = 1 ; i <= n ;i ++){
		if(in[i] == 0){
			q.push(i);
		}
	}
	vector<int>ans;
	while(!q.empty()){
		int x = q.front();
		q.pop();
		if(s[x] == '1'){
			s[x] = '0';
			ans.pb(x);
			if(s[e[x]] == '1'){
				s[e[x]] = '0';
			}
			else{
				s[e[x]] = '1';
			}
		}
		in[e[x]]--;
		if(in[e[x]] == 0){
			q.push(e[x]);
		}
	}
	for(int i = 1 ; i <= n ; i ++){
		if(in[i]){
			int j = i;
			int t = 0;//分为两组
			int len = 0;
			int res = 0;//t = 1 的组需要操作的数
			while(in[j]){
				if(s[j] == '1'){
					t ^= 1;
				}
				res += t;
				in[j] = 0;
				len ++;
				j = e[j];
			}
			if(t == 1){
				cout << "-1\n";
				return;
			}
			for(int k = 0 ; k < len ; k ++){
				if(s[j] == '1'){
					t ^= 1;
				}
				if(t == (res < len - res)){
					ans.pb(j);
				}
				j = e[j];
			}
		}
	}
	cout << ans.size() << endl;
	for(auto it : ans){
		cout << it <<" ";
	}
}            
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/1288104.html

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

相关文章

附录B 存储次层次结构回顾

附录B 存储次层次结构回顾

1. 引言 缓存是指地址离开处理器后遇到的最高级或第一级存储器层次结构。 如果处理器在缓存中找到了所请求的数据项&#xff0c;就说发生了缓存命中。如果处理器没有在缓存中找到所请求的数据项&#xff0c;就说发生了缓存缺失。此时&#xff0c;包含所请求的字的固定大小的数…
阅读更多...
EPWM初学笔记

EPWM初学笔记

时钟 PCLKCR0 PCLKCR1 EPWM总体预览 三部分就可以简单的使用EPWM 时基模块&#xff0c;比较模块&#xff0c;动作限定模块 时基模块 TBCTL时基控制寄存器 TBCTR计数寄存器 TBPHS相位寄存器 TBPRD周期寄存器 比较模块 CMPCTL比较控制寄存器 影子模式&#xff0c;加载模式 CMP…
阅读更多...
C语言进阶之路-指针、数组等混合小boss篇

C语言进阶之路-指针、数组等混合小boss篇

目录 一、学习目标&#xff1a; 二、指针、数组的组合技能 引言 指针数组 语法 数组指针 三、勇士闯关秘籍 四、大杂脍 总结 一、学习目标&#xff1a; 知识点&#xff1a; 明确指针数组的用法和特点掌握数组指针的用法和特点回顾循环等小怪用法和特点 二、指针、数…
阅读更多...
avamar DD组合的备份故障

avamar DD组合的备份故障

证书过期导致的失败 先是显示DD页面崩了 Avamar DD 集成 — DD 在 Avamar AUI/GUI 中显示红色解决方案路径 | Dell 中国 排查了一番 尝试了重启DD 然而并没用 然后尝试更新证书 页面确实起来了 但是证书还是更新失败 确定原因还是因为版本太低而宣告失败 证书更新失败 …
阅读更多...
自助POS收银机-亿发互联网收银解决方案助力零售业迎接数字经济挑战

自助POS收银机-亿发互联网收银解决方案助力零售业迎接数字经济挑战

零售业作为中国经济的主动脉&#xff0c;扮演着至关重要的角色。最新发布的《中国线下零售小店数字化转型报告》揭示了当前线下零售小店所面临的多重痛点&#xff0c;经营方式传统、滞后的内部管理和营销模式&#xff0c;以及缺乏消费数据等问题&#xff0c;这些痛点都指明&…
阅读更多...
C语言 - 字符函数和字符串函数

C语言 - 字符函数和字符串函数

系列文章目录 文章目录 系列文章目录前言1. 字符分类函数islower 是能够判断参数部分的 c 是否是⼩写字⺟的。 通过返回值来说明是否是⼩写字⺟&#xff0c;如果是⼩写字⺟就返回⾮0的整数&#xff0c;如果不是⼩写字⺟&#xff0c;则返回0。 2. 字符转换函数3. strlen的使⽤和…
阅读更多...
一文读懂中间件

一文读懂中间件

前言&#xff1a;在程序猿的日常工作中&#xff0c; 经常会提到中间件&#xff0c;然而大家对中间件的理解并不一致&#xff0c;导致了一些不必要的分歧和误解。“中间件”一词被用来描述各种各样的软件产品&#xff0c;在不同文献中有着许多不同的中间件定义&#xff0c;包括操…
阅读更多...
住宅IP代理如何选择？如何识别高质量的住宅IP代理服务商

住宅IP代理如何选择？如何识别高质量的住宅IP代理服务商

选择海外住宅IP代理时&#xff0c;了解其评估标准、优势和实际应用至关重要。住宅IP代理不同于其他类型的代理&#xff0c;它提供更高的匿名性和较低的封禁风险&#xff0c;适用于多种网络场景。本指南将深入分析如何根据服务质量、速度、安全性和客户支持等关键因素&#xff0…
阅读更多...
数学建模之相关系数模型及其代码

数学建模之相关系数模型及其代码

发现新天地&#xff0c;欢迎访问小铬的主页(www.xiaocr.fun) 引言 本讲我们将介绍两种最为常用的相关系数&#xff1a;皮尔逊pearson相关系数和斯皮尔曼spearman等级相关系数。它们可用来衡量两个变量之间的相关性的大小&#xff0c;根据数据满足的不同条件&#xff0c;我们要…
阅读更多...
uniapp 微信小程序连接蓝牙卡死 uni.onNeedPrivacyAuthorization

uniapp 微信小程序连接蓝牙卡死 uni.onNeedPrivacyAuthorization

解决方法&#xff0c;需要同意隐私保护协议&#xff0c;否则不能开启蓝牙权限和定位权限&#xff0c;会导致连接蓝牙失败
阅读更多...
【Vue】使用cmd命令创建vue项目

【Vue】使用cmd命令创建vue项目

上一篇&#xff1a; node的安装与配置 https://blog.csdn.net/m0_67930426/article/details/134562278?spm1001.2014.3001.5502 目录 一.创建空文件夹专门存放vue项目 二. 查看node , npm 和vue脚手架的版本 三.安装vue脚手架 四.创建vue项目 五.运行项目 一.创建空文件…
阅读更多...
在Windows11（WSL）中如何迁移Docker

在Windows11（WSL）中如何迁移Docker

前言&#xff1a; 在Windows 10中Docker是默认安装到WSL中的&#xff0c;而安装到WSL中的任意分发版都是默认放在C盘中的。这样会让我们的C盘资源极度紧张&#xff0c;而且也限制了Docker的镜像数量。 迁移步骤 假设我有一个临时目录“D:\docker”用来存放临时文件&#xff0c;…
阅读更多...
基于ssm vue的社区互助平台源码和论文

基于ssm vue的社区互助平台源码和论文

摘 要 随着社区互助规模的不断扩大&#xff0c;社区互助数量的急剧增加&#xff0c;有关社区互助的各种信息量也在不断成倍增长。面对庞大的信息量&#xff0c;就需要有社区互助管理来提高社区互助管理工作的效率。通过这样的系统&#xff0c;我们可以做到信息的规范管理和快速…
阅读更多...
【从零开始学习JVM | 第一篇】快速了解JVM

【从零开始学习JVM | 第一篇】快速了解JVM

前言&#xff1a; 在探索现代软件开发的丰富生态系统时&#xff0c;我们不可避免地会遇到一个强大而神秘的存在——Java虚拟机&#xff08;JVM&#xff09;。作为Java语言最核心的组成之一&#xff0c;JVM已经超越了其最初的设计目标&#xff0c;成为一个多语言的运行平台&…
阅读更多...
nacos启动报错 java.lang.RuntimeException: [db-load-error]load jdbc.properties error

nacos启动报错 java.lang.RuntimeException: [db-load-error]load jdbc.properties error

以standalone mode sh startup.sh -m standalone 为例子 启动nacos 报错&#xff1a; Caused by: org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcatat org.springframework.boot.web.embedded.tomcat.TomcatWebServer.initialize(To…
阅读更多...
【九】linux下部署frp客户端服务端实践（内网穿透）

【九】linux下部署frp客户端服务端实践（内网穿透）

linux下部署frp客户端服务端实践 简介&#xff1a; 今天有一个这样的需求&#xff0c;部署在公司内部局域网虚拟机上的服务需要在外网能够访问到&#xff0c;这不就是内网穿透的需求吗&#xff0c;之前通过路由器实现过&#xff0c;现在公司这块路由器不具备这个功能了&#x…
阅读更多...
『亚马逊云科技产品测评』活动征文｜基于亚马逊EC2云服务器配置Nginx静态网页

『亚马逊云科技产品测评』活动征文｜基于亚马逊EC2云服务器配置Nginx静态网页

授权声明&#xff1a;本篇文章授权活动官方亚马逊云科技文章转发、改写权&#xff0c;包括不限于在 Developer Centre, 知乎&#xff0c;自媒体平台&#xff0c;第三方开发者媒体等亚马逊云科技官方渠道 亚马逊EC2云服务器&#xff08;Elastic Compute Cloud&#xff09;是亚马…
阅读更多...
网络安全威胁——中间人攻击

网络安全威胁——中间人攻击

中间人攻击 1. 定义2. 中间人攻击如何工作3. 常见中间人攻击类型4. 如何防止中间人攻击 1. 定义 中间人攻击&#xff08;Man-in-the-Middle Attack&#xff0c;简称MITM&#xff09;&#xff0c;是一种会话劫持攻击。攻击者作为中间人&#xff0c;劫持通信双方会话并操纵通信过…
阅读更多...
生产环境_从数据到层级结构JSON：使用Spark构建多层次树形数据_父子关系生成

生产环境_从数据到层级结构JSON：使用Spark构建多层次树形数据_父子关系生成

代码补充了&#xff01;兄弟萌 造的样例数据 val data Seq(("USA", "Male", "Asian", "Chinese"),("USA", "Female", "Asian", "Chinese"),("USA", "Male", "Bl…
阅读更多...
flask web学习之flask与http（一）

flask web学习之flask与http（一）

文章目录 一、请求响应循环二、HTTP请求1. 请求报文2. request对象3. 在flask中处理请求3.1 路由匹配3.2 设置监听的http方法3.3 URL处理 三、请求钩子 一、请求响应循环 每一个web应用都包含这种处理方式&#xff0c;请求-响应循环&#xff1a;客户端发出请求&#xff0c;服务…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023