Educational Codeforces Round 159 (Rated for Div. 2)(A~E)

        A - Binary Imbalance 

        题意：给定一个01串，你能够在相邻相同字符中插入‘1’,在相邻不同字符中插入‘0’，求最终能否使得0的数量严格大于1的数量。

        思路：可以发现，当出现了‘01’或者‘10’子序列时，能够无限在中间插入‘0’，所以只要出现了0，最终一定能满足题意。

// Problem: F. Trees and XOR Queries Again
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/problem/F
// Memory Limit: 512 MB
// Time Limit: 6500 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;
	string s;
	cin >> s;
	for(int i = 0 ; i < s.size() ; i ++){
		if(s[i] == '0'){
			cout <<"YES\n";
			return;
		}
	}	
	cout <<"NO\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;
}

 B - Getting Points 

        题意：给定数字n,p,l,t。表示了总共有n天，其中每一天能够休息或者去狠狠得分，每次能够得l的分数。同时会在第1天、第8天、第15天....第(7x+1)天得到一个任务，任务能够在之后的任意一天完成，且每个任务的分值为t。同时每天能够在得分的过程中完成最多两项任务。求达到目标分数p及以上的得分方案中，休息天数最大的天数。

        思路：由于任务是累计的，因此在越后面的天数选择得分就越优。因此有如下最优方案：从最后一天往前开始得分，直到满足分数p为止。注意任务总数有上限即可。

        

// Problem: B. Getting Points
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/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;
}
LL n , p , l , t;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n >> p >> l >> t;
	LL maxt = (n - 1) / 7 + 1;
	LL day = 0;
	if(maxt * t + l * ((maxt + 1) / 2) >= p){//最后(maxt +1)/2天上课做任务
		day += (p - 1) / (l + 2 * t) + 1;
		cout << n - day<< endl;
	}
	else{
		p -= maxt * t + l * ((maxt + 1) / 2);
		day += (maxt + 1) / 2;
		day += (p - 1) / l + 1;
		cout << n - day<< 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 - Insert and Equalize 

        题意:给定一个完全不同的数组a，要求添加不同于a数组中任意一个数的自然数到数组a当中，且选择一个正整数x，要求数组中每个数加上若干次x后全部都相等。求加x操作的最小操作数。

        思路：可以发现x应该是越大越好。注意到如下事实：若两个数最终加上若干次x相等，那么必然能够满足其中一个数加上若干次x后等于另一个数。也就是说两个数相减是x的倍数。因此x应当为所有数差值的gcd。

        求出x以后，考虑添加的数为多少，我们可以令最终所有的数都成为整个数组当中最大的数，那么添加的数就应该尽可能的靠近最大的数。这样才能够使得操作数最小。

        所有都求完时候求出需要增加的总数/x即可。

// Problem: C. Insert and Equalize
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/problem/C
// 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'
#define int long long
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<LL>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	a[0] = -llinf;
	cin >> n;
	LL sum = 0;
	for(int i = 1 ; i <= n ; i ++)
		cin >> a[i] , sum += a[i];
	sort(a.begin() + 1 , a.begin() + n + 1);	
	if(n == 1){
		cout << 1 << endl;
		return;
	}
	int x = a[2] - a[1];
	for(int i = 3 ; i <= n ; i ++){
		int nx = gcd(x , a[i] - a[i - 1]);
		x = nx;
	}
	for(int i = n ; i >= 1; i --){
		if(a[i] - a[i - 1] != x){
			sum += a[i] - x;
			break;
		}
	}
	cout << (a[n] * (n + 1) - sum) / x << endl;
}            
signed 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 - Robot Queries 

        题意：有一个无限的 2 维网格。一开始，机器人站在 (0,0)点。机器人可以执行四条指令：

  • U - 从点 (x,y)移动到 (x,y+1)；
  • D - 从点 (x,y)移动到 (x,y−1)；
  • L--从点 (x,y)移动到 (x−1,y)；
  • R--从点 (x,y)移动到 (x+1,y)。

        给你一串长度为 n的命令 s 。您的任务是回答 q 独立查询：给定四个整数 x 、 y 、 l 和 r ；判断机器人在执行命令序列 s 时是否访问了点 (x,y) ，但 l 到 r 的子串是相反的(即机器人执行命令的顺序是 s1s2s3…sl−1srsr−1sr−2…slsr+1sr+2…sn )。

        思路：（一定要想清楚题目在干什么...比赛时想假了）可以发现：对于反转[L,R]的操作而言，机器人从[0,L - 1]上的位置时不会改变的，从[R,n]的位置也是不会改变的，因此考虑记录机器人所有时刻能够到达的点的情况，同时记录一下机器人到达某个点的时间情况。查询的时候只需要判断（x,y）所对应的时间情况是否存在与上述两个区间当中。

        在处理一个查询时，我们不可能去从[L,R]逐个修改位置，因此考虑的是（x , y）这个点在[L,R]范围内反转的等价情况（x',y')。例如pos(r - 1) = {0 , 1} , pos(r) = {1 , 1} , pos(l - 1) = {x , y} 。 那么在翻转之后，pos(l - 1 + 1) = {x + (pos(r - 1).x - pos(r).x , y + (pos(r - 1).y - pos(r).y)}  ,将r - 1 中的 1改成任意数也是一样的情况。也就是说[L,R]中翻转后的点p相当于为{pos(l - 1).x + pos(r).x - pos(p).x , pos(l-1).y +pos(r).y - pos(p).y}。我们对范围内每个点进行操作显然是不成立的，因此可以对（x , y）进行操作。然后判断（x' ,y')是否出现在[L,R]内。

        

// Problem: D. Robot Queries
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/problem/D
// 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 >> m;
	int nx = 0 , ny = 0;
	string s;
	cin >> s;
	s = " " + s;
	pair<int,int>pos[n + 5];
	pos[0] = {nx , ny};
	for(int i = 1 ; i <= n ; i ++){
		if(s[i] == 'R'){
			nx++;
		}
		else if(s[i] == 'D'){
			ny--;
		}
		else if(s[i] == 'L'){
			nx--;
		}
		else{
			ny++;
		}
		pos[i] = {nx , ny};
	}
	map< pair<int,int> , set<int> >vis;
	for(int i = 0 ; i <= n ; i ++){
		vis[pos[i]].insert(i);
	}
	auto check = [&] (pair<int,int> p, int l ,int r){
		if(!vis.count(p)){
			return false;
		}
		else{
			auto it = vis[p].lower_bound(l);
			return it != vis[p].end() && *it <= r;
		}
	};
	//X' = POS[L - 1].X + (POS[R].X - X) 
	for(int i = 0 ; i < m ; i ++){
		int x , y , l , r;
		cin >> x >> y >> l >> r;
		if(check({x , y} , 0 , l - 1) || check({x , y} , r , n) || check({pos[l - 1].x + pos[r].x - x ,pos[l - 1].y + pos[r].y -  y} , l , r)){
			cout << "YES\n";
		}
		else{
			cout << "NO\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;
}

E - Collapsing Strings 

        题意：给你 n 个由小写拉丁字母组成的字符串 s1,s2,…,sn 。假设 |x| 是字符串 x

的长度。

假设两个字符串 a 和 b 的合并 C(a,b)

运算如下：

  • 如果 a为空，则 C(a,b)=b；
  • 如果 b为空，则 C(a,b)=a；
  • 如果 a的最后一个字母等于 b 的第一个字母，则 C(a,b)=C(a_{1 , |a|-1},b_{2 , |b|}) ，其中s_{l , r} 是 s 从 l字母到 r字母的子串；
  • 否则为 C(a,b)=a+b，即两个字符串的连接。

计算 \sum_{i = 1}^{n} \sum _{j = 1}^{n}|C(s_{i} , s_{j})|.

        思路：所有区间求和考虑定1求1，即枚举每个s_{j},考虑整体维护s_{i}的情况，整个过程中，我们需要记录的是满足s_{i}的后缀等于s_{j}的每个前缀子串的数量。最傻瓜的方法就是直接用字符串哈希（很容易被卡）来维护每个后缀的数量以及这些后缀所对应的字符串的总长度。然后再枚举每个s_{j}的前缀去逐一相加。

// Problem: E. Collapsing Strings
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/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'
#define int long long
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
const int M1 = 1e9 + 7;
const int B1 = 29;
const int M2 = 1e15 + 7;
const int B2 = 31;
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;
	}
}
LL get_hash1(LL pre , char c) {
  return (pre * B1 + (LL)(c - 'a' + 1)) % M1;
}
LL get_hash2(LL pre , char c){
  return (pre * B2 + (LL)(c - 'a' + 1)) % M2;	
}
map<pair<int,int>,int>cnt_r , r;
void solve() 
{
	cin >> n;
	string s[n + 5];
	int tot = 0;
	for(int i = 1 ; i <= n ; i ++)
		cin >> s[i];
	for(int i = 1 ; i <= n ; i ++){
		int len = s[i].size();
		tot += len;
		LL hash1 = 0;
		LL hash2 = 0;
		for(int j = len - 1 ; j >= 0 ; j --){
			hash1 = get_hash1(hash1 , s[i][j]);
			hash2 = get_hash2(hash2 , s[i][j]);
			cnt_r[{hash1 , hash2}]++;
			r[{hash1 , hash2}] += len;
		}
	}
	LL ans = 0;
	for(int i = 1 ; i <= n ; i ++){
		int len = s[i].size();
		int res = n;
		LL num = tot;//所有字符串中未被计算过的字符串总长度
		LL hash1 = 0;
		LL hash2 = 0;
		hash1 = get_hash1(hash1 , s[i][0]);
		hash2 = get_hash2(hash2 , s[i][0]);
		int pre = cnt_r[{hash1 , hash2}];
		int prer = r[{hash1 , hash2}];
		int t = res - pre;//字符串结尾与当前字符串开头不一样的个数
		LL ss = num - (prer);
		num -= ss;
		res -= t;
		ans += len * t + ss;
		int f = 1;
		for(int j = 0 ; j < len - 1; j ++){
			LL H1 = get_hash1(hash1 , s[i][j + 1]);
			LL H2 = get_hash2(hash2 , s[i][j + 1]);
			int npre;
			int nprer;
			if(!cnt_r.count({H1 , H2})){
				f = 0;
				npre = 0;
				nprer = 0;
			}
			else{
				npre = cnt_r[{H1 , H2}];
				nprer = r[{H1 , H2}];				
			}
			int t = pre - npre;
			LL ss = num - (nprer);
			ans += (len - j - 1) * t + ss - t * (j + 1);
			num -= ss;
			res -= t;
			if(!f)
			break;
			hash1 = H1;
			hash2 = H2;
			pre = npre;
			prer = nprer;
		}
		if(f)
		ans += r[{hash1 , hash2}] - cnt_r[{hash1,hash2}] * len;
	}
	cout << ans << endl;
}            
signed 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;
}

    傻瓜版本十分复杂，过程中我们会发现：要求不同字符串的总和非常困难，但是相反，对于相同字符串的统计非常简单，直接用map即可。因此考虑正难则反，先假设不考虑删字母的情况，然后去逐一删去相同字符。

// Problem: E. Collapsing Strings
// Contest: Codeforces - Educational Codeforces Round 159 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1902/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'
#define int long long
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
const int M1 = 1e9 + 7;
const int B1 = 29;
const int M2 = 1e15 + 7;
const int B2 = 31;
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;
	}
}
LL get_hash1(LL pre , char c) {
  return (pre * B1 + (LL)(c - 'a' + 1)) % M1;
}
LL get_hash2(LL pre , char c){
  return (pre * B2 + (LL)(c - 'a' + 1)) % M2;	
}
map<pair<int,int>,int>cnt_r , r;
void solve() 
{
	cin >> n;
	string s[n + 5];
	int tot = 0;
	for(int i = 1 ; i <= n ; i ++)
		cin >> s[i];
	for(int i = 1 ; i <= n ; i ++){
		int len = s[i].size();
		tot += len;
		LL hash1 = 0;
		LL hash2 = 0;
		for(int j = len - 1 ; j >= 0 ; j --){
			hash1 = get_hash1(hash1 , s[i][j]);
			hash2 = get_hash2(hash2 , s[i][j]);
			cnt_r[{hash1 , hash2}]++;
		}
	}
	LL ans = n * 2 *  tot;
	for(int i = 1 ; i <= n ; i ++){
		int len = s[i].size();
		LL hash1 = 0;
		LL hash2 = 0;
		for(int j = 0 ; j < len; j ++){
			hash1 = get_hash1(hash1 , s[i][j]);
			hash2 = get_hash2(hash2 , s[i][j]);
			if(cnt_r.count({hash1 , hash2})){
		//		cout << cnt_r[{hash1 , hash2}] << endl;
				ans -= 2 * cnt_r[{hash1 , hash2}];
			}
			else{
				break;
			}
		}
	}
	cout << ans << endl;
}            
signed 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;
}

发现只需要统计后缀的数量即可，再进一步可以用字典树来维护数量。

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

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

相关文章

分享74个节日PPT，总有一款适合您

分享74个节日PPT，总有一款适合您

分享74个节日PPT&#xff0c;总有一款适合您 74个节日PPT下载链接&#xff1a;https://pan.baidu.com/s/18YHKkyJsplx-Gjj7ofpFrg?pwd6666 提取码&#xff1a;6666 Python采集代码下载链接&#xff1a;采集代码.zip - 蓝奏云 学习知识费力气&#xff0c;收集整理更不易…
阅读更多...
机器学习---环境准备

机器学习---环境准备

一、pySpark环境准备 1、window配置python环境变量 window安装python&#xff0c;配置python环境变量。安装python后,在环境变量path中加入安装的路径&#xff0c;cmd中输入python&#xff0c;检验python是否安装成功。 注意&#xff1a;如果使用的是anaconda安装的python环境…
阅读更多...
【滑动窗口】长度最小的数组

【滑动窗口】长度最小的数组

长度最小的数组 长度最小的数组 文章目录 长度最小的数组题目描述解法暴力解法滑动窗口Java示例代码c示例代码 题目描述 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, num…
阅读更多...
若依微服务项目整合rocketMq

若依微服务项目整合rocketMq

原文链接&#xff1a;ttps://mp.weixin.qq.com/s/IYdo_suKvvReqCiEKjCeHw 第一步下载若依项目 第二步安装rocketMq&#xff08;推荐在linux使用docker部署比较快&#xff09; 第二步新建一个生产者模块儿&#xff0c;再建一个消费者模块 第四步在getway模块中配置接口映射规…
阅读更多...
【高效开发工具系列】gson入门使用

【高效开发工具系列】gson入门使用

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
HT4822 无输出隔直电容 立体声耳机放大器 中文资料

HT4822 无输出隔直电容 立体声耳机放大器 中文资料

HT4822是一款无需输出隔直电容的立体声耳机放大器。HT4822支持差分和单端的模拟信号输入。 HT4822在3.6V供电下&#xff0c;THDN 1%&#xff0c;32ohm负载时能提供80mW的输出。其具有低至0.007%的THDN。HT4822能在2.5V-6.0V电源条件下工作&#xff0c;具有过热保护和欠压保护等…
阅读更多...
微信公众号端在线客服系统源码 聊天记录云端实时保存 附带完整的搭建教程

微信公众号端在线客服系统源码 聊天记录云端实时保存 附带完整的搭建教程

随着社交媒体的普及&#xff0c;越来越多的用户通过微信公众号与企业进行沟通。因此&#xff0c;开发一款基于微信公众号的在线客服系统&#xff0c;可以帮助企业更好地服务用户&#xff0c;提高客户满意度。同时&#xff0c;为了解决聊天记录的存储和管理问题&#xff0c;我们…
阅读更多...
python自学之《艾伯特用Python做科学计算》(1)——(待完善)

python自学之《艾伯特用Python做科学计算》(1)——(待完善)

好吧&#xff0c;刚开始就打了一波而广告 啄木鸟社区的Python图书概览&#xff1a; http://wiki.woodpecker.org.cn/moin/PyBooks &#xff08;22/388&#xff09;
阅读更多...
python之pyqt专栏11-事件（QEvent）

python之pyqt专栏11-事件（QEvent）

QApplication.exec() 在main.py中&#xff0c;实例化app对象&#xff0c;然后在 sys.exit(app.exec())中调用app.exec()&#xff0c; if __name__ __main__:# 实例化应用app QApplication(sys.argv)# 实例化MyMainFormmyw MyMainForm()myw.show()# 启动应用程序的事件循环并…
阅读更多...
Android 手机的高级终端 Termux 安装使用、busybox、安卓 手机 web

Android 手机的高级终端 Termux 安装使用、busybox、安卓 手机 web

From&#xff1a;https://www.sqlsec.com/2018/05/termux.html Termux 高级终端安装使用配置教程 &#xff1a;https://www.cnblogs.com/cutesnow/p/11430833.html 神器Termux 的使用记录&#xff1a;https://cloud.tencent.com/developer/article/1609398 ​adb shell 下使用 …
阅读更多...
运维02：Linux

运维02：Linux

Linux安装 VMWare安装&#xff1a;夸克网盘分享&#xff08;提取码&#xff1a;refg&#xff09; CentOS安装&#xff1a;Index of /centos/7.9.2009/isos/x86_64/ Xshell安装&#xff1a;百度网盘 请输入提取码&#xff08;提取码&#xff1a;juau&#xff09; 环境准备 1、…
阅读更多...
构建满足流批数据质量监控用火山引擎DataLeap

构建满足流批数据质量监控用火山引擎DataLeap

更多技术交流、求职机会&#xff0c;欢迎关注字节跳动数据平台微信公众号&#xff0c;回复【1】进入官方交流群 面对今日头条、抖音等不同产品线的复杂数据质量场景&#xff0c;火山引擎 DataLeap 数据质量平台如何满足多样的需求&#xff1f;本文将介绍我们在弥合大数据场景下…
阅读更多...
IDA常用操作、快捷键总结以及使用技巧

IDA常用操作、快捷键总结以及使用技巧

先贴一张官方的图&#xff0c;然后我再总结一下&#xff0c;用的频率比较高的会做一些简单标注 快捷键 F系列【主要是调试状态的处理】 F2 添加/删除断点F4 运行到光标所在位置F5 反汇编F7 单步步入F8 单步跳过F9 持续运行直到输入/断点/结束 shift系列【主要是调出对应的页…
阅读更多...
完美解决：wget命令下载时遇到“错误 308：Permanent Redirect。”

完美解决：wget命令下载时遇到“错误 308：Permanent Redirect。”

目录 1 问题 2 解决方法 1 问题 使用wget命令下载时候遇到&#xff1a; --2023-12-02 20:36:08-- http://mirrors.jenkins.io/war-stable/latest/jenkins.war 正在解析主机 mirrors.jenkins.io (mirrors.jenkins.io)... 20.7.178.24, 2603:1030:408:5::15a 正在连接 mirror…
阅读更多...
西南科技大学模拟电子技术实验七（集成运算放大器的非线性应用）预习报告

西南科技大学模拟电子技术实验七（集成运算放大器的非线性应用）预习报告

一、计算/设计过程 说明：本实验是验证性实验，计算预测验证结果。是设计性实验一定要从系统指标计算出元件参数过程，越详细越好。用公式输入法完成相关公式内容，不得贴手写图片。（注意：从抽象公式直接得出结果，不得分，页数可根据内容调整） 预习计算内容根据运放的非线…
阅读更多...
酵母双杂交服务专题（四）

酵母双杂交服务专题（四）

关于酵母双杂交服务的常见问题 问题1&#xff1a;酵母双杂交的筛选流程&#xff1f; 研究者将特定基因作为钓饵&#xff0c;在一个精心挑选的cDNA文库中进行筛选&#xff0c;目的是找到与该钓饵蛋白发生相互作用的蛋白质。通过这种筛选&#xff0c;可以从阳性反应的酵母菌株中…
阅读更多...
Matlab 生成license

Matlab 生成license

参考下面两个帖子 https://ww2.mathworks.cn/matlabcentral/answers/389888-matlab https://www.mathworks.com/matlabcentral/answers/131749-id-id-id-id 登陆 https://ww2.mathworks.cn/licensecenter 针对R2020b版本,点击下面红框生成 ip addr | grep ether看第一行 根据…
阅读更多...
【每日OJ —— 110. 平衡二叉树】

【每日OJ —— 110. 平衡二叉树】

每日OJ —— 110. 平衡二叉树 1.题目&#xff1a;110. 平衡二叉树2.解法2.1.算法讲解2.2.代码实现2.3.提交通过展示 1.题目&#xff1a;110. 平衡二叉树 2.解法 2.1.算法讲解 1.这道题中的平衡二叉树的定义是&#xff1a;二叉树的每个节点的左右子树的高度差的绝对值不超过 11…
阅读更多...
python动态圣诞下雪图

python动态圣诞下雪图

运行图片 代码 import pygame import random# 初始化Pygame pygame.init()# 创建窗口 width, height 800, 600 screen pygame.display.set_mode((width, height)) pygame.display.set_caption(Christmas Tree)# 定义颜色 GREEN (34, 139, 34) RED (255, 0, 0) WHITE (255…
阅读更多...
YOLOv8创新魔改教程（二）如何添加注意力机制

YOLOv8创新魔改教程（二）如何添加注意力机制

YOLOv8创新魔改教程&#xff08;二&#xff09;如何添加注意力机制 &#xff08;一&#xff09;找代码 github找各种注意力机制的代码 &#xff08;二&#xff09;融合 1.创建文件 在ultralytics/nn/attention.py创建attention.py 文件 将找到的代码粘贴进来 2.修改task…
阅读更多...
最新文章

Copyright @ 2022~2023