【算法笔记自学】第 10 章 提高篇（4）——图算法专题

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量403 收藏
点赞数 2
分类专栏： 算法笔记自学 文章标签： 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62704693/article/details/140377633
版权

10.1图的定义和相关术语

#include <cstdio>

const int MAXN = 100;
int degree[MAXN] = {0};

int main() {
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int j = 0; j < m; j++) {
        scanf("%d%d", &u, &v);
        degree[u]++;
        degree[v]++;
    }
    for (int i = 0; i < n; i++) {
        printf("%d", degree[i]);
        if (i < n - 1) {
            printf(" ");
        }
    }
    return 0;
}

#include <cstdio>

const int MAXN = 100;
int inDegree[MAXN] = {0};
int outDegree[MAXN] = {0};

int main() {
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int j = 0; j < m; j++) {
        scanf("%d%d", &u, &v);
        outDegree[u]++;
        inDegree[v]++;
    }
    for (int i = 0; i < n; i++) {
        printf("%d %d\n", inDegree[i], outDegree[i]);
    }
    return 0;
}

10.2图的存储

#include <cstdio>
#include <cstring>

const int MAXN = 100;
int G[MAXN][MAXN];

int main() {
    memset(G, 0, sizeof(G));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u][v] = G[v][u] = 1;
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d", G[i][j]);
            printf(j < n - 1 ? " " : "\n");
        }
    }
    return 0;
}

#include <cstdio>
#include <cstring>

const int MAXN = 100;
int G[MAXN][MAXN];

int main() {
    memset(G, 0, sizeof(G));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u][v] = 1;
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d", G[i][j]);
            printf(j < n - 1 ? " " : "\n");
        }
    }
    return 0;
}

#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];

int main() {
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    for (int i = 0; i < n; i++) {
        printf("%d(%d)", i, (int)G[i].size());
        for (int j = 0; j < G[i].size(); j++) {
            printf(" %d", G[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];

int main() {
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
    }
    for (int i = 0; i < n; i++) {
        printf("%d(%d)", i, (int)G[i].size());
        for (int j = 0; j < G[i].size(); j++) {
            printf(" %d", G[i][j]);
        }
        printf("\n");
    }
    return 0;
}

10.3图的遍历

#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
bool vis[MAXN];

void DFS(int u) {
    vis[u] = true;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!vis[v]) {
            DFS(v);
        }
    }
}

int main() {
    memset(vis, false, sizeof(vis));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    int blockCount = 0;
    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            DFS(i);
            blockCount++;
        }
    }
    printf("%d", blockCount);
    return 0;
}

#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
bool vis[MAXN];

void DFS(int u) {
    vis[u] = true;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!vis[v]) {
            DFS(v);
        }
    }
}

int main() {
    memset(vis, false, sizeof(vis));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    int blockCount = 0;
    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            DFS(i);
            blockCount++;
        }
    }
    printf(blockCount == 1 ? "Yes" : "No");
    return 0;
}

#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
int vis[MAXN];

bool isCyclic(int u) {
    vis[u] = 0;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (vis[v] == -1 && isCyclic(v)) {
            return true;
        } else if (vis[v] == 0) {
            return true;
        }
    }
    vis[u] = 1;
    return false;
}

int main() {
    memset(vis, -1, sizeof(vis));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
    }
    int isCyclicResult = false;
    for (int i = 0; i < n; i++) {
        if (vis[i] == -1 && isCyclic(i)) {
            isCyclicResult = true;
        }
        if (isCyclicResult) {
            break;
        }
    }
    printf(isCyclicResult ? "Yes" : "No");
    return 0;
}

#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = 100;
int weight[MAXN];
vector<int> G[MAXN];
bool vis[MAXN];

int DFS(int u) {
    vis[u] = true;
    int weightSum = weight[u];
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!vis[v]) {
            weightSum += DFS(v);
        }
    }
    return weightSum;
}

int main() {
    memset(vis, false, sizeof(vis));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &weight[i]);
    }
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    int maxWeightSum = 0;
    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            maxWeightSum = max(maxWeightSum, DFS(i));
        }
    }
    printf("%d", maxWeightSum);
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
bool inQueue[MAXN] = {false};
int layers[MAXN];

void BFS(int s) {
    queue<int> q;
    q.push(s);
    inQueue[s] = true;
    int layer = 0;
    while (!q.empty()) {
        int cnt = q.size();
        for (int i = 0; i < cnt; i++) {
            int front = q.front();
            q.pop();
            layers[front] = layer;
            for (int j = 0; j < G[front].size(); j++) {
                int v = G[front][j];
                if (!inQueue[v]) {
                    q.push(v);
                    inQueue[v] = true;
                }
            }
        }
        layer++;
    }
}

int main() {
    int n, m, start, u, v;
    scanf("%d%d%d", &n, &m, &start);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    BFS(start);
    for (int i = 0; i < n; i++) {
        printf("%d", layers[i]);
        if (i < n - 1) {
            printf(" ");
        }
    }
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
bool inQueue[MAXN] = {false};

int BFS(int s, int maxLayer) {
    queue<int> q;
    q.push(s);
    inQueue[s] = true;
    int layer = 0;
    int vertexCount = 0;
    while (!q.empty() && layer <= maxLayer) {
        int cnt = q.size();
        vertexCount += cnt;
        for (int i = 0; i < cnt; i++) {
            int front = q.front();
            q.pop();
            for (int j = 0; j < G[front].size(); j++) {
                int v = G[front][j];
                if (!inQueue[v]) {
                    q.push(v);
                    inQueue[v] = true;
                }
            }
        }
        layer++;
    }
    return vertexCount;
}

int main() {
    int n, m, start, maxLayer, u, v;
    scanf("%d%d%d%d", &n, &m, &start, &maxLayer);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
    }
    int vertexCount = BFS(start, maxLayer);
    printf("%d", vertexCount);
    return 0;
}

10.4最短路径

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100;
const int INF = 1e9;

struct Edge {
    int v, dis;
    Edge(int _v, int _dis) {
        v = _v, dis = _dis;
    }
};

vector<Edge> G[MAXN];
int d[MAXN];
bool vis[MAXN];

void dijkstra(int n, int s) {
    fill(d, d + MAXN, INF);
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return;
        }
        vis[u] = true;
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            if (!vis[v] && d[u] + dis < d[v]) {
                d[v] = d[u] + dis;
            }
        }
    }
}

int main() {
    int n, m, s, t;
    scanf("%d%d%d%d", &n, &m, &s, &t);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    dijkstra(n, s);
    if (d[t] == INF) {
        printf("-1");
    } else {
        printf("%d", d[t]);
    }
    return 0;
}

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100;
const int INF = 1e9;

struct Edge {
    int v, dis;
    Edge(int _v, int _dis) {
        v = _v, dis = _dis;
    }
};

vector<Edge> G[MAXN];
int d[MAXN];
bool vis[MAXN];

void dijkstra(int n, int s) {
    fill(d, d + MAXN, INF);
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return;
        }
        vis[u] = true;
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            if (!vis[v] && d[u] + dis < d[v]) {
                d[v] = d[u] + dis;
            }
        }
    }
}

int main() {
    int n, m, s;
    scanf("%d%d%d", &n, &m, &s);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    dijkstra(n, s);
    for (int i = 0; i < n; i++) {
        if (d[i] == INF) {
            printf("-1");
        } else {
            printf("%d", d[i]);
        }
        if (i < n - 1) {
            printf(" ");
        }
    }
    return 0;
}

 

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100;
const int INF = 1e9;

struct Edge {
    int v, dis, cost;
    Edge(int _v, int _dis, int _cost) {
        v = _v, dis = _dis, cost = _cost;
    }
};

vector<Edge> G[MAXN];
int d[MAXN], c[MAXN];
bool vis[MAXN];

void dijkstra(int n, int s) {
    fill(d, d + MAXN, INF);
    fill(c, c + MAXN, INF);
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    c[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return;
        }
        vis[u] = true;
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            int cost = G[u][j].cost;
            if (!vis[v]) {
                if (d[u] + dis < d[v]) {
                    d[v] = d[u] + dis;
                    c[v] = c[u] + cost;
                } else if (d[u] + dis == d[v] && c[u] + cost < c[v]) {
                    c[v] = c[u] + cost;
                }
            }
        }
    }
}

int main() {
    int n, m, s, t;
    scanf("%d%d%d%d", &n, &m, &s, &t);
    int u, v, dis, cost;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d%d", &u, &v, &dis, &cost);
        G[u].push_back(Edge(v, dis, cost));
        G[v].push_back(Edge(u, dis, cost));
    }
    dijkstra(n, s);
    printf("%d %d", d[t], c[t]);
    return 0;
}

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100;
const int INF = 1e9;

struct Edge {
    int v, dis;
    Edge(int _v, int _dis) {
        v = _v, dis = _dis;
    }
};

vector<Edge> G[MAXN];
int d[MAXN], pathCount[MAXN];
bool vis[MAXN];

void dijkstra(int n, int s) {
    fill(d, d + MAXN, INF);
    memset(pathCount, 0, sizeof(pathCount));
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    pathCount[s] = 1;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return;
        }
        vis[u] = true;
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            if (!vis[v]) {
                if (d[u] + dis < d[v]) {
                    d[v] = d[u] + dis;
                    pathCount[v] = pathCount[u];
                } else if (d[u] + dis == d[v]) {
                    pathCount[v] += pathCount[u];
                }
            }
        }
    }
}

int main() {
    int n, m, s, t;
    scanf("%d%d%d%d", &n, &m, &s, &t);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    dijkstra(n, s);
    printf("%d %d", d[t], pathCount[t]);
    return 0;
}

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 100;
const int INF = 1e9;

struct Edge {
    int v, dis;
    Edge(int _v, int _dis) {
        v = _v, dis = _dis;
    }
};

vector<Edge> G[MAXN];
int d[MAXN], pre[MAXN];
bool vis[MAXN];

void dijkstra(int n, int s) {
    fill(d, d + MAXN, INF);
    memset(pre, -1, sizeof(pre));
    memset(vis, false, sizeof(vis));
    d[s] = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return;
        }
        vis[u] = true;
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            if (!vis[v] && d[u] + dis < d[v]) {
                d[v] = d[u] + dis;
                pre[v] = u;
            }
        }
    }
}

vector<int> path;

void DFS(int v, int s) {
    if (v == s) {
        path.push_back(v);
        return;
    }
    DFS(pre[v], s);
    path.push_back(v);
}

int main() {
    int n, m, s, t;
    scanf("%d%d%d%d", &n, &m, &s, &t);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    dijkstra(n, s);
    DFS(t, s);
    printf("%d ", d[t]);
    for (int i = 0; i < path.size(); i++) {
        printf("%d", path[i]);
        if (i < (int)path.size() - 1) {
            printf("->");
        }
    }
    return 0;
}

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

const int MAXN = 50;
const int INF = 1e9;

int d[MAXN][MAXN];

void floyd(int n) {
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (d[i][k] != INF && d[k][j] != INF && d[i][k] + d[k][j] < d[i][j]) {
                    d[i][j] = d[i][k] + d[k][j];
                }
            }
        }
    }
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    fill(d[0], d[0] + MAXN * MAXN, INF);
    for (int i = 0; i < n; i++) {
        d[i][i] = 0;
    }
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        d[u][v] = d[v][u] = w;
    }
    floyd(n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (d[i][j] == INF) {
                printf("-1");
            } else {
                printf("%d", d[i][j]);
            }
            if (j < n - 1) {
                printf(" ");
            }
        }
        printf("\n");
    }
    return 0;
}

10.5最小生成树

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 500;
const int INF = 1e9;

struct Edge {
    int v, dis;
    Edge(int _v, int _dis) {
        v = _v, dis = _dis;
    }
};

vector<Edge> G[MAXN];
int d[MAXN];
bool vis[MAXN];

int prim(int n) {
    fill(d, d + MAXN, INF);
    memset(vis, false, sizeof(vis));
    d[0] = 0;
    int weightSum = 0;
    for (int i = 0; i < n; i++) {
        int u = -1, minDis = INF;
        for (int j = 0; j < n; j++) {
            if (!vis[j] && d[j] < minDis) {
                u = j;
                minDis = d[j];
            }
        }
        if (u == -1) {
            return -1;
        }
        vis[u] = true;
        weightSum += d[u];
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int dis = G[u][j].dis;
            if (!vis[v] && dis < d[v]) {
                d[v] = dis;
            }
        }
    }
    return weightSum;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        G[v].push_back(Edge(u, w));
    }
    int weightSum = prim(n);
    printf("%d", weightSum);
    return 0;
}

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 10000;

struct Edge {
    int u, v, w;
    Edge(int _u, int _v, int _w) {
        u = _u, v = _v, w = _w;
    }
};

vector<Edge> edges;

bool cmp(Edge a, Edge b) {
    return a.w < b.w;
}

int father[MAXN];

int findFather(int x) {
    int xCopy = x;
    while (father[x] != x) {
        x = father[x];
    }
    int root = x;
    x = xCopy;
    while (father[x] != x) {
        int fatherX = father[x];
        father[x] = root;
        x = fatherX;
    }
    return root;
}

int kruskal(int n, int m) {
    for (int i = 0; i < n; i++) {
        father[i] = i;
    }
    int weightSum = 0, edgeCount = 0;
    sort(edges.begin(), edges.end(), cmp);
    for (int i = 0; i < m; i++) {
        int faU = findFather(edges[i].u);
        int faV = findFather(edges[i].v);
        if (faU != faV) {
            father[faU] = faV;
            weightSum += edges[i].w;
            edgeCount++;
        }
        if (edgeCount == n - 1) {
            break;
        }
    }
    if (edgeCount != n - 1) {
        return -1;
    } else {
        return weightSum;
    }
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        edges.push_back(Edge(u, v, w));
    }
    int weightSum = kruskal(n, m);
    printf("%d", weightSum);
    return 0;
}

10.6拓扑排序

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXN = 100;

vector<int> G[MAXN];
int inDegree[MAXN];
vector<int> topoOrder;

void topoSort(int n) {
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        topoOrder.push_back(u);
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
        }
        G[u].clear();
    }
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v;
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        inDegree[v]++;
    }
    topoSort(n);
    for (int i = 0; i < topoOrder.size(); i++) {
        printf("%d", topoOrder[i]);
        if (i < (int)topoOrder.size() - 1) {
            printf(" ");
        }
    }
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXN = 100;

vector<int> G[MAXN];
int inDegree[MAXN];

bool topoSort(int n) {
    int vertexCount = 0;
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
        }
        G[u].clear();
        vertexCount++;
    }
    return vertexCount == n;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v;
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        inDegree[v]++;
    }
    printf(topoSort(n) ? "Yes" : "No");
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXN = 100;

vector<int> G[MAXN];
int inDegree[MAXN];
vector<int> topoOrder;

int topoSort(int n) {
    int vertexCount = 0;
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        topoOrder.push_back(u);
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i];
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
        }
        G[u].clear();
        vertexCount++;
    }
    return vertexCount;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v;
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        inDegree[v]++;
    }
    int learnCount = topoSort(n);
    if (learnCount == n) {
        printf("Yes\n");
        for (int i = 0; i < topoOrder.size(); i++) {
            printf("%d", topoOrder[i]);
            if (i < (int)topoOrder.size() - 1) {
                printf(" ");
            }
        }
    } else {
        printf("No\n%d\n", n - learnCount);
    }
    return 0;
}

10.7关键路径

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = 100;

struct Edge {
    int v, w;
    Edge(int _v, int _w) {
        v = _v, w = _w;
    }
};

vector<Edge> G[MAXN];
int inDegree[MAXN] = {0};
vector<int> topoOrder;
int ve[MAXN], vl[MAXN];
vector<int> activity[MAXN];

bool topoSort(int n) {
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        topoOrder.push_back(u);
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
            if (ve[u] + G[u][i].w > ve[v]) {
                ve[v] = ve[u] + G[u][i].w;
            }
        }
    }
    return (int)topoOrder.size() == n;
}

int getCriticalPathLength(int n) {
    memset(ve, 0, sizeof(ve));
    if (!topoSort(n)) {
        return -1;
    }
    int maxLength = 0;
    for(int i = 0; i < n; i++) {
        if(ve[i] > maxLength) {
            maxLength = ve[i];
        }
    }
    return maxLength;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        inDegree[v]++;
    }
    int pathLength = getCriticalPathLength(n);
    if (pathLength == -1) {
        printf("No");
    } else {
        printf("Yes\n%d", pathLength);
    }
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = 100;

struct Edge {
    int v, w;
    Edge(int _v, int _w) {
        v = _v, w = _w;
    }
};

vector<Edge> G[MAXN];
int inDegree[MAXN] = {0};
vector<int> topoOrder;
int ve[MAXN], vl[MAXN];
vector<int> activity[MAXN];

bool topoSort(int n) {
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        topoOrder.push_back(u);
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
            if (ve[u] + G[u][i].w > ve[v]) {
                ve[v] = ve[u] + G[u][i].w;
            }
        }
    }
    return (int)topoOrder.size() == n;
}

int getCriticalPath(int n) {
    memset(ve, 0, sizeof(ve));
    if (!topoSort(n)) {
        return -1;
    }
    int maxLength = 0;
    for(int i = 0; i < n; i++) {
        if(ve[i] > maxLength) {
            maxLength = ve[i];
        }
    }
    fill(vl, vl + n, maxLength);

    for (int i = (int)topoOrder.size() - 1; i >= 0; i--) {
        int u = topoOrder[i];
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int w = G[u][j].w;
            if (vl[v] - w < vl[u]) {
                vl[u] = vl[v] - w;
            }
        }
    }

    for (int u = 0; u < n; u++) {
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            int w = G[u][i].w;
            int e = ve[u], l = vl[v] - w;
            if (e == l) {
                activity[u].push_back(v);
            }
        }
    }
    return maxLength;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        inDegree[v]++;
    }
    if (getCriticalPath(n) == -1) {
        printf("No");
    } else {
        printf("Yes\n");
        for (int i = 0; i < n; i++) {
            sort(activity[i].begin(), activity[i].end());
            for (int j = 0; j < activity[i].size(); j++) {
                printf("%d %d\n", i, activity[i][j]);
            }
        }
    }
    return 0;
}

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = 100;

struct Edge {
    int v, w;
    Edge(int _v, int _w) {
        v = _v, w = _w;
    }
};

vector<Edge> G[MAXN];
int inDegree[MAXN] = {0}, inDegreeOrigin[MAXN] = {0};
vector<int> topoOrder;
int ve[MAXN], vl[MAXN];
vector<int> activity[MAXN];

bool topoSort(int n) {
    priority_queue<int, vector<int>, greater<int> > q;
    for (int i = 0; i < n; i++) {
        if (inDegree[i] == 0) {
            q.push(i);
        }
    }
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        topoOrder.push_back(u);
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            inDegree[v]--;
            if (inDegree[v] == 0) {
                q.push(v);
            }
            if (ve[u] + G[u][i].w > ve[v]) {
                ve[v] = ve[u] + G[u][i].w;
            }
        }
    }
    return (int)topoOrder.size() == n;
}

int getCriticalPath(int n) {
    memset(ve, 0, sizeof(ve));
    if (!topoSort(n)) {
        return -1;
    }
    int maxLength = 0;
    for(int i = 0; i < n; i++) {
        if(ve[i] > maxLength) {
            maxLength = ve[i];
        }
    }
    fill(vl, vl + n, maxLength);

    for (int i = (int)topoOrder.size() - 1; i >= 0; i--) {
        int u = topoOrder[i];
        for (int j = 0; j < G[u].size(); j++) {
            int v = G[u][j].v;
            int w = G[u][j].w;
            if (vl[v] - w < vl[u]) {
                vl[u] = vl[v] - w;
            }
        }
    }

    for (int u = 0; u < n; u++) {
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            int w = G[u][i].w;
            int e = ve[u], l = vl[v] - w;
            if (e == l) {
                activity[u].push_back(v);
            }
        }
    }
    return maxLength;
}

vector<int> criticalPath;
void printCriticalPath(int u) {
    if(activity[u].size() == 0) {
        criticalPath.push_back(u);
        for(int i = 0; i < criticalPath.size(); i++) {
            printf("%d", criticalPath[i]);
            if(i < criticalPath.size() - 1) {
                printf("->");
            } else {
                printf("\n");
            }
        }
        criticalPath.pop_back();
        return;
    }
    criticalPath.push_back(u);
    sort(activity[u].begin(), activity[u].end());
    for(int i = 0; i < activity[u].size(); i++) {
        printCriticalPath(activity[u][i]);
    }
    criticalPath.pop_back();
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    int u, v, w;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back(Edge(v, w));
        inDegree[v]++;
        inDegreeOrigin[v]++;
    }
    if (getCriticalPath(n) == -1) {
        printf("No");
    } else {
        printf("Yes\n");
        for(int i = 0; i < n; i++) {
            if(inDegreeOrigin[i] == 0 && activity[i].size() != 0) {
                printCriticalPath(i);
            }
        }
    }
    return 0;
}

Polaris北极星少女
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
遗传算法自学笔记2
fei_shang的博客
12-11 276
自学遗传算法的过程，小白学习笔记
yolo入门自学笔记.pdf
06-23
如基于滑动窗口（Sliding Window）或区域提议（Region Proposal）的技术，YOLO采用了全新的设计理念——将目标检测任务视为一个回归问题，直接从整个图像中预测目标的位置和类别，极大提高了检测的速度。这一特点...
操作系统自学笔记代码篇——磁盘调度算法之SSTF
Maolianwika的博客
07-02 203
【代码】操作系统自学笔记代码篇——磁盘调度算法之SSTF。
李沐72_深度学习优化算法——自学笔记
Rrrrrr900的博客
04-29 398
1.深度学习模型大部分是凸2.小批量随机梯度下降是最常用的优化算法3.冲量对梯度做平滑4.Adam对梯度做平滑，且对梯度各个维度值做重新调整。
遗传算法自学笔记4
fei_shang的博客
12-13 97
遗传算法自学，小白学习笔记
面试八股之集合篇7.5——面试题——hashMap的寻址算法
做一个善良的人，做好自己的事，如果愿意，再发一份光。
06-01 959
🔥本篇概览：详细讲解了hashMap的寻址算法。
学习笔记——动态路由——OSPF工作原理（SPF算法）
灵韵的博客
07-05 891
RTA将自己添加到最短路径树的树根位置，然后检查自己生成的Router-LSA，对于该LSA中所描述的每一个连接，如果不是一个Stub连接，就把该连接添加到候选列表中，分节点的候选列表为Link ID，对应的候选总开销为本LSA中描述的Metric值和父节点到达根节点开销之和。将节点3.3.3.3，Metric=0，父节点到根节点的开销为2，候选总开销为2，加入候选列表。第三个P-2-P连接中，Link ID为4.4.4.4，Metric=48，父节点到根节点的开销为1，候选总开销为49，加入候选列表。
算法笔记——一张A4纸让你看懂递归全排列
终成大师的博客
05-21 448
唉，这个问题我想了一天半，一直没想通，哈啊哈哈哈。 今天动手画了画图，把程序走了一遍，才搞出来，但对于递归还是不太理解，这个算法，最好画一遍图，自己走一遍。要不然真的容易绕进去。本人是一个菜鸡，之前参加学校的ACM纳新赛惨遭淘汰，现在自学算法，唉，给自己加加油，说不定我就是下一个大佬呢，人可以不强大，但一定要有梦想，梦想看起来很扯淡，不扯淡那还叫梦想？？？（手动滑稽~） 全排列指的是n个整数的所有排列，按从小到大的顺序输出n个整数的全排列，其中（a1,a2,…ana1,a2,…an)的顺序小于（b1,b2
小白算法自学笔记数字1——整数的各位积和之差
旗袍不开、怎么得胜？
12-21 460
小白算法自学笔记数字1——整数的各位积和之差 题目描述： 给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。 示例 1： 输入：n = 234 输出：15 解释： 各位数之积 = 2 * 3 * 4 = 24 各位数之和 = 2 + 3 + 4 = 9 结果 = 24 - 9 = 15 示例 2： 输入：n = 4421 输出：21 解释： 各位数之积 ...
神奇的兔子数列——算法学习笔记
m0_57158496的博客
10-23 2779
这是我参加“14天阅读挑战赛”第一周第二篇 点击查看“14天阅读挑战赛”详情，《趣学算法第二版》1.4 神奇的兔子数列。 跟着小玉老师学算法 神奇的“兔子数列” (递归、循环，哪个更好？)   假设第1个月有1对初生的兔子，第2个月进入成熟期，第3个月开始生育兔子，而1对成熟的兔子每月会生1对兔子，兔子永不死去……那么，由1对初生的兔子开始，12个月后会有多少对兔子呢？  兔子数列即斐波那契数列，它的发明者是意大利数学家莱奥纳尔多·斐波那契（Leonardo Fibonacci，1170—
遗传算法自学笔记1
fei_shang的博客
12-10 208
自学遗传算法笔记
Cortex-M4自学笔记
03-10
**知识点详解：Cortex-M4自学笔记——基于Kinetis K60** 1. **Cortex-M4架构解析** - Cortex-M4是ARM公司推出的一款高性能、低功耗的微处理器内核，专为实时操作系统（RTOS）设计。它在Cortex-M3的基础上加入了...
自学考试心得分享——自考学习总结篇计算机技术及应用专业.doc
03-06
在自学考试的道路上，计算机技术及应用专业是一个充满挑战与机遇的选择。这个专业涵盖了广泛的领域，包括编程语言、操作系统、数据库管理、网络技术、软件工程等。以下是我在这段自学旅程中的几点心得和学习总结： ...
福建省算法夏令营2018——课件
10-22
7. **复习材料与模拟测试**：课件可能包含复习资料，如算法笔记、习题集和模拟测试题，帮助学生巩固所学知识，提高实战能力。 通过学习这份课件，学生不仅可以深入理解各种算法，还能掌握如何将理论知识应用于实际...
数据结构处算法分析――读书笔记.doc
09-22
从标题"数据结构处算法分析――读书笔记"可以看出，这是一个读书笔记，作者对《数据结构与算法分析——C 语言描述》一书的笔记和心得体会。该书的作者是 Mark Allen Weiss，是一本非常有名的数据结构和算法分析书籍...
P1145 约瑟夫
zty20120913的博客
08-06 424
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 940
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 249
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 574
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Polaris北极星少女

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值