Pro练习 - 技术栈

1.分段

cpp 复制代码

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

//int aN = 200002;

int aSubscriber[200002] = { 0 };//记录数组元素对应的值
int L[450], R[450];//记录每块内左右端点的下标，最大块数448
int pos[200002];//记录第i个元素的块号
int sumK[450];//记录第k块的元素总和
int maxK[450];//记录第k块的最大值
int minK[450];//记录第k块的最小值

void init(int N, int mSubscriber[]) {
	//aN = N;
	aSubscriber[0] = 0;
	for (int i = 0; i < N; i++)
	{
		pos[i] = 0;
		aSubscriber[i + 1] = mSubscriber[i];
	}
	
	for (int i = 1; i <450; i++)
	{
		maxK[i] = -1;//每个块最大值
		minK[i] = 10001;//每个块最小值
		sumK[i] = 0;
		L[i] = 0;
		R[i] = 0;
	}

	int t = sqrt(N*1.0);//每个块内元素个数
	int num = N / t;//块数
	if (N%t)//余数不为0，说明有不能整除的块
	{
		num++;
	}

	for (int i = 1; i <= num; i++)//i遍历块号
	{
		L[i] = (i - 1)*t + 1;//第i块左端点下标
		//(i-1)*t
		//i*t-1
		R[i] = i * t;//第i块右端点下标
	}
	//这里要注意 当上面处理完第num块时 R[num]是按照长度为t进行分配的右端点
    //但是这个右端点有可能比n还大 然而我们只需要处理到n就可以了
    //因此这里还要特殊处理最后一段的右端点 取到n即可 不一定取最后一段分配到的右端点
	R[num] = N;

	for ( int i = 1;  i <=num;  i++)//i遍历块数
	{
		//int maxi=-1, mini=10001;//初始化每个块的最大值，最小值
		for (int j = L[i]; j <= R[i]; j++)//j遍历这个块的元素
		{
			pos[j] = i;//下标j对应元素 属于块号i
			sumK[i] += aSubscriber[j]; //i块元素总和
			if (minK[i] > aSubscriber[j])
			{
				minK[i] = aSubscriber[j];//更新第i块的最小值
			}
			if (maxK[i] < aSubscriber[j])
			{
				maxK[i] = aSubscriber[j];//更新第i块的最大值
			}
		}
	}
	
	return;
}

int updateKuai(int mId)//更新块内维护最值数组，返回块号
{
	int kuai = pos[mId];//确定mId的块号
	//初始化块内的最值，块内元素有变动，则从头遍历重新排序
	minK[kuai] = 10001;
	maxK[kuai] = -1;

	for (int j = L[kuai]; j <= R[kuai]; j++)//遍历这个块，更新最大/小值
	{
		if (minK[kuai] > aSubscriber[j])
		{
			minK[kuai] = aSubscriber[j];//更新第i块的最小值
		}
		if (maxK[kuai] < aSubscriber[j])
		{
			maxK[kuai] = aSubscriber[j];//更新第i块的最大值
		}
	}
	return kuai;
}

int subscribe(int mId, int mNum) {
	aSubscriber[mId] += mNum;
	int kuai = updateKuai(mId);
	sumK[kuai] += mNum; //更新第kuai块元素总和
	return aSubscriber[mId];
	/*
	int kuai = pos[mId];//确定mId的块号
	minK[kuai] = 10001;//如果加的是之前最小的哪个，比较原来的最小值永远不会更新（所有的值都比他大），而实际的最小值已经变大了，所以直接从头遍历，重置这个块的最小值
	//如果加的是最大值，那肯定会更新
	for (int j = L[kuai]; j <= R[kuai]; j++)//遍历这个块，更新最大/小值
	{
		if (minK[kuai] > aSubscriber[j])
		{
			minK[kuai] = aSubscriber[j];//更新第i块的最小值
		}
		if (maxK[kuai] < aSubscriber[j])
		{
			maxK[kuai] = aSubscriber[j];//更新第i块的最大值
		}
	}
	*/
	//cout << "subscribe:" << aSubscriber[mId] << endl;

}

int unsubscribe(int mId, int mNum) {//如果减的最小的哪个，那最小值可能会变化成之前第二小的，需要比较
	aSubscriber[mId] -= mNum;
	int kuai = updateKuai(mId);
	sumK[kuai] -= mNum; //更新第kuai块元素总和
	return aSubscriber[mId];
	/*
	int kuai = pos[mId];//确定mId的块号
	maxK[kuai] = -1;//如果减少的是之前最大的哪个值，比较原来的最大值永远不会更新（所有的值都比他小），而实际的最大值已经变小了，所以直接从头遍历，重置这个块的最大值
	for (int j = L[kuai]; j <= R[kuai]; j++)//遍历这个块，更新最大/小值
	{
		if (minK[kuai] > aSubscriber[j])
		{
			minK[kuai] = aSubscriber[j];//更新第i块的最小值
		}
		if (maxK[kuai] < aSubscriber[j])
		{
			maxK[kuai] = aSubscriber[j];//更新第i块的最大值
		}
	}
	*/
	
	//cout << "unsubscribe:" << aSubscriber[mId] << endl;

}

int count(int sId, int eId) {
	int res = 0;
	/*无脑遍历会超时，需要分块优化
	for (int i = sId; i <= eId; i++)
	{
		res += aSubscriber[i];
	}*/
	int kuais = pos[sId];
	int kuaie = pos[eId];
	if (kuais == kuaie)//如果在同一个块里
	{
		for (int i = sId; i <= eId; i++)//复杂度不高，直接累加
		{
		    res += aSubscriber[i];
		}
	}
	else//不在同一个块，说明跨越了不同的块，左边半块，中间是[kuais+1,kuaie-1]块，右边半块
	{
		//先处理中间整块，直接将分块求和数组 取对应块 累加
		for (int i = kuais + 1; i <= kuaie - 1; i++)
		{
			res += sumK[i];
		}
		//处理左半块累加
		for (int i = sId; i <= R[kuais]; i++)//块头是给定的起点sid，块尾是R[pos[sid]]
		{
			res += aSubscriber[i];
		}
		//处理右边半块累加
		for (int i = L[kuaie]; i <=eId; i++)
		{
			res += aSubscriber[i];
		}
	}
	//cout << "count:" << res << endl;
	return res;
}

int calculate(int sId, int eId) {

	/*无脑遍历会超时，需要分块优化
	for (int i = sId; i <= eId; i++)
	{
		if (min > aSubscriber[i])
		{
			min = aSubscriber[i];
		}
		if (max < aSubscriber[i])
		{
			max = aSubscriber[i];
		}
	}*/
	int res = 0;
	int kuais = pos[sId];
	int kuaie = pos[eId];
	int min = 10001, max = -1;
	if (kuais == kuaie)//如果在同一个块里
	{
		for (int i = sId; i <= eId; i++)//复杂度不高，直接比较求最值，相减
		{
			if (min > aSubscriber[i])
			{
				min = aSubscriber[i];
			}
			if (max < aSubscriber[i])
			{
				max = aSubscriber[i];
			}
		}
		res = max - min;
	}

	else//不在同一个块，说明跨越了不同的块，左边半块，中间是[kuais+1,kuaie-1]块，右边半块
	{
		//先处理中间整块,找出最大，最小值
		for (int i = kuais + 1; i <= kuaie - 1; i++)
		{
			if (min > minK[i])
			{
				min = minK[i];
			}
			if (max < maxK[i])
			{
				max = maxK[i];
			}
		}
		//处理左半块
		for (int i = sId; i <= R[kuais]; i++)
		{
			if (min > aSubscriber[i])
			{
				min = aSubscriber[i];
			}
			if (max < aSubscriber[i])
			{
				max = aSubscriber[i];
			}
		}
		//处理右边半块
		for (int i = L[kuaie]; i <= eId; i++)
		{
			if (min > aSubscriber[i])
			{
				min = aSubscriber[i];
			}
			if (max < aSubscriber[i])
			{
				max = aSubscriber[i];
			}
		}
		res = max - min;
	}
	//cout << "calculate:" << res << endl;
	return res;
}

2.迪杰斯特拉

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
const int MAXN = 1000000;
bool visit[MAXN];
int mDis[MAXN];
vector <point> Graph[MAXN];

struct point {
	int vec, dis;
	point(int v, int d)
	{
		vec = v;
		dis = d;
	}
	bool operator < (const point &other)const {
		if (dis != other.dis)
		{
			return dis > other.dis;//dis从大到小降序，但是优先队列中dis越大优先级越低，排在队尾
			//return dis < other.dis;//dis从小到大升序
		}
	}
};

int djs(int start)
{
    //1priority_queue<point,vector<point>,less<point>> q;== priority_queue<point>; return dis < other.dis； //以dis大的为队首
	//2如果以disx小的为队首（最短路径），则需要在结构体修改 <的逻辑return dis > other.dis

	memset(visit, false, sizeof(visit));//初始默认没访问过
	memset(mDis, INF, sizeof(mDis));//初始起点到达其他点距离，设为无穷大代表全部不可达
	mDis[start] = 0;//起点到自己的距离为0
	priority_queue<point> q;
	q.push({ start,0 });//起点入队
	while (!q.empty())
	{
		point temp = q.top();
        int midV = temp.vec;//本次循环最短边终点的编号，可能的中间节点mid
		int midD = temp.dis;//代表s到mid的距离
		q.pop();

		/*if (mDis[vec] < dis)//如果起点直接到当前队首顶点的距离 比 记录默认dis[]的最短距离（初始为INF）大，则break
		{
			continue;
		}
		*/
		if (visit[midV])//如果此点已经被访问过加入集合，则跳过
		{
			continue;
		}
		visit[midV] = true;//本次循环确认该点的最短距离

		for (int i = 0; i < Graph[midV].size(); i++)
		{
			int eV = Graph[midV][i].vec;//本次循环目标点
			int eD = Graph[midV][i].dis;
			
			if (!visit[eV] && temp.dis + idis < mDis[eV])
			{
				mDis[eV] = eD + idis;
				//q.push({ ivec,idis });注意 不是更新idis 这个是起点到ivec的距离是固定的，应该更新最短距离
				q.push({ eV,mDis[ivec]});//更新到ivec的最短距离
			}
			
		}
	}

	if (mDis[start] != INF)
	{
		return mDis[start];
	}
	else
	{
		return -1;
	}
}

vector<pair<int, int>> g[500005];//用于存放图信息
int dis[500005];
void dijkstra(int s)        //(m)log(m) n=1e5 m=1e6
{
	memset(dis, 0x3f3f3f3f, sizeof(dis));
	dis[s] = 0;
	priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;//小顶堆，队首是最小的距离
	q.push({ 0, s });
	while (!q.empty())
	{
		pair<int, int> p = q.top();
		q.pop();
		int u = p.second;//u是顶点
		int d = p.first;//d是距离，优先按照距离比较
		if (dis[u] < d) continue;
		for (int i = 0; i < g[u].size(); i++)//遍历u的也就是队首的各个相邻接点
		{
			int v = g[u][i].second;
			int w = g[u][i].first;
			if (dis[v] > dis[u] + w)//如果通过s->u->v间接的 距离比 当前s->v直接到相邻节点v的最短距离 短
			{
				dis[v] = dis[u] + w;//更新s->v最短距离
				q.push({ dis[v], v });//{v和，s->v的距离}入队
			}
		}
	}
}


int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++)//初始化图的各个顶点间权值
	{
		int u, v, w;
		scanf("%d %d %d", &u, &v, &w);
		g[u].push_back({ w, v });
		g[v].push_back({ w, u });
	}
	dijkstra(1);
	for (int i = 1; i <= n; i++)
	{
		printf("%d ", dis[i]);
	}

}