Codeforces 374D Inna and Sequence 二分+树状数组

本文探讨了如何通过一系列操作来模拟字符串的增删过程,包括向字符串添加字符和删除特定位置的字符,通过简单的模拟实现字符串的动态变化。

题目链接:点击打开链接

给定n个操作,m长的序列a
下面n个数

if(co>=0)则向字符串添加一个co (开始是空字符串)

else 删除字符串中有a的下标的字符

直接在序列上搞,简单模拟

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<set>
#include<vector>
#include<map>
#include<math.h>
#include<string>
#include<stdlib.h>
#include<algorithm>
using namespace std;
#define N 1000005
bool use[N], b[N];
int top;
int n, m;
int a[N];
int c[N], maxn;
inline int lowbit(int x){return x&(-x);}
void change(int pos, int val){
	while(pos<=maxn){
		c[pos]+=val;
		pos+=lowbit(pos);
	}
}
int sum(int pos){
	int ans = 0;
	while(pos)ans+=c[pos], pos-=lowbit(pos);
	return ans;
}
set<int>myset;
set<int>::iterator p;
void Erase(int pos, int r){
	int l = 1;
	while(l<=r) {
		int mid = (l+r)>>1;
		int tmp = sum(mid);
		if(tmp==pos) {
			p = myset.upper_bound(mid);
			p--;
			mid = *p;
			change(mid, -1);
			use[mid] = 1;
			myset.erase(p);
			return ;
		}
		if(tmp>pos) r = mid-1;
		else l = mid+1;
	}
}
void init(){myset.clear(); memset(c, 0, sizeof c); maxn = n+10; top = 0;}
int main(){
	int i,j,co;
	while(~scanf("%d %d",&n,&m)){
		init();
		for(i=0;i<m;i++)scanf("%d",&a[i]);
		int len = 0;
		for(i = 1; i <= n; i++) {
			scanf("%d",&co);
			if(co>=0)
				use[i] = 0, b[i] = co, change(i,1), len++, myset.insert(i);
			else {
				use[i] = 1;
				int j = lower_bound(a, a+m, len) - a;
				if(j==0 && len<a[0])continue;
				if(len!=a[j])j--;
				while(j>=0) {
					Erase(a[j], i);
					j--;
					len--;
				}
			}
		}

		if(!len)puts("Poor stack!");
		else {
			for(i = 1; i <= n; i++) if(!use[i])
				printf("%d",b[i]);
			puts("");
		}
	}
	return 0;
}


<think>首先,用户的问题是关于一个算法问题的:使用“堆优化Dijkstra + bool数组标记 + dist数组记录权重”是否能通过一道题。但用户没有指定具体的题目,所以我需要基于上下文来推测。之前的对话是关于最小生成树的,特别是Kruskal算法,但这次用户提到了Dijkstra算法,这是用于单源最短路径的。 用户的问题似乎是针对某个具体的编程问题,但这里没有提供题目描述。所以,在回答时,我需要给出一般性的建议,并假设这是一个最短路径问题。 关键元素: - **堆优化Dijkstra**:这是Dijkstra算法的优化版本,使用优先队列(通常是堆)来高效地选择下一个要处理的节点。 - **bool数组标记**:这通常是一个布尔数组(如`visited`数组),用于标记节点是否已被访问过,以避免重复处理。 - **dist数组记录权重**:`dist`数组存储从源点到每个节点的最短距离。 在标准Dijkstra算法中,这些组件是常见的: - 堆优化:减少时间复杂度,从O(V^2)到O(E + V log V)。 - bool数组:用于标记节点是否已确定最短路径。 - dist数组:存储当前已知的最短距离。 所以,对于大多数最短路径问题(尤其是正权重图),这个组合应该是有效的。 现在,回答结构: 1. **回答用户的问题**:我需要确认是否这个组合能通过题目。既然没有具体题目,我可以说在一般情况下,对于单源最短路径问题(非负权重),这个方法是标准且高效的。但如果有特定约束(如负权重、大图等),可能需要调整。 2. **提供代码示例**:用户之前的示例中有Python代码,所以我应该给出一个简单的Dijkstra算法实现,使用堆优化、bool数组和dist数组。 3. **提出3-5个相关问题**:在末尾,必须以“§§相关问题§§”开头,然后列出问题。问题应该基于用户的问题和我的回答。 用户消息的最后部分:"堆优化dijstra+bool数组标记+dist数组记录权重,是否能通过这道题"。这里的“这道题”可能指的是一个隐含的题目,但从上下文看,似乎是通用的。或许是之前的“牧场”问题,但Dijkstra用于最短路径,不是MST。 在之前的对话中,用户提到了“枚举牧场作为起点”,这可能暗示一个需要从每个节点计算最短路径的问题,比如所有对最短路径或多源最短路径。但Dijkstra通常是单源的。如果用户想从每个起点运行Dijkstra,那可能会用到堆优化版本。 所以,在回答中,我应该: - 解释堆优化Dijkstra的适用性。 - 给出一个代码示例。 - 讨论在枚举起点时的情况。 代码示例:我将写一个Python函数,实现堆优化的Dijkstra算法。 伪代码或实际代码: ```python import heapq def dijkstra(graph, start): n = len(graph) dist = [float('inf')] * n dist[start] = 0 visited = [False] * n # bool数组标记 heap = [(0, start)] # (distance, node) while heap: d, node = heapq.heappop(heap) if visited[node]: continue visited[node] = True for neighbor, weight in graph[node]: new_dist = d + weight if new_dist < dist[neighbor]: dist[neighbor] = new_dist heapq.heappush(heap, (new_dist, neighbor)) return dist ``` 在这个代码中: - `graph` 是一个邻接表,例如 `graph[i]` 是列表的元组 `(neighbor, weight)`。 - 使用 `heapq` 实现最小堆。 - `visited` 数组确保每个节点只处理一次。 - `dist` 数组记录最短路径权重。 现在,回答是否能通过题目:一般来说,对于非负权重图,这个算法是正确且高效的。但如果题目有负权重,Dijkstra可能不适用(需要Bellman-Ford)。如果图很大,堆优化是必要的。如果题目要求多源,可能需要多次调用Dijkstra。 最后,提出相关问题: 1. 堆优化Dijkstra算法的时间复杂度是多少? 2. 如果图中存在负权边,Dijkstra算法还能使用吗? 3. 如何修改代码以记录最短路径本身,而不仅仅是距离? 4. 在稀疏图和稠密图中,堆优化Dijkstra的性能如何比较? 5. 如果从每个节点运行Dijkstra,总时间复杂度是多少? 确保3-5个问题。 输出格式: - 先回答问题。 - 然后代码块(用```python ... ```)。 - 然后“§§相关问题§§”开头,列出问题。 完整回答: 首先,解释是否能通过:是的,对于大多数单源最短路径问题(非负权重),这个组合是有效的。 然后,提供代码。 最后,相关问题。</think>基于您的查询,使用“堆优化Dijkstra + bool数组标记 + dist数组记录权重”的方法,在解决单源最短路径问题(图边权重非负)时是标准且高效的。该组合能通过大多数相关题目(如LeetCode、CodeForces中的最短路径问题),原因如下: - **堆优化Dijkstra**:使用优先队列(最小堆)高效选择下一个节点,时间复杂度优化为O(E + V log V),适合稀疏图。 - **bool数组标记**:记录节点是否被访问(`visited`数组),避免重复处理。 - **dist数组**:存储从源点到各节点的最短距离。 在非负权重图中,该方法是正确的。但如果题目有特殊约束(如负权重、大输入规模或需多源处理),可能需要调整(例如负权重需用Bellman-Ford)。以下是一个Python实现示例: ```python import heapq def dijkstra(graph, start): n = len(graph) dist = [float('inf')] * n # 初始化dist数组,记录权重 dist[start] = 0 visited = [False] * n # bool数组标记节点访问状态 heap = [(0, start)] # 最小堆:(距离, 节点) while heap: d, node = heapq.heappop(heap) if visited[node]: # 跳过已访问节点 continue visited[node] = True for neighbor, weight in graph[node]: new_dist = d + weight if new_dist < dist[neighbor]: dist[neighbor] = new_dist heapq.heappush(heap, (new_dist, neighbor)) return dist # 示例使用:graph为邻接表,graph[0] = [(1, 2), (2, 5)] 表示节点0到1的边权重为2。 # result = dijkstra(graph, 0) # 从节点0开始 ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值