第 3 场 小白入门赛（1~6） + 第 3 场 强者挑战赛 （1 ~ 5）

news2024/12/24 21:54:43

第 3 场 小白入门赛

1、厉不厉害你坤哥（暴力）

2、思维

3、暴力，前缀和，贪心

4、二分

5、DP

6、容斥，双指针

第 3 场 强者挑战赛

2、BFS

5、树上倍增求第k祖先

1. 召唤神坤

        题意：

可以发现,如果我们钦定练习生j,那么舞力值的(max(W_{1} , W_{2}...W_{j - 1}) +max(W_{j + 1} , W_{j + 2} ... W_{n})) / W_{j}。

因此对于j而言，需要知道前j - 1的最大值跟后j +1的最大值。可以通过数组来存前缀最大跟后缀最大。然后遍历每个j即可。

        

#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;
    int l[n + 5] ,r[n + 5];
    memset(l , 0 , sizeof l);
    memset(r , 0 , sizeof r);
    for(int i = 1 ; i <= n ; i ++){
        cin >> a[i];
    }
    for(int i = 1 ; i <= n ; i++){
        l[i] = max(l[i - 1] , a[i]);
    }
    for(int i = n ; i >= 1 ; i --){
        r[i] = max(r[i + 1] , a[i]);
    }
    int ans = 0;
    for(int i = 2 ; i < n ; i ++){
        ans = max(ans , (l[i - 1] + r[i + 1]) / a[i]);
    }
    cout << ans;
}            
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;
}

2. 聪明的交换策略 

        题意：

思路： 观察题意可以得出，最终的序列为连续的0 + 连续的1或者连续的1 + 连续的0。分别计算出两种情况所需要的交换数即可。

        

#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 < n ; i ++){
		a[i] = s[i] - '0';
	}
	int id = 0;
	int ans = 0;
	for(int i = 0 ; i < n ; i ++){
		if(a[i] == 1){
			ans += i - id;
			id++;
		}
	}
	id = n - 1;
	int ans1 = 0;
	for(int i = n - 1 ; i >= 0 ; i--){
		if(a[i] == 1){
			ans1 += id - i;
			id--;
		}
	}
	cout << min(ans , ans1);
}            
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;
}

3. 怪兽突击 

        题意：

        思路：好像跟cf上有道题差不多思路，假设当前将前i个怪兽全部击败一次,那么最终消耗的体力应当再加上min(a_{1} + b_{1} , a_{2} + b_{2} ..., a_{i} + b_{i}) * (k - i)。从前往后遍历所有的 i，然后取最小值即可。min(a_{1} + b_{1} , a_{2} + b_{2} ..., a_{i} + b_{i})可以在遍历的时候顺便更新了。

        

#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<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n >> m;
	vector<int>b(N , 0);
	vector<int>sum(N, 0);
	for(int i = 1 ; i <= n ; i ++)	{
		cin >> a[i];
		sum[i] = sum[i - 1] + a[i];
	}
	for(int i = 1 ; i <= n ; i ++){
		cin >> b[i];
	}
	int mi = 1e9;
	int ans = 1e18;
	for(int i = 1 ; i <= n ; i ++){
		mi = min(mi , a[i] + b[i]);
		int tmp = sum[i] + max(m - i , 0 * 1LL) * mi;
		ans = min(tmp , ans);
	}
	cout << ans;
}            
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;
}

4. 蓝桥快打 

        题意：

        思路：首先求出小蓝能够进攻多少次，然后再二分攻击力看能否击败小桥。

#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;
#define int long long
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() 
{
	int a , b , c;
	cin >> a >> b >> c;
	int t = (a - 1) / c + 1;
	auto check = [&](int x){
		if(x * t >= b){
			return true;
		}
		else{
			return false;
		}
	};
	int l = 1 , r = 1e9;
	while(l < r){
		int mid = (l + r) / 2;
		if(check(mid)){
			r = mid;
		}
		else{
			l = mid + 1;
		}
	}
	cout << l <<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;
}

5. 奇怪的段 

        题意：

        思路：观察到数据较小,可以考虑DP解决问题。 定义dp[i][j]表示前i个数，分成j段的最大权值和，于是发现第i个数必然放在第j段中。于是有状态转移方程：dp[i][j] = max(dp[i - 1][j] , dp[i - 1][j - 1]) + a[i] * p[j]。最后输出dp[n][k]即可，这道题就愉快的出来了。

#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;
#define int long long
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 dp[n + 5][m + 5];
	int p[m + 5];
	memset(dp , -0x3f , sizeof dp);
	dp[0][0] = 0;
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
	}	
	for(int i = 1 ;i <= m ; i ++){
		cin >> p[i];
	}
	for(int i = 1 ; i <= n ; i ++){
		for(int j = 1 ; j <= m ; j ++){
			dp[i][j] = max(dp[i - 1][j] , dp[i - 1][j - 1]) + a[i] * p[j];
		}
	}
	cout << dp[n][m];
}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
    while(t--)
    {
    	solve();
    }
    return 0;
}

6. 小蓝的反击 

        题意：

        思路：首先只考虑A的倍数的情况，可以发现：若区间[i , j]范围内的乘积是A的倍数，那么[i , j + 1]也必然是A的倍数，以此类推....也就是说，若钦定区间左端点 i ，可以找到最小的j，使得\prod _{x = i}^{j} a_{x}是A的倍数，那么左端点是i,满足题意的区间共有n - j + 1个。很容易想到：j随着i的增大也必然是越来越大的,因此用双指针来代表每个区间左端点 i 以及所对应的最小的j。将所有i都遍历完就是最终的满足A的倍数的区间总数。

       假设P（A）代表了A的倍数的区间总数。根据容斥原理，P(A \cap !B) = P(A) - P(A\cap B)，也就是P(A \cap !B) = P(A) - P(lcm(A , B)) , 因此分别把两个P求出来相减即可。

        

#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 = 1e06+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>num(N , 0);
vector<LL>prime;//存储素数
bool vis[N+5];
void su() 
{
	for(int i=2;i<=N;i++)
	{
		if(!vis[i])
		prime.pb(i);
		for(int j=0;j < (int)prime.size() && prime[j] * i <= N;j ++)
		{
			vis[prime[j]*i]=1;
			if(i % prime[j]==0)
			break;
		}
	}
} 

set<int>st;
vector<int>st_num;
int len;
int ans(int x){
	int maxx[len];
	int cnt[len];
	memset(cnt , 0 , sizeof cnt);
	memset(maxx , 0 , sizeof maxx);
	for(int i = 0 ; i < len ; i++){
		while(x % st_num[i] == 0){
			maxx[i]++;
			x /= st_num[i];
		}
	}
	int out = 0;
	int f = 1;
	for(int i = 0 , j = 0 ; i < n ; i ++){
		if(j <= i){
			memset(cnt , 0 , sizeof cnt);
			j = i;
			int tmp = num[j];
			for(int t = 0 ; t < len ; t ++){
				while(tmp % st_num[t] == 0){
					cnt[t]++;
					tmp /= st_num[t];
				}
			}			
			j++;
			f = 1;
		}
		for(int t = 0 ; t < len ; t ++){
			if(cnt[t] < maxx[t]){
				f = 0;
			}
		}
		while(j < n && !f){
			int tmp = num[j];
			for(int t = 0 ; t < len ; t ++){
				while(tmp % st_num[t] == 0){
					cnt[t]++;
					tmp /= st_num[t];
				}
			}
			f = 1;		
			for(int t = 0 ; t < len ; t ++){
				if(cnt[t] < maxx[t]){
					f = 0;
					break;
				}
			}
			j++;	
		}
		if(f){
			out += (n - j + 1);
		}
		int tmp = num[i];
		for(int t = 0 ; t < len ; t ++){
			while(tmp % st_num[t] == 0){
				cnt[t]--;
				tmp /= st_num[t];
			}
		}		
	}
	return out;
}
void solve() 
{
	int  a , b;
	cin >> n >> a >> b;
	int A = a , B = b;
	for(int i = 0 ; i < n ; i ++){
		cin >> num[i];
	}
	int t = prime.size();
	for(int i = 0 ; i < t ; i ++){
		while(a % prime[i] == 0){
			st.insert(prime[i]);
			a /= prime[i];
		}
	}	
	if(a > 1){
		st.insert(a);
	}
	for(int i = 0 ; i < t ; i ++){
		while(b % prime[i] == 0){
			st.insert(prime[i]);
			b /= prime[i];
		}
	}	
	if(b > 1){
		st.insert(b);
	}
	for(auto it : st){
		st_num.pb(it);
	}
	len = st_num.size();
	cout << ans(A) - ans(A * B / gcd(A , B))<< endl;

}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	su();
    int t=1;
	//cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

 2. 暖气冰场

        题意：

        思路：最短路/BFS,把所有格子第一次被暖气覆盖的时间求出来,然后求出所有时间的最大值即可。

#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;
#define int long long
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 vis[1010][1010];
int tx[8] = {-1 , 1 , -1 , 1 , 1 , -1 , 0 , 0};
int ty[8] = {-1 , 1 , 1 , -1 , 0 , 0 , 1 , -1};
void solve() 
{
	cin >> n >> m;
	int t;
	cin >> t;
	int mp[n + 5][m + 5];
	memset(mp , 0x3f , sizeof mp);
	queue<pair<int,int>>q;
	for(int i = 0 ; i < t ; i ++){
		int x , y;
		cin >> x >> y;
		mp[x][y] = 0;
		vis[x][y] = 1;
		q.push({x , y});
	}
	auto check = [&](int x , int y){
		return x >=1 && x <= n && y >= 1 && y <= m && vis[x][y] == 0;
	};
	int ans = 0;
	while(!q.empty()){
		auto it = q.front();
		q.pop();
		int x = it.first;
		int y = it.second;
		for(int i = 0 ; i < 8 ; i ++){
			int nx = x + tx[i];
			int ny = y + ty[i];
			if(check(nx , ny)){
				mp[nx][ny] = mp[x][y] + 1;
				vis[nx][ny] = 1; 
				q.push({nx , ny});
			}
		}
	}
	for(int i = 1 ; i <= n ; i ++){
		for(int j = 1 ;j <= m ; j++){
			ans = max(ans , mp[i][j]);
		}
	}
	cout << ans;
}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
    while(t--)
    {
    	solve();
    }
    return 0;
}

 5. 逃跑

        题意：

        思路：首先考虑小蓝位于节点x之上，且他只会往深度更深的地方走，那么最终小蓝能够坚持的时间为节点x所构成的子树的最大深度。假设这个最大深度为max\_dep[x]，他是可以通过一遍DFS求出来的。然后发现有max\_dep[x] \leq max\_dep[parent[x]]。因此对于一个起点x而言，小蓝需要先尽可能的往上走，因为越往上,其节点的max\_dep就越大。所以只需要考虑往上最多能走到哪个祖先y即可。然后得到max\_dep[y]即是起点x所能坚持的最长时间。

        参考倍增法求LCA的过程，求出每个节点的祖先情况即可。

        

#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 = 1e06+10;
const LL mod = 998244353;
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 dp[N][30];
struct HLD {//轻重链剖分
    int n;
    std::vector<int> siz, top, dep, parent, in, out, seq , max_dep;//子树大小 所在重链的顶部节点 深度 父亲 子树DFS序的起点 子树DFS序的终点
    std::vector<std::vector<int>> adj;
    int cur = 1;
    HLD() {}
    HLD(int n) {
        init(n);
    }
    void init(int n) {
        this->n = n;
        siz.resize(n);
        top.resize(n);
        dep.resize(n);
        parent.resize(n);
        in.resize(n);
        out.resize(n);
        seq.resize(n);
        max_dep.resize(n);
        cur = 0;
        adj.assign(n, {});
    }
    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    void work(int root = 1) {
        top[root] = root;
        dep[root] = 0;
        parent[root] = -1;
        dfs1(root);
        dfs2(root);
    }
    void dfs1(int u) {
        if (parent[u] != -1) {
            adj[u].erase(std::find(adj[u].begin(), adj[u].end(), parent[u]));
        }
        siz[u] = 1;
        for (auto &v : adj[u]) {
            parent[v] = u;
            dep[v] = dep[u] + 1;
            dfs1(v);
            siz[u] += siz[v];
            if (siz[v] > siz[adj[u][0]]) {
                std::swap(v, adj[u][0]);
            }
        }
    }
    void dfs2(int u) {
        in[u] = ++cur;
        max_dep[u] = dep[u];
        seq[in[u]] = u;
        for (auto v : adj[u]) {
            top[v] = v == adj[u][0] ? top[u] : v;
            dfs2(v);
            max_dep[u] = max(max_dep[u] , max_dep[v]);
        }
        out[u] = cur;
    }
    int lca(int u, int v) {
        while (top[u] != top[v]) {
            if (dep[top[u]] > dep[top[v]]) {
                u = parent[top[u]];
            } else {
                v = parent[top[v]];
            }
        }
        return dep[u] < dep[v] ? u : v;
    }
    void dfs3(){
    	for(int i = 1 ; i <= n - 5 ; i ++){
    		dp[i][0] = parent[i];
    	}
    	for(int i = 1 ; i <= n - 5; i ++){
	    	for(int j = 1 ; j < 30 ; j ++){
	    		if(dp[i][j - 1] < 1){
	    			continue;
	    		}
	    		dp[i][j] = dp[dp[i][j - 1]][j - 1];
	    	}
	    }
    }
    int find_an(int x , int y){
    	for(int i = 20 ; i >= 0 ; i--){
			int t = 1 << i;
			if(y >= t){
				x = dp[x][i];
				y -= t;
			}
    	}
    	return x;
    }
    int dist(int u, int v) {
        return dep[u] + dep[v] - 2 * dep[lca(u, v)];
    }
    
    int jump(int u, int k) {
        if (dep[u] < k) {
            return -1;
        }
        
        int d = dep[u] - k;
        
        while (dep[top[u]] > d) {
            u = parent[top[u]];
        }
        
        return seq[in[u] - dep[u] + d];
    }
    
    bool isAncester(int u, int v) {//是否为祖先
        return in[u] <= in[v] && in[v] < out[u];
    }
    
    int rootedParent(int u, int v) {
        std::swap(u , v);
        if (u == v) {
            return u;
        }
        if (!isAncester(u, v)) {
            return parent[u];
        }
        auto it = std::upper_bound(adj[u].begin(), adj[u].end(), v, [&](int x, int y) {
            return in[x] < in[y];
        }) - 1;
        return *it;
    }
    int rootedSize(int u, int v) {
        if (u == v) {
            return n;
        }
        if (!isAncester(v, u)) {
            return siz[v];
        }
        return n - siz[rootedParent(u, v)];
    }
    
    int rootedLca(int a, int b, int c) {
        return lca(a, b) ^ lca(b, c) ^ lca(c, a);
    }
}hld;
LL qpow(LL a , LL b)//快速幂
{
	LL sum=1;
	while(b){
		if(b&1){
			sum=sum*a%mod;
		}
		a=a*a%mod;
		b>>=1;
	}
	return sum;
}
void solve() 
{
	cin >> n;
	hld.init(n + 5);
	memset(dp , 0 ,sizeof dp);
	for(int i = 1 ; i < n ; i ++){
		int u , v;
		cin >> u >> v;
		hld.addEdge(u , v);
	}
	hld.work();
	hld.dfs3();
	int ans = 0;
	for(int i = 2 ; i <= n ; i ++){
		int t = hld.dep[i];
		if(t <= 2){
			ans += hld.max_dep[i];
		}
		else{
			int to = (t - 1) / 2;
			int an = hld.find_an(i , to);
			ans += hld.max_dep[an];
		}
	}
  ans %= mod;
	cout << (ans * qpow(n , mod - 2)) % mod<< 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;
}

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

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

相关文章

2023 IoTDB Summit：天谋科技高级开发工程师苏宇荣《汇其流：如何用 IoTDB 流处理框架玩转端边云融合》...

2023 IoTDB Summit：天谋科技高级开发工程师苏宇荣《汇其流：如何用 IoTDB 流处理框架玩转端边云融合》...

12 月 3 日&#xff0c;2023 IoTDB 用户大会在北京成功举行&#xff0c;收获强烈反响。本次峰会汇集了超 20 位大咖嘉宾带来工业互联网行业、技术、应用方向的精彩议题&#xff0c;多位学术泰斗、企业代表、开发者&#xff0c;深度分享了工业物联网时序数据库 IoTDB 的技术创新…
阅读更多...
Git相关3 —— 命令及添加Gitee的公钥

Git相关3 —— 命令及添加Gitee的公钥

1.Git相关命令1 -- 工作目录、暂存区、本地仓库、 使用平台有&#xff1a;cmd、Git bash、VSCode window系统修改VSCode默认终端为git bash git init 初始化 --- 新增.git 文件夹 git status 查看 文件/文件夹 状态 git add 需要追踪的文件名/文件夹名 提交到暂存区 git add…
阅读更多...
【JavaSE语法】图书管理系统实现详解

【JavaSE语法】图书管理系统实现详解

图片出处&#xff1a;The worlds biggest drone photo and video sharing platform | SkyPixel.com 导言 在学完JavaSE语法后&#xff0c;我们就可以去尝试写一个简单的图书管理系统来进一步提升我们面对对象编程的思想。在该系统中会涉及到数组&#xff0c;接口&#xff0c;封…
阅读更多...
OceanBase架构概览

OceanBase架构概览

了解一个系统或软件&#xff0c;比较好的一种方式是了解其架构&#xff0c;下图是官网上的架构图&#xff0c;基于V 4.2.1版本 OceanBase 使用通用服务器硬件&#xff0c;依赖本地存储&#xff0c;分布式部署在多个服务器上&#xff0c;每个服务器都是对等的&#xff0c;数据库…
阅读更多...
YOLOv8改进 | 注意力篇 | 实现级联群体注意力机制CGAttention (全网首发)

YOLOv8改进 | 注意力篇 | 实现级联群体注意力机制CGAttention (全网首发)

一、本文介绍 本文给大家带来的改进机制是实现级联群体注意力机制CascadedGroupAttention，其主要思想为增强输入到注意力头的特征的多样性。与以前的自注意力不同，它为每个头提供不同的输入分割，并跨头级联输出特征。这种方法不仅减少了多头注意力中的计算冗余，而且通过增…
阅读更多...
【国内访问github不稳定】可以尝试fastgithub解决这个问题

【国内访问github不稳定】可以尝试fastgithub解决这个问题

1、下载 https://github.com/dotnetcore/FastGithub https://github.com/dotnetcore/FastGithub/releases 官网下载即可&#xff0c;比如&#xff0c;我用的是这个&#xff1a;fastgithub_osx-x64.zip&#xff08;点这里下载&#xff09; 2、安装 如下图双击启动即可 3、…
阅读更多...
【SSM框架】SpringMVC

【SSM框架】SpringMVC

SpringMVC简介 SpringMVC概述 SpringMvC是一种基于Java实现MVC模型的轻量级web框架 SpringMVC技术与Servlet技术功能等同&#xff0c;用于表现层功能开发 SpringMVC入门 1、导入坐标 <dependency><groupId>javax.servlet</groupId><artifactId>ja…
阅读更多...
Docker安装Odoo17

Docker安装Odoo17

Docker安装Odoo 前言所需环境安装步骤登录Odoo 配置数据库 前言 Odoo是一个开源的ERP框架&#xff0c;它提供了一套完整的、可定制的、模块化的企业管理软件解决方案。以下是Odoo的主要特点&#xff1a; 模块化设计&#xff1a;Odoo的各个功能都以模块的形式提供&#xff0c;包…
阅读更多...
三端负电源电压调节器79LXX，具有一系列固定电压输出，适用于小于100mA电源供给的场合

三端负电源电压调节器79LXX，具有一系列固定电压输出，适用于小于100mA电源供给的场合

79LXX系列三端负电源电压调节器是单片双极型线性集成电路&#xff0c;采用TO92、SOT89-3的封装形式封装&#xff0c;有一系列固定的电压输出&#xff0c;适用于小于100mA电源供给的场合。 主要特点&#xff1a; 最大输出电流为100mA 固定输出电压分别为-5V、-6V、-8V、-9V、-10…
阅读更多...
Windows无法登录管理路由器故障排查

Windows无法登录管理路由器故障排查

问题描述 家里的路由器使用拨号上网&#xff0c;路由器DHCP分发IP的范围是192.168.1.0/24。默认使用192.168.1.1管理路由器。然后拨号上网成功后&#xff0c;修改了私网IP的分发范围&#xff1a;192.168.5.1-192.168.5.10。为了防止有人蹭网&#xff0c;只分配的10个IP地址。修…
阅读更多...
html5基础入门

html5基础入门

html5基础语法与标签 前言前端开发零基础入门介绍前端开发行业介绍&#xff1a;大前端时代&#xff1a;前端开发主要技术介绍学习方法IDE简介vscode快捷键&#xff1a; 总结 HTML语法与基础标签互联网基本原理HTTP协议&#xff08;请求、响应&#xff09;什么是前端、后端&…
阅读更多...
MongoDB认证考试小题库

MongoDB认证考试小题库

Free MongoDB C100DBA Exam Actual Questions 关于MongoDB C100 DBA 考试真题知识点零散整理 分片架构 应用程序 --> mongos --> 多个mongod对于应用来说&#xff0c;连接分片集群跟连接一台单机mongod服务器一样分片好处&#xff0c; 增加可用RAM、增加可用磁盘空间、…
阅读更多...
C++ 实现游戏（例如MC）键位显示

C++ 实现游戏（例如MC）键位显示

效果&#xff1a; 是不是有那味儿了&#xff1f; 显示AWSD&#xff0c;空格&#xff0c;Shift和左右键的按键情况以及左右键的CPS。 彩虹色轮廓&#xff0c;黑白填充。具有任务栏图标&#xff0c;可以随时关闭字体是Minecraft AE Pixel&#xff0c;如果你没有装&#xff08;大…
阅读更多...
网络安全技术新手入门：利用永恒之蓝获取靶机控制权限

网络安全技术新手入门：利用永恒之蓝获取靶机控制权限

目录 前言 一、搜索永恒之蓝可用模块 二、使用攻击模块 三、配置攻击模块 四、攻击 五、总结 前言 相关法律声明&#xff1a;《中华人民共和国网络安全法》第二十七条 任何个人和组织不得从事非法侵入他人网络、干扰他人网络正常功能、窃取网络数据等危害网络安全的活动&…
阅读更多...
网络安全技术新手入门：在docker上安装dvwa靶场

网络安全技术新手入门：在docker上安装dvwa靶场

前言 准备工作&#xff1a;1.已经安装好kali linux 步骤总览&#xff1a;1.安装好docker 2.拖取镜像&#xff0c;安装dvwa 一、安装docker 输入命令&#xff1a;sudo su 输入命令&#xff1a;curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key …
阅读更多...
MATLAB - 机器人关节空间运动模型

MATLAB - 机器人关节空间运动模型

系列文章目录 前言 关节空间运动模型描述了在闭环关节空间位置控制下机械手的运动&#xff0c;在关节空间运动模型&#xff08;jointSpaceMotionModel&#xff09;对象和关节空间运动模型块中使用。 机器人机械手是典型的位置控制设备。要进行关节空间控制&#xff0c;需要指…
阅读更多...
C# 图解教程 第5版 —— 第24章 预处理指令

C# 图解教程 第5版 —— 第24章 预处理指令

文章目录 24.1 什么是预处理指令24.2 基本规则24.3 符号指令&#xff08;#define、#undef &#xff09;24.4 条件编译&#xff08;#if、#else、#elif、#endif&#xff09;24.5 条件编译结构24.6 诊断指令&#xff08;#warning、#error&#xff09;24.7 行号指令&#xff08;#li…
阅读更多...
order by之后的injection(sqllabs第四十六关)

order by之后的injection(sqllabs第四十六关)

order by相关注入知识 这一关的sql语句是利用的order by 根据输入的id不同数据排序不一样可以确定就是order by order by后面无法使用ubion注入&#xff08;靠找不到&#xff09; 可以利用后面的参数进行攻击 1&#xff09;数字 没作用考虑布尔类型 rand和select ***都可以 …
阅读更多...
瑞幸黑金鹿王者霸屏尊享权益的技术实现方式探讨

瑞幸黑金鹿王者霸屏尊享权益的技术实现方式探讨

上周六&#xff0c;公司加班举办技术专场招聘活动&#xff0c;在忙碌的下午茶歇时间&#xff0c;我尊敬的伟大的韩百万老师提议带着我去瑞幸装了个 BI&#xff0c;扫码领取咖啡的那一个瞬间&#xff0c;瑞幸店内的电视大屏上赫然显示了&#xff1a;韩百万。回来的路上我虚心请教…
阅读更多...
gem5学习（14）：将gem5扩展到ARM——Extending gem5 for ARM

gem5学习（14）：将gem5扩展到ARM——Extending gem5 for ARM

目录 一、Downloading ARM Binaries 二、Building gem5 to run ARM Binaries 三、Modifying simple.py to run ARM Binaries 四、Running gem5 五、ARM Full System Simulation An aside on FS simulations 这个是gem5-learning中Getting Started的最后一篇文章&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023