SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）(A~F)（最爱线段树的一集）

news2024/11/26 20:30:18

A - Sanitize Hands

        题意：

        模拟

// Problem: A - Sanitize Hands
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_a
// Memory Limit: 1024 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() 
{
	int n , m;
	cin >> n >> m;
	for(int i = 0 ; i < n ; i++){
		cin >> a[i];
	}	
	int cnt = 0;
	for(int i = 0 ; i < n ; i ++){
		if(m >= a[i]){
			cnt ++;
			m -= a[i];
		}
		else{
			m = 0;
		}
	}
	cout << cnt << 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 - Uppercase and Lowercase

        题意：

        还是模拟

// Problem: B - Uppercase and Lowercase
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_b
// Memory Limit: 1024 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() 
{
	int cnt1 = 0;
	string s;
	cin >> s;	
	for(auto c : s){
		if(c >= 'a' && c <= 'z'){
			cnt1++;
		}
	}
	if(cnt1 * 2 > s.size()){
		for(auto c : s){
			if(c >= 'a' && c <= 'z'){
				cout << c;
			}
			else{
				cout << (char)(c + 32);
			}
		}
	}
	else{
		for(auto c : s){
			if(c >= 'a' && c <= 'z'){
				cout << (char)(c - 32);
			}
			else{
				cout << (char)c;
			}
		}		
	}
}            
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 - Sierpinski carpet 

题意：

依旧是模拟..不知道前排大佬怎么能写这么快的

// Problem: C - Sierpinski carpet
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_c
// Memory Limit: 1024 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;
	}
}
vector<vector<string>>v(7 , vector<string>(10101));
void solve() 
{
	int n;
	cin >> n;
	for(int i = 1 ; i <= (int)pow(3 , n) ; i ++){
		cout << v[n][i] <<endl;
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	int t = 1;
	v[0][1] = '#';
	for(int i = 1 ; i < 7 ; i ++){
		int pre = (int)pow(3 , i - 1);
		for(int j = 1 ; j <= 3 * pre ; j ++){
			if((j - 1) / pre != 1){
				for(int t = 0 ; t < 3 ; t ++){
					v[i][j] += v[i - 1][(j - 1) % pre + 1];				
				}
			}
			else{
				v[i][j] += v[i - 1][(j - 1) % pre + 1];
				for(int t = 0 ; t < pre ; t ++){
					v[i][j] += '.';
				}
				v[i][j] += v[i - 1][(j - 1) % pre + 1];
			}
		}
	}
    while(t--)
    {
    	solve();
    }
    return 0;
}

 

D - 88888888

        

思路：将答案拆成加和的形式：假设N的位数为x，那么最终答案为n +n * pow(10 , x)+n*pow(10,2 * x)...n * pow(10 ,( n - 1) * x),然后可以将 N提出来之后，其余的是一个等比数列，因此有等比数列求和公式将答案化简为：n * (pow(10 , n * x) - 1 )/( pow(10 ,x ) -1)

注意n*x可能爆longlong

// Problem: D - 88888888
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_d
// Memory Limit: 1024 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 = 998244353;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
#define int unsigned 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;
	}
}
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;
	int tmp = n;
	int len = 0;
	while(tmp){
		len ++;
		tmp /= 10;
	}
	int t = n % mod;
	int fenzi = qpow(qpow(10 , n) , len) - 1 + mod;
	fenzi %= mod;
	int bei = qpow(10 , len) - 1 + mod;
	int tbei = qpow(bei , mod - 2);
	int ans = t;
	t *= fenzi;
	t %= mod;
	t *= tbei;
	t %= mod;
	cout << t;
}            
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;
}

 

E - Reachability in Functional Graph

        题意：

        思路：将有向图通过SCC缩点形成一个有向无环图（DAG）, 然后思考答案：同一个强连通分量的点两两互相连通，然后与该连通分量相连的所有点与该连通分量上的所有点相连通，因此本题变成了DAG图上DP，直接逆拓扑序走一遍。考虑单独存储每一个强连通分量上的点，与能够连接到该连通分量上的点即可。 （SCC知识快忘记的差不多了..只记得bel从大到小就是逆拓扑序）

// Problem: E - Reachability in Functional Graph
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_e
// Memory Limit: 1024 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;
#define int long long
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;
	}
}
struct SCC {
    int n;
    std::vector<std::vector<int>> adj;//邻边
    std::vector<int> stk;//存储同一个SCC
    std::vector<int> dfn, low, bel;//dfn : dfs的时间戳 low : 子树能跳到的最上方的点 bel : 结点位于哪块强连通分量上 
    int cur, cnt;
    
    SCC() {}
    SCC(int n) {
        init(n);
    }
    
    void init(int n) {
        this->n = n;
        adj.assign(n, {});
        dfn.assign(n, -1);
        low.resize(n);
        bel.assign(n, -1);
        stk.clear();
        cur = cnt = 0;
    }
    
    void addEdge(int u, int v) {
        adj[u].push_back(v);
    }
    
    void dfs(int x) {
        dfn[x] = low[x] = cur++;
        stk.push_back(x);
        
        for (auto y : adj[x]) {
            if (dfn[y] == -1) {
                dfs(y);
                low[x] = std::min(low[x], low[y]);
            } else if (bel[y] == -1) {
                low[x] = std::min(low[x], dfn[y]);
            }
        }
        
        if (dfn[x] == low[x]) {
            int y;
            do {
                y = stk.back();
                bel[y] = cnt;
                stk.pop_back();
            } while (y != x);
            cnt++;
        }
    }
    
    std::vector<int> work() {
        for (int i = 0; i < n; i++) {
            if (dfn[i] == -1) {
                dfs(i);
            }
        }
        return bel;
    }
};

void solve() 
{
	int n;
	cin >> n;
	SCC scc(n + 5);
	for(int i = 1 ; i <= n ; i ++){
		int x;
		cin >> x;
		if(x != i){
			scc.addEdge(i , x);
		}
	}
	vector<int>t = scc.work();
	vector<int>dp(n + 5 , 0);
	vector<int>cnt(n + 5 , 0);
	vector<int>chan[n + 5];
	int ma = -1;
	for(int i = 1; i <= n ; i ++){
		//cout << t[i] << endl;
		cnt[t[i]]++;
		chan[t[i]].pb(i);
		ma = max(ma , t[i]);
	}
	int ans = 0;
	vector<int>vis(n + 5, 0);
	for(int i = ma ; i >= 1 ; i --){
		int tmp = cnt[i];
		ans += cnt[i] * cnt[i];
		ans += dp[i] * cnt[i];
		cnt[i] += dp[i];
		vector<int>path;
		for(auto it : chan[i]){
			int next;
			if(scc.adj[it].size() != 0){
				next = scc.adj[it][0];
			}
			else{
				continue;
			}
			int belo = scc.bel[next];
			if(!vis[belo]){
				path.pb(belo);
				vis[belo] = 1;
				dp[belo] += cnt[i];
			}
		}
		for(auto it : path){
			vis[it] = 0;
		}
	}
	//cout << cnt[3] << endl;
	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;
}

F - Two Sequence Queries 

        题意：

        思路：很明显的线段树题目（在这几天做的题里面算简单的了）。一个区间需要维护的信息有：区间点的个数（act）、区间中A数组的和（asum）、区间中B数组的和（bsum）、以及区间A*B的和（tot）。区间合并非常简单，全部相加即可。主要考虑tag怎么设置，可以发现，若区间A都加上X，那么其asum += act * X ， tot += bsum * X。反之B区间也是一样。然后本题就完成了

        

// Problem: F - Two Sequence Queries
// Contest: AtCoder - SuntoryProgrammingContest2024（AtCoder Beginner Contest 357）
// URL: https://atcoder.jp/contests/abc357/tasks/abc357_f
// Memory Limit: 1024 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 int long long
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
#define i64 long long
const LL mod =  998244353;
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;
}
template<class Info, class Tag>
struct LazySegmentTree {
    const int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LazySegmentTree(int n) : n(n), info(4 << std::__lg(n)), tag(4 << std::__lg(n)) {}
    LazySegmentTree(std::vector<Info> init) : LazySegmentTree(init.size()) {
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag &v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag &v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    void half(int p, int l, int r) {
        if (info[p].act == 0) {
            return;
        }
        if ((info[p].min + 1) / 2 == (info[p].max + 1) / 2) {
            apply(p, {-(info[p].min + 1) / 2});
            return;
        }
        int m = (l + r) / 2;
        push(p);
        half(2 * p, l, m);
        half(2 * p + 1, m, r);
        pull(p);
    }
    void half() {
        half(1, 0, n);
    }
};
struct Tag {
    i64 adda = 0;
    i64 addb = 0;
    void apply(Tag t) {
        adda += t.adda;
        adda %= mod;
        addb += t.addb;
        addb %= mod;
    }
};
struct Info {
	int asum = 0;
	int bsum = 0;
	int tot = 0;
    int act = 0;
    void apply(Tag t) {
		asum += (t.adda * act) % mod;
		asum %= mod;
		tot += (bsum * t.adda) % mod;
		tot %= mod;
		bsum += (t.addb * act) % mod;
		bsum %= mod;
		tot += ((asum % mod) *( t.addb % mod)) % mod;
		tot %= mod;
    }
};
Info operator + (Info a, Info b) {
    Info c;
	c.asum = a.asum + b.asum;
	c.asum %= mod;
    c.bsum = a.bsum + b.bsum;
    c.bsum %= mod;
    c.act = a.act + b.act;
    c.act %= mod;
    c.tot = a.tot + b.tot;
    c.tot %= mod;
    return c;
}
void solve() 
{
	int n , m;
	cin >> n >> m;
	vector<Info>v(n);
	for(int i = 0 ; i < n ; i ++){
		cin >> v[i].asum;
	}
	for(int i = 0 ; i < n ; i ++){
		cin >> v[i].bsum;
	}
	for(int i = 0 ; i < n ; i ++){
		v[i].act = 1;
		v[i].tot = v[i].asum * v[i].bsum;
		v[i].tot %= mod;
	}
	LazySegmentTree <Info , Tag> seg(v);
	for(int i = 0 ; i < m; i ++){
		int op;
		cin >> op;
		if(op == 1){
			int l , r , x;
			cin >> l >> r >> x;
			Tag tmp;
			tmp.adda = x;
			seg.rangeApply(l - 1 , r , tmp);
		}
		else if(op == 2){
			int l , r , x;
			cin >> l >> r >>x;
			Tag tmp;
			tmp.addb = x;
			seg.rangeApply(l - 1 , r , tmp);
		}
		else{
			int l , r;
			cin >> l >> r;
			cout << seg.rangeQuery(l - 1 , r).tot << 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/1803214.html

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

相关文章

【python报错】TypeError: ‘dict_values‘ Object IsNot Subscriptable

【python报错】TypeError: ‘dict_values‘ Object IsNot Subscriptable

【Python报错】TypeError: ‘dict_values’ object is not subscriptable 在Python中&#xff0c;字典&#xff08;dict&#xff09;提供了几种不同的视图对象&#xff0c;包括dict_keys、dict_values和dict_items。这些视图对象允许你以只读方式遍历字典的键、值或键值对。如果…
阅读更多...
30-unittest生成测试报告（HTMLTestRunner插件）

30-unittest生成测试报告（HTMLTestRunner插件）

批量执行完测试用例后&#xff0c;为了更好的展示测试报告&#xff0c;最好是生成HTML格式的。本文使用第三方HTMLTestRunner插件生成测试报告。 一、导入HTMLTestRunner模块 这个模块下载不能通过pip安装&#xff0c;只能下载后手动导入&#xff0c;下载地址是&#xff1a;ht…
阅读更多...
Elasticsearch之写入原理以及调优

Elasticsearch之写入原理以及调优

1、ES 的写入过程 1.1 ES支持四种对文档的数据写操作 create&#xff1a;如果在PUT数据的时候当前数据已经存在&#xff0c;则数据会被覆盖&#xff0c;如果在PUT的时候加上操作类型create&#xff0c;此时如果数据已存在则会返回失败&#xff0c;因为已经强制指定了操作类型…
阅读更多...
vue ts 导入 @/assets/ 红色显示的问题解决

vue ts 导入 @/assets/ 红色显示的问题解决

vue ts 导入 /assets/ 红色显示的问题解决 一、问题描述 在使用的时候这样导入会出现如上的错误。 在使用的时候&#xff0c;导入的类型也没有对应的代码提示&#xff0c;说明导入有问题。 二、解决 在 tsconfig.json 中添加如下内容&#xff1a; {"compilerOptions&…
阅读更多...
【机器学习】因TensorFlow所适配的numpy版本不适配，用anaconda降低numpy的版本

【机器学习】因TensorFlow所适配的numpy版本不适配，用anaconda降低numpy的版本

目录 0 TensorFlow最高支持的numpy版本 1 激活你的环境&#xff08;如果你正在使用特定的环境&#xff09; 2 查找可用的NumPy版本 3 安装特定版本的NumPy 4. 验证安装 5.&#xff08;可选&#xff09;如果你更改了base环境 0 TensorFlow最高支持的numpy版本 要使用 …
阅读更多...
pytorch 笔记：pytorch 优化内容（更新中）

pytorch 笔记：pytorch 优化内容（更新中）

1 Tensor创建类 1.1 直接创建Tensor&#xff0c;而不是从Python或Numpy中转换 不要使用原生Python或NumPy创建数据&#xff0c;然后将其转换为torch.Tensor直接用torch.Tensor创建或者直接&#xff1a;torch.empty(), torch.zeros(), torch.full(), torch.ones(), torch.…
阅读更多...
关于python中的关键字参数

关于python中的关键字参数

在python语言中存在两种传参方式&#xff1a; 第一种是按照先后顺序来传参&#xff0c;这种传参风格&#xff0c;称为“位置参数”这是各个编程语言中最普遍的方式。 关键字传参~按照形参的名字来进行传参&#xff01; 如上图所示&#xff0c;在函数中使用关键字传参的最大作…
阅读更多...
MySQL-备份（三）

MySQL-备份（三）

备份作用&#xff1a;保证数据的安全和完整。 一 备份类别 类别物理备份 xtrabackup逻辑备份mysqldump对象数据库物理文件数据库对象&#xff08;如用户、表、存储过程等&#xff09;可移植性差&#xff0c;不能恢复到不同版本mysql对象级备份&#xff0c;可移植性强占用空间占…
阅读更多...
为什么说组合优于继承？

为什么说组合优于继承？

在编程中&#xff0c;继承和组合是用于在面向对象语言中设计和构建类和对象的两种基本技术。 继承&#xff0c;它允许一个类&#xff08;称为派生类或子类&#xff09;从另一个类&#xff08;称为基类或超类&#xff09;继承属性和行为。换句话说&#xff0c;子类“是”超类的…
阅读更多...
独立游戏之路 -- 获取OAID提升广告收益

独立游戏之路 -- 获取OAID提升广告收益

Unity 之 获取手机&#xff1a;OAID、IMEI、ClientId、GUID 前言一、Oaid 介绍1.1 Oaid 说明1.2 移动安全联盟(MSA) 二、站在巨人的肩膀上2.1 本文实现参考2.2 本文实现效果2.3 本文相关插件 三、Unity 中获取Oaid3.1 查看实现源码3.2 工程配置3.3 代码实现3.4 场景搭建 四、总…
阅读更多...
编译和运行qemu-uboot-arm64单板的Armbian系统

编译和运行qemu-uboot-arm64单板的Armbian系统

这篇文章ARM虚拟机安装OMV-CSDN博客遗留一个启动qemu-uboot-arm64单板Armbian镜像的问题&#xff0c;使用官方下载的镜像&#xff0c;会报错&#xff1a; fatal: no kernel available .... Failed to load /vmlinuz ...... qemu-system-aarch64 -smp 8 -m 8G -machine virt …
阅读更多...
搭建多平台比价系统需要了解的电商API接口？

搭建多平台比价系统需要了解的电商API接口？

搭建一个多平台比价系统涉及多个步骤&#xff0c;以下是一个大致的指南&#xff1a; 1. 确定需求和目标 平台选择&#xff1a;确定你想要比较价格的平台&#xff0c;例如电商网站、在线旅行社等。数据类型&#xff1a;明确你需要收集哪些数据&#xff0c;如产品价格、产品名称…
阅读更多...
苹果手机微信如何直接打印文件

苹果手机微信如何直接打印文件

在快节奏的工作和生活中&#xff0c;打印文件的需求无处不在。但你是否曾经遇到过这样的困扰&#xff1a;打印店价格高昂&#xff0c;让你望而却步&#xff1f;今天&#xff0c;我要给大家介绍一款神奇的微信小程序——琢贝云打印&#xff0c;让你的苹果手机微信直接变身移动打…
阅读更多...
二叉树的实现（初阶数据结构）

二叉树的实现（初阶数据结构）

1.二叉树的概念及结构 1.1 概念 一棵二叉树是结点的一个有限集合&#xff0c;该集合&#xff1a; 1.或者为空 2.由一个根结点加上两棵别称为左子树和右子树的二叉树组成 从上图可以看出&#xff1a; 1.二叉树不存在度大于2的结点 2.二叉树的子树有左右之分&#xff0c;次序不能…
阅读更多...
后端启动项目端口冲突问题解决

后端启动项目端口冲突问题解决

后端启动项目端口冲突 原因&#xff1a; Vindows Hyper-V虚拟化平台占用了端口。 解决方案一&#xff1a; 查看被占用的端口范围&#xff0c;然后选择一个没被占用的端口启动项目。netsh interface ipv4 show excludedportrange protocoltcp 解决方案二&#xff1a; 禁用H…
阅读更多...
调试环境搭建（Redis 6.X 版本）

调试环境搭建（Redis 6.X 版本）

今儿&#xff0c;我们来搭建一个 Redis 调试环境&#xff0c;目标是&#xff1a; 启动 Redis Server &#xff0c;成功断点调试 Server 的启动过程。使用 redis-cli 启动一个 Client 连接上 Server&#xff0c;并使用 get key 指令&#xff0c;发起一次 key 的读取。 视频可见…
阅读更多...
鸿蒙状态管理-@Builder自定义构建函数

鸿蒙状态管理-@Builder自定义构建函数

Builder 将重复使用的UI元素抽象成一个方法 在build方法里调用 使其成为 自定义构建函数 Entry Component struct BuilderCase {build() {Column(){Row(){Text("西游记").fontSize(20)}.justifyContent(FlexAlign.Center).backgroundColor("#f3f4f5").hei…
阅读更多...
技术革命的十年：计算机、互联网、大数据、云计算与AI

技术革命的十年：计算机、互联网、大数据、云计算与AI

近10年来&#xff0c;计算机、互联网、大数据、云计算和人工智能等技术领域发展迅速&#xff0c;带来了巨大的变革和创新。以下是各个领域的发展历史、现状、问题瓶颈、未来趋势以及可能的奇点。 计算机技术&#xff1a; 发展历史&#xff1a; 过去&#xff1a;过去十年间&am…
阅读更多...
SpringBoot+Vue学生作业管理系统【附：资料➕文档】

SpringBoot+Vue学生作业管理系统【附：资料➕文档】

前言&#xff1a;我是源码分享交流Coding&#xff0c;专注JavaVue领域&#xff0c;专业提供程序设计开发、源码分享、 技术指导讲解、各类项目免费分享&#xff0c;定制和毕业设计服务&#xff01; 免费获取方式--->>文章末尾处&#xff01; 项目介绍047&#xff1a; 【…
阅读更多...
使用OpenPCDet训练与测试多传感器融合模型BEVFusion，OPenPCdet代码架构介绍

使用OpenPCDet训练与测试多传感器融合模型BEVFusion，OPenPCdet代码架构介绍

引言 在自动驾驶领域&#xff0c;多传感器融合技术是一种常见的方法&#xff0c;用于提高感知系统的准确性和鲁棒性。其中&#xff0c;BevFusion是一种流行的融合方法&#xff0c;可以将来自不同传感器的数据进行融合&#xff0c;生成具有丰富信息的鸟瞰图&#xff08;BEV&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023