2024.4.15-4.21 训练记录（27）

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量858 收藏 30
点赞数 13
分类专栏： 2024春季学期训练记录 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhxbshbdjzxy/article/details/137950161
版权
  • 周末要打天梯赛和蓝桥杯，过了这周总算事情少一点了
  • 最近精神内耗好严重

ATC - abc348

A - Penalty Kick

输出题

#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 = 2e5 + 10;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i ++ )
	{
		if (i % 3 == 0) cout << 'x';
		else cout << 'o';
	}
}

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

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

B - Farthest Point

纯暴力

#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 = 2e5 + 10;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

int dist(int x1, int y1, int x2, int y2)
{
	return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}

void solve()
{
	int n;
	cin >> n;
	vector<PII> a(n);
	for (int i = 0; i < n; i ++ ) cin >> a[i].first >> a[i].second;
	for (int i = 0; i < n; i ++ )
	{
		int maxx = 0, pos = -1;
		for (int j = 0; j < n; j ++ )
		{
			if (dist(a[i].first, a[i].second, a[j].first, a[j].second) > maxx) maxx = dist(a[i].first, a[i].second, a[j].first, a[j].second), pos = j;
		}
		cout << pos + 1 << '\n';
	}
}

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

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

C - Colorful Beans

暴力，找到每种颜色最小值里的最大值

#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<int, string> PIS;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

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


void solve()
{
	int n;
	cin >> n;
	map<int, vector<int>> mp;
	for (int i = 0; i < n; i ++ )
	{
		int a, c;
		cin >> a >> c;
		mp[c].push_back(a);
	}
	int ans = 0;
	for (auto t : mp)
	{
		sort(t.second.begin(), t.second.end());
		ans = max(ans, t.second[0]);
	}
	cout << ans << '\n';
}

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

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

D - Medicines on Grid（dijkstra）

一开始把题目看错了，走到有药品的格子，是把自身能量变成药品值

那就很简单了，在 dijkstra 更新状态的时候更新一下如果当前格有药品的情况即可

#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<int, string> PIS;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

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

int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};

void solve()
{
	int h, m;
	cin >> h >> m;
	vector<vector<char>> g(h + 1, vector<char>(m + 1));
	int stx, sty, edx, edy;
	for (int i = 1; i <= h; i ++ )
	{
		for (int j = 1; j <= m; j ++ )
		{
			cin >> g[i][j];
			if (g[i][j] == 'S') stx = i, sty = j;
			if (g[i][j] == 'T') edx = i, edy = j;
		}
	}
	int n;
	cin >> n;
	vector<vector<int>> w(h + 1, vector<int>(m + 1));
	vector<vector<int>> dist(h + 1, vector<int>(m + 1, -1));
	for (int i = 0; i < n; i ++ ) 
	{
		int r, c, e;
		cin >> r >> c >> e;
		w[r][c] += e;
	}
	priority_queue<PIII> pq;
	if (w[stx][sty] == 0)
	{
		cout << "No\n";
		return;
	}
	pq.push({w[stx][sty], {stx, sty}});
	while (pq.size())
	{
		auto t = pq.top();
		pq.pop();

		int ery = t.first, x = t.second.first, y = t.second.second;

		if (dist[x][y] < w[x][y])
		{
			dist[x][y] = w[x][y];
			pq.push({dist[x][y], {x, y}});
			continue;
		}

		for (int i = 0; i < 4; i ++ )
		{
			int nx = x + dx[i], ny = y + dy[i];
			if (nx <= 0 || nx > h || ny <= 0 || ny > m) continue;
			if (st[nx][ny] || g[nx][ny] == '#') continue;

			if (dist[nx][ny] < ery - 1)
			{
				dist[nx][ny] = ery - 1;
				pq.push({dist[nx][ny], {nx, ny}});
			}
		}
	}
	if (dist[edx][edy] == -1) cout << "No\n";
	else cout << "Yes\n";
}

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

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

E - Minimize Sum of Distances（换根dp）

还算是比较典的换根dp（能让我看出来那就是非常典的换根dp

先跑一遍dfs处理每个结点子树的大小

然后计算选择第一个点的答案

f[i] 表示第 i 个点为根的答案

换之前的根是 u，换之后的是 ver，从 u 换到 ver ，所有在 ver 子树中的结点到根的距离加一，其他结点到根的距离减一

#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<int, string> PIS;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

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

void solve()
{
	int n;
	cin >> n;
	vector<vector<int>> g(n + 1);
	for (int i = 0; i < n - 1; i ++ )
	{
		int u, v;
		cin >> u >> v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	vector<int> c(n + 1), sz(n + 1), dist(n + 1, INF);
	for (int i = 1; i <= n; i ++ ) cin >> c[i];
	function<void(int, int)> dfs1 = [&](int u, int fa)
	{
		sz[u] = c[u];
		for (int i = 0; i < g[u].size(); i ++ )
		{
			int j = g[u][i];
			if (j == fa) continue;
			dfs1(j, u);
			sz[u] += sz[j];
		}
	};
	dfs1(1, -1);

	dist[1] = 0;
	queue<int> q;
	q.push(1);
	while (q.size())
	{
		auto t = q.front();
		q.pop();

		for (int i = 0; i < g[t].size(); i ++ )
		{
			int ver = g[t][i];
			if (dist[ver] > dist[t] + 1)
			{
				dist[ver] = dist[t] + 1;
				q.push(ver);
			}
		}
	}

	int ans = INF;
	vector<int> f(n + 1, INF);
	f[1] = 0;
	for (int i = 1; i <= n; i ++ ) f[1] += c[i] * dist[i];

	function<void(int, int)> dfs2 = [&](int u, int fa)
	{
		ans = min(ans, f[u]);
		for (int i = 0; i < g[u].size(); i ++ )
		{
			int ver = g[u][i];
			if (ver == fa) continue;
			f[ver] = min(f[ver], f[u] - sz[ver] + sz[1] - sz[ver]);
			dfs2(ver, u);
		}
	};
	dfs2(1, -1);
	cout << ans << '\n';
}

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

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

F - Oddly Similar（bitset优化）

计算不同状态的个数，且状态只有两种，可以利用bitset

#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<int, string> PIS;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

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

void solve()
{
	int n, m;
	cin >> n >> m;
	vector<vector<int>> g(n, vector<int>(m));
	vector<vector<bitset<2010>>> a(m, vector<bitset<2010>>(1010));
	for (int i = 0; i < n; i ++ )
	{
		for (int j = 0; j < m; j ++ )
		{
			int x; cin >> x;
			g[i][j] = x;
			a[j][x][i] = 1;
		}
	}
	int ans = 0;
	for (int i = 0; i < n; i ++ )
	{
		bitset<2010> bt = {};
		for (int j = 0; j < m; j ++ )
		{
			bt ^= a[j][g[i][j]];
		}
		bt[i] = 0;
		ans += bt.count();
	}
	cout << ans / 2 << '\n';
}

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

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

G - Max (Sum - Max)（主席树+二分）

很明显先按b排序，然后枚举b，再找b和b之前对应的a中最大的k个值，这个用主席树维护

同时这里又有个二分性，如果在前 j 个 b 中我们选择了第 i 个 b ，那么我们称 i 是对于 j 的最优决策点，可以发现，最优决策点一定是非递减的，所以套个二分处理（其实这里也没有理解的很好，但主席树真的调了超级无敌久）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define int long long
typedef pair<int, int> PII;
const int N = 2e5 + 10, INF = 1000000000, inf = 1e18;

struct node {
    int ls, rs;
    int sz;
    int sum;
};

node tr[N * 35];
int idx = 0;
int rt[N];
int n, ans[N];
pair<int, int> v[N];
bool cmp(PII x, PII y)
{
	return x.second < y.second;
}
int add(int p, int l, int r, int x)
{ // 插入
	int q = ++ idx;
	if (p != 0)  tr[q] = tr[p];
	if (l == r)
	{
		tr[q].sz += 1;
		tr[q].sum += x;
		return q;
	}
	int mid = l + r >> 1;
	if (x <= mid) tr[q].ls = add(tr[p].ls, l, mid, x);
	else tr[q].rs = add(tr[p].rs, mid + 1, r, x);
	tr[q].sz = tr[tr[q].ls].sz + tr[tr[q].rs].sz;
	tr[q].sum = tr[tr[q].ls].sum + tr[tr[q].rs].sum;
	return q;
}

int query(int p, int l, int r, int k)
{
	if (p == 0) return 0;
	if (l == r) return l * k;
	int mid = l + r >> 1;
	if (tr[tr[p].rs].sz >= k) return query(tr[p].rs, mid + 1, r, k);
	else return tr[tr[p].rs].sum + query(tr[p].ls, l, mid, k - tr[tr[p].rs].sz);
}
int ask(int k, int x)
{
	return query(rt[x - 1], -INF, INF, k - 1) + v[x].first - v[x].second;
}
void work(int l, int r, int L, int R)
{
	if (l > r) return;
	int mid = l + r >> 1;
	ans[mid] = -inf;
	int pos;
	for (int i = max(mid, L); i <= R; i ++ )
	{
		int tmp = ask(mid, i);
		if (tmp > ans[mid]) ans[mid] = tmp, pos = i;
	}
	work(l, mid - 1, L, pos);
	work(mid + 1, r, pos, R);
}
signed main()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> v[i].first >> v[i].second;
	}
	sort(v + 1, v + 1 + n, cmp);

	for (int i = 1; i <= n; i++)
	{
		rt[i] = add(rt[i - 1], -INF, INF, v[i].first);
	}
	work(1, n, 1, n);
	for (int i = 1; i <= n; i++)
	{
		cout << ans[i] << endl;
	}
	return 0;
}

CF-1286B-Numbers on Tree

题目链接

有意思的构造，构造题还是容易想复杂啊

想到了把每个点赋值 [1, n]，但是没注意到 n 挺小的完全暴力查找就可以，一直在想怎么二分找值。。。

树上构造的大致思路还是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 = 2e5 + 10;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n;
	cin >> n;
	vector<int> p(n + 1), c(n + 1);
	vector<vector<int>> g(n + 1);
	int root = 0;
	for (int i = 1; i <= n; i ++ )
	{
		cin >> p[i] >> c[i];
		g[p[i]].push_back(i);
		if (p[i] == 0) root = i;
	}
	vector<int> sz(n + 1);
	function<void(int, int)> dfs1 = [&](int u, int fa)
	{
		sz[u] = 1;
		for (int i = 0; i < g[u].size(); i ++ )
		{
			int j = g[u][i];
			if (j == fa) continue;
			dfs1(j, u);
			sz[u] += sz[j];
		}
	};
	dfs1(root, -1);
	vector<int> ans(n + 1);
	vector<int> st(n + 1);
	auto find_a = [&](int x)
	{
		int cnt = 0;
		for (int i = 1; i <= n; i ++ )
		{
			if (!st[i])
			{
				cnt ++ ;
				if (cnt == x + 1)
				{
					st[i] = true;
					return i;
				}
			}
		}
		return (i64)-1;
	};
	function<bool(int, int)> dfs2 = [&](int u, int fa)
	{
		int tmp = find_a(c[u]);
		if (tmp == -1) return false;
		if (sz[u] - 1 < c[u]) return false;
		ans[u] = tmp;
		for (int i = 0; i < g[u].size(); i ++ )
		{
			int ver = g[u][i];
			if (ver == fa) continue;
			if (!dfs2(ver, u)) return false;
		}
		return true;
	};
	if (dfs2(root, -1))
	{
		cout << "YES\n";
		for (int i = 1; i <= n; i ++ ) cout << ans[i] << ' ';
	}
	else cout << "NO\n";
}

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

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

ATC - abc350

C - Airport Code

暴力判断

#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 = 2e5 + 10;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	string s, t;
	cin >> s >> t;
	int flag = 0;
	for (int i = 0; i < s.size(); i ++ )
	{
		if (s[i] >= 'a' && s[i] <= 'z') s[i] += 'A' - 'a';
		if (s[i] == t[flag]) flag ++ ;
		if (flag == 3)
		{
			cout << "Yes\n";
			return;
		}
	}
	if (flag == 2 && t[2] == 'X') cout << "Yes\n";
	else cout << "No\n";
}

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

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

D - Divide Interval（贪心）

首先很容易想到要让每个 2 i 2^i 2i 尽可能大（所以 j × 2 i j\times2^i j×2i 里的 j 必须是奇数，因为偶数可以直接再出一个2），但让 2 i 2^i 2i 尽可能大的同时不要忘了让 l + 2 i l+2^i l+2i 不超过 r r r，找到同时满足这两个条件的一个数，再往后贪心下去

#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 = 2e5 + 10;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int l, r;
	cin >> l >> r;
	vector<PII> ans;
	while (l < r)
	{
		int p1 = 1;
		int p2 = l;
		while (p2 % 2 == 0 && l + p1 <= r)
		{
			p2 /= 2;
			p1 *= 2;
		}
		while (l + p1 > r)
		{
			p1 /= 2;
		}
		ans.push_back({l, l + p1});
		l = l + p1;
	}
	cout << ans.size() << '\n';
	for (auto t : ans) cout << t.first << ' ' << t.second << '\n';
}

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

	int t = 1;
	// cin >> t;
	while (t--)
	{
		solve();
	}
}
Texcavator
关注
  • 13
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
题解 | avg(s.salary)作为字段名，要加双引号
2301_78234743的博客
04-22 1040
发个面经，攒攒人品时间线：3.26投递--3.31笔试--4.11被捞约面--4.12一面--面完秒。面试首先是自我介绍，然后问一下项目，接着对恒生的了解，八股什么也没问，就纯聊天，大概十分钟左右[疑惑。时间线-------笔试，3.09-------ac 4.03前期：被美团优选、无人车挂------有人有消息了吗，又是漫长的等待，我已经快麻了引流，引流 #牛客帮帮团来啦！有问必答# #软件开发薪资。三面后一直在横向对比，以为凉了，周四HR约面1.自我介绍2.工作中碰到的最难的问题，如何解决的3.工。
2021.03.18 训练
Mei_Tou_Nao_的博客
03-27 1239
7-1 简单题 7-2 计算指数 7-3 A除以B 7-4 洛希极限 7-5 输出分数的最简形式 7-6 吃火锅 7-7 出租 7-8 前世档案 7-9 简单计算器 7-10 口罩发放 7-11 完全二叉树的层序遍历 7-12 冰岛人 7-13 代码排版 7-14 传送门 7-15 计算图 7-1 简单题 7-2 计算指数 7-3 A除以B 7-4 洛希极限 7-7 出租 7-8 前世档案 7-9 简单计算器 7-10 口罩发放 7-11 完全二叉树的层序遍历 7-12 冰岛人
运行代码（环境，问题等等）
m2272536077的博客
07-02 751
运行官方项目记录
2020-9-21训练
行走天涯的豆沙包的博客
09-21 399
B. Balls of Buma 祖玛游戏，如果我们只射出一个子弹可以把所有都消掉的话那么我们分段的数量一定是一个奇数，然后对称的地方的种类是相同的并且对称位置相加后的数字一定是大于3的。 #include <bits/stdc++.h> //#define int long long using namespace std; const int N=3e5+10; int a[N],pos[N]; char s[N]; void solve() { cin>>s+1;
目标跟踪论文代码汇总
如果想成为中心，那么就到中心去吧。
07-21 520
近年来，分割任意模型（SAM）因其对图像分割性能而迅速获得了广泛的关注。由于其较强的图像分割能力和不同提示的高交互性，我们发现其在视频一致性分割效果较差。因此，在本报告中，我们提出了跟踪任何事物模型（TAM），它可以在视频中实现高性能的交互式跟踪和分割。详细地说，给定一个视频序列，只有很少的人类参与，也就是说，几次点击，人们可以跟踪任何他们感兴趣的东西，并在本体推理中得到令人满意的结果。没有额外的训练，这种交互式设计执行的视频对象跟踪和分割令人印象深刻。
【2024校招总结帖】数据分析、面试经验、心得体会分享
华鑫的专栏
04-30 591
工作节奏比较快，公司对员工的加班要求也比较严格，而且没有加班费，缺乏福利待遇。只有一个面试官，人挺好的，见我答不上来就赶紧换题[赞]。最后7个月想极限改命一波，有英语基础，数学忘得差不多了，所以408挑战不了，有没有22自命题推荐的，#华兴源创# 这家公司真不行，芯片测试岗位，乱刷人，人事之前打电话也没说会刷人，去培训之后，60个估。面试体验：有难度，体验不算好面试结果：被告知要等一到两周，感觉希望不大面试流程：4.17 投了简历，末九本，二战失败出来找工作，投了几十家只面了个电信，而且终面还挂了。
华为 笔试 4.24 第二题：这一题只通过了36%why
2301_78234743的博客
04-24 1770
小米# #小米求职进展汇总#rt，投的日常实习，自动驾驶方向，因为暑期实习没有想去的岗位。只有一面，本人是自动化专业，简历上主要是嵌入式方向的，面试的岗位是。担惊受怕日子我真的过够了，每天对电话和信息都应激了，虽然感觉二面我回答的很勾史，但是还是希望美团救救。这次只问了第一个java项目，先介绍有无难点，然后问了某块设计的流程，问库存秒杀流程，然后就问到了r。目前面过的厂如下：美团，整个暑期实习的第一面，表现太差，一面挂。
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 569
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 509
四、实验结果。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 641
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1056
动态规划
第四讲：拟合算法
PGeorge6的博客
09-03 1321
与插值问题不同，在拟合问题中不需要曲线一定经过给定的点。拟合问题的目标是寻求一个函数(曲线)使得该曲线在某种准则下与所有的数据点最为接近，即曲线拟合的最好(最小化损失函数)。插值算法中，得到的多项式f(x)要经过所有样本点。但是如果样本点太多，那么这个多项式次数过高，会造成龙格现象。尽管我们可以选择分段的方法避免这种现象，但是更多时候我们更倾向于得到-个确定的曲线，尽管这条曲线不能经过每一个样本点，但只要保证误差足够小即可，这就是拟合的思想。(拟合的结果是得到一个确定的曲线)
树状数组记录
最新发布
volcan的博客
09-06 483
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 297
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 340
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 428
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1089
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 427
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
1.0e-4 240.0 500.0 240.0 1000.0 240.0 1500.0 240.0 2000.0 240.0 2500.0 240.0 3000.0 240.0 3500.0 205.0 4000.0 180.0 4500.0 160.0 5000.0 140.0 5500.0 130.0 6000.0 120.0 6500.0 110.0 7000.0 105.0 7500.0 95.0 1.0 -229.183 750.0 -229.1831181 1500.0 -235.5493158 2250.0 -237.6713817 3000.0 -238.7324146 3750.0 -190.9859317 4500.0 -159.1549431 5250.0 -136.4185227 6000.0 -119.3662073 6750.0 -106.1032954 7500.0 -95.49296586 第一列是电机的转速（1/min），第二列是电机的转矩（Nm），请问这个电机是多少kw的？
07-10
1.0e-4 rpm: 0 kW 500.0 rpm: 0 kW 1000.0 rpm: 0 kW 1500.0 rpm: 0 kW 2000.0 rpm: 0 kW 2500.0 rpm: 0 kW 3000.0 rpm: 0 kW 3500.0 rpm: 2.24 kW 4000.0 rpm: 3.37 kW 4500.0 rpm: 3.79 kW 5000.0 rpm: 4.21 kW ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Texcavator

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值