【算法2-2】线性复杂度优化 / 离散化

已于 2022-02-08 14:34:59 修改
阅读量623 收藏
点赞数
分类专栏： 洛谷 文章标签： 算法 c++
于 2022-02-03 16:45:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53199925/article/details/122776092
版权

P1950 长方形

题目链接：P1950 长方形 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <stack>
#include <cstring>
using namespace std;
char a[1010][1010];
int h[1010], g1[1010], g2[1010];

int main() {
	long long n, m, ans = 0;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> a[i] + 1;
		for (int j = 1; j <= m; j++) {
			if (a[i][j] == '*') {
				h[j] = 0;
			} else {
				h[j]++;
			}
		}
		memset(g1, 0, sizeof(g1));
		memset(g2, 0, sizeof(g2));
		stack<int>s;
		for (int j = 1; j <= m; j++) {
			while (!s.empty() && h[s.top()] > h[j]) {
				g2[s.top()] = j - 1;
				s.pop();
			}
			s.push(j);
		}
		while (!s.empty()) {
			g2[s.top()] = m;
			s.pop();
		}
		for (int j = m; j >= 1; j--) {
			while (!s.empty() && h[s.top()] >= h[j]) {
				g1[s.top()] = j + 1;
				s.pop();
			}
			s.push(j);
		}
		while (!s.empty()) {
			g1[s.top()] = 1;
			s.pop();
		}
		for (int j = 1; j <= m; j++) {
			ans += (j - g1[j] + 1) * (g2[j] - j + 1) * h[j];
		}
	}
	cout << ans;
	return 0;
}

P2032 扫描

题目链接：P2032 扫描 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <deque>
using namespace std;
int a[2000010];
deque<int>d;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	for (int i = 1; i <= n; i++) {
		while (!d.empty() && i - d.front() >= k) {
			d.pop_front();
		}
		while (!d.empty() && a[d.back()] < a[i]) {
			d.pop_back();
		}
		d.push_back(i);
		if (i >= k) {
			cout << a[d.front()] << endl;
		}
	}
	return 0;
}

参考博客：算法学习笔记(66): 单调队列 - 知乎 (zhihu.com)

P1440 求m区间内的最小值

题目链接：P1440 求m区间内的最小值 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <deque>
using namespace std;
int a[2000010];
deque<int>d;

int main() {
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	cout << 0 << endl;
	for (int i = 1; i <= n - 1; i++) {
		while (!d.empty() && i - d.front() >= m) {
			d.pop_front();
		}
		while (!d.empty() && a[d.back()] > a[i]) {
			d.pop_back();
		}
		d.push_back(i);
		printf("%d\n", a[d.front()]);
	}
	return 0;
}

P1886 滑动窗口 /【模板】单调队列

题目链接：P1886 滑动窗口 /【模板】单调队列 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <deque>
using namespace std;
int a[1000010];
deque<int>d1, d2;

int main() {
	int n, k;
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	for (int i = 1; i <= n; i++) {
		while (!d1.empty() && i - d1.front() >= k) {
			d1.pop_front();
		}
		while (!d1.empty() && a[d1.back()] > a[i]) {
			d1.pop_back();
		}
		d1.push_back(i);
		if (i >= k) {
			printf("%d ", a[d1.front()]);
		}
	}
	cout << endl;
	for (int i = 1; i <= n; i++) {
		while (!d2.empty() && i - d2.front() >= k) {
			d2.pop_front();
		}
		while (!d2.empty() && a[d2.back()] < a[i]) {
			d2.pop_back();
		}
		d2.push_back(i);
		if (i >= k) {
			printf("%d ", a[d2.front()]);
		}
	}
	return 0;
}

P3143 [USACO16OPEN]Diamond Collector S

题目链接：P3143 [USACO16OPEN]Diamond Collector S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <algorithm>
using namespace std;
int a[50005], b[50005];

int main() {
	int n, k, t = 0, le = 0, ans = 0;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	sort(a, a + n);
	for (int i = 0; i < n; i++) {
		while (t < n && a[t] - a[i] <= k) {
			t++;
		}
		b[t] = max(b[t], t - i);
		le = max(le, b[i]);
		ans = max(ans, le + t - i);
	}
	cout << ans;
	return 0;
}

P1638 逛画展

题目链接：P1638 逛画展 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <deque>
using namespace std;
int c[1000010], d[2010], minn = 1 << 30;
deque<int>q;

int main() {
	int n, m, a, b, cnt = 0;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> c[i];
		if (!d[c[i]]) {
			cnt++;
		}
		d[c[i]]++;
		q.push_back(i);
		while (!q.empty() && d[c[q.front()]] > 1) {
			d[c[q.front()]]--;
			q.pop_front();
		}
		if (cnt == m && minn > q.size()) {
			minn = q.size();
			a = q.front();
			b = q.back();
		}
	}
	cout << a << ' ' << b;
	return 0;
}

P1419 寻找段落

题目链接：P1419 寻找段落 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <deque>
#include <cstring>
#include <iomanip>
using namespace std;
int n, s, t;
double a[100010];
double sum[100010];

bool check(double x) {
	memset(sum, 0, sizeof(sum));
	for (int i = 1; i <= n; i++) {
		sum[i] = sum[i - 1] + a[i] - x;
	}
	deque<int>q;
	for (int i = 1; i <= n; i++) {
		if (i >= s) {
			while (!q.empty() && sum[q.back()] > sum[i - s]) {
				q.pop_back();
			}
			q.push_back(i - s);
		}
		if (!q.empty() && q.front() < i - t) {
			q.pop_front();
		}
		if (!q.empty() && sum[i] - sum[q.front()] >= 0) {
			return true;
		}
	}
	return false;
}

int main() {
	cin >> n >> s >> t;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	double Left = -10000, Right = 10000;
	while (Right - Left > 1e-5) {
		double mid = (Left + Right) / 2;
		if (check(mid)) {
			Left = mid;
		} else {
			Right = mid;
		}
	}
	cout << setprecision(3) << fixed << Left;
	return 0;
}

P2882 [USACO07MAR]Face The Right Way G

题目链接：P2882 [USACO07MAR]Face The Right Way G - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <cstring>
using namespace std;
int a[5005], d[5005];

int main() {
	int n, ansm = 1 << 30, ansk;
	char c;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> c;
		if (c == 'F') {
			a[i] = 1;
		}
	}
	for (int k = 1; k <= n; k++) {
		memset(d, 0, sizeof(d));
		bool flag = 1;
		int now = 0, cnt = 0;
		for (int i = 1; i <= n; i++) {
			now ^= d[i];
			if (now ^ a[i] == 0) {
				if (i + k - 1 > n) {
					flag = 0;
					break;
				}
				now ^= 1;
				d[i + k] ^= 1;
				cnt++;
			}
		}
		if (flag && ansm > cnt) {
			ansm = cnt;
			ansk = k;
		}
	}
	cout << ansk << ' ' << ansm;
	return 0;
}

参考博客：差分 --算法竞赛专题解析（32）_罗勇军的博客-CSDN博客_差分算法 

P1147 连续自然数和

题目链接：P1147 连续自然数和 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
using namespace std;

int main() {
	int m;
	cin >> m;
	for (int i = 1; i <= m / 2; i++) {
		int sum = 0, j;
		for (j = i; j <= m; j++) {
			sum += j;
			if (sum >= m) {
				break;
			}
		}
		if (sum == m) {
			cout << i << ' ' << j << endl;
		}
	}
	return 0;
}

P4086 [USACO17DEC]My Cow Ate My Homework S

题目链接：P4086 [USACO17DEC]My Cow Ate My Homework S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <algorithm>
using namespace std;
double a[100010], sum[100010], minn[100010];
double avg[100010];

int main() {
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		minn[i] = 10010;
	}
	minn[n + 1] = 10010;
	for (int i = n; i >= 2; i--) {
		minn[i] = min(minn[i + 1], a[i]);
		sum[i] = sum[i + 1] + a[i];
		if (i != n) {
			avg[i] = (sum[i] - minn[i]) / (double)(n - i);
		}
	}
	double maxx = 0;
	for (int i = 2; i <= n - 1; i++) {
		maxx = max(maxx, avg[i]);
	}
	for (int i = 2; i <= n - 1; i++) {
		if (maxx == avg[i]) {
			cout << i - 1 << endl;
		}
	}
	return 0;
}

P3124 [USACO15OPEN]Trapped in the Haybales S

题目链接：P3124 [USACO15OPEN]Trapped in the Haybales S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <algorithm>
using namespace std;

struct A {
	int pos, size;
} a[100010];

bool cmp(A a1, A a2) {
	return a1.pos < a2.pos;
}

int main() {
	int n, b, now, ans = 1 << 30;
	cin >> n >> b;
	for (int i = 1; i <= n; i++) {
		cin >> a[i].size >> a[i].pos;
	}
	sort(a + 1, a + n + 1, cmp);
	for (int i = 1; i <= n; i++) {
		if (a[i].pos > b) {
			now = i;
			break;
		}
	}
	int l = now - 1, r = now, d = a[r].pos - a[l].pos;
	while (l >= 1 && r <= n) {
		if (a[l].size >= d && a[r].size >= d) {
			cout << 0;
			return 0;
		}
		if (a[r].size < d) {
			r++;
			d += a[r].pos - a[r - 1].pos;
			continue;
		}
		if (a[l].size < d) {
			ans = min(ans, d - a[l].size);
			l--;
			d += a[l + 1].pos - a[l].pos;
		}
	}
	l = now - 1;
	r = now;
	d = a[r].pos - a[l].pos;
	while (l >= 1 && r <= n) {
		if (a[l].size >= d && a[r].size >= d) {
			cout << 0;
			return 0;
		}
		if (a[l].size < d) {
			l--;
			d += a[l + 1].pos - a[l].pos;
			continue;
		}
		if (a[r].size < d) {
			ans = min(ans, d - a[r].size);
			r++;
			d += a[r].pos - a[r - 1].pos;
		}
	}
	if (ans == (1 << 30)) {
		cout << -1;
	} else {
		cout << ans;
	}
	return 0;
}

P1496 火烧赤壁

题目链接：P1496 火烧赤壁 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include <iostream>
#include <algorithm>
using namespace std;
int a[20010], b[20010];

int main() {
	int n, ans = 0;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i] >> b[i];
	}
	sort(a, a + n);
	sort(b, b + n);
	for (int i = 0; i < n; i++) {
		ans += b[i] - a[i];
		if (i != n - 1) {
			if (b[i] > a[i + 1]) {
				ans -= b[i] - a[i + 1];
			}
		}
	}
	cout << ans;
	return 0;
}

P1884 [USACO12FEB]Overplanting S

题目链接：P1884 [USACO12FEB]Overplanting S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

参考博客：扫描线 - Ling_Lover - 博客园 (cnblogs.com) 

【算法】线段树详解__Alexander_的博客-CSDN博客_线段树详解 

Brosto_Cloud
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算线性复杂度 BM算法
07-24
BM算法，用于计算序列的线性复杂度及其反馈多项式。使用JAVA实现
线性复杂度优化 / 离散化
srh20的博客
09-11 531
文章目录1.连续自然数和2.扫描3. 1.连续自然数和 传送门 1.数论推公式做法： 思路： 假设连续子段为[L,R],则这段的和为(L+R)(R-L+1)/2=M,（等差数列求和公式） (L+R)(R-L+1)=2M; 设x=L+R,y=R-L+1,联立得 L=(x-y+1)/2,R=(x+y-1)/2; （1）L，R要是整数，则x,y必须一奇一偶； （2）L!=R ，则x!=1. 所以x从sqrt(2M)枚举到2,如果满足y为整数且为一奇一偶，则输出L,R 代码如下： #include <bit
洛谷：P1147 连续自然数和（普及-，【算法2-2】线性复杂度优化 / 离散化）
weixin_42721412的博客
09-14 279
题目： 分析：终于，还算是能想出来一个题。 正着暴力不如倒着暴力，想i想，很清楚的。 代码： #include<bits/stdc++.h> using namespace std; int m; int main() { cin>>m; int e=(m+1)/2; vector<int> v; int sum=e; for(int i=e-1;i>=0;i--) { if(i+sum==m){ v.push_back(e);v.push_
短学期 线性复杂度优化 / 离散化
北边小洛的博客
07-12 316
https://www.luogu.com.cn/problem/P1950 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #define N 1007 #define int long long using namespace std; int n, m, now, ans; int high[N]; signed main() { //scanf("%l
洛谷：P2032 扫描（普及/提高-，滑动窗口，线性复杂度优化 / 离散化）
weixin_42721412的博客
09-14 136
题目： 分析：滑动窗口基础题。 只有上升的最后一个才可能是最大值的候选。 又卡住了，在想我怎么知道现在存的数还在队列中呢？ 记得再leetcode上做过，翻解。很简单， 那你存坐标呀。 上次leetcode也是卡这里了，无语啊。 写不出来。。。。。 代码： ...
2-回归算法.7z2-回归算法.7z
07-03
4. **岭回归**：为了解决线性回归中的过拟合问题，岭回归引入了L2正则化，通过增加惩罚项来约束模型复杂度。 5. **Lasso回归**：与岭回归类似，Lasso回归（Least Absolute Shrinkage and Selection Operator）引入...
MATLAB源码集锦-基于枚举法离散型优化问题代码
02-14
- MATLAB的Global Optimization Toolbox提供了多种全局优化算法，包括混合整数线性规划（MIQP）、遗传算法、模拟退火等，适用于更复杂的离散优化问题。 - 除了枚举法，还可以利用工具箱中的其他算法，如分支定界、...
编程实现按时间抽取的基2FFT算法1
08-08
**编程实现按时间抽取的基2FFT算法** 在数字信号处理领域，快速傅里叶变换（FFT）是一种高效的计算离散傅里叶变换（DFT）的方法，尤其适用于大规模数据的处理。本项目由小组成员张豪、贾雪琪、王珍琨共同完成，主要...
离散优化算法课件
01-05
4. **随机化技术**：如模拟退火、遗传算法、粒子群优化等，这些方法常用于处理复杂、难解的离散优化问题，它们能够跳出局部最优，寻找全局最优。 5. **近似算法与NP完全问题**：对于某些难以求解的离散优化问题，如...
常用正则化MATLAB算法-附带详细说明
06-11
2. **L1正则化**：又称为Lasso回归，它会强制某些参数变为零，从而实现特征选择，降低模型的复杂度。 3. **L曲线法**：是一种选择正则化参数λ的有效方法，通过绘制模型误差与正则化项之和的曲线，选择转折点附近的...
洛谷题单【算法2-2】线性复杂度优化 / 离散化
Tracy_yi的博客
08-11 228
洛谷题单自用整理
P1147 连续自然数和
lannister_awalys_pay的博客
08-18 187
题目描述 对一个给定的自然数MM，求出所有的连续的自然数段，这些连续的自然数段中的全部数之和为MM。 例子：1998+1999+2000+2001+2002=100001998+1999+2000+2001+2002=10000，所以从19981998到20022002的一个自然数段为M=10000M=10000的一个解。 输入格式 包含一个整数的单独一行给出M的值（10≤M≤2,000,...
左偏树(DP)问题
weixin_30808253的博客
06-10 104
问题：A straight dirt road connects two fields on FJ's farm, but it changes elevation more than FJ would like. His cows do not mind climbing up or down a single slope, but they are not fond of an alterna...
POJ 3666 Making the Grade——DP + 离散化
hao_zong_yin的博客
09-02 244
首先这道题有问题，只需要考虑上升的情况，考虑下降的情况就错了。 dp[i][j]表示到第i个位置高度为j时的最小花费 状态转移方程为dp[i][j] = min{dp[i - 1][k]|1 很明显这是一个O(n^3)的状态转移方程，但可以写做dp[i][j] = dp_min[i][j] + |a[j] - a[i]|, 在递推时将dp_min一起递推就可以省去一层循环， 把复杂度优化到O
有限序列线性复杂度和k-错线性复杂度的计算 —— 密码与密码工程实践No.2
无名的博客
06-26 929
有限序列线性复杂度和k-误差线性复杂度的计算 在本节中，我们的目标是开发算法，计算有限序列的线性复杂度和k-误差线性复杂度，将其视为周期为2次方的二进制序列的初始段（我们不需要知道是哪一次方）。 注意，任何周期为2v{{2}^{v}}2v的无穷序列s∈Ts\in \Taus∈T，其中 最小，c(s)≤2vc(s)\le {{2}^{v}}c(s)≤2v。因此，如果我们知道s的至少2c(s)2c(s)2c(s)项，我们实际上知道序列的整个周期，即我们知道整个序列。 我们将用 表示周期任意幂为2的二进制序列集，
数据结构与算法二：时间/空间复杂度（complexity）
沐风
06-29 861
从架构的角度来看，可扩展性是指更改 app 的难易程度。从数据库的角度来看，可伸缩性是指在数据库中保存或检索数据所需的时间快慢程度。对于算法，可扩展性是指随着输入大小的增加，算法在执行时间和内存使用方面的表现情况。当处理少量数据时，不好的算法（时间、空间代价昂贵）可能仍然让人感觉执行速度很快。然而，随着数据量的增加，昂贵的算法将会变得很糟糕。只是它会变得多糟糕呢？如何量化这个糟糕程度是我们需要了解的一项重要技能。对于少量数据，由于现代硬件的速度，即使是最昂贵的算法也可能看起来执行速度很快。然而，随着数据的增
P1884 [USACO12FEB]Overplanting S——洛谷
Annabel_CM的博客
08-15 742
解题思路： 离散化 + 差分矩阵 解题步骤： 因为原始坐标系与差分的坐标系不同，所以要进行坐标系的变换 离散化处理缩小查找空间 图中坐标离散化后，再转化为格子的坐标，因为之前存贮的坐标是点的坐标，每个格子存储一个矩形 #include<iostream> #include<vector> #include<algorithm> #include<map> using namespace std; typedef pair<int, int&gt.
离散化问题整理
hacker__man的博客
07-21 667
离散化问题整理
线段树+扫描线【p1884】[Usaco12FEB]过度种植（银）Overplanting …
weixin_30381793的博客
10-31 137
Description 在一个笛卡尔平面坐标系里（则X轴向右是正方向，Y轴向上是正方向），有\(N(1<=N<=1000)\)个矩形，第i个矩形的左上角坐标是\((x1, y1)\),右下角坐标是\(（x2,y2）\)。问这\(N\)个矩形所覆盖的面积是多少？注意：被重复覆盖的区域的面积只算一次。 Input 第一行，一个整数Ｎ。 \((1<=N<=1000)\)。 接下...
华侨大学自动化专业-数字信号处理ppt教学(与“专业”相关共44张).pptx
最新发布
11-14
1. **离散傅里叶变换（DFT）的计算复杂度**：DFT原本的时间复杂度为O(N^2)，其中N是序列的长度，因为需要进行N个复数乘法和N(N-1)/2个复数加法。这在处理大规模数据时效率低下。 2. **提高运算效率的动机**：为了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值