Coursera - Algorithm (Princeton) - 课程笔记 - Week 7

最新推荐文章于 2024-06-17 20:27:16 发布

支锦铭

最新推荐文章于 2024-06-17 20:27:16 发布

阅读量223

点赞数

分类专栏： Cousera-课程笔记文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/cary_leo/article/details/105829503

版权

Cousera-课程笔记专栏收录该内容

141 篇文章 17 订阅

订阅专栏

Week 7

无向图 Undirected Graphs

图 Graphs

图：一组由边成对连接的点
路径：由边连接的点的序列
环路：首末点相同的路径
连通：如果两个点之间存在一条路径，则两个点是连通的
连通分量：图的一个子集，其中的任一对点都是联通的
图处理问题：
- 路径：在点s和t之间是否存在一条路径
- 最短路径：在点s和t之间是否存在一条最短路径
- 环路：途中是否存在环路
- 欧拉遍历：是否存在一个环路，用到每条边一次
- 汉密尔顿遍历：是否存在一个环路，用到每个顶点一次
- 连通性：有没有链接所有点的方式
- 最小生成树（MST）：链接所有点的最佳方式
- 双连通性（Biconnectivity）：是否有一个顶点其移除将解除图的链接
- 平面性（Planarity）：图上无交叉边
- 图同形：两组可以代表同一个图的邻接表

图的API Graph API

图的绘制：提供图结构的基本引导，但是这种引导可能发生误导
顶点（Vertex）表示：以顶点为核心表示图，边视为点的邻接关系
- 使用 $0$ 到 $V - 1$ 的整数（V为顶点个数）
- 思路：表示图的过程中使用整数数组
- 使用标记表将名称（各个顶点的名称）转换为整数
- 异常：自循环（同一点上的环边），平行边（两点间的多条边）

基本API

public class Graph
{
    Graph(int V); // create an empty graph with V vertices
    Graph(In in); // create a graph from input stream
    void addEdge(int v, int w); // add an edge v-w
    Iterable<Integer> adj(int v); // vertices adjacent to v
    int V(); // number of vertices
    int E(); // number of edges
    String toString(); // string representation
}

一些使用上述API的一些典型图处理代码

// compute the degree of v
public static int degree(Graph G, int v)
{
    int degree = 0;
    for (int w : G.adj(v)) degree++;
    return degree;
}

// compute maximum degree
public static int maxDegree(Graph G)
{
    int max = 0;
    for (int v = 0; v < G.V(); v++)
    if (degree(G, v) > max)
    max = degree(G, v);
    return max;
}

// compute average degree
public static double averageDegree(Graph G)
{ return 2.0 * G.E() / G.V(); }

// count self-loops
public static int numberOfSelfLoops(Graph G)
{
    int count = 0;
    for (int v = 0; v < G.V(); v++)
    for (int w : G.adj(v))
    if (v == w) count++;
    return count/2; // each edge counted twice
}

边集合（Set-of-edges）表示：维护一个边（一条边即两个端点）的列表，低效
邻接矩阵（Adjacency-matrix）表示：维护一个 $\times V$ 的布尔数列（矩阵），对存在邻接关系的点i和j，有a[i][j] = a[j][i] = true，同样很低效

邻接列表（Adjacency-list）表示：维护一个以顶点编号为索引的数组，每一项保存了与之邻接的点的列表（一个包），遍历的时间和空间占用均正比于顶点个数，可用于大型图表示

代码表示为

public class Graph
{
    private final int V;
    private Bag<Integer>[] adj;
    
    public Graph(int V)
    {
        this.V = V;
        adj = (Bag<Integer>[]) new Bag[V];
        for (int v = 0; v < V; v++)
        adj[v] = new Bag<Integer>();
    }
    
    public void addEdge(int v, int w)
    {
        adj[v].add(w);
        adj[w].add(v);
    }
    
    public Iterable<Integer> adj(int v)
    { return adj[v]; }
}

实际中，使用邻接列表表示
- 因为算法都是基于对与特定点V邻接的顶点的遍历
- 同时现实中的图都是稀疏的（点很多但是平均度数很小，这种表示使时间线性于边个数）

表示方法	空间占用	添加新边	确认v和w之间有边	遍历与v邻接的顶点
边集合	$E$	$1$	$E$	$E$
邻接矩阵	$V^2$	$1$	$1$	$V$
邻接列表	$E + V$	$1$	$d e g r e e (v)$	$d e g r e e (v)$

深度优先搜索 Depth-First Search

迷宫探索问题
- 顶点：通道的交点
- 边：通道
- 目标：探索迷宫中的每一个交点
Tremaux（特莱谋）迷宫探索
- 边走便用一根线标记路程
- 标记每一个走过的交点和通道
- 当（交点处）没有其他没有走多的选择时，回溯步骤
- 确保同一位置只走一次
深度优先搜索
- 目标：系统地搜索一张图
- 基本思路：仿照迷宫的探索
- 算法：深度优先遍历一个点v
  - 将v标记为遍历过
  - 递归地遍历与v相邻接为标记点w
- 典型应用：
  - 给定一个源点，找到所有与之连接的顶点
  - 找到两个点之间的路径
- 数据结构
  - 使用一个布尔数组标记已遍历过的顶点
  - 使用一个整数数组保存路径信息（与之相连的点）

图处理方法的设计模式：将图数据类型从图处理中解耦

创建一个图（Graph）实例
将这个Graph实例送入到图处理流程中
查询这个流程的信息
举例：path API

public class Paths
{
    Paths(Graph G, int s)； // find paths in G from source s
    boolean hasPathTo(int v)； // is there a path from s to v?
    Iterable<Integer> pathTo(int v)； // path from s to v; null if no such path
}

DFS代码实现

public class DepthFirstPaths
{
    private boolean[] marked; // 是否连接到指定点
    private int[] edgeTo; // 邻接的上一个点
    private int s;
    
    public DepthFirstPaths(Graph G, int s)
    {
        ... // 初始化
        dfs(G, s); // 递归遍历
    }
    
    private void dfs(Graph G, int v)
    {
        marked[v] = true; // 遍历完啦
        for (int w : G.adj(v))
            // 遍历所有邻接点
            if (!marked[w])
            {
                // 所有没有遍历过的点，递归遍历
                dfs(G, w);
                edgeTo[w] = v; // 因为需要找到最开始到达该点的父结点，因此需要在递归完再标记
            }
    }
}

性质：
- DFS将所有与s连接的点标记上的时间正比于其度之和
- 在完成DFS后，可以在常数时间找到与s相连接的点，并在线性于路径长度的时间内找到一条到s的路径

广度优先搜索 Breadth-Frist Search

广度优先搜索思路，重复下述步骤直到队列维空
- 从队列中移出一个顶点v
- 将与v邻接的所有未标记点标记并加入队列
与DFS不同，非递归算法（实际使一个栈），使用一个循环从队列中取出点
最短路：从s到t使用最少数量边的路径，BFS可实现
性质
- BFS计算从s到其他节点的最短路的时间正比于 $E + V$

实现

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;
                }
            }
        }
    }
}

连通分量 Connected Components

连通性查询
- 定义：如果顶v和w之间存在一条路径，则这两个点是连通的
- 目标：对图进行预处理以在常数时间内回答v与w连通的查询
根据目标，如果使用邻接矩阵表示图，那么可以轻松实现，但是实际中我们不能使用邻接矩阵表示图
API

public class CC
{
    CC(Graph G); // find connected components in G
    boolean connected(int v, int w); // are v and w connected?
    int count(); // number of connected components
    int id(int v); // component identifier for v
}

解决方法
- 并查集？找到相连的部分
  - 不好，因为达不到常数时间
  - 也算好，因为同时做到了并（count）和查（id）
- DFS？是的，保存下来然后查找
“相连通”是一个等价关系
- 自反性：v与v连通
- 对称性：v与w连通，那么w与v连通
- 传递性：如果v与w连通，w与x连通，那么v与x连通
- 定理：一个连通分量是相连通的节点的最大集
- 思考：在给定连通分量的前提下，可以实现连通性问询的常数时间回答

构造连通分量

目标：将顶点划分为连通分量
算法：
- 将所有顶点v初始化为未标记
- 对于每一个未标记的点v，使用DFS找出与其在同一连通分量的顶点
  - 将当前v标记
  - 递归地遍历与v邻接的未标记顶点
代码实现

public class CC
{
    private boolean[] marked;
    private int[] id; // id of component containing v
    private int count;
    
    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);
                count++;
            }
        }
    }
    
    public int count()
    { return count; }
    
    public int id(int v)
    { return id[v]; }
    
    // 同一个dfs函数调用下的顶点在一个
    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);
    }
}

图上的挑战问题 Graph Challenges

尝试回答：一个图处理能有多难
- 0级：任何程序员都能做
- 1级：一般的优秀的算法学生可以做
- 2级：需要雇佣一个专家
- 3级：棘手的（Intractable）
- 4级：没人知道
- 5级：不可能
双边性（Bipartite）：将一个图中的顶点分为两个子集，其中任一边均连接着两个子集的顶点
- 1级：一些简单的DFS方法可以解决
环路：
- 1级：一些简单的DFS方法可以解决
欧拉遍历（七桥问题）：是否存在一个环路能够经过每条边一次且仅一次
- 如果所有的点的度数都是偶数，那么可以实现（Eulerian）
- 1级：欧拉遍历问题，经典图处理问题，有一定的挑战性
汉密尔顿遍历（旅行商问题）：是否存在一个环路能够经过每一个点一次且仅一次
- 3级：经典NP问题
同形：除了顶点命名不同外，两个图是一样的
- 4级：目前基本无法解决（根本不知道这个问题是否有解）
平面图：在没有交叉便的情况下铺平一张图
- 2级：目前有一个线性DFS算法

有向图 Directed Graphs

有向图 Digraphs

有向图：被有方向的边成对连接的点的集合
由于边是有向的，因此描述边的顶点顺序就变得很重要了（有向路径，有向环路）
边的度扩展为入度和出度
- 出度，从该顶点离开的边的个数
- 入读，来到该顶点的边的个数
一些有向图问题
- 路径：是否存在由s到t的有向路径
- 最短路径：由s到t的最短有向路径
- 拓扑排序：存在一张有向图，所有的边都向一个方向指（在有流程限制的时间安排问题中有很多应用）
- 强连通性：是否有一个有向图，其所有的顶点对均存在一条有向边（需要双向才满足）
- 传递闭包：对v和w是否存在一条路径（v和w位于其中且方向明确）
- PageRank：一个网页的重要性（网页之间的链接是有向图）

有向图的API Digraph API

和无向图基本相同
仍然保持了无向图API的设计模式：创建图的类作为图处理算法的客户
API如下

public class Digraph
{
    Digraph(int V); // create an empty digraph with V vertices
    Digraph(In in); // create a digraph from input stream
    void addEdge(int v, int w); // add a directed edge v→w
    Iterable<Integer> adj(int v); // vertices pointing from v
    int V(); // number of vertices
    int E(); // number of edges
    Digraph reverse(); // reverse of this digraph
    String toString(); // string representation
}

有向图的实现：邻接列表，对应索引存储的是从该点发出的边的邻接情况
对于基本实现，有向图和无向图基本没有区别，只是在添加边时只添加给定方向的边

表示方法	空间占用	添加新边	确认由v到w有边	遍历从v发出的边
边集合	$E$	$1$	$E$	$E$
邻接矩阵	$V^2$	$1$	$1$	$V$
邻接列表	$E + V$	$1$	$o u t d e g r e e (v)$	$o u t d e g r e e (v)$

遍历到达v的边，时间复杂度为 $E + V$

有向图搜索 Digraph Search

可达性：在一张有向图上找到所有由s可达的顶点
方法：和无向图一样使用DFS
- 每一张无向图都是一张有向图（一条无向边相当于方向相反的两条有向边）
- DFS是一个有向图算法
- 代码实现完全相同
可达性应用：程序控制流分析
- 顶点：指令块（顺序指令集合）
- 边：程序跳转
- 死代码销毁：寻找不可达的代码
- 死循环检测：查看推出指令是否不可达
可达性应用：mark-sweep垃圾收集器
- 顶点：对象实例
- 边：引用
- 根：可以被程序直接访问的对象（不需要引用的那种）
- 可达对象：从根出发的非直接可访问对象
- mark-sweep算法：
  - 标记所有可达对象
  - 如果对象没有被标记，那么就是垃圾
  - 空间占用：每一个对象一个标记位（还有DFS需要的栈）
DFS能够解决很多有向图的问题
BFS同样也是一个有向图算法，其实现和无向图的BFS是一样的
- 在有向图中，BFS计算最短路径的时间仍正比于 $E + V$
多源最短路：给定一张有向图和一组源点，找出其中任一点到其他任何点的最短路
- 使用BFS，但是初始化时将所有源点都入队
BFS应用：网络爬虫
- 以根网页作为源点s
- 维护要探索的网站队列
- 维护已发现的网站集合
- 出队下一个网站，将其链接的网站入队

拓扑排序 Topological Sort

流程调度：给定一组需要完成的但是存在流程顺序限制的任务，应当如何安排调度这些任务呢
- 顶点：各个任务
- 边：流程限制
拓扑排序：工作于有向无环图中（Directed Acyclic Graph，DAG）
- 实质就是想办法让这张有向无环图的边都向上

DFS实现：先一遍DFS，然后按照反后缀顺序返回节点（最先结束搜索顺序，然后反过来）

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);
    }
    //使用栈的目的就是为了使输出反向
    public Iterable<Integer> reversePost()
    { return reversePost; }
}

性质：对一个DAG的DFS搜索的后序反向结果就是一个拓扑顺序（线性时间）
性质：一个有向图拥有拓扑顺序当且仅当其没有有向环路
- DFS判断环路：到达一个节点时，如果其已经标记且并未退出其本身DFS调用递归，那么存在环

有环意味着调度是不可能的

强连通分量 Strong Components

强连通：如果一张有向图同时存在一条v到w和w到v的路径，那么v和w是强连通的
强连通关系是一个等价关系
强联通分量：强连通顶点的最大子集
对于一张DAG，其连通分量个数为 $V$
应用
- 食物网
  - 顶点：生物
  - 边：从生产者到消费者
  - 强连通分量：具有公共能量流的物种子集（吃成一条环）
- 软件模块依赖关系
  - 顶点：软件模块
  - 边：依赖关系（从模块到依赖）
  - 强连通分量：项目交流的模块子集
  - 解决方案：把互相依赖的模块打包到一块，或者改进设计

K-S算法：

反转图： $G$ 中的强连通分量和 $G^R$ 中的相同
核心DAG：将每一个强连通分量视为一个顶点，最终的图就成为了一张DAG
想法：
- 计算核心DAG的拓扑顺序
- 运行DFS，以反拓扑顺序考虑顶点
思路：
- 计算 $G^R$ 的反后缀顺序
- 在 $G$ 上运行DFS，以 $G^R$ 的反后缀顺序遍历未标记的点（一次递归就是一个强连通分量）
- 两趟DFS
性质：计算时间正比于 $E + V$
实现

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]; }
}

支锦铭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Coursera - Algorithm (Princeton) - 课程笔记 - Week 7

Week 7无向图 Undirected Graphs图 Graphs图：一组由边成对连接的点路径：由边连接的点的序列环路：首末点相同的路径连通：如果两个点之间存在一条路径，则两个点是连通的连通分量：图的一个子集，其中的任一对点都是联通的图处理问题：路径：在点s和t之间是否存在一条路径最短路径：在点s和t之间是否存在一条最短路径环路：途中是否存在环路欧拉遍历：是否存在一...
复制链接

扫一扫