圖論的兩個經典問題。

1、先介紹樹的概念：

樹的概念挺簡單的，一個祖先，一個兒子只能有一個父親節點，不能形成環。n個節點只能有n-1條邊，要不然會形成環。（易得知）

2、再來講講我用來存圖的兩種方式：

1、鄰接矩陣（使用於稠密圖）

map[b][a] = map[a][b] = c;代表的意思是a到b的距離為c.

如圖（網上找的圖）：

2、鄰接表（適用於稀疏圖）

struct Edge {///陣列的下標代表邊的另一個端點
	int v; //邊端點，另一端點已知
	int w; //邊權值
	Edge(int v_ = 0, int w_ = INFINITE): v(v_), w(w_) { }
	
};
 

vector< vector <Edge> > G(110); //圖的鄰接表

開始進入正題。（有些題目我會用兩種存圖方式寫，有些只能用其中一種）

一、最小生成樹

1、概念：一個有 n 個結點的連通圖的生成樹是原圖的極小連通子圖，且包含原圖中的所有 n 個結點，並且有保持圖連通的最少的邊。

我們先介紹prim演算法，然後再介紹kruskal演算法。

prim演算法的思路很簡單。就是從一個起點開始進行連通始終尋找沒有訪問過且最小的邊來進行連通。

題意很簡單就是根據n個點求一顆最小生成樹。

prim程式碼如下：

#include<cstdio>
#include<cstring>
#include<iostream>
#define maxn 100 + 15
#define inf 200000005
int dis[maxn], vis[maxn];
int map[maxn][maxn];
int n, sum;
using namespace std;
void prim() {
	memset(vis, 0, sizeof(vis));
	for(int i = 0; i < n; ++i)  dis[i] = map[i][0];
	vis[0] = 1;
	dis[0] = 0;
	for(int i = 0; i < n - 1; ++i) { ///n-1條邊
		int k, temp = inf; ///temp用來找最小的邊，k儲存最小邊的對應的點
		for(int j = 0; j < n; ++j) {
			if(!vis[j] && dis[j] < temp) temp = dis[j], k = j;
		}
		vis[k] = 1;  ///標記找到的點
		sum += dis[k]; ///最小邊加入到最小生成樹裡面
		for(int j = 0;j <n;++j)
            if(!vis[j]&&dis[j] > map[k][j])  dis[j] = map[k][j]; ///儲存小的
	}
	cout << sum << endl;
}
int main() {
	while(scanf("%d", &n) != EOF) {
		for(int i = 0; i < n; ++i)
			for(int j = 0; j < n; ++j) {
				int value;
				scanf("%d", &value);
				map[i][j] = value; ///鄰接矩陣存圖
			}
		sum = 0;
		prim();
	}
	return 0;
}
 

         kruskal演算法的思路：把邊按從小到大排序，然後運用並查集的知識按照邊的兩個端點進行合併，判斷是不是同一個連通分量如果不是進行合併，如果是的話則跳過。讀到n-1條邊合併之後則是最小生成樹。

程式碼如下：（POJ1258）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#define maxn 100 + 15
int father[maxn];
using namespace std;
///鄰接矩陣存圖
struct Edge {
	int s, e, v;
	Edge(int ss, int ee, int vv): s(ss), e(ee), v(vv) {}
	Edge() {}
};
///按邊從大到小排序
bool cmp(Edge a,Edge b)
{
    return a.v < b.v;
}
vector<Edge>vp;
///並查集
int Find(int x) {
	if(x == father[x]) return x;
	else    return father[x] = Find(father[x]);
}
void Union(int a, int b) {
	int aa = Find(a);
	int bb = Find(b);
	if(aa == bb) return ;
	else  father[bb] = aa;
}
void Clear(int n) {
	for(int i = 0; i < n; ++i) father[i] = i;
}
int main() {
	int n;
	while(scanf("%d", &n) != EOF) {
		Clear(n);
		vp.clear();
		for(int i = 0; i < n; ++i)
			for(int j = 0; j < n; ++j) {
				int value;
				scanf("%d", &value);
				vp.push_back(Edge(i,j,value));
			}
        sort(vp.begin(),vp.end(),cmp); ///按邊排序
		int sum = 0;
		int num = 0;
		for(int i = 0; i < vp.size(); ++i) {
			int a = vp[i].s, b = vp[i].e, c = vp[i].v;
			if(Find(a) != Find(b)) { ///是不是同一個祖先
				num++;
				sum += c;
				Union(a, b);        ///合併成統一個連通分量
			}
			if(num == n - 1) break; ///找到n-1條邊，數已經生成，退出。
		}
		cout << sum << endl;
	}
	return 0;
}
 

1、概念：若網路中的每條邊都有一個數值（長度、成本、時間等），則找出兩節點（通常是源節點和阱節點）之間總權和最小的路徑就是最短路問題。

這裡我介紹兩種個演算法。floyd，dijkstra

裸裸的最短路。

2、dijkstra程式碼：

#include<cstdio>
#include<iostream>
#include<cstring>
#define MIN(a,b) a>b?b:a
#define maxn 201
#define INF 200000005
int map[maxn][maxn];
int dis[maxn];
bool vis[maxn];
using namespace std;
int main() {
	int n, m;
	while(scanf("%d%d", &n, &m) != EOF) {
		if(n == 0 && m == 0)
			break;
		memset(vis, 0, sizeof(vis));
		for(int i = 1; i <= n; i++) {
			for(int j = 1; j <= n; j++)
				if(i == j)
					map[i][j] = 0; ///自己到自己的距離為0
				else
					map[i][j] = INF; ///初始到其他點的距離為無窮大
		}
		for(int i = 1; i <= m; i++) {
			int a, b, c;
			scanf("%d%d%d", &a, &b, &c);
			map[a][b] = map[b][a] = c; ///雙向距離相等
		}
		for(int i = 1; i <= n; i++)
			dis[i] = map[1][i];
		vis[1] = true;
		for(int i = 1; i < n; i++) {
			int temp = INF;
			int k;
			for(int j = 1; j <= n; j++) {
				if(vis[j]) continue;
				if(temp > dis[j]) {
					temp = dis[j];
					k = j;
				}
			}
			vis[k] = true;
			for(int j = 1; j <= n; j++) {
				if(vis[j]) continue;
				dis[j] = MIN(dis[j], dis[k] + map[k][j]);
			}
		}
		cout << dis[n] << endl;
	}
	return 0;
}

///HDU 2544.
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 100 + 15
#define inf 100000005
int a[maxn][maxn], dis[maxn], vis[maxn];
int n, m;
using namespace std;
int main() {
	while(scanf("%d%d", &n, &m) != EOF && (n && m)) {
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++) {
				a[i][j] = 0;
				if(i != j) a[i][j] = inf;
			}
		for(int i = 1; i <= m; i++) {
			int x, y, z;
			scanf("%d%d%d", &x, &y, &z);
			///更新最小值
			if(a[x][y] > z) a[x][y] = a[y][x] = z;
		}
		///更新了所有點的最短路
		for(int k = 1; k <= n; k++)
			for(int i = 1; i <= n; i++)
				for(int j = 1; j <= n; ++j) {
					a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
				}
		printf("%d\n", a[1][n]);
	}
	return 0;
}

POJ3159

程式碼：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
#include<vector>
#define maxn 30000 + 5
#define inf 200000005
int vis[maxn];
int n, m;
using namespace std;
///鄰接表存圖
struct edge {
	int e, cc; ///本身自帶一個節點，e代表另一個節點 v代表權值
};
bool operator < (const edge &a, const edge &b) {
	return a.cc > b.cc;
}
///優先佇列
priority_queue<edge>pq;
///鄰接表
vector< vector<edge> >v;
int main() {
	while(scanf("%d%d", &n, &m) != EOF) {
		edge d, z;
		v.clear();
		v.resize(n + 1);
		for(int i = 0; i < m; ++i) {
			int a, b, c;
			scanf("%d%d%d", &a, &b, &c);
			d.e = b;
			d.cc = c;
			v[a].push_back(d);///鄰接表存圖
		}
		memset(vis,0,sizeof(vis));
		d.e = 1;
		d.cc = 0;
		pq.push(d);
		while(!pq.empty()) {
			d = pq.top();///不能使用pq.front();
			pq.pop();
			if(vis[d.e]) continue; ///表示已經走過
			vis[d.e] = 1;
			if(d.e == n) break; ///找到該點
			for(int i = 0 ; i < v[d.e].size(); ++i) {
				z.e = v[d.e][i].e;
				if(vis[z.e]) continue; ///鄰接表裡的點有沒有訪問過
				z.cc = v[d.e][i].cc + d.cc;
				pq.push(z);
			}
		}
		cout << d.cc << endl;
	}
	return 0;
}