第 1 场 算法季度赛 蓝桥搜狐畅游(1~5 , 7）

1、水题

2、树上dp

3、模拟

4、概率

5、拆位

6、（是没学过的东西了...）

7、组合数学

1. 新年快乐【算法赛】

        

直接模拟

#include <iostream>
using namespace std;
int main()
{
  cout <<"2024 AK";
  return 0;
}

 2. 蓝桥圣诞树【算法赛】

思路：其实就是连通块大小小于3。定义dp[u]代表了u的子树中，包含了u这个结点的连通块的大小。 状态转移方程就呼之欲出：dp[u] = 1 + \sum dp[v]，其中v是u的孩子且跟u颜色相同。在树上跑一边dfs把所有节点的dp值求出来即可。然后再看有无大于3的连通块。

        

#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;
    }
}
struct HLD {//轻重链剖分
    int n;
    std::vector<int> siz, top, dep, parent, in, out, seq , color , dp;//子树大小 所在重链的顶部节点 深度 父亲 子树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);
        color.resize(n);
        dp.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;
        seq[in[u]] = u;
        dp[u] = 1;
        for (auto v : adj[u]) {
            top[v] = v == adj[u][0] ? top[u] : v;
            dfs2(v);
            if(color[u] == color[v]){
                dp[u] += dp[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;
    }
    
    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;
void solve() 
{
    cin >> n;
    string s;
    cin >> s;
    hld.init(n + 5);
    for(int i = 1 ; i <= n ; i ++){
        hld.color[i] = s[i - 1] - '0';
    }
    for(int i = 1 ; i < n ; i ++){
        int u , v;
        cin >> u >> v;
        hld.addEdge(u , v);
    }
     hld.work();
     for(int i = 1 ; i <= n ; i ++){
         if(hld.dp[i] >= 3){
             cout <<"NO\n";
             return;
         }
     }
     cout <<"YES\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;
}

3. 空间复杂度【算法赛】 

        

模拟题，注意数据大小。

#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;
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;
	cin >> m;
	map<string , int> mp;
	mp["MB"] = 2;
	mp["KB"] = 1;
	mp["B"] = 0;
	int res = n * pow(1024 , mp[s]);
	cout << res / m << 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;
}

 

 4. 开关【算法赛】

        

思路：先想最暴力的做法：对于处于(i , j)坐标的灯而言，会被第i次操作1和第j次操作2所影响。最终该灯亮的情况共有两种：1、触发了操作1且没有触发操作2。2、没触发操作1且触发了操作2。那么它最终亮的概率是\frac{a_{i}}{b_{i}}* \frac{1 - c_{j}}{d_{j}} + \frac{1-a_{i}}{b_{i}}* \frac{ c_{j}}{d_{j}}。 对于每个灯都求一遍的话时间复杂度为O(N^{2})。

        现考虑如何去优化，可以发现：将所有灯的概率全加起来的式子是可以合并同类项的，即\sum_{i = 1}^{n} (\frac{a_{i}}{b_{i}}*\sum _{j = 1}^{n} \frac{1 - c_{j}}{d_{j}}) + \sum_{i = 1}^{n}(\frac{1-a_{i}}{b_{i}}* \sum _{j = 1}^{n}\frac{ c_{j}}{d_{j}})。因此只需要预处理出\sum _{j = 1}^{n} \frac{1 - c_{j}}{d_{j}}和\sum _{j = 1}^{n} \frac{c_{j}}{d_{j}}。然后再遍历所有的i即可。这样做复杂度是O(N)的。

        

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

void solve() 
{
	int n;
	cin >> n;
	n++;
	vector<int>a(n , 0) , b(n , 0) , c(n , 0) , d(n , 0);
	for(int i = 1 ; i < n ; i ++){
		cin >> a[i];
	}
	for(int i = 1 ; i < n ; i ++){
		cin >> b[i];
	}
	for(int i = 1 ; i < n ; i ++){
		cin >> c[i];
	}
	for(int i = 1 ; i < n ; i ++){
		cin >> d[i];
	}
	vector<int>ab(n , 0) , cd(n , 0) ,ba(n , 0) , dc(n , 0);
	for(int i = 1 ; i < n ; i ++){
		ab[i] = a[i] * qpow(b[i] , mod - 2);
		cd[i] = c[i] * qpow(d[i] , mod - 2);
		ba[i] = (b[i] - a[i]) * qpow(b[i] , mod - 2);
		dc[i] = (d[i] - c[i]) * qpow(d[i] , mod - 2);
		ab[i] %= mod;
		cd[i] %= mod;
		ba[i] %= mod;
		dc[i] %= mod;
	}
	vector<int>sum1(n , 0) , sum2(n , 0);
	for(int i = 1 ; i < n ; i ++){
		sum1[i] = sum1[i - 1] + cd[i];
		sum2[i] = sum2[i - 1] + dc[i];
		sum1[i] %= mod;
		sum2[i] %= mod;
	}
	//对于第i行的灯而言，有两种方案使得其亮：ab && !cd  !ab && cd
	int ans = 0;
	for(int i = 1 ; i < n ; i ++){
		ans += ab[i] * sum2[n - 1];
		ans %= mod;
		ans += ba[i] * sum1[n - 1];
		ans %= mod;
	}
	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. 异或与求和【算法赛】 

        

题意：某不知名高手曾经说过，对于所有情况求和，采用定1求1的思考方式，即遍历右端点，考虑如何O(1)的去处理每个右端点。

        由于i_{1}i_{2}与i_{3}i_{4}不存在关联关系，因此此题可以转化为求解\sum a_{i_{1}} \oplus a_{i_{2}} + \sum a_{i_{3}} \oplus a_{i_{4}}。

然后可以先求\sum a_{i_{1}} \oplus a_{i_{2}}，再求\sum a_{i_{3}} \oplus a_{i_{4}}，过程是差不多的。

        至此，本题其实跟普通的求解 \sum a_{i_{1}} \oplus a_{i_{2}} 差不多，只不过(a_{i_{1}} ,a_{i_{2}})这组数对在求和中不止出现了一次，而是总共出现了(a_{i_{3}} , a_{i_{4}})所能形成的数对的个数。

        然后就是普通的拆位求异或和。

#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;
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 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;
}
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 dp1[32] , dp0[32];
void solve() 
{
	int n;
	cin >> n;
	vector<int>a(n , 0);
	for(int i = 0 ; i < n ; i ++){
		cin >> a[i];
	}
	vector<int>dp(n , 0);
	int cnt0 = 0 , cnt1 = 0;
	int ans = 0;
	for(int j = 0 ; j < 32 ; j ++){
		cnt0 = 0 , cnt1 = 0;
		for(int i = 0 ; i < n ; i ++){
			if((a[i] >> j) & 1){
				dp[i] = cnt0; 
				cnt1 ++;
			}
			else{
				dp[i] = cnt1;
				cnt0 ++;
			}
			dp[i] %= mod;	
			int res = n - i - 1;
			res = res * (res - 1) / 2;
			res %= mod;
			ans += ((dp[i] * (1 << j)) % mod) * res;
			ans %= mod;

		}
	}
	for(int j = 0 ; j < 32 ; j ++){
		cnt0 = 0 , cnt1 = 0;
		for(int i = n - 1 ; i >= 0 ; i --){
			if((a[i] >> j) & 1){
				dp[i] = cnt0; 
				cnt1 ++;
			}
			else{
				dp[i] = cnt1;
				cnt0 ++;
			}
			dp[i] %= mod;	
			int res = i;
			res = res * (res - 1) / 2;
			res %= mod;
			ans += ((dp[i] * (1 << j)) % mod)* res;
			ans %= mod;
		}
		//cout << ans << endl;
	}
//	cout << dp0[1];
	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;
}

7. 集合统计【算法赛】 

        

思路：将有关联的（相互牵制的）数放在到一个集合。然后根据乘法原理，最终方案数为所有集合能够拿出的方案数的乘积，最后再减去空集即最终答案。

        直接看例子1 3 2 ， 可以发现：（1 ， 2）是相互牵制的一组数（有1就不能有2，有2就不能有1）共有3种取数方案，而（3）是单独的数，这个集合共有2种取数方案。因此包含空集的方案共有3 * 2 = 6 个，再减去1就是答案5了。

        然后再看(1 4 2)这个例子，可以发现（1 ， 2 ， 4）这三个数是相互牵制的，但是需要注意的是：1、4是可以同时取到的，因此这个集合共有5种取数方案。1 4 2 最终的答案也就是9。

        接下来考虑如果一个集合当中有n个数，那么能拿出多少种方案？可以发现，这就是一个简单的dp问题，设dp[i]代表了集合中共有i个元素，能够选择的非空方案数。若不能和前一个数同时选dp[i] = dp[i - 1] + 1（不选择自己 + 只选择自己）。同时又能和前一个数以外的数同时选，因此dp[i] = dp[i]+ dp[i - 2]。

        解决完一个集合的方案数，接下来考虑总共有多少个集合：[r/k + 1 , r]之间的数，其都只是一个元素的集合。同理，[r/k^{2} + 1, r/k]之间的数，都是只有两个元素的集合...以此类推。但是需要注意的是：例如题中1 3 2 这个例子，按照上述思路，[2 , 3] 之间的数都是只有一个元素的集合，那么只有一个元素的集合数应该为2，但是事实并非如此，这是因为2这个元素实际上包含在（1,2）这个集合当中了。因此要求真正的集合数量，还需要减去重复的数。

        假设一个集合元素为(a , ka , k^2a),那么ka会出现在集合大小为2的范围内，k^2a会出现在集合大小为1的范围内，这些都是重复的，需要减去的。因此可以得出，假设集合大小为x的集合共有y个，那么所有集合大小小于x的集合数都要减去y，这样才能避免重复。

        解决完集合数量之后就是用快速幂快速求解了。

#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;
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 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;
}
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 inv[200];
void init(){
	inv[0] = 1;
	for(int i = 1 ; i < 200 ; i ++){
		inv[i] = inv[i - 1] + 1;
		if(i >= 2){
			inv[i] += inv[i - 2];
		}
		inv[i] %= mod;
	}
}
void solve() 
{
	int l , r , k;
	cin >> l >> r >> k;
	if(k == 1){
		cout << 0 << endl;		
	}
	else{
		int x = r;
		int pre = r;
		vector<int>t;
		while(x >= l){
			//[x + 1 , pre] 都是处于一个集合的
			x /= k;
			t.pb(pre - max(x , l - 1));
			pre = x;
		}
		int len = t.size();
		for(int i = len - 1 ; i >= 0 ; i --){
			for(int j = i - 1 ; j >= 0 ; j --){
				t[j] -= t[i];
			}
		}
		int ans = 1;
		for(int i = 0 ; i < len ; i ++){
			ans *= qpow(inv[i] + 1 , t[i]);
			ans %= mod;
		}
		cout << (ans - 1 + mod) % mod << endl;
	}
}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
	int t = 1;
	init();
	cin >> t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

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

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

相关文章

VS2019 驱动两个函数地址相同？

VS2019 驱动两个函数地址相同？

VS2019对于两个函数名不同&#xff0c;但是函数代码实现相同的情况&#xff0c;在链接时会将两个函数合并为同一个代码段&#xff0c;导致两个函数的地址相等。代码如下&#xff1a; #include <wdm.h>static void InnerFunc(int i, const char* name) {DbgPrint("i…
阅读更多...
C语言字符串知识点和算法总结

C语言字符串知识点和算法总结

目录 一、字符串遍历 1、字符串和字符数组 2、获取字符串长度 3、字符串遍历 4、大小写转换 5、字符串数组 二、字符串拷贝 三、字符串比较 四、字符串分割 五、字符串翻转 1、题目详解 2、算法详解 3、源码剖析 六、回文串 1、定义 2、例题讲解 3、算法详解 …
阅读更多...
数据库进阶教学——读写分离（Mycat1.6+Ubuntu22.04主+Win10从）

数据库进阶教学——读写分离（Mycat1.6+Ubuntu22.04主+Win10从）

目录 1、概述 2、环境准备 3、读写分离实验 3.1、安装jdk 3.2、安装Mycat 3.3、配置Mycat 3.3.1、配置schema.xml ​​​​3.3.2、配置server.xml 3.4、修改主从机远程登陆权限 3.4.1、主机 3.4.2、从机 3.5、启动Mycat 3.6、登录Mycat 3.7、验证 1、概述 读写分…
阅读更多...
Linux自定义shell编写

Linux自定义shell编写

Linux自定义shell编写 一.最终版本展示1.动图展示2.代码展示 二.具体步骤1.打印提示符2.解析命令行3.分析是否是内建命令1.shell对于内建名令的处理2.cd命令3.cd函数的实现4.echo命令的实现5.export命令的实现6.内建命令函数的实现 4.创建子进程通过程序替换执行命令5.循环往复…
阅读更多...
在markdown中添加视频的两种方法

在markdown中添加视频的两种方法

查看专栏目录 Network 灰鸽宝典专栏主要关注服务器的配置&#xff0c;前后端开发环境的配置&#xff0c;编辑器的配置&#xff0c;网络服务的配置&#xff0c;网络命令的应用与配置&#xff0c;windows常见问题的解决等。 文章目录 方式一源代码: 方式二结尾语网络的梦想 markd…
阅读更多...
UniApp小程序使用vant引入vant weapp

UniApp小程序使用vant引入vant weapp

HBuilder X里新建项目指路 HBuilderX新建项目 安装node.js指路 安装node.js 1.通过npm安装 查看npm环境 //打开终端输入命令查看版本 npm -version 1.1.右键打开外部终端窗口 1.2.输入npm init -y命令 1.3.通过命令安装 npm i vant/weapp1.3.3 -S --production 1.4.打开工具…
阅读更多...
2024年汉字小达人比赛的几个常见问题，往届真题示例和备赛建议

2024年汉字小达人比赛的几个常见问题，往届真题示例和备赛建议

这一届家长真是拼&#xff01;也很让人佩服。 2023年汉字小达人市级比赛的结果出来还没多久&#xff0c;就开始谋划着为孩子准备2024年的汉字小达人比赛。可以预料&#xff0c;类似于汉字小达人这样的比赛活动竞争会越来越激烈&#xff0c;毕竟&#xff0c;大家都希望孩子积累…
阅读更多...
年终回顾与展望：CSDN成就之路，2023年AI浪潮展望及2024 Flag

年终回顾与展望：CSDN成就之路，2023年AI浪潮展望及2024 Flag

文章目录 2023年在CSDN获得的肯定1&#xff0c;入围2023博客之星2&#xff0c;《有哪些让你目瞪口呆的Bug&#xff1f;》征文获得TOP33&#xff0c;通过创作者身份认证4&#xff0c;多篇文章被城市开发者社区收录5&#xff0c;多篇文章进入全站综合热榜6&#xff0c;积极参与社…
阅读更多...
数据结构-八大排序详解（动图+实现详解+总结）

数据结构-八大排序详解（动图+实现详解+总结）

1 前言 本章主要讲解&#xff1a; 八大排序的基本知识及其实现 注&#xff1a;这里的八大排序指直接插入&#xff0c;希尔&#xff0c;选择&#xff0c;堆排&#xff0c;冒泡&#xff0c;快排&#xff0c;归并&#xff0c;基数 八大排序汇总图&#xff1a; 2 排序概念及应用 …
阅读更多...
计算机毕业设计选题分享-ssm智能停车场系统小程序67860（赠送源码数据库）JAVA、PHP，node.js，C++、python，大屏数据可视化等

计算机毕业设计选题分享-ssm智能停车场系统小程序67860（赠送源码数据库）JAVA、PHP，node.js，C++、python，大屏数据可视化等

ssm智能停车场系统小程序 摘 要 科技进步的飞速发展引起人们日常生活的巨大变化&#xff0c;电子信息技术的飞速发展使得电子信息技术的各个领域的应用水平得到普及和应用。信息时代的到来已成为不可阻挡的时尚潮流&#xff0c;人类发展的历史正进入一个新时代。在现实运用中&a…
阅读更多...
计算机图形学光线追踪大作业C++基于Optix为框架实现的光线追踪算法合集，含直射光阴影效果、漫反射阴影效果、镜面反射效果等示例

计算机图形学光线追踪大作业C++基于Optix为框架实现的光线追踪算法合集，含直射光阴影效果、漫反射阴影效果、镜面反射效果等示例

MineRay 使用Optix为框架实现的光线追踪算法。 包含4个示例&#xff0c;直射光阴影效果、漫反射阴影效果、镜面反射效果、折射效果 环境需求 本项目在Windows 10中测试&#xff0c;以下环境为Windows中的环境 CUDA 10.1 OptiX 7 SDK cmake 编译方式 使用cmake编译 打开Mi…
阅读更多...
certum的ip证书购买流程

certum的ip证书购买流程

Certum是成立于欧洲的CA认证机构&#xff0c;经过二十几年的发展Certum已经成为欧洲知名的CA认证机构之一&#xff0c;拥有广泛的客户群体和合作伙伴。IP证书是Certum为只有公网IP地址的网站准备的数字加密服务。今天就随SSL盾小编了解购买Certum旗下的IP证书流程。 第一步&am…
阅读更多...
Vue3-31-路由-RouterView的name属性的作用

Vue3-31-路由-RouterView的name属性的作用

作用描述 <router-view> 标签是用来渲染路由对应的组件的位置&#xff1b; 默认情况下&#xff0c;一个路由是只对应一个组件的。 但是&#xff0c;可以通过给 <router-view> 指定 name 属性的方式&#xff0c;实现同时渲染多个组件的效果。 这也叫做 命名视图。 注…
阅读更多...
鸿蒙开发之崩溃信息收集FaultLogger

鸿蒙开发之崩溃信息收集FaultLogger

前申&#xff1a;果然系统的API没有让我失望&#xff0c;日志完全看不出来崩溃原因所在 一、使用 logCrash() {FaultLogger.query(FaultLogger.FaultType.JS_CRASH,(err,val) > {if (err) {console.log(fault log get an errJSON.stringify(err))return}let len val.lengt…
阅读更多...
隧道代理HTTP工作原理：一场奇妙的网络魔法表演

隧道代理HTTP工作原理：一场奇妙的网络魔法表演

嘿&#xff0c;小伙伴们&#xff01;今天我们要一起探索一个有趣的话题——隧道代理HTTP的工作原理。这不是普通的表演&#xff0c;而是一场奇妙的网络魔法表演&#xff01; 首先&#xff0c;让我们想象一下&#xff0c;网络世界就像一个大舞台&#xff0c;而我们每个人都是这…
阅读更多...
1 - 数据库服务概述 | 构建MySQL服务 | 数据库基本管理 | MySQL基本类型

1 - 数据库服务概述 | 构建MySQL服务 | 数据库基本管理 | MySQL基本类型

数据库服务概述 | 构建MySQL服务 | 数据库基本管理 | MySQL基本类型 数据库服务概述构建mysql服务安装mysql软件包连接mysql服务器 修改密码 密码管理修改密码策略&#xff08;需要登陆&#xff09;破解数据库管理员root密码&#xff08;数据库服务处于运行状态但是root忘记了密…
阅读更多...
C++ 侯捷 内存管理

C++ 侯捷 内存管理

C 的内存获取机制&#xff1a; void* p1 malloc(512); free(p1);complex<int>* p2 new complex<int>; delete p2;void* p3 ::operator new(512); ::operator delete(p3);//GNUC void* p4 alloc::allocate(512); alloc::deallocate(p4, 512);//GNUC4.9 void* p5…
阅读更多...
【经验分享】日常开发中的故障排查经验分享（一）

【经验分享】日常开发中的故障排查经验分享（一）

目录 简介CPU飙高问题1、使用JVM命令排查CPU飙升100%问题2、使用Arthas的方式定位CPU飙升问题3、Java项目导致CPU飙升的原因有哪些&#xff1f;如何解决&#xff1f; OOM问题&#xff08;内存溢出&#xff09;1、如何定位OOM问题&#xff1f;2、OOM问题产生原因 死锁问题的定位…
阅读更多...
SQL Server 存储过程 触发器 事务处理

SQL Server 存储过程 触发器 事务处理

CSDN 成就一亿技术人&#xff01; 难度指数&#xff1a;* * CSDN 成就一亿技术人&#xff01; 目录 1. 存储过程的作用 创建存储过程 2. 触发器 触发器的种类 insert触发器 update触发器 delete触发器 测试 3. 事务 开始事务 提交事务 回滚事务 举个实例 在 SQ…
阅读更多...
深度学习在自然语言处理中的应用

深度学习在自然语言处理中的应用

深度学习在自然语言处理中的应用 一、引言 随着人工智能技术的飞速发展&#xff0c;自然语言处理&#xff08;NLP&#xff09;作为其重要分支&#xff0c;已经在诸多领域取得了令人瞩目的成果。深度学习作为当前最炙手可热的技术&#xff0c;为NLP带来了革命性的变革。本文将…
阅读更多...
最新文章

Copyright @ 2022~2023