Algorithm Part1 没学多久就结课了,真是忧桑,当时开始学这门课的时候离结课也就还剩下一个星期,所以学到的东西也不是很多。
于是,就直接跳到 Algorithm Part2 了,不知道没有Part1 的基础直接进入Part2 压力会不会很大。
中间大概等了一两个星期吧,开始Part2 的课程。一上来就是图论,自己心里当时还真有点打鼓,毕竟图论是一个看上去很抽象、很深奥的东西。而且当时学习算法的时候对图论也是抱着一知半解的理解,知道的图论的算法也就最最基础的深搜、广搜、最小生成树、单源点最短路径,可即使是这最最基础的算法玩得也不利索。所以这次真的是抱着认认真真、不打一点马虎眼、不骗自己的态度来学习的,认真学习理解每一个算法、认真写每一行靠谱的代码(每星期的课后作业还是很有意思的,有难度但有心就能做),还有及时作总结,就像现在做的事情一样。
我希望能够在这门课结束的时候能够坚实自己的基础,也能够保持对代码的感觉,代码量的不同真的会让程序员有不同的感觉。
好了,进入正题吧、、
1.1 数据结构
构建图的数据结构不多,典型的就几种吧:链表或者是数组,存放的方式可以是二维矩阵,0/1表示两个节点是否相连,空间开销是V*V,V表示图的节点个数;再有就是直接存放每条边,空间开销是E,E表示边的条数。
显然,有更好的数据结构方式,那就是邻接表。V大小的数组存放每个节点,数组的每个元素又由链表链出,链表中的每个元素表示与该数组元素相连的节点。邻接表的数据结构节省了空间的开销,也降低了查找的时间代价,是一种常用的图论的数据结构。
坑爹的csdn,好不容易写一回blog,竟然不能上传图片,只得一行一行敲代码!!!注:所有的示例代码以及所需包含的库都可以在这里下载。
public class Graph {
private final int V;
private Bag<Integer>[] adj; // adjacency lists (using Bag data type)
public Graph(int V) {
this.V = V;
adj = (Bag<Integer>[]) new Bag[V]; // create empty graph with V vertices
for (int v = 0; v < V; v++)
adj[v] = new Bag<Integer>();
}
public void addEdge(int v, int w) {
// add edge v-w (parallel edges and self-loops allowed)
adj[v].add(w);
adj[w].add(v);
}
// iterator for vertices adjacent to v
public Iterable<Integer> adj(int v) {
return adj[v]
}
}
1.2 深搜(带路径记录)
深搜是图论中很常见的算法,可能是图论中很多算法的基础,也许比广搜用得还多,话不多说,直接上代码。
public class DepthFirstPaths {
private boolean[] marked[]; // marked[v]=true if v connected to s
private int[] edgeTo; // edge[v] = previous vertex on path from s to v
private int s;
public DepthFirstPahts(Graph G, int s) {
// ... initialize data structire
dfs(G, s); // find vertices connected to s
}
// recursive DFS does the work
private void dfs(Graph G, int v) {
marked[v] = true;
for (int w : G.adj(v)) {
if (!marked[w]) {
dfs(G, w);
edge[w] = v;
}
}
}
public boolean hasPathTo(int v) {
return marked[v];
}
public Iterable<Integer> pathTo(int v) {
if (!hasPathTo(v)) return null;
Stack<Integer> path = new Stack<Integer>();
for (int x = v; x != s; x = edgeTo[x])
path.push(x);
path.push(s);
return path;
}
}
1.3 广搜
与深搜不同,同样是图搜索,但是更广泛地用于最短路径的算法中。
public class BreadthFirstPaths {
private boolean[] marked;
private int[] edgeTo;
private void bfs(Graph G, int s) {
Queue<Integer> q = new Queue<Integer>();
q.enqueue(s);
marked[s] = true;
while(!q.isEmpty()) {
int v = q.dequeue();
for (int w : G.adj(v)) {
if (!marked[w]) {
q.enqueue(w);
marked[w] = true;
edgeTo[w] = v;
}
}
}
}
}
1.4 连通分量(深搜解决)
public class CC {
private boolean[] marked;
private int[] id; // id[v] = id of component containing v
private int count; // number of components
public CC(Graph G) {
marked = new boolean[G.V()];
id = new int[G.V()];
for (int v = 0; v < G.V(); v++) {
if (!marked[v]) {
dfs(G, v); // run DFS from one vertex in each component
count++;
}
}
}
// number of components
public int count() {
return count;
}
// id of component containing v
public int id(int v) {
return id[v];
}
// all vertices discovered in same call of dfs have same id
private void dfs(Graph G, int v) {
marked[v] = true;
id[v] = count;
for (int w : G.adj(v))
if (!marked[w])
dfs(G, w);
}
}
下面是有向图的基本算法,深搜和广搜就不再赘述了,和无向图基本上一致,没什么好说的。
2.1 拓扑排序(DAG:Directed acyclic graph)
首先,什么是拓补排序呢。我自己也说不清楚,只能感觉出来,就比如一批工作,每两个工作有先后次序,什么先做、什么后做,需要给出所有这些工作它们之间清楚的序列关系,大概就是拓扑排序了吧。这里拓扑排序算法是借助深搜,终于认识到深搜的强大了吧。
public class DepthFirstOrder {
private boolean[] marked;
private Stack<Integer> reversePost;
public DepthFirstOrder(Digraph G) {
reversePost = new Stack<Integer>();
marked = new boolean[G.V()];
for (int v = 0; v < G.V(); v++)
if (!marked[v]) dfs(G, v);
}
private void dfs(Digraph G, int v) {
marked[v] = true;
for (int w : G.adj(v))
if (!marked[w]) dfs(G, w);
reversePost.push(v);
}
// returns all vertices in "reverse DFS postorder"
public Iterable<Integer> reversePost() {
return reversePost;
}
}
2.2 强连通分量
首先,强连通的定义:节点v和节点w强连通充分必要条件是在有向图中有v到w的路径,也有w到v的路径。
那么强连通分量的定义:最大化强连通集合的节点个数。
这里用的是Kosaraju-Sharir算法计算强连通分量,Kosaraju-Sharir算法主要由两部分组成:
(1)计算图G'的拓扑排序,其中图G'是图G中所有的有向边调转指向,即原来由v->w的边变成w->v
(2)根据图G'的拓扑排序的顺序在图G中进行深搜,所能访问到的节点属于同一个强连通分量
其实代码和连通分量非常像,就是加了个拓扑排序,深搜的节点顺序是拓扑排序的结果。话不多说,上代码:
public class KosarajuSharirSCC {
private boolean[] marked;
private int[] id;
private int count;
public KosarajuSharirSCC(Digraph G) {
marked = new boolean[G.V()];
id = new int[G.V()];
DepthFirstOrder dfs = new DepthFirstOrder(G.reverse());
for (int v : dfs.reversePost()) {
if (!marked[v]) {
dfs(G, v);
count++;
}
}
}
private void dfs(Digraph G, int v) {
marked[v] = true;
id[v] = count;
for (int w : G.adj(v))
if (!marked[w]) dfs(G, w);
}
public boolean stronglyConnected(int v, int w) {
return id[v] == id[w];
}
}
Assigment
最后附上Algorithm Part2 Week1 的作业和测试用例。看这里。
冬冬加油!再苦再累路也得走完,想明白自己想要的是什么,放弃的是什么。每天进步一点点,我知道过程会很艰苦,会没有人相信你,但是真的要自己相信自己。一定行行行!!!