2023年广东省大学生程序设计竞赛题解

比赛链接：The 2023 Guangdong Provincial Collegiate Programming Contest

文章目录

  • A. Programming Contest（签到）
  • B. Base Station Construction（单调队列优化dp）
  • C. Trading（排序）
  • D. New Houses（枚举+排序）
  • E. New but Nostalgic Problem（字典树）
  • F. Traveling in Cells（线段树+树状数组+二分）
  • I. Path Planning（二分）
  • K. Peg Solitaire（DFS）

A. Programming Contest（签到）

#include <bits/stdc++.h>
 
using namespace std;
 
#define int long long
using i64 = long long;
 
typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;
 
const int N = 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;
 
void solve()
{
	int x1, x2;
	cin >> x1;
	int x; cin >> x;
	vector<int> a(x);
	for (int i = 0; i < x; i ++ ) cin >> a[i];
	cin >> x2;
	int ans = x2 - x1 + 1;
	for (auto t : a)
	{
		if (t >= x1 && t <= x2) ans -- ;
	}
	cout << ans << '\n';
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
 
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

B. Base Station Construction（单调队列优化dp）

设计状态 dp[i] 表示前 i 个位置满足条件，且第 i 个位置必选的最小代价，转移方程即为： d p [ i ] = min ⁡ d p [ j ] + a [ i ] dp[i]=\min{dp[j]}+a[i] dp[i]=mindp[j]+a[i]，j 需要满足的条件是， [ j ,   i − 1 ] [j,\ i-1] [j, i−1] 没有完整的区间限制

所以我们先在存储限制的时候记录下每个右端点对应的左端点，之后用单调队列更新当前能取的最大的 j

我们可以将 a[n + 1] 赋值为 0，这样最终答案即为 dp[n + 1]

#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 5e5 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	vector<int> a(n + 2);
	for (int i = 1; i <= n; i ++ ) cin >> a[i];
	a[n + 1] = 0;
	vector<int> dp(n + 2);
	int m; cin >> m;
	vector<int> lt(n + 2);
	for (int i = 1; i <= m; i ++ )
	{
		int l, r; cin >> l >> r;
		lt[r] = max(l, lt[r]);
	}
	deque<int> dq;
	dq.push_back(0);
	for (int i = 1; i <= n + 1; i ++ )
	{
		dp[i] = dp[dq.front()] + a[i];
		while (!dq.empty() && dp[dq.back()] > dp[i]) dq.pop_back();
		dq.push_back(i);
		while (!dq.empty() && dq.front() < lt[i]) dq.pop_front();
	}
	cout << dp[n + 1] << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

C. Trading（排序）

排序即可，便宜的买，贵的卖

#include <bits/stdc++.h>
 
using namespace std;
 
#define int long long
using i64 = long long;
 
typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;
 
const int N = 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;
 
void solve()
{
	int n;
	cin >> n;
	vector<PII> a(n);
	for (int i = 0; i < n; i ++ ) cin >> a[i].first >> a[i].second;
	sort(a.begin(), a.end());
	int sum = 0;
	for (auto t : a) sum += t.second;
	int cnt = sum / 2;
	int sum1 = 0, sum2 = 0;
	for (auto t : a)
	{
		if (t.second <= cnt)
		{
			sum1 += t.first * t.second;
			cnt -= t.second;
		}
		else if (cnt > 0)
		{
			sum1 += cnt * t.first;
			cnt = 0;
			break;
		}
		else if (cnt <= 0) break;
	} 
	cnt = sum / 2;
	for (int i = n - 1; i >= 0; i -- )
	{
		if (a[i].second <= cnt)
		{
			sum2 += a[i].first * a[i].second;
			cnt -= a[i].second;
		}
		else if (cnt > 0)
		{
			sum2 += cnt * a[i].first;
			cnt = 0;
			break;
		}
		else if (cnt <= 0) break;
	}
	cout << sum2 - sum1 << '\n';
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
 
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

D. New Houses（枚举+排序）

根据二者的差值排序，然后枚举多少人没有邻居就可以了

#include <bits/stdc++.h>
 
using namespace std;
 
#define int long long
using i64 = long long;
 
typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;
 
const int N = 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;
 
void solve()
{
	int n, m;
	cin >> n >> m;
	vector<PII> a(n + 1);
	for (int i = 1; i <= n; i ++ ) cin >> a[i].first >> a[i].second;
	auto cmp = [&](PII a, PII b)
	{
		return a.second - a.first > b.second - b.first;
	};
	sort(a.begin() + 1, a.end(), cmp);
	vector<int> pre1(n + 1), pre2(n + 1);
	for (int i = 1; i <= n; i ++ )
	{
		pre1[i] = pre1[i - 1] + a[i].first;
		pre2[i] = pre2[i - 1] + a[i].second;
	}
	int ans = 0;
	for (int i = 0; i <= n; i ++ )
	{
		int j = n - i;
		if (j == 1) continue;
		if (j == 0 && (i - 1) * 2 + 1 > m) continue;
		else if (j != 0 && i * 2 + j > m) continue;
		int res = pre2[i] + pre1[n] - pre1[i];
		ans = max(ans, res);
	}
	cout << ans << '\n';
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
 
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

E. New but Nostalgic Problem（字典树）

从左到右确定答案的每一位，假设我们已经确定了前三位 abc，开始枚举第四位，假设枚举到第四位为 g，那么我们的取值是怎样的呢？

首先 abc[a-g] 随便取，因为他们的公共前缀对最终答案不造成影响，然后 abc[h-z] 每种情况只能取一个，因为只要取了两个，就不能保证最终公共前缀是 abcg 了

如果这样可以选择大于等于 k 个字符串，那么答案的前缀确定是 abcg，如果不能，就要继续枚举第四个字符是其他的情况

前四位确定之后我们要看是不是只有四位呢？

如果答案只有四位的话，abcg[a-z] 每种情况最多取一个，看这样能不能取大于等于 k 个字符串，如果可以的话答案就是 abcg，不能的话再继续枚举第五位

#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

int idx, cnt[N], st[N], tr[N][26];

int newNode()
{
    idx++;
    st[idx] = cnt[idx] = 0;
    memset(tr[idx], 0, sizeof(tr[idx]));
    return idx;
}

void add(string s)
{
	int p = 1;
	// cnt[p] ++ ;
	for (auto t : s)
	{
		int c = t - 'a';
		if (!tr[p][c]) tr[p][c] = newNode();
		p = tr[p][c];
		cnt[p] ++ ;
	}
	st[p] ++ ;
}

void solve()
{
	idx = 0;
	newNode();
	int n, k;
	cin >> n >> k;
	for (int i = 0; i < n; i ++ )
	{
		string s;
		cin >> s;
		add(s);
	}
	int p = 1;
	while (1)
	{
		int tmp = st[p];
		for (int i = 0; i < 26; i ++ )
			if (cnt[tr[p][i]]) tmp ++ ;
		if (tmp >= k)
		{
			if (p == 1) cout << "EMPTY";
			cout << '\n';
			return;
		}

		for (int i = 0; i < 26; i ++ )
		{
			if (cnt[tr[p][i]])
			{
				tmp += cnt[tr[p][i]] - 1;
				if (tmp >= k)
				{
					k -= tmp - cnt[tr[p][i]];
					p = tr[p][i];
					cout << (char)(i + 'a');
					break;
				}
			}
		}
	}
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

F. Traveling in Cells（线段树+树状数组+二分）

首先看查询操作，很容易想到，就是要找包含起始点的最长子段，子段的左端点和右端点都可以通过二分找到

二分的check函数怎么写呢？以左端点为例，如果 [mid, x] 在集合内的颜色数是 x - mid + 1 个，说明这一段都是满足条件的，mid 可以继续往左搜索，否则往右搜索

现在我们需要的就是，查找 [l, r] 之间第 i 个颜色的出现次数，再把集合内的颜色累加一下得到答案，但是直接加会mle的很惨，所以考虑一下怎么优化

我们可以把所有颜色捡到一棵树上，用动态开点线段树，然后再存储一下每个颜色的树根结点，每次从这个颜色的根节点往下找就可以

最后用树状数组维护一下区间的权值和

#include <bits/stdc++.h>

using namespace std;

#define int long long
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 3e5 + 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

int n;
int c[N], v[N];
int rt[N], idx;

struct node
{
	int ls, rs, sum;
} tr[N * 10];

void modify(int &u, int l, int r, int pos, int val)
{
	if (!u) u = ++ idx;
	if (l == r)
	{
		tr[u].sum += val;
		return;
	}
	int mid = l + r >> 1;
	if (pos <= mid) modify(tr[u].ls, l, mid, pos, val);
	else modify(tr[u].rs, mid + 1, r, pos, val);
	tr[u].sum = tr[tr[u].ls].sum + tr[tr[u].rs].sum;
}

int query(int u, int l, int r, int ql, int qr)
{
	if (!u) return 0;
	if (l >= ql && r <= qr) return tr[u].sum;
	int mid = l + r >> 1;
	int res = 0;
	if (ql <= mid) res += query(tr[u].ls, l, mid, ql, qr);
	if (qr > mid) res += query(tr[u].rs, mid + 1, r, ql, qr);
	return res;
}

int ttr[N];

int lowbit(int x)
{
	return x & -x;
}

void add(int pos, int val)
{
	for (int i = pos; i <= n; i += lowbit(i))
		ttr[i] += val;
}

int get_sum(int pos)
{
	int res = 0;
	for (int i = pos; i > 0; i -= lowbit(i)) res += ttr[i];
	return res;
}

int get_sum(int l, int r)
{
	return get_sum(r) - get_sum(l - 1);
}

vector<int> cq;

bool check(int l, int r, int cnt)
{
	int res = 0;
	for (auto t : cq)
		res += query(rt[t], 1, n, l, r);
	return res == cnt;
}

void get_ans()
{
	int st, k;
	cin >> st >> k;
	cq.clear();
	for (int i = 1; i <= k; i ++ )
	{
		int xx; cin >> xx;
		cq.push_back(xx);
	}

	sort(cq.begin(), cq.end());
	cq.erase(unique(cq.begin(), cq.end()), cq.end());

	int l = 1, r = n;
	int lr = st, rl = st;

	while (l < lr)
	{
		int mid = l + lr >> 1;
		if (check(mid, st, st - mid + 1)) lr = mid;
		else l = mid + 1;
	}
	while (rl < r)
	{
		int mid = rl + r + 1 >> 1;
		if (check(st, mid, mid - st + 1)) rl = mid;
		else r = mid - 1;
	}

	cout << get_sum(l, r) << '\n';
}

void clear()
{
    for (int i = 0; i <= idx; i++)
        tr[i] = {0, 0, 0};
    for (int i = 1; i <= n; i++)
        rt[i] = ttr[i] = 0;
    idx = 0;
}

void solve()
{
	clear();
	int q;
	cin >> n >> q;
	for (int i = 1; i <= n; i ++ )
	{
		cin >> c[i];
		modify(rt[c[i]], 1, n, i, 1);
	}
	for (int i = 1; i <= n; i ++ )
	{
		cin >> v[i];
		add(i, v[i]);
	}
	while (q -- )
	{
		int op, pos, x;
		cin >> op;
		if (op == 1)
		{
			cin >> pos >> x;
			modify(rt[c[pos]], 1, n, pos, -1);
			c[pos] = x;
			modify(rt[c[pos]], 1, n, pos, 1);
		}
		else if (op == 2)
		{
			cin >> pos >> x;
			add(pos, x - v[pos]);
			v[pos] = x;
		}
		else get_ans();
	}
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

I. Path Planning（二分）

输入的时候存储每一个数字所在的位置，然后二分，把路径存储下来，按 x 排序，判断 y 有没有不合理的地方即可

#include <bits/stdc++.h>
 
using namespace std;
 
#define int long long
using i64 = long long;
 
typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;
 
const int N = 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;
 
void solve()
{
	int n, m;
	cin >> n >> m;
	vector<PII> pos(n * m);
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ )
		{
			int x; cin >> x;
			pos[x] = {i, j};
		}
	auto check = [&](int x)
	{
		vector<PII> v;
		for (int i = 0; i < x; i ++ )
		{
			v.push_back(pos[i]);
		}
		sort(v.begin(), v.end());
		int tmp = v[0].second;
		for (int i = 1; i < v.size(); i ++ )
		{
			if (v[i].second < tmp) return false;
			tmp = v[i].second;
		}
		return true;
	};
	int l = 0, r = n * m;
	while (l < r)
	{
		int mid = l + r + 1 >> 1;
		if (check(mid)) l = mid;
		else r = mid - 1;
	}
	cout << r << '\n';
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
 
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

K. Peg Solitaire（DFS）

数据范围特别小，所以直接打暴力即可

#include <bits/stdc++.h>
 
using namespace std;
 
#define int long long
using i64 = long long;
 
typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;
 
const int N = 10;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;
 
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
 
void solve()
{
	int n, m, k;
	cin >> n >> m >> k;
	vector<vector<int>> g(n + 1, vector<int>(m + 1));
	vector<vector<int>> st(n + 1, vector<int>(m + 1, -1));
	for (int i = 0; i < k; i ++ )
	{
		int x, y;
		cin >> x >> y;
		g[x][y] = 1;
	}
	int res = 0;
	int ans = 0;
	function<void(int, int)> dfs = [&](int x, int y)
	{
		for (int i = 0; i < 4; i ++ )
		{
			int nx = x + dx[i], ny = y + dy[i];
			int nnx = nx + dx[i], nny = ny + dy[i];
			if (nx <= 0 || ny <= 0 || nx > n || ny > m) continue;
			if (nnx <= 0 || nny <= 0 || nnx > n || nny > m) continue;
			if (g[nx][ny] == 1 && g[nnx][nny] == 0)
			{
				g[x][y] = 0;
				g[nx][ny] = 0;
				g[nnx][nny] = 1;
				res ++ ;
				ans = max(ans, res);
				for (int ii = 1; ii <= n; ii ++ )
				{
					for (int jj = 1; jj <= m; jj ++ )
					{
						if (g[ii][jj] == 1) dfs(ii, jj);
					}
				}
				g[x][y] = 1;
				g[nx][ny] = 1;
				g[nnx][nny] = 0;
				res -- ;
			}
		}
	};
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ )
			if (g[i][j] == 1) dfs(i, j);
	cout << k - ans << '\n';
}
 
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
 
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

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

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

相关文章

2024-05-06 问AI: 介绍一下深度学习中的LSTM网络

2024-05-06 问AI: 介绍一下深度学习中的LSTM网络

文心一言 当谈到深度学习中的LSTM&#xff08;Long Short-Term Memory&#xff09;网络时&#xff0c;它是一种特殊的循环神经网络&#xff08;RNN&#xff09;架构&#xff0c;旨在解决传统RNN在处理长序列时遇到的梯度消失和梯度爆炸问题。LSTM网络因其能够捕捉序列数据中的…
阅读更多...
VTK —— 三、简单操作 - 示例1 - 3D点之间的平方距离和欧几里得距离（附完整源码）

VTK —— 三、简单操作 - 示例1 - 3D点之间的平方距离和欧几里得距离（附完整源码）

代码效果 本代码编译运行均在如下链接文章生成的库执行成功&#xff0c;若无VTK库则请先参考如下链接编译vtk源码&#xff1a; VTK —— 一、Windows10下编译VTK源码&#xff0c;并用Vs2017代码测试&#xff08;附编译流程、附编译好的库、vtk测试源码&#xff09; 教程描述 本…
阅读更多...
如何使用resource-counter统计跨Amazon区域的不同类型资源数量

如何使用resource-counter统计跨Amazon区域的不同类型资源数量

关于resource-counter resource-counter是一款功能强大的命令行工具&#xff0c;该工具基于纯Python 3开发&#xff0c;可以帮助广大研究人员跨Amazon区域统计不同类型资源的数量。 该工具在统计完不同区域的各类资源数量后&#xff0c;可以在命令行中输出并显示统计结果。res…
阅读更多...
【C++ | 语句】条件语句(if、switch)、循环语句(while、do while、for、范围for)、跳转语句、try语句块和异常处理

【C++ | 语句】条件语句(if、switch)、循环语句(while、do while、for、范围for)、跳转语句、try语句块和异常处理

&#x1f601;博客主页&#x1f601;&#xff1a;&#x1f680;https://blog.csdn.net/wkd_007&#x1f680; &#x1f911;博客内容&#x1f911;&#xff1a;&#x1f36d;嵌入式开发、Linux、C语言、C、数据结构、音视频&#x1f36d; ⏰发布时间⏰&#xff1a;2024-05-02 2…
阅读更多...
Vue前端环境准备

Vue前端环境准备

vue-cli Vue-cli是Vue官方提供的脚手架&#xff0c;用于快速生成一个Vue项目模板 提供功能&#xff1a; 统一的目录结构 本地调试 热部署 单元测试 集成打包上线 依赖环境&#xff1a;NodeJs 安装NodeJs与Vue-Cli 1、安装nodejs&#xff08;已经安装就不用了&#xff09; node-…
阅读更多...
【PuTTY/PuttyGen创建密钥及利用密钥登录服务器】

【PuTTY/PuttyGen创建密钥及利用密钥登录服务器】

PuTTY/PuttyGen创建密钥及利用密钥登录服务器http://t.csdnimg.cn/n7kJ9
阅读更多...
W801学习笔记十九：古诗学习应用——下

W801学习笔记十九：古诗学习应用——下

经过前两章的内容&#xff0c;背唐诗的功能基本可以使用了。然而&#xff0c;仅有一种模式未免显得过于单一。因此&#xff0c;在本章中对其进行扩展&#xff0c;增加几种不同的玩法&#xff0c;并且这几种玩法将采用完全不同的判断方式。 玩法一&#xff1a;三分钟限时挑战—…
阅读更多...
SpringBoot自动连接数据库的解决方案

SpringBoot自动连接数据库的解决方案

在一次学习设计模式的时候&#xff0c;沿用一个旧的boot项目&#xff0c;想着简单&#xff0c;就把数据库给关掉了&#xff0c;结果报错 Consider the following: If you want an embedded database (H2, HSQL or Derby), please put it on the classpath. 没有数据库的需…
阅读更多...
75.网络游戏逆向分析与漏洞攻防-角色与怪物信息的更新-伪造服务端更新属性消息欺骗客户端

75.网络游戏逆向分析与漏洞攻防-角色与怪物信息的更新-伪造服务端更新属性消息欺骗客户端

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 如果看不懂、不知道现在做的什么&#xff0c;那就跟着做完看效果&#xff0c;代码看不懂是正常的&#xff0c;只要会抄就行&#xff0c;抄着抄着就能懂了 内容…
阅读更多...
IRFBC30PBF 进口原装现货 TO-220直插 N沟道 600V/3.6A 场效应管

IRFBC30PBF 进口原装现货 TO-220直插 N沟道 600V/3.6A 场效应管

IRFBC30PBF是一款通用型高性能MOSFET&#xff0c;它可以应用于多种电子和电力电子设备中。以下是一些可能的应用案例&#xff1a; 1. 开关电源&#xff1a;在开关电源设计中&#xff0c;IRFBC30PBF可以作为高频开关来控制电源的通断&#xff0c;实现电压转换和电流控制。 2. …
阅读更多...
自动驾驶融合定位系列教程四：惯性导航解算

自动驾驶融合定位系列教程四：惯性导航解算

自动驾驶融合定位系列教程四&#xff1a;惯性导航解算 一、概述 惯性导航的解算是一个实现起来非常简单&#xff0c;但是理解起来要费一番功夫的东西&#xff0c;所谓“实现”就是把公式变成代码&#xff0c;所谓“理解”&#xff0c;就是要弄明白几个公式是怎么推导出来的。…
阅读更多...
【driver5】调用堆栈函数，printk，动态打印，ftrace，proc，sysfs

【driver5】调用堆栈函数，printk，动态打印，ftrace，proc，sysfs

文章目录 1.内核函数调用堆栈&#xff1a;4个函数2.printk&#xff1a;cat /proc/cmdline查看consolettyS03.动态打印&#xff1a;printk是全局的且只能设打印等级&#xff0c;动态打印可控制选择模块的打印&#xff0c;在内核配置打开CONFIG_DYNAMIC_DEBUG4.ftrace&#xff1a…
阅读更多...
【考研数学】武忠祥「基础篇」如何衔接进入强化?

【考研数学】武忠祥「基础篇」如何衔接进入强化?

如果基础篇已经做完&#xff0c;并且讲义上的例题也都做完了&#xff0c; 那下一步就是该做题了 这个时候&#xff0c;不能盲目做题&#xff0c;做什么题很重要&#xff01;我当初考研之前&#xff0c;基础也很差&#xff0c;所以考研的时候选了错误的题集&#xff0c;做起来就…
阅读更多...
AI+客服行业落地应用

AI+客服行业落地应用

一、客服行业变迁 1.传统客服时代 &#xff08;1&#xff09;客服工作重复性高&#xff0c;技术含量低 &#xff08;2&#xff09;呼出效率低&#xff0c;客服水平参差不齐 &#xff08;3&#xff09;管理难度高&#xff0c;情绪不稳定 &#xff08;4&#xff09;服务质量…
阅读更多...
偏微分方程算法之椭圆型方程差分格式编程示例

偏微分方程算法之椭圆型方程差分格式编程示例

目录 一、示例1-五点菱形格式 1.1 C代码 1.2 计算结果 二、示例2-九点紧差分格式 2.1 C代码 2.2 计算结果 三、示例3-二阶混合边值 3.1 C代码 3.2 计算结果 本专栏对椭圆型偏微分方程的三种主要差分方法进行了介绍&#xff0c;并给出相应格式的理论推导过程。为加深对…
阅读更多...
“全国首批EVO+ ICL（V5）临床应用专家”授牌仪式在铭依眼科举行

“全国首批EVO+ ICL（V5）临床应用专家”授牌仪式在铭依眼科举行

近日&#xff0c;“全国首批EVO ICL&#xff08;V5&#xff09;新技术临床应用专家”授牌仪式在上海铭依眼科门诊部举行。仪式现场&#xff0c;瑞金医院谢冰教授获得此项荣誉称号。铭依眼科连锁医疗机构创始人吴英、Staar Surgical代表出席仪式现场。 为让近视人群不出国门即可…
阅读更多...
ECC 号码总结

ECC 号码总结

1、问题背景 在手机开发过程中&#xff0c;经常遇见各种紧急号码问题&#xff0c;在此特意总结下紧急号码相关知识。 2、紧急号码来源 在MTK RILD EccNumberSource.h中&#xff0c;定义了如下几种紧急号码来源。 按优先级排序介绍如下 2.1、SOURCE_NETWORK 网络下发&#xff…
阅读更多...
车牌检测识别功能实现(pyqt)

车牌检测识别功能实现(pyqt)

在本专题前面相关博客中已经讲述了 pyqt + yolo + lprnet 实现的车牌检测识别功能。带qt界面的。 本博文将结合前面训练好的模型来实现车牌的检测与识别。并用pyqt实现界面。最终通过检测车牌检测识别功能。 1）、通过pyqt5设计界面 ui文件如下： <?xml version="1…
阅读更多...
K. 子串翻转回文串

K. 子串翻转回文串

给一个串 s  s1s2... sn&#xff0c;你可以选定其一个非空子串&#xff0c;然后将该子串翻转。具体来说&#xff0c;若选定的子串区间为 [l, r]&#xff08;1 ≤ l ≤ r ≤ n&#xff09;&#xff0c;则翻转后该串变为 s1s2... sl - 1srsr - 1... slsr  1... sn…
阅读更多...
Sharding Capital: 为什么投资全链流动性基础设施 Entangle ？

Sharding Capital: 为什么投资全链流动性基础设施 Entangle ？

写在前面&#xff1a;Entangle 项目的名称取自于量子纠缠(Quantum entanglement)&#xff0c;体现了项目对于构建连接、关联和互通的愿景。就像量子纠缠将不同的粒子联系在一起&#xff0c;Entangle 旨在通过其跨链流动性和合成衍生品的解决方案将不同的区块链网络连接在一起&a…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站