给出一个图的邻接矩阵,再给出指定顶点v0,求顶点v0到其他顶点的最短路径
第一行输入t,表示有t个测试实例
第二行输入n,表示第1个图有n个结点
第三行起,每行输入邻接矩阵的一行,以此类推输入n行
第i个结点与其他结点如果相连则为1,无连接则为0,数据之间用空格隔开
第四行输入v0,表示求v0到其他顶点的最短路径距离
以此类推输入下一个示例
每行输出v0到某个顶点的最短距离和最短路径
每行格式:v0编号-其他顶点编号----[最短路径],具体请参考示范数据
1
5
0 5 0 7 15
0 0 5 0 0
0 0 0 0 1
0 0 2 0 0
0 0 0 0 0
0
0-1-5----[0 1 ]
0-2-9----[0 3 2 ]
0-3-7----[0 3 ]
0-4-10----[0 3 2 4 ]
#include
using namespace std;
const int MaxLen = 20;
const int MaxDist = 9999;
class Map {
private:
int Matrix[MaxLen][MaxLen];
int Vexnum;
public:
void SetMatrix(int vnum, int mx[MaxLen][MaxLen]);
void ShortestPath_DIJ(int v0);
};
void Map::SetMatrix(int vnum, int mx[MaxLen][MaxLen]) {
int i, j;
Vexnum = vnum;
for (i = 0; i < Vexnum; i++)
for (j = 0; j < Vexnum; j++)
Matrix[i][j] = MaxDist;
for (i = 0; i < Vexnum; i++)
for (j = 0; j < Vexnum; j++)
if (mx[i][j]) Matrix[i][j] = mx[i][j];
}
void Map::ShortestPath_DIJ(int v0) {
int i, j, v, w, min;
int *dist = new int[Vexnum];
bool *final = new bool[Vexnum];
int path[MaxLen][MaxLen];
int len[MaxLen];
for (j = 0; j < Vexnum; j++) {
final[j] = false;
dist[j] = Matrix[v0][j];
}
for (i = 0; i < Vexnum; i++)
for (j = 0; j < Vexnum; j++)
path[i][j] = -1;
for (i = 0; i < Vexnum; i++) {
if (dist[i] < MaxDist) {
path[i][1] = i;
path[i][0] = v0;
}
len[i] = 2;
}
dist[v0] = 0;
final[v0] = true;
for (i = 0; i < Vexnum; i++) {
min = MaxDist;
for (w = 0; w < Vexnum; w++)
if (!final[w])
if (dist[w] < min) {
v = w;
min = dist[w];
}
final[v] = true;
for (w = 0; w < Vexnum; w++) {
if (!final[w] && (min + Matrix[v][w] < dist[w])) {
len[w] = 0;
dist[w] = min + Matrix[v][w];
for (j = 0; path[v][j] != -1; j++) {
path[w][j] = path[v][j];
len[w]++;
}
path[w][j] = w;
len[w]++;
}
}
}
for (i = 0; i < Vexnum; i++) {
if (i != v0) {
cout << v0 << '-' << i << '-' << dist[i] << "----" << '[';
for (j = 0; j < len[i]; j++)
cout << path[i][j] << ' ';
cout << ']' << endl;
}
}
delete[]dist;
delete[]final;
}
int main() {
int i, j, k, t;
int vnum, v0;
int mx[MaxLen][MaxLen];
Map myMap;
cin >> t;
while (t--) {
for (i = 0; i < MaxLen; i++)
for (j = 0; j < MaxLen; j++)
mx[i][j] = 0;
cin >> vnum;
for (i = 0; i < vnum; i++)
for (j = 0; j < vnum; j++)
cin >> mx[i][j];
myMap.SetMatrix(vnum, mx);
cin >> v0;
myMap.ShortestPath_DIJ(v0);
}
return 0;
}
已知有向图,顶点从0开始编号,求它的求拓扑有序序列。
拓扑排序算法:给出有向图邻接矩阵
1.逐列扫描矩阵,找出入度为0且编号最小的顶点v
2.输出v,并标识v已访问
3.把矩阵第v行全清0
重复上述步骤,直到所有顶点输出为止
/
// STL::vector基本用法
1)
vector::push_back(1); //将1增加到数组尾部
vector::push_back(e); //将类型为E的一个对象e增加到数组尾部.其中类型E可以自行定义,如Vertex类,int类等。
2.1)
vector vec;
int x = vec[1]; //读取组数v(索引从0开始)的第1个元素
2.2)
vector v;
int& x = v[1]; //引用组数v的第1个元素,注意此处的引用&的用法
x = 10; //修改组数v的第1个元素为10
3)
vector
vector row; //声明一个vector(动态数组)对象row表示矩阵的一行
int j=0;
for(; j
cin >> edge;
row.push_back(edge); //将边信息增加到数组row的最后
}
this->adjMat.push_back(row); //将row增加到数组adjMat的最后
//
//参考代码框架
#include
#include
using namespace std;
class Graph {
public:
vector isFinished; //索引号所指示的顶点是否已处理过
vector
int n; //顶点数 as 成员变量
public:
void readAdjMatrix() {
//从输入读入邻接矩阵,存入this->adjMat
cin >> this->n; //顶点数
int i=0;
for(; i
//提示:调用vector::push_back方法
vector row;
int j=0;
for(; j
cin >> edge; //读入顶点对i,j之间是否有一条边
//TODO:将边信息增加入row
}
//TODO:将row增加入this->adjMat
//提示:以row为参数,调用adjMat的push_back方法
}
}
bool isZeroInDegrees(int vertexNo) {
//判定顶点vertexNo是否没有入度
int i=0;
//this->adjMat[i][vertexNo] == 0
//表示顶点i与vertexNo之间没有边相连
for(; i
//TODO:返回true if 顶点vertexNo没有入度; false [otherwise]
}
int select() {
//从所有顶点中,选出一个顶点i,满足:
//1) i没有处理过,即isFinished[i]=false
//2) i的入度为0
int i = 0;
for (; i < n; ++i) {
//TODO:若顶点i的已经处理过,则pass
//TODO:若顶点度>0,则pass
//提示:调用isZeroInDegrees
//TODO: 设置顶点i已经处理过,即isFinished[i]为正确值
//TODO: 返回i
}
//TODO: 返回-1, 表示未找到满足1)+2)条件的顶点
}
void update(int rootNo) {
//更新顶点rootNo的出弧,即将顶点rootNo从图中断开
int j=0;
for(;j
}
}
/
// 拓扑排序主算法
void topologySort() {
int i=0;
for(; i
//TODO: 调用select方法,并将其返回值存入root
//TODO: 若root=-1,则break;
// root=-1表示没有可以排出的顶点
//TODO: 以root为参数,调用update方法
//TODO:输出当前选出的顶点root 和一个空格
}
//TODO:输出一行
}
void main() {
readAdjMatrix();
topologySort();
}
};
int main() {
int t;
cin >> t;
while (t–) {
Graph g;
g.main();
}
return 0;
}
第一行输入一个整数t,表示有t个有向图
第二行输入n,表示图有n个顶点
第三行起,输入n行整数,表示图对应的邻接矩阵
以此类推输入下一个图的顶点数和邻接矩阵
每行输出一个图的拓扑有序序列
2
5
0 1 0 1 1
0 0 1 0 0
0 0 0 0 1
0 0 1 0 0
0 0 0 0 0
7
0 0 0 0 0 0 0
1 0 1 1 0 0 0
1 0 0 0 0 0 0
1 0 1 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 0 0 1 0 1 0
0 1 3 2 4
4 6 5 1 3 2 0
#include
#include
using namespace std;
class Graph {
public:
vector<bool> isFinished; //索引号所指示的顶点是否已处理过
vector<vector<int> > adjMat; //邻接矩阵
int n; //顶点数 as 成员变量
public:
void readAdjMatrix() {
//从输入读入邻接矩阵,存入this->adjMat
cin >> this->n; //顶点数
int i, j;
for (i = 0; i < n; ++i) {
for (int k = 0; k < n; k++)
isFinished.push_back(false);
//TODO:设置this->isFinished数组:每个顶点未曾访问过
//提示:调用vector::push_back方法
vector<int> row;
for (j = 0; j < n; ++j) {
int edge;
cin >> edge; //读入顶点对i,j之间是否有一条边
row.push_back(edge);
//TODO:将边信息增加入row
}
this->adjMat.push_back(row);
//TODO:将row增加入this->adjMat
//提示:以row为参数,调用adjMat的push_back方法
}
}
bool isZeroInDegrees(int vertexNo) {
//判定顶点vertexNo是否没有入度
int i;
//this->adjMat[i][vertexNo] == 0
//表示顶点i与vertexNo之间没有边相连
for (i = 0; i < n && this->adjMat[i][vertexNo] == 0; ++i){}
if(i>=n) return true;
else return false;
//TODO:返回true if 顶点vertexNo没有入度; false [otherwise]
}
int select() {
//从所有顶点中,选出一个顶点i,满足:
//1) i没有处理过,即isFinished[i]=false
//2) i的入度为0
int i = 0;
for (; i < n; ++i) {
if(isFinished[i]) continue;
//TODO:若顶点i的已经处理过,则pass
if(!isZeroInDegrees(i)) continue;
//TODO:若顶点度>0,则pass
//提示:调用isZeroInDegrees
isFinished[i]=true;
//TODO: 设置顶点i已经处理过,即isFinished[i]为正确值
return i;
//TODO: 返回i
}
return -1;
//TODO: 返回-1, 表示未找到满足1)+2)条件的顶点
}
void update(int rootNo) {
//更新顶点rootNo的出弧,即将顶点rootNo从图中断开
int j = 0;
for (; j < n; ++j) {
adjMat[rootNo][j]=0;
//TODO: 设置adjMat[rootNo][j]为0
}
}
/
// 拓扑排序主算法
void topologySort() {
int i = 0;
for (; i < n; ++i) { //遍历n次:即按拓扑序,依次选择(排出)n个顶点
int root; // 声明顶点索引号(编号)用于存放本次选出的顶点
root=select();
//TODO: 调用select方法,并将其返回值存入root
if(root==-1) break;
//TODO: 若root=-1,则break;
// root=-1表示没有可以排出的顶点
update(root);
//TODO: 以root为参数,调用update方法
cout<<root<<' ';
//TODO:输出当前选出的顶点root 和一个空格
}
cout<<endl;
//TODO:输出一行
}
void main() {
readAdjMatrix();
topologySort();
}
};
int main() {
int t;
cin >> t;
while (t--) {
Graph g;
g.main();
}
return 0;
}
给定有向图无环的边信息,求每个顶点的最早开始时间、最迟开始时间。
// 参考代码
#include
#include
#include
#include
using namespace std;
class Vertex {
public:
int indexNo;
bool hasEnterQueue;
int early;
int later;
Vertex(int indexNo) {
this->indexNo = indexNo;
this->hasEnterQueue = false;
early = -1;
later = 0x7FFFF;
}
void updateEarly(int parentEarly, int edgeValue) {
int newEarly = parentEarly + edgeValue;
if (newEarly > this->early)
this->early = newEarly;
}
void updateLater(int childLater, int edgeValue) {
int newLater = childLater - edgeValue;
if (newLater < this->later)
this->later = newLater;
}
};
class Graph {
public:
vector vertexes;
vector
int n;
public:
void readVertexes() {
//TODO: 将顶点数读入成员变量n
//TODO: 从输入初始化vertexes数组
int i=0;
for(; ivertexes.push_back(v);
}
//为成员变量adjMat创建内存,赋初值
for(i=0; i row;
int j=0;
for(; jadjMat
int edges;
cin >> edges;
int i=0;
int s, t, w; //s源顶点编号,t目的顶点编号,w边长
for(; i& earlyQue) {
int parentEarly = vertexes[parentNo].early; //读入父结点early值
int j=0;
for(; j& laterQue) {
//TODO:
}
int getRoot() {
//获取入度为0的顶点
int j=0;
for(; j=n) return j; //j has not any in-edges.
}
return -1; //表示没找到
}
int getLeaf() {
//TODO: 获取出度为0的顶点
}
void printEarlyLater(bool isEarly) {
int i=0;
for(; i que;
que.push(r);
while(!que.empty()) {
int p = que.front();
que.pop();
updateEarly(p, que);
}
printEarlyLater(true);
}
void clearEnterQueue() {
int i=0;
for(; i
};
int main() {
int t=1;
//cin >> t;
while (t–) {
Graph g;
g.main();
}
return 0;
}
第一行图的顶点总数
第二行边的总数
第三行开始,每条边的时间长度,格式为源结点 目的结点 长度
第一行:第个顶点的最早开始时间
第二行:每个顶点的最迟开始时间
9
12
0 1 3
0 2 10
1 3 9
1 4 13
2 4 12
2 5 7
3 6 8
3 7 4
4 7 6
5 7 11
6 8 2
7 8 5
0 3 10 12 22 17 20 28 33
0 9 10 23 22 17 31 28 33
#include
#include
#include
#include
using namespace std;
class Vertex {
public:
int indexNo;
bool hasEnterQueue;
int early;
int later;
Vertex(int indexNo) {
this->indexNo = indexNo;
this->hasEnterQueue = false;
early = -1;
later = 0x7FFFF;
}
void updateEarly(int parentEarly, int edgeValue) {
int newEarly = parentEarly + edgeValue;
if (newEarly > this->early)
this->early = newEarly;
}
void updateLater(int childLater, int edgeValue) {
int newLater = childLater - edgeValue;
if (newLater < this->later)
this->later = newLater;
}
};
class Graph {
public:
vector<Vertex> vertexes;
vector<vector<int> > adjMat;
int n;
public:
void readVertexes() {
cin >> this->n;
//TODO: 将顶点数读入成员变量n
//TODO: 从输入初始化vertexes数组
int i;
for (i = 0; i < n; ++i) {
Vertex v(i);
this->vertexes.push_back(v);
}
//为成员变量adjMat创建内存,赋初值
for (i = 0; i < n; ++i) {
vector<int> row;
int j = 0;
for (; j < n; ++j) {
row.push_back(0);
//TODO: 将0增加到row最后
}
adjMat.push_back(row);
//TODO: 将row增加到adjMat最后
}
}
void readAdjMatrix() {
//read the adjacent info into this->adjMat
int edges;
cin >> edges;
int i = 0;
int s, t, w; //s源顶点编号,t目的顶点编号,w边长
for (; i < edges; ++i) {
cin >> s >> t >> w;
adjMat[s][t] = w;
//TODO: 读入s,t,w,并将adjMat的第s行、第t列的值改为w.
}
}
void updateEarly(int parentNo, queue<int> &earlyQue) {
int parentEarly = vertexes[parentNo].early; //读入父结点early值
int j = 0;
for (; j < n; ++j) {
int edgeValue = adjMat[parentNo][j];
if (edgeValue == 0) continue; //若父结点与结点j没有边相连,pass
Vertex &child = vertexes[j];
child.updateEarly(parentEarly, edgeValue); //更新子结点j的early信息
if (!child.hasEnterQueue) {
child.hasEnterQueue = true; //将子结点加入队列
earlyQue.push(j);
}
}
}
void updateLater(int childNo, queue<int> &laterQue) {
int childlater = vertexes[childNo].later; //读入父结点early值
int j = 0;
for (; j < n; ++j) {
int edgeValue = adjMat[j][childNo];
if (edgeValue == 0) continue; //若子结点与结点j没有边相连,pass
Vertex &father = vertexes[j];
father.updateLater(childlater, edgeValue);//更新父结点j的later信息
if (!father.hasEnterQueue) {
father.hasEnterQueue = true; //将fu结点加入队列
laterQue.push(j);
}
}
//TODO:
}
int getRoot() {
//获取入度为0的顶点
int j = 0;
for (; j < n; ++j) {
int i = 0;
for (; i < n && adjMat[i][j] == 0; ++i);
if (i >= n) return j; //j has not any in-edges.
}
return -1; //表示没找到
}
int getLeaf() {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n && adjMat[i][j] == 0; j++);
if (j >= n) return i;
}
return -1;
//TODO: 获取出度为0的顶点
}
void printEarlyLater(bool isEarly) {
int i = 0;
for (; i < n; ++i) {
Vertex &v = vertexes[i];
if (isEarly)
cout << v.early << " ";
else {
cout << v.later << " ";
}
}
cout << endl;
}
void findEarly() {
//执行关键路径算法,求每个顶点的最早开始时间。
int r = getRoot();
Vertex &root = vertexes[r];
root.hasEnterQueue = true;
root.early = 0;
queue<int> que;
que.push(r);
while (!que.empty()) {
int p = que.front();
que.pop();
updateEarly(p, que);
}
printEarlyLater(true);
}
void clearEnterQueue() {
int i = 0;
for (; i < n; ++i) {
vertexes[i].hasEnterQueue = false;
}
}
void findLater() {
int i;
clearEnterQueue();
int L = getLeaf();
Vertex &leaf = vertexes[L];
leaf.hasEnterQueue = true;
leaf.later = leaf.early;
queue<int> que;
que.push(L);
while (!que.empty()) {
int p = que.front();
que.pop();
updateLater(p, que);
}
printEarlyLater(false);
//TODO:调用clearEnterQueue,以清除每个顶点的hasEnterQueue=false
//TODO:执行关键路径算法,求每个顶点的最迟开始时间。
}
void main() {
readVertexes();
readAdjMatrix();
findEarly();
findLater();
}
};
int main() {
int t = 1;
while (t--) {
Graph g;
g.main();
}
return 0;
}
有N个村庄,编号从1到N,你应该建造一些道路,使每个村庄都可以相互连接。
两个村A和B是相连的,当且仅当A和B之间有一条道路,或者存在一个村C使得在A和C之间有一条道路,并且C和B相连。
现在一些村庄之间已经有一些道路,你的任务就是修建一些道路,使所有村庄都连通起来,并且所有道路的长度总和是最小的。
测试数据有多组
第一行是整数N(3 <= N <= 100),代表村庄的数量。 然后是N行,其中第i行包含N个整数,这些N个整数中的第j个是村庄i和村庄j之间的距离(距离是[1,1000]内的整数)。
然后是整数Q(0 <= Q <= N *(N + 1)/ 2),接下来是Q行,每行包含两个整数a和b(1 <= a
输出
对于每组测试数据
输出一个整数,表示要构建的道路的长度总和最小值
3
0 990 692
990 0 179
692 179 0
1
1 2
179
#include
using namespace std;
const int MaxLen = 100;
const int inf = 9999;
struct closEdge{
int lowCost;
int point;
};
class Graph{
int Mat[MaxLen][MaxLen];
int n;
public:
void readGraph(int m){
this->n= m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin>>Mat[i][j];
if(!Mat[i][j])
Mat[i][j] = inf;
}
}
}
void origin_road(){
int m;
cin>>m;
for (int i = 0; i < m; ++i) {
int a,b;
cin>>a>>b;
Mat[a-1][b-1] =0;
Mat[b-1][a-1] =0;
}
prime();
}
void prime(){
int start =0;
closEdge c[n];
int sum=0;
for (int i = 0; i < n; ++i) {
if(i!=start){
c[i].point = start;
c[i].lowCost = Mat[start][i];
}
}
c[start].lowCost = -1;
for (int i = 1; i < n; ++i) {
int min = inf;
for (int j = 0; j < n; ++j) {
if(c[j].lowCost==-1) {
continue;
}
if(c[j].lowCost<min){
start = j;
min = c[j].lowCost;
}
}
sum+=min;
c[start].lowCost = -1;
for (int j = 0; j < n; ++j) {
if(Mat[start][j]<c[j].lowCost){
c[j].point = start;
c[j].lowCost = Mat[start][j];
}
}
}
cout<<sum<<endl;
}
};
int main(){
int n;
while (cin>>n) {
Graph g;
g.readGraph(n);
g.origin_road();
}
return 0;
}