数据结构与算法——编程作业——第七章 图

1.The Unique MST

题目

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

Given a connected undirected graph, tell if its minimum spanning tree is unique.
Definition 1 (Spanning Tree): Consider a connected, undirected graph G = (V, E). A spanning tree of G is a subgraph of G, say T = (V', E'), with the following properties:
1. V' = V.
2. T is connected and acyclic.
Definition 2 (Minimum Spanning Tree): Consider an edge-weighted, connected, undirected graph G = (V, E). The minimum spanning tree T = (V, E') of G is the spanning tree that has the smallest total cost. The total cost of T means the sum of the weights on all the edges in E'.

输入

The first line contains a single integer t (1 <= t <= 20), the number of test cases. Each case represents a graph. It begins with a line containing two integers n and m (1 <= n <= 100), the number of nodes and edges. Each of the following m lines contains a triple (xi, yi, wi), indicating that xi and yi are connected by an edge with weight = wi. For any two nodes, there is at most one edge connecting them.

输出

For each input, if the MST is unique, print the total cost of it, or otherwise print the string 'Not Unique!'.

样例输入

2
3 3
1 2 1
2 3 2
3 1 3
4 4
1 2 2
2 3 2
3 4 2
4 1 2

样例输出

3
Not Unique!

来源
　　　　POJ Monthly--2004.06.27 srbga@POJ

我的代码

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

typedef struct{
    int x, y, w;
} EDGE;

bool cmp(EDGE e1, EDGE e2){
    return e1.w < e2.w;
}

EDGE * e;   //按权重增序存储所有边的信息
int * f;    //父节点表示法
int T, N, M,//输入参数
    sum;    //最小生成树的边权和

//带路径压缩的根节点搜索算法
int FindRoot(int i){
    if(f[i] != i)
        f[i] = FindRoot(f[i]);
    return f[i];
}

//判断最小生成树是否唯一
bool IsUnique(){
    int cnt1 = 0;   //可选的加入最小生成树的边的数量
    int cnt2 = 0;   //实际上加入最小生成树的边的数量
    int i = 0, j = 0;
    int fx, fy;
    while(i < M){
        j = i;
        while(e[i].w == e[j].w && j < M){
            fx = FindRoot(e[j].x);
            fy = FindRoot(e[j].y);
            if(fx != fy)
                cnt1++; //计数：边j可以加入最小生成树
            j++;
        }
        j = i;
        while(e[i].w == e[j].w && j < M){
            fx = FindRoot(e[j].x);
            fy = FindRoot(e[j].y);
            if(fx != fy){
                cnt2++;         //计数：边j实际加入最小生成树
                f[fx] = fy;     //合并以fx和fy为根的树(等价类)
                sum += e[j].w;  //计算边权和
            }
            j++;
        }
        i = j;
    }
    return cnt1 == cnt2;
}

//等价类森林初始化
void ForestIni(){
    cin >> N >> M;
    sum = 0;
    e = new EDGE[M+1];
    f = new int[N+1];
    for(int i=0; i<M; ++i)
        cin >> e[i].x >> e[i].y >> e[i].w;
    sort(e, e+M, cmp);
    for(int i=1; i<=N; ++i)
        f[i] = i;
}

//等价类森林删除
void ForestDel(){
    delete [] e;
    delete [] f;
}

int main(){
    cin >> T;
    while(T--){
        ForestIni();
        if(IsUnique())
            cout << sum << endl;
        else
            cout << "Not Unique!\n";
        ForestDel();
    }
    return 0;
}

实现思路

思路1：MST的可选边多于实际MST的边数 <=> MST不唯一（我的代码采用这个思路）

思路2：构造MST，删除其中一条边，重新构造MST，构造成功 <=> MST不唯一（参见https://blog.csdn.net/libin56842/article/details/17339525）

MST的构造方法

1.Prim算法

任选起始顶点加入树，寻找一顶点在树中&&另一顶点不在树中的权重最小的边，扩展树；重复上述过程，直至所有顶点加入树。

2.Kruskal算法

为顶点划分等价类，初始状态下每个顶点一个等价类；寻找两顶点不在同一等价类中的权重最小的边，合并等价类；重复上述过程，直至所有节点合并为一个等价类。

 

2.兔子与星空

题目

总时间限制: 

1000ms

 

内存限制: 

10000kB

描述

很久很久以前，森林里住着一群兔子。兔子们无聊的时候就喜欢研究星座。如图所示，天空中已经有了n颗星星，其中有些星星有边相连。兔子们希望删除掉一些边，然后使得保留下的边仍能是n颗星星连通。他们希望计算，保留的边的权值之和最小是多少？

输入

第一行只包含一个表示星星个数的数n，n不大于26，并且这n个星星是由大写字母表里的前n个字母表示。接下来的n-1行是由字母表的前n-1个字母开头。最后一个星星表示的字母不用输入。对于每一行，以每个星星表示的字母开头，然后后面跟着一个数字，表示有多少条边可以从这个星星到后面字母表中的星星。如果k是大于0，表示该行后面会表示k条边的k个数据。每条边的数据是由表示连接到另一端星星的字母和该边的权值组成。权值是正整数的并且小于100。该行的所有数据字段分隔单一空白。该星星网络将始终连接所有的星星。该星星网络将永远不会超过75条边。没有任何一个星星会有超过15条的边连接到其他星星（之前或之后的字母）。在下面的示例输入，数据是与上面的图相一致的。

输出

输出是一个整数，表示最小的权值和

样例输入

9
A 2 B 12 I 25
B 3 C 10 H 40 I 8
C 2 D 18 G 55
D 1 E 44
E 2 F 60 G 38
F 0
G 1 H 35
H 1 I 35

样例输出

216

提示

考虑看成最小生成树问题，注意输入表示。

我的代码

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

//边类
typedef struct {
    int x, y, w;
} EDGE;
//比较边权值
bool cmp(EDGE e1, EDGE e2){
    return e1.w < e2.w;
}
EDGE e[80]; //e[i]存储边i的信息
int f[30];  //f[i]存储节点i的父节点下标
int n, m;   //结点数量n，边的数量m
int sum = 0;//最小生成树的边权和
//带路径压缩的根节点搜索算法
int FindRoot(int i){
    if(f[i] != i)
        f[i] = FindRoot(f[i]);
    return f[i];
}
//Kruskal方法找最小生成树
void Kruskal(){
    int i = 0, fx, fy, cnt = 1;
    //边i<m未检测 或 合并等价类操作只进行了cnt<n次
    while(i < m && cnt < n){
        fx = FindRoot(e[i].x);
        fy = FindRoot(e[i].y);
        //合并以fx和fy为根的等价类等价类
        if(fx != fy){
            f[fx] = fy;
            sum += e[i].w;
            ++cnt;  //记录合并等价类操作的次数
        }
        ++i;
    }
}
//图的输入和初始化
void BuildGraph(){
    int x, edge, w;
    char xc, yc;
    cin >> n;   //共有n个节点
    //初始化f[]，每个等价类中只有一个元素，元素的父节点为自身
    for(x = 0; x < n; ++x)
        f[x] = x;
    //初始化e[]，记录边的数量m
    for(x = 0, m = 0; x < n-1; ++x){
        //输入第x个节点的信息
        cin >> xc >> edge;
        for(int j = 0; j < edge; ++j, ++m){
            //输入边的信息
            cin >> yc >> w;
            e[m].x = x;
            e[m].y = yc-'A';
            e[m].w = w;
        }
    }
    sort(e, e+m, cmp);  //按边权值增序排列
}

int main(){
    BuildGraph();
    Kruskal();
    cout << sum << endl;
    return 0;
}

 

3.舰队、海域出击！

题目

总时间限制: 

5000ms

 

单个测试点时间限制: 

2000ms

 

内存限制: 

262144kB

描述

作为一名海军提督，Pachi将指挥一支舰队向既定海域出击！
Pachi已经得到了海域的地图，地图上标识了一些既定目标和它们之间的一些单向航线。如果我们把既定目标看作点、航线看作边，那么海域就是一张有向图。不幸的是，Pachi是一个会迷路的提督QAQ，所以他在包含环(圈)的海域中必须小心谨慎，而在无环的海域中则可以大展身手。
受限于战时的消息传递方式，海域的地图只能以若干整数构成的数据的形式给出。作为舰队的通讯员，在出击之前，请你告诉提督海域中是否包含环。

例如下面这个海域就是无环的：

而下面这个海域则是有环的（C-E-G-D-C）：

输入

每个测试点包含多组数据，每组数据代表一片海域，各组数据之间无关。
第一行是数据组数T。
每组数据的第一行两个整数N，M，表示海域中既定目标数、航线数。
接下来M行每行2个不相等的整数x,y，表示从既定目标x到y有一条单向航线（所有既定目标使用1~N的整数表示）。
描述中的图片仅供参考，其顶点标记方式与本题数据无关。
1<=N<=100000，1<=M<=500000，1<=T<=5
注意：输入的有向图不一定是连通的。

输出

输出包含T行。
对于每组数据，输出Yes表示海域有环，输出No表示无环。

样例输入

2
7 6
1 2
1 3
2 4
2 5
3 6
3 7
12 13
1 2
2 3
2 4
3 5
5 6
4 6
6 7
7 8
8 4
7 9
9 10
10 11
10 12

样例输出

No
Yes

提示

输入中的两张图就是描述中给出的示例图片。

我的代码

# include <iostream>
using namespace std;

//有向边类
typedef struct{
    int x, y;   //始点x,终点y
    bool v;     //是否被添加到DFS-tree中
} EDGE;
//节点类
typedef struct{
    int f;      //记录DFS-tree中的父节点下标
    bool v;     //是否被添加到DFS-tree中
} NODE;
EDGE * e;   //e[]记录有向边信息
NODE * n;   //f[]记录节点信息
int T, N, M;//数据组数T，节点数N，有向边数M

//输入并建立图
void BiuldGraph(){
    cin >> N >> M;
    e = new EDGE[M + 1];
    n = new NODE[N + 1];
    //边信息e[]初始化
    for(int i = 0; i < M; ++i){
        cin >> e[i].x >> e[i].y;
        e[i].v = 0;
    }
    //节点信息n[]初始化
    for(int i = 1; i <= N; ++i){
        n[i].f = i;
        n[i].v = 0;
    }
}
//清除图
void DeleGraph(){
    delete [] e;
    delete [] n;
}
//深度优先遍历图中所有节点
//s是当前搜索的起始节点
void DFS(int s){
    if(n[s].v) return;  //已经访问过
    n[s].v = 1;         //标记节点s为已访问过
    //找节点i的未访问过的邻边j
    for(int j = 0; j < M; ++j)
        if(!e[j].v && e[j].x == s && !n[e[j].y].v){
            e[j].v = 1;     //边j加入DFS-tree
            n[e[j].y].f = s;//边j的终点y的父节点设置为节点s
            DFS(e[j].y);    //递归地深度优先搜索节点y
        }
}
//判断在DFS-tree中，节点x是否是节点y的子孙
bool IsDescend(int x, int y){
    //节点x是根节点
    if(n[x].f == x)
        return false;
    //节点x的父节点是节点y
    if(n[x].f == y)
        return true;
    //判断节点x的父节点是否是节点y的子孙
    return IsDescend(n[x].f, y);
}

//寻找backward-edge，找到则说明有环
bool FindBackwardEdge(){
    for(int j = 0; j < M; ++j)
        //寻找图中未加入DFS-tree的边
        if(!e[j].v)
            //判断backward
            if(IsDescend(e[j].x, e[j].y))
                return true;
    //未找到backward-edge
    return false;
}

int main(){
    cin >> T;
    while(T--){
        //建立图
        BiuldGraph();
        //深度优先遍历图，建立DFE-tree
        for(int i = 1; i <= N; ++i)
            DFS(i);
        //寻找backward-edge，找到则说明有环
        if(FindBackwardEdge())
            cout << "Yes\n";
        else
            cout << "No\n";
        //清除图
        DeleGraph();
    }
    return 0;
}

实现思路

　背景知识：基于DFS的边的分类

　　

　　Forward Edges: 从DFS树的祖先到子孙。

　　Backward Edges: 从DFS树的子孙到祖先。

　　Cross Edges: DFS树上两个不是“祖先-子孙”关系的两个点之间的边。

 存在Backward Edges <=> 图中有环