2. 程式人生 > 其它 >資料結構與演算法（Java版）_07_環形雙鏈表的增、刪、改、查

資料結構與演算法（Java版）_07_環形雙鏈表的增、刪、改、查

阿新 • • 發佈：2021-11-02

最短路演算法：

單源最短路：所有邊權都是正數

1、Dijkstra演算法：

對於稠密圖（邊相對較多）：樸素Dijkstra 時間複雜度：\(O(n^2+m)\)

思路分析：該演算法是基於貪心思想的，每次從已經更新過的st陣列中找到最小的沒有更新的dist[t]，再用它來更新它的出邊即可

849. Dijkstra求最短路 I - AcWing題庫

程式碼示例：

//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
//#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;

#define For(i,a,b) for (int i=(a);i<=(b);++i)
#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
#define mls multiset
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define itt iterator
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define lowbit(x) x & (-x)
#define clr(x) memset(x, 0, sizeof(x));

typedef vector<int> vii;
typedef vector<long long> vll;
typedef long long ll;
typedef unsigned long long ull;
		
const int MAXN = 0x7fffffff;
const int MOD = 1000000007;
const ll MOD1 = 212370440130137957ll;
const int N = 510;

int g[N][N];
int dist[N];
int n, m;
bool st[N];

int dijkstra()
{
	dist[1] = 0;
	for(int i = 1; i <= n; i ++)
	{
		int t = -1;
		for(int j = 1; j <= n; j ++)
		{
			if(!st[j] && (t == -1 || dist[j] < dist[t])) t = j;
		}
		st[t] = true;
		for(int j = 1; j <= n; j ++) dist[j] = min(dist[j], dist[t] + g[t][j]);
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main ()
{	
	//IOS;
	memset(dist, 0x3f, sizeof dist);
	memset(g, 0x3f, sizeof g);
	cin >> n >> m;
	For(i, 1, m)
	{
		int a, b, c;
		cin >> a >> b >> c;
		g[a][b] = min(g[a][b], c);
	}

	cout << dijkstra() << endl;

	return 0;
}	
/*

*/

對於稀疏圖（邊相對較少）：堆優化Dijkstra 時間複雜度：\(O(mlogn)\)

思路分析：相對於樸素Dijkstra，通過堆，我們每次可以用\(O(1)\)的時間去查詢dist[t]，然後再用其去更新t的出邊，但更新這一步維護堆的過程每次時間複雜度為\(O(logn)\),一共m次，因此時間複雜度\(O(mlogn)\)

850. Dijkstra求最短路 II - AcWing題庫

程式碼示例：

//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
//#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;

#define For(i,a,b) for (int i=(a);i<=(b);++i)
#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
#define mls multiset
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define itt iterator
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define lowbit(x) x & (-x)
#define clr(x) memset(x, 0, sizeof(x));
#define fi first
#define se second

typedef vector<int> vii;
typedef vector<long long> vll;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
		
		
const int MAXN = 0x7fffffff;
const int MOD = 1000000007;
const ll MOD1 = 212370440130137957ll;
const int N = 150050;

typedef pair<int , int> PII;
int n, m;
int h[N], e[N], w[N], nxt[N], idx;
bool st[N];

int dist[N];

void add(int a, int b, int c)
{
	e[idx] = b, w[idx] = c, nxt[idx] = h[a], h[a] = idx ++;
}

int dijkstra()
{
	memset(dist, 0x3f, sizeof dist);
	priority_queue <PII, vector<PII>, greater<PII> > heap;
	dist[1] = 0;
	heap.push({0, 1});
	while(!heap.empty())
	{
		auto t = heap.top();
		heap.pop();
		int ver = t.se, distance = t.fi;
		if(st[ver]) continue;
		st[ver] = true;
		for(int i = h[ver]; i != -1; i = nxt[i])
		{
			int j = e[i]; 
			if(dist[j] > distance + w[i])
			{ 
				dist[j] = distance + w[i];
				heap.push({dist[j], j});
			} 
		}
	}
	if(dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}


int main ()
{	
	//IOS;
	cin >> n >> m;
	memset(h, -1, sizeof h);

	For(i, 1, m)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}

	cout << dijkstra() << endl;

	return 0;
}	
/*

*/

單源最短路：存在負權邊

3、Bellman-Ford演算法：可以處理最多經過k條邊的問題

演算法分析：外層迴圈k次，內層遍歷所有的邊並進行鬆弛操作，即令所有的邊的滿足三角不等式dist[b] <= dist[a] + w[i]，而外層迴圈的意義就是，相當於一層一層的去鬆弛求最短路，外層遍歷幾次即最短路徑過幾條邊，需要注意的問題是每次鬆弛必須用上一層的dist，以防止串聯

同時可以利用如果外層迴圈超過n次，仍能進行鬆弛更新，即存在負環

時間複雜度：\(O(nm)\)

853. 有邊數限制的最短路 - AcWing題庫

程式碼示例：

//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
//#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;

#define For(i,a,b) for (int i=(a);i<=(b);++i)
#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
#define mls multiset
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define itt iterator
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define lowbit(x) x & (-x)
#define clr(x) memset(x, 0, sizeof(x));
#define fi first
#define se second

typedef vector<int> vii;
typedef vector<long long> vll;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
		
const int MAXN = 0x7fffffff;
const int MOD = 1000000007;
const ll MOD1 = 212370440130137957ll;

const int M = 1e5 + 5;
const int N = 505;
int n, k, m;
int dist[N];
int backup[N]; 

struct node 
{
	int a, b, w;
}edge[M];

int bmf()
{
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	for(int i = 1; i <= k; i ++)
	{
		memcpy(backup, dist, sizeof dist);//備份上一層的dist
		for(int j = 1; j <= m; j ++)
		{
			int a = edge[j].a, b = edge[j].b, w = edge[j].w;
			if(dist[b] > backup[a] + w) dist[b] = backup[a] + w;
		}
	}
	return dist[n];
}

int main ()
{	
	//IOS;
	cin >> n >> m >> k;
	For(i, 1, m)
	{
		int a, b, w;
		cin >> a >> b >> w;
		edge[i] = {a, b, w};
	}

	int t = bmf();
	if(t >= 0x3f3f3f3f / 2) cout << "impossible" << endl;
	else cout << t << endl;

	return 0;
}	
/*

*/

4、SPFA演算法：佇列優化的Bellman-Ford演算法

演算法分析：我們知道Bellman-Ford演算法在內層迴圈的時候每次會遍歷所有的邊，但實際上對於t，我們只需要遍歷t的所有臨邊即可，因此我們可以利用佇列，同時通過st狀態陣列防止佇列中點的重複，每次將隊頭的臨邊更新即可。

時間複雜度：平均\(O(m)\)，最壞情況\(O(nm)\)，因此很容易被出題人卡

851. spfa求最短路 - AcWing題庫

程式碼示例：

//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
//#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;

#define For(i,a,b) for (int i=(a);i<=(b);++i)
#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
#define mls multiset
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define itt iterator
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define lowbit(x) x & (-x)
#define clr(x) memset(x, 0, sizeof(x));
#define fi first
#define se second

typedef vector<int> vii;
typedef vector<long long> vll;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
		
const int MAXN = 0x7fffffff;
const int MOD = 1000000007;
const ll MOD1 = 212370440130137957ll;
const int N = 1e5 + 5;

int e[N], h[N], ne[N], idx, w[N];
bool st[N];
int dist[N];
int n, m;

void add(int a, int b, int c)
{
	e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

int spfa()
{
	queue <int> q;
	memset(dist, 0x3f3f3f3f, sizeof dist);
	dist[1] = 0;
	q.push(1);
	st[1] = true;
	while(!q.empty())
	{
		int t = q.front();
		q.pop();
		st[t] = false;
		for(int i = h[t]; i != -1; i = ne[i])
		{
			int j = e[i];
			if(dist[j] > dist[t] + w[i])
			{
				dist[j] = dist[t] + w[i];
				if(!st[j])
				{
                q.push(j); //此時推進到j，dist[j]一定是最短路
					st[j] = true;
				}
			}
		}
	}
	return dist[n];
}

int main ()
{	
	//IOS;
	memset(h, -1, sizeof h);
	cin >> n >> m;
	For(i, 1, m)
	{
		int a, b, c;
		cin >> a >> b >> c;
		add(a, b, c);
	}

	int t = spfa();
	if(t == 0x3f3f3f3f) cout << "impossible" << endl;
	else cout << t << endl;

	return 0;
}	
/*

*/

SPFA判斷負權迴路

演算法分析：我們可以開一個數組cnt來記錄每個點最短路的經過的邊數，一張有n個點圖中，最短路不可能超過n-1，倘若cnt[i] >= n 就說明一定存在負權迴路

PS：需要注意的是，最開始初始化佇列的時候需要把每個點都放進佇列，因為此時不是求1-n的最短路，每個點都有無法被遍歷到的可能性。

852. spfa判斷負環 - AcWing題庫

程式碼示例：

	//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
	//#pragma GCC optimize(2)

	#include <bits/stdc++.h>
	using namespace std;

	#define For(i,a,b) for (int i=(a);i<=(b);++i)
	#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
	#define mls multiset
	#define lb lower_bound
	#define ub upper_bound
	#define pb push_back
	#define pob pop_back
	#define itt iterator
	#define endl '\n'
	#define IOS ios::sync_with_stdio(0); cin.tie(0);
	#define lowbit(x) x & (-x)
	#define clr(x) memset(x, 0, sizeof(x));
	#define fi first
	#define se second

	typedef vector<int> vii;
	typedef vector<long long> vll;
	typedef long long ll;
	typedef unsigned long long ull;
	typedef pair<int, int> pii;
	typedef pair<ll, ll> pll;
			
	const int MAXN = 0x7fffffff;
	const int MOD = 1000000007;
	const ll MOD1 = 212370440130137957ll;
	const int N = 2005;
	const int M = 10005;

	int e[M], h[N], w[M], idx, ne[M];
	bool st[N];
	int cnt[N];
	int n, m;
	int dist[N];

	void add(int a, int b, int c)
	{
		e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
	}

	bool spfa()
	{
		memset(dist, 0x3f, sizeof dist);
		queue <int> q;
		for(int i = 1; i <= n; i ++)
		{
			q.push(i);
			st[i] = true;
		}
		while(!q.empty())
		{
			int t = q.front();
			q.pop();
			st[t] = false;
			for(int i = h[t]; i != -1; i = ne[i])
			{
				int j = e[i];
				if(dist[j] > dist[t] + w[i])
				{
					cnt[j] = cnt[t] + 1;	
					if(cnt[j] >= n) return true;
					dist[j] = dist[t] + w[i];
					if(!st[j])
					{
						q.push(j);
						st[j] = true;
					}
				}
			}
		}
		return false;
	} 

	int main ()
	{	
		//IOS;
		cin >> n >> m;
		memset(h, -1, sizeof h);
		For(i, 1, m)
		{
			int a, b, c;
			cin >> a >> b >> c;
			add(a, b, c);
		}
		if(spfa()) cout << "Yes" << endl;
		else cout << "No" << endl;
		return 0;
	}	
	/*

	*/

多源匯最短路

1、Floyd演算法:（不可求負權邊）

演算法分析：Floyd是基於動態規劃思想的演算法，轉移方程為\(d[k][i][j] = min(d[k][i][j], d[k-1][i][k] + d[k-1][k][j])\)

省去第一維後，即\(d[i][j] = min(d[i][j], d[i][k] + d[k][j])\)

時間複雜度：\(O(n^3)\)

854. Floyd求最短路 - AcWing題庫

程式碼示例：

//#pragma comment(linker,   "/STACK:10240000000000,10240000000000")
//#pragma GCC optimize(2)

#include <bits/stdc++.h>
using namespace std;

#define For(i,a,b) for (int i=(a);i<=(b);++i)
#define Fod(i,b,a) for (int i=(b);i>=(a);--i)
#define mls multiset
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define itt iterator
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define lowbit(x) x & (-x)
#define clr(x) memset(x, 0, sizeof(x));
#define fi first
#define se second

typedef vector<int> vii;
typedef vector<long long> vll;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
		
const int MAXN = 1e9;
const int MOD = 1000000007;
const ll MOD1 = 212370440130137957ll;
const int N = 205; 

int n, m, t;
int d[N][N];

void floyd()
{
	For(k, 1, n)
		For(i, 1, n)		
			For(j, 1, n)			
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}	

int main ()
{	
	IOS;
	cin >> n >> m >> t;
	For(i, 1, n)
		For(j, 1, n)
			if(i == j) d[i][j] = 0;
			else d[i][j] = MAXN;

	For(i, 1, m)
	{
		int a, b, c;
		cin >> a >> b >> c;
		d[a][b] = min(d[a][b], c);
	}

	floyd();
	
	For(i, 1, t)
	{
		int a, b;
		cin >> a >> b;
		if(d[a][b] > MAXN / 2) cout << "impossible" << endl;
		else cout << d[a][b] << endl;
	}

	return 0;
}	
/*

*/

相關推薦

資料結構與演算法（Java版）_07_環形雙鏈表的增、刪、改、查

單鏈表缺點： 僅存在後繼，沒有前驅，故只能正向遍歷; 節點無法完成自我刪除；

資料結構與演算法（Java版）_02_SparseArray稀疏陣列

稀疏陣列使用場景： 當一個二維陣列中很多元素為0或為同一個值時，可以用稀疏陣列儲存該陣列。

資料結構與演算法（Java版）_05_單向連結串列的建立與遍歷

單向連結串列： 連結串列是以節點的方式來儲存資料的，是鏈式儲存結構。 每個節點包含data域和next域，next域指向下一個節點。

資料結構與演算法（Java版）_08_棧的學習與程式碼實現

棧（Stack），其為線性結構，元素在其內部操作規則是先進後出，其有棧頂與棧底。

資料結構與演算法（Java）——佇列

資料結構與演算法（Java）——普通佇列與迴圈佇列的Java程式碼實現 目錄1. 佇列的介紹2. 陣列模擬佇列的思路3. 普通佇列實現的參考程式碼4.陣列模擬迴圈佇列5. 迴圈佇列實現的參考程式碼

重新整理資料結構與演算法（c#系列）—— 樹的前中後序遍歷[十六]

前言 理論文章： 直接看百度百科。 這個比較簡單，直接放c#程式碼。 正文 建立節點模型:

資料結構與演算法（十一）：二叉樹

一、什麼是二叉樹 1.概述 首先，需要了解樹這種資料結構的定義： 樹：是一類重要的非線性資料結構，是以分支關係定義的層次結構。每個結點有零個或多個子結點；沒有父結點的結點稱為根結點；每一個非根結點有且只有

資料結構與演算法（十二）：堆排序

一、什麼是堆排序 1.概述 堆排序是利用堆這種資料結構而設計的一種排序演算法，堆排序是一種選擇排序，它的最壞，最好，平均時間複雜度均為O(nlogn)，它也是不穩定排序。

資料結構與演算法（十四）：赫夫曼編碼

一、什麼是赫夫曼編碼 哈夫曼編碼(Huffman Coding)，又稱霍夫曼編碼，是一種編碼方式，可變字長編碼(VLC)的一種。Huffman於1952年提出一種編碼方法，該方法完全依據字元出現概率來構造異字頭的平均長度最短的碼字，有

資料結構與演算法（十六）：平衡二叉樹

一、什麼是平衡二叉樹 1.概述 平衡二叉樹（AVL樹）是一種帶有平衡條件的二叉搜尋樹。它的特性如下：

資料結構與演算法（十八）：圖

一、什麼是圖 1.概述 首先，我們已經在之前學習過了樹這種資料結構，樹能反映一對多的關係，但是卻無法反映多對多的關係，因此我們引入了圖這種資料結構。

資料結構與演算法（十一）——串

iwehdio的部落格園：https://www.cnblogs.com/iwehdio/ 1、串 串（字串）：來自字母表的字元所構成的有限序列。

資料結構與演算法（十二）——排序演算法

iwehdio的部落格園：https://www.cnblogs.com/iwehdio/ 1、快排 快速排序： 將子序列劃分為兩個部分S1、S2，並且滿足S1中最大值小於S2中最小值。

資料結構與演算法（十八）

技術標籤：演算法資料結構二分法leetcodejava 順序查詢演算法及二分查詢 一、順序查詢：

資料結構與演算法（連結串列）

資料結構與演算法（連結串列） 1，連結串列的資料結構 （1）基本實現（組成）：由一個一個結點構成。

Python的資料結構與演算法（持續更新......）

目的： 這個隨筆可以是看做是一個筆記，會記錄一些自己覺得有意義或是有趣的或是優雅的或是......所以隨筆的整體會比較凌亂，看到了這部分內容或許就會記錄進來，好記性不如爛筆頭，也給以後的自己翻閱提供一些回憶的

JAVA資料結構與演算法（一）

目錄 經典考題： 字串匹配問題 1）有一個字串 str1="abdbciauociebufebcdlkjsncklds"，和一個子字串 str2="fe";

Java資料結構與演算法（二）--簡單排序

目錄 1.氣泡排序 2.選擇排序 3.插入排序 4.總結 為了對大量的資料進行檢索，需要對資料進行排序，就像上章講的，二分查詢要快於迭代查詢。

Java資料結構與演算法（三）--棧

目錄 1.棧的基本概念 2.棧的簡單實現 3.程式碼解析 4.應用場景 5.總結 在第一章我們講了資料這個具體的資料儲存結構，它主要應用與資料的記錄。

資料結構與演算法（十三）：赫夫曼樹

一、什麼是赫夫曼樹 給定n個權值作為n個葉子節點，構造一課二叉樹，若該樹的帶權路徑長度和（wpl）達到最小，稱這樣的二叉樹為最優二叉樹，也就是赫夫曼樹。