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

第 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;
}

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

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

相关文章

Python Flask教程

Python Flask教程

Flask Doc: https://rest-apis-flask.teclado.com/docs/course_intro/what_is_rest_api/Github: https://github.com/tecladocode/rest-apis-flask-python 1. 最简单的应用 最小应用 from flask import Flaskapp Flask(__name__)app.route("/") def hello_world()…
阅读更多...
“华为杯“第四届中国研究生数学建模竞赛-D题：邮路规划与邮车调度

“华为杯“第四届中国研究生数学建模竞赛-D题：邮路规划与邮车调度

目录 摘 要&#xff1a; 1.问题的重述 2.模型的假设与符号说明 2.1 针对本问题&#xff0c;本文做出如下假设 2.2 符号说明 3.问题的数学模型 4.问题的求解 4.1 问题一的求解 4.1.1 最少邮车数的求法 4.1.2 邮路规划及路径选择 4.1.3 问题的求解结果 4.2 问题二的求…
阅读更多...
记录下载安装rabbitmq（Linux） 并整合springboot--详细版（全）

记录下载安装rabbitmq（Linux） 并整合springboot--详细版（全）

下载rabbitmq&#xff08;Linux&#xff09;&#xff1a; erlang压缩包&#xff1a; https://share.weiyun.com/TGhfV8eZ rabbitMq-server压缩包&#xff1a; https://share.weiyun.com/ZXbUwWHD &#xff08;因为RabbitMQ采用 Erlang 实现的工业级的消息队列(MQ)服务器&#…
阅读更多...
推荐一款.NET开发的物联网开源项目

推荐一款.NET开发的物联网开源项目

物联网&#xff08;IoT&#xff09;是一个正在快速发展的技术领域&#xff0c;它涉及到各种设备、物体和系统的互联。所以各种物联网平台和物联网网关项目层出不穷&#xff0c;在物联网&#xff08;IoT&#xff09;领域&#xff0c;.NET平台扮演着重要的角色。作为一款广泛使用…
阅读更多...
备战抖音商城好物年货节，品牌焕发新商机

备战抖音商城好物年货节，品牌焕发新商机

农历春节前的最后一个月&#xff0c;打工人们逐渐将置办年货提上日程。忙碌了一年的辛苦与疲惫&#xff0c;总能在喜气洋洋买年货的过程中&#xff0c;被一扫而空。这是“年味”的开始&#xff0c;也是公司高管郭广宇面临的一场关键战役。 郭广宇今年35岁&#xff0c;是三只松鼠…
阅读更多...
强化学习应用（八）：基于Q-learning的无人机物流路径规划研究（提供Python代码）

强化学习应用（八）：基于Q-learning的无人机物流路径规划研究（提供Python代码）

一、Q-learning简介 Q-learning是一种强化学习算法&#xff0c;用于解决基于马尔可夫决策过程&#xff08;MDP&#xff09;的问题。它通过学习一个价值函数来指导智能体在环境中做出决策&#xff0c;以最大化累积奖励。 Q-learning算法的核心思想是通过不断更新一个称为Q值的…
阅读更多...
uni-app做A-Z排序通讯录、索引列表

uni-app做A-Z排序通讯录、索引列表

上图是效果图&#xff0c;三个问题 访问电话通讯录&#xff0c;拿数据拿到用户的联系人数组对象&#xff0c;之后根据A-Z排序根据字母索引快速搜索 首先说数据怎么拿 - 社区有指导https://ask.dcloud.net.cn/question/64117 uniapp 调取通讯录 // #ifdef APP-PLUSplus.contac…
阅读更多...
【深度学习目标检测】十六、基于深度学习的麦穗头系统-含GUI和源码（python，yolov8）

【深度学习目标检测】十六、基于深度学习的麦穗头系统-含GUI和源码（python，yolov8）

全球麦穗检测是植物表型分析领域的一个挑战&#xff0c;主要目标是检测图像中的小麦麦穗。这种检测在农业领域具有重要意义&#xff0c;可以帮助农民评估作物的健康状况和成熟度。然而&#xff0c;由于小麦麦穗在视觉上具有挑战性&#xff0c;准确检测它们是一项艰巨的任务。 全…
阅读更多...
DP读书：《openEuler操作系统》（八）TCP、UDP与跨机器通讯

DP读书：《openEuler操作系统》（八）TCP、UDP与跨机器通讯

10min速通TCP与UDP 2024 DP读书计算机网络简介TCP/IP协议栈A. 物理层1.信号及信道传递2.信号调制与调解3.信道的复用 B. 数据链路层1.封装成帧2.透明传输3.差错控制 C. 网络层1.IP2.ARP3.路由选择协议 D. 传输层1.端口号2.3.UDP 2024 DP读书 第八章 跨机器通讯 在第六章之中&a…
阅读更多...
翻译: Streamlit从入门到精通 基础控件 一

翻译: Streamlit从入门到精通 基础控件 一

这个关于Streamlit的教程旨在帮助数据科学家或机器学习工程师&#xff0c;他们不是网络开发者&#xff0c;也不想花费数周时间学习使用这些框架来构建网络应用程序。 1. 什么是Streamlit&#xff1f; Streamlit是一个免费且开源的框架&#xff0c;用于快速构建和共享美观的机器…
阅读更多...
（南京观海微电子）——色温介绍

（南京观海微电子）——色温介绍

色温是表示光线中包含颜色成分的一个计量单位。从理论上说&#xff0c;黑体温度指绝对黑体从绝对零度&#xff08;&#xff0d;273℃&#xff09;开始加温后所呈现的颜色。黑体在受热后&#xff0c;逐渐由黑变红&#xff0c;转黄&#xff0c;发白&#xff0c;最后发出蓝色光。当…
阅读更多...
【MCAL】MCU模块详解

【MCAL】MCU模块详解

目录 前言 正文 1. MCU模块介绍 2. MCU依赖的模块 3. MCU模块提供服务 3.1 时钟的初始化 3.2 MCU模式的配置 3.3 MCU软件复位功能 3.4 RAM的初始化 4.MCU重要数据类型 4.1 Mcu_ResetType 4.2 Mcu_ModeType 5. MCU重要API 5.1 Mcu_Init 5.2 Mcu_InitClock 5.3 M…
阅读更多...
qayrup-switch开发文档

qayrup-switch开发文档

因为只是一个小组件,所以直接拿csdn当开发文档了 书接上文uniapp怎么开发插件并发布 : https://blog.csdn.net/weixin_44368963/article/details/135576511 因为我业没有开发过uniapp的组件,所以我看到下面这个文件还是有点懵的 也不清楚怎么引入, 然后去翻了翻官方文档,官方…
阅读更多...
Java设计模式-备忘录模式

Java设计模式-备忘录模式

备忘录模式 一、概述二、结构三、案例实现&#xff08;一&#xff09;“白箱”备忘录模式&#xff08;二&#xff09;“黑箱”备忘录模式 四、优缺点五、使用场景 一、概述 备忘录模式提供了一种状态恢复的实现机制&#xff0c;使得用户可以方便地回到一个特定的历史步骤&…
阅读更多...
系列七、Spring Security中基于Jdbc的用户认证 授权

系列七、Spring Security中基于Jdbc的用户认证 授权

一、Spring Security中基于Jdbc的用户认证 & 授权 1.1、概述 前面的系列文章介绍了基于内存定义用户的方式&#xff0c;其实Spring Security中还提供了基于Jdbc的用户认证 & 授权&#xff0c;再说基于Jdbc的用户认证 & 授权之前&#xff0c;不得不说一下Spring Se…
阅读更多...
[Vue]从数据库中动态加载阿里巴巴矢量图标的两种方式

[Vue]从数据库中动态加载阿里巴巴矢量图标的两种方式

记录一次在Vue中动态使用阿里巴巴矢量图标库 这是本人第一次使用阿里巴巴的矢量图标库&#xff0c;简单的导入和使用的话网上的教程很多&#xff0c;这里不多赘述&#xff0c;本人的需求是从数据库中加载出来并且显示到页面上&#xff0c;接下来简述一下如何实现。 以下代码均是…
阅读更多...
【非监督学习 02】高斯混合模型

【非监督学习 02】高斯混合模型

高斯混合模型&#xff08;Guassian Mixed Model, GMM&#xff09;也是一种常见的聚类算法&#xff0c;与K均值算法类似&#xff0c;同样使用了EM算法进行迭代计算。高斯混合模型假设每个簇的数据都是符合高斯分布的&#xff0c;当前数据呈现的分布就是各个簇的高斯分布叠加在一…
阅读更多...
QT通过QPdfWriter类实现pdf文件生成与输出

QT通过QPdfWriter类实现pdf文件生成与输出

一.QPdfWriter类介绍 本文代码工程下载地址&#xff1a; https://download.csdn.net/download/xieliru/88736664?spm1001.2014.3001.5503 QPdfWrite是一个用于创建PDF文件的类&#xff0c;它是Qt库的一部分。它提供了一些方法和功能&#xff0c;使您能够创建和写入PDF文件。…
阅读更多...
极简Oracle 11g Release 2 (11.2.0.1.0)

极简Oracle 11g Release 2 (11.2.0.1.0)

注意&#xff1a;此法无法安装oracle11g(11.2.0.4)&#xff0c;会报如下错&#xff1a; [FATAL] [INS-10105] The given response file /assets/db_install.rsp is not valid. 一、下载解压ORACLE安装包。 从 oracle 官网 下载所需要的安装包&#xff0c;这里我们以 oracle 11…
阅读更多...
113.QT中的信号槽

113.QT中的信号槽

目录 一、信号和槽概述 信号和槽的基本概念&#xff1a; 信号和槽的关系&#xff1a; 二、标准信号槽使用 三、自定义信号槽的使用 自定义信号&#xff1a; 自定义槽&#xff1a; 四、Lambda表达式 1.Lambda 表达式不带参数和返回值&#xff1a; 2.Lambda 表达式带参…
阅读更多...
最新文章

Copyright @ 2022~2023