数据结构以及图论补充

最新推荐文章于 2024-08-07 19:21:33 发布
最新推荐文章于 2024-08-07 19:21:33 发布
阅读量353 收藏
点赞数
文章标签： 数据结构 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenchlove/article/details/128060952
版权

线段树：
一、单点修改，区间查询

#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 100;
int n, Q;
int a[maxn];
int suma[maxn];
typedef struct
{
	int l, r;
	int sum;
}T;
T t[maxn << 1];

inline void build(int rt, int l, int r)
{
	t[rt].l = l;
	t[rt].r = r;
	if (l == r)
	{
		t[rt].sum = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(rt << 1, l, mid);
	build(rt << 1 | 1, mid + 1, r);
	t[rt].sum = t[rt << 1].sum + t[rt << 1 | 1].sum;
}
inline int interval_add(int rt, int l, int r)
{
	if (t[rt].l >= l && t[rt].r <= r)return t[rt].sum;
	if (t[rt].l > r || t[rt].r < l)return 0;
	int temp = 0;
	if (t[rt << 1].r >= l)temp += interval_add(rt << 1, l, r);
	if (t[rt << 1 | 1].l <= r)temp += interval_add(rt << 1 | 1, l, r);
	return temp;
}
inline void point_modify(int rt, int pos, int val)
{
	if (t[rt].l == t[rt].r)
	{
		t[rt].sum += val;
		return;
	}
	if (pos <= t[rt << 1].r)point_modify(rt << 1, pos, val);
	else point_modify(rt << 1 | 1, pos, val);
	t[rt].sum = t[rt << 1].sum + t[rt << 1 | 1].sum;
	return;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 1; i <= n; i++)cin >> a[i], suma[i] = suma[i - 1] + a[i];
	build(1, 1, n);
	cin >> Q;
	while (Q--)
	{
		bool f;
		cin >> f;
		if (f)
		{
			int l, r;
			cin >> l >> r;
			cout << interval_add(1, l, r) << "\n";
		}
		else
		{
			int p, v;
			cin >> p >> v;
			point_modify(1, p, v);
			a[p] += v;
			for (int i = 1; i <= n; i++)cout << a[i] << " ";
			cout << "\n";
		}
	}
}

二.区间修改，单点查询

#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 100;
int n, Q;
int a[maxn];
int suma[maxn];
typedef struct
{
	int l, r;
	int sum;
}T;
T t[maxn << 1];

inline void build(int rt, int l, int r)
{
	t[rt].l = l;
	t[rt].r = r;
	if (l == r)
	{
		t[rt].sum = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(rt << 1, l, mid);
	build(rt << 1 | 1, mid + 1, r);
}
inline void interval_modify(int rt, int l, int r, int val)
{
	if (t[rt].l >= l && t[rt].r <= r)
	{
		t[rt].sum += val;
		return;
	}
	int mid = t[rt].l + t[rt].r >> 1;
	if (l <= mid)interval_modify(rt << 1, l, r, val);
	if (r > mid)interval_modify(rt << 1 | 1, l, r, val);
}
inline int point_ask(int rt, int pos)
{
	int ans = 0;
	ans += t[rt].sum;
	if (t[rt].l == t[rt].r)return ans;
	int mid = t[rt].l + t[rt].r >> 1;
	if (pos <= mid) ans += point_ask(rt << 1, pos);
	if (pos > mid)ans += point_ask(rt << 1 | 1, pos);
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n; cin >> Q;
	for (int i = 1; i <= n; i++)cin >> a[i], suma[i] = suma[i - 1] + a[i];
	build(1, 1, n);

	while (Q--)
	{
		bool f;
		cin >> f;
		if (f)
		{
			int l, r, v;
			cin >> l >> r >> v;
			interval_modify(1, l, r, v);
			for (int i = l; i <= r; i++)a[i] += v;
			for (int i = 1; i <= n; i++)cout << a[i] << " ";
			cout << "\n";
		}
		else
		{
			int pos;
			cin >> pos;
			cout << point_ask(1, pos) << "\n";
		}
	}
	return 0;
}

扫描线法

#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 100;
typedef struct line
{
	double x, y1, y2;
	int c;
	bool friend operator <(line p, line q)
	{
		return p.x < q.x;
	}
}A;
A a[maxn << 1];
typedef struct tree
{
	int l, r;
	int cnt;
	double len;
}T;
T t[maxn << 2];
int n;
double raw[maxn << 1];
int cnt;
double ans;
int val[maxn << 1][2];

inline void build(int rt, int l, int r)
{
	t[rt].l = l;
	t[rt].r = r;
	t[rt].cnt = 0;
	t[rt].len = 0;
	if (l == r)return;
	int mid = l + r >> 1;
	build(rt << 1, l, mid);
	build(rt << 1 | 1, mid + 1, r);
}
void push_up(int rt)
{
	if (t[rt].cnt > 0)t[rt].len = raw[t[rt].r + 1] - raw[t[rt].l];
	else if (t[rt].l == t[rt].r)t[rt].len = 0;
	else t[rt].len = t[rt << 1].len + t[rt << 1 | 1].len;
}
void interval_modify(int rt, int l, int r, int val)
{
	if (t[rt].l >= l && t[rt].r <= r)
	{
		t[rt].cnt += val;
		push_up(rt);
		return;
	}
	int mid = t[rt].l + t[rt].r >> 1;
	if (l <= mid)interval_modify(rt << 1, l, r, val);
	if (r > mid)interval_modify(rt << 1 | 1, l, r, val);
	push_up(rt);
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int casenum = 0;
	while (cin >> n && n)
	{
		cnt = 0;
		ans = 0;
		for (int i = 1; i <= n; i++)
		{
			double x1, y1, x2, y2;
			cin >> x1 >> y1 >> x2 >> y2;
			a[i * 2 - 1] = { x1,y1,y2,1 };
			a[i * 2] = { x2,y1,y2,-1 };
			raw[++cnt] = y1;
			raw[++cnt] = y2;
		}
		sort(a + 1, a + 1 + 2 * n);
		sort(raw + 1, raw + 1 + cnt);
		cnt = unique(raw + 1, raw + 1 + cnt) - (raw + 1);
		for (int i = 1; i <= n * 2; i++)
		{
			val[i][0] = lower_bound(raw + 1, raw + 1 + cnt, a[i].y1) - raw;
			val[i][1] = lower_bound(raw + 1, raw + 1 + cnt, a[i].y2) - raw;
		}
		build(1, 1, cnt);
		for (int i = 1; i <= 2 * n; i++)
		{
			interval_modify(1, val[i][0], val[i][1] - 1, a[i].c);
			ans += (a[i + 1].x - a[i].x) * t[1].len;
		}
		cout << "Test case #" << ++casenum << "\n";
		cout << "Total explored area: " << fixed << setprecision(2) << ans << "\n";
		cout << "\n";
	}
	return 0;
}

单点修改，区间查询最大子段和

#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 100;
int n, Q;
int a[maxn];
int suma[maxn];
typedef struct node
{
	int l, r;
	int sum;
	int dat;
	int lmax, rmax;
	node()
	{
		l = r = sum = dat = lmax = rmax = 0;
	}
}T;
T t[maxn << 2];

inline void build(int rt, int l, int r)
{
	t[rt].l = l;
	t[rt].r = r;
	if (l == r)
	{
		t[rt].sum = a[l];
		t[rt].lmax = t[rt].rmax = t[rt].dat = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(rt << 1, l, mid);
	build(rt << 1 | 1, mid + 1, r);
	t[rt].sum = t[rt << 1].sum + t[rt << 1 | 1].sum;
	t[rt].lmax = max(t[rt << 1].lmax, t[rt << 1].sum + t[rt << 1 | 1].lmax);
	t[rt].rmax = max(t[rt << 1 | 1].rmax, t[rt << 1].rmax + t[rt << 1 | 1].sum);
	t[rt].dat = max(t[rt << 1].dat, t[rt << 1 | 1].dat);
	t[rt].dat = max(t[rt].dat, t[rt << 1].rmax + t[rt << 1 | 1].lmax);
}

inline void point_modify(int rt, int pos, int val)
{
	if (t[rt].l == t[rt].r)
	{
		t[rt].sum = t[rt].dat = t[rt].lmax = t[rt].rmax = val;
		return;
	}
	int mid = t[rt].l + t[rt].r >> 1;

	if (pos <= mid)point_modify(rt << 1, pos, val);
	else point_modify(rt << 1 | 1, pos, val);
	t[rt].sum = t[rt << 1].sum + t[rt << 1 | 1].sum;
	t[rt].lmax = max(t[rt << 1].lmax, t[rt << 1].sum + t[rt << 1 | 1].lmax);
	t[rt].rmax = max(t[rt << 1 | 1].rmax, t[rt << 1].rmax + t[rt << 1 | 1].sum);
	t[rt].dat = max(t[rt << 1].dat, t[rt << 1 | 1].dat);
	t[rt].dat = max(t[rt].dat, t[rt << 1].rmax + t[rt << 1 | 1].lmax);
	return;
}

T interval_ask(int rt, int l, int r)                       
{	
	//此时的ask函数返回的是临时开的T，想一想为什么，如果是void类型ask，每次ask一个区间（l,r）dat，lmax,rmax都会随着l,r不同而修改，一定会影响后续ask
	if (t[rt].l >= l && t[rt].r <= r)return t[rt];
	int mid = t[rt].l + t[rt].r >> 1;

	if (l <= mid && r > mid)
	{
		T tt, tl, tr;
		tl = interval_ask(rt << 1, l, r);
		tr = interval_ask(rt << 1 | 1, l, r);
		tt.sum = tl.sum + tr.sum;
		tt.lmax = max(tl.lmax, tl.sum + tr.lmax);
		tt.rmax = max(tr.rmax, tl.rmax + tr.sum);
		tt.dat = max(tl.dat, tr.dat);
		tt.dat = max(tt.dat, tl.rmax + tr.lmax);
		return tt;
	}
	else if (l <= mid)
	{
		return interval_ask(rt << 1, l, r);
	}
	else if (r > mid)
	{
		return interval_ask(rt << 1 | 1, l, r);
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n >> Q;
	for (int i = 1; i <= n; i++)cin >> a[i];
	build(1, 1, n);
	while (Q--)
	{
		int k, x, y;
		cin >> k >> x >> y;
		if (k & 1)
		{
			if (x > y)swap(x, y);
			T ans = interval_ask(1, x, y);
			cout << ans.dat << "\n";
		}
		else
		{
			point_modify(1, x, y);
		}
	}
	return 0;
}

图论补充：第K短路（A*）

//Made In Heaven
#pragma GCC optimize(3, "Ofast", "inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e4 + 1000;
int n, m;
int S, E, K, T;
int dis[maxn];
int h1[maxn], h2[maxn];
bool vis1[maxn];
int num1, num2;
typedef struct
{
    int nt, to, w;
}EDGE;
EDGE e1[maxn], e2[maxn];
void add1(int u, int v, int w)
{
    e1[++num1].w = w;
    e1[num1].to = v;
    e1[num1].nt = h1[u];
    h1[u] = num1;
}
void add2(int v, int u, int w)
{
    e2[++num2].w = w;
    e2[num2].to = v;
    e2[num2].nt = h2[u];
    h2[u] = num2;
}
typedef pair<int, int>P;
//反向建边dj  T->S
void dj()
{
    memset(dis, 0x3f, sizeof(dis));
    dis[E] = 0;
    priority_queue<P, vector<P>, greater<P> >q;
    q.push(make_pair(dis[E], E));
    while (!q.empty())
    {
        P p = q.top();
        q.pop();
        int u = p.second;
        int diss = p.first;
        if (vis1[u])continue;
        vis1[u] = 1;
        for (int i = h2[u]; i; i = e2[i].nt)
        {
            int v = e2[i].to;
            if (dis[v] > diss + e2[i].w)
            {
                dis[v] = diss + e2[i].w;
                q.push(make_pair(dis[v], v));
            }
        }
    }
}
typedef pair<int, P>PP;
int A_start()
{
    if (dis[S] >= 0x3f3f3f3f)return -1;
    priority_queue<PP, vector<PP>, greater<PP> >q;
    q.push(make_pair(dis[S], make_pair(0, S)));
    int cnt = 0;
    while (!q.empty())
    {
        PP p = q.top();
        q.pop();
        int u = p.second.second;
        int diss = p.second.first;
        if (u == E)cnt++;
        if (cnt == K)return diss;
        for (int i = h1[u]; i; i = e1[i].nt)
        {
            int v = e1[i].to;
            q.push(make_pair(diss + e1[i].w + dis[v], make_pair(diss + e1[i].w, v)));
        }
    }
    return -1;
}

void init() {
    num1 = num2 = 0;
    memset(vis1, 0, sizeof vis1);
    memset(h1, 0, sizeof h1);
    memset(h2, 0, sizeof h2);
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    while (cin >> n >> m) {
        init();
        cin >> S >> E >> K >> T;
        if (S == E)K++;
        while (m--)
        {
            int u, v, w;
            cin >> u >> v >> w;
            add1(u, v, w);
            add2(u, v, w);
        }
        dj();
        int ans = A_start();
        if (ans == -1 || ans > T)cout << "Whitesnake!\n";
        else cout << "yareyaredawa\n";
    }

    return 0;
}
新图学霸猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构 图论
hello world
09-17 1279
0.引入 在生活中，随处可见与图相关的应用： 地图：在使用地图中，经常会想知道“从xx到xx的最短路线”这样的问题，要回答这些问题，需要把地图抽象成一个图(Graph)，十字路口就是顶点，公路就是边。 互联网： 整个互联网其实就是一张图，它的顶点为网页，边为超链接，图论可以帮我们在网络上定位信息。 任务调度：当一些任务拥有优先级限制且需要满足前置条件时，如何在满足条件的情况下用最少的时间完成...
数据结构（C语言版）源代码
12-25
在本主题中，我们关注的是“数据结构（C语言版）”的源代码，这是一份补充电子课件，旨在帮助学生深入理解数据结构的概念，并通过实际编程实践来巩固这些概念。 1. **排序算法（code8_Sort.c）** 这个文件可能包含...
数据结构之图论概念大全
Z_timer的博客
10-28 6219
本文一些概念引用他人博文 如有侵权 联系删除 顶点的度、入度、出度 无向图及性质 无向完全图：连通图:极大连通子图：极小连通子图：生成树：最小生成树及算法：生成森林 非连通图：连通图及特性 有向图及性质 极大强连通子图：极小强连通子图：不存在这个概念 最小树形图（难点，考研忽略）：邻接矩阵 邻接表 逆邻接表 十字链表 邻接多重表 特殊矩阵 图的遍历BFS DFS最短路径Dijkstra Floyd （逆）拓扑排序 AOV网 关键路径 AOE网（路径长度、完成工程的最短时间、关键路径） 稠密图、稀疏图
【数据结构与算法】07：图论算法
https://blog.csdn.net/m0_74834215
06-13 433
与图G相关的概念：与顶点V相关的概念：与边E相关的概念：图没有顺序存储结构，但是可以借助二维数组来表示元素之间的关系。建立一个顶点表（记录各个顶点的信息）和一个邻接矩阵（表示各个顶点之间边的关系）设图有n个顶点：图的邻接矩阵是一个二维数组定义为：有向图邻接矩阵表示：有向网邻接矩阵表示：的邻接矩阵是一个二维数组定义为：邻接矩阵的存储表示：用两个数组分别存储顶点表和邻接矩阵，演示案例：采用邻接矩阵表示法创建无向网邻接矩阵的优点：邻接矩阵的缺点：建立一个顶点表（记录各个顶点的信息）和一个线性链表（记录关联着同一顶
数据结构之图论（邻接表）
weixin_55850954的博客
11-25 720
数据结构之图论（邻接表） 这篇文章是对上一篇文章的补充，暂时还没有总结完毕，在阅读中如果对算法的用途有所疑问的，可参考上一篇：数据结构之图论（邻接矩阵） 文章还未总结完毕，后续会进一步补充和修改。 文章目录数据结构之图论（邻接表）图的创建拓扑排序无权最短路径DijkstraFloydDFSBellman_FordSPFA总结 图的创建 template<typename T> class Graph { private: struct Node { T value;//值 int
【数据结构】实验六：图论
Lenhart001的博客
10-28 2285
【数据结构】实验六：图论
数据结构笔记(全)
señoritaw的博客
04-25 3244
线性表：是具有相同数据类型的 n 个数据元素的有限序列。(Eg:所有的整数按递增次序排列，不是顺序表，因为所有的整数是无限的)其中n为表长，当n=0时线性表是一个空表。若用L表示一个线性表，则是线性表中的第i个元素，称为线性表中的位序是表头元素;是表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱;除最后一个元素外，每个元素有且仅有一个直接后继2.1.2 线性表的基本操作InitList(&L)：初始化表。构造一个空的线性表 L，分配内存空间。
数据结构与算法实验6——图论 7-8 森森美图
m0_63040123的博客
11-05 727
森森最近想让自己的朋友圈熠熠生辉，所以他决定自己写个美化照片的软件，并起名为森森美图。众所周知，在合照中美化自己的面部而不美化合照者的面部是让自己占据朋友圈高点的绝好方法，因此森森美图里当然得有这个功能。这个功能的第一步是将自己的面部选中。森森首先计算出了一个图像中所有像素点与周围点的相似程度的分数，分数越低表示某个像素点越“像”一个轮廓边缘上的点。森森认为，任意连续像素点的得分之和越低，表示它们组成的曲线和轮廓边缘的重合程度越高。
数据结构十大习题|part1
m0_73770619的博客
05-13 2279
本篇博客给出核心代码及其思路注释，还有其他不同的方法不一一讨论1.new是一个操作符，它用于在堆上分配内存，并调用相应的构造函数。new 类型名(参数列表)它会返回一个指向新分配内存的指针，如果分配失败，会抛出一个bad_alloc异常。2.delete也是一个操作符，它用于释放new分配的内存，并调用相应的析构函数。delete 指针它会将指针所指向的内存归还给系统，如果指针是NULL，不会有任何效果。如果指针不是由new分配的，或者已经被delete过，会导致未定义行为。
数据结构：图的基本概念
热门推荐
qq_44937699的博客
03-16 1万+
数据结构：图的基本概念一、什么是图？二、图的分类1. 无向图1.1 无向完全图1.2 连通图（无向图）1.3 无向图的度2. 有向图2.1 有向完全图2.2 强连通图（有向图）2.3 有向图的度2. 稀疏图和稠密图3. 有环图和无环图4. 加权图和无权图三、图的存储结构1. 邻接矩阵2. 邻接表参考链接 一、什么是图？ 图是一种非线性的数据结构，表示多对多的关系。 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V, E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中
数据结构 吴陈 科学出版社 课后答案
07-07
数据结构是计算机科学中的核心课程之一，主要研究如何在计算机中高效地组织和管理数据，以便进行快速查找、插入和删除等操作。吴陈教授编写的《数据结构》教材是许多大学计算机专业的重要参考书，科学出版社出版的...
数据结构-2014-2-期末-2（补充）1
08-04
本文旨在总结数据结构相关知识点，涵盖图论、树、堆、排序算法、散列表、红黑树、左式堆、K-选取等方面。 一、图论和树 1. BFS、DFS的复杂度可能不是O(N+E)，因为 BFS、DFS 在遍历图或树时需要考虑图或树的结构，...
电子科技大学数据结构ppt.zip
03-18
绪论部分通常会介绍数据结构的基本定义，它的重要性以及在实际问题解决中的应用。数据结构不仅包括数据的存储，还涉及数据之间的关系以及对这些数据的操作。 2. **补充知识**： 这部分可能包含预备知识，如计算机...
数据结构C语言版教学笔记（严蔚敏）
04-20
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和管理数据，以便进行快速查找、插入和删除等操作。严蔚敏教授的《数据结构》是这方面的经典教材，以其深入浅出的讲解和丰富的例题深受广大师生...
单链表-数据结构
qq_31804097的博客
08-07 118
【代码】单链表、双向带头循环链表-数据结构。
数据结构初阶：栈和队列
LCL200356的博客
08-03 875
栈的结构的定义和顺序表结构定义一样，在栈中定义一个指针data用于操作数据，然后定义整型变量capacity用于表示栈的空间大小，最后定义一个整型变量top用于表示有效数据个数也就是我们的栈顶。//定义一个栈的结构//数组//栈的空间的大小int top;//有效数据个数}ST;队列的结点结构就是单链表结点结构，队列结构phead指向头结点和ptail指向尾结点，还有一个size用同统计结点个数。//链式结构表示队列}QNode;//队列结构int size;//计数器。
算法回忆录（2）
m0_73399576的博客
08-05 1249
算法回忆录（2）
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 100
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值