数据结构机测三

最新推荐文章于 2020-11-07 11:38:30 发布

devhg_

最新推荐文章于 2020-11-07 11:38:30 发布

阅读量188

点赞数

本文链接：https://blog.csdn.net/Cherishlife_/article/details/103251093

版权

A基于邻接矩阵的广度优先搜索遍历和 B图的深度遍历


int gra[101][101];
int vis[101], ans[101];
int k, m, t, cnt;

void bfs(int begin) {
    vis[begin] = 1;
    queue<int> q;
    q.push(begin);
    while (!q.empty()) {
        int temp = q.front();
        q.pop();
        ans[cnt++] = temp;
        for (int i = 0; i < k; i++) {
            if (!vis[i] && gra[temp][i]) {
                q.push(i);
                vis[i] = 1;
            }
        }
    }

    for (int i = 0; i < cnt; i++) {
        printf(i == cnt - 1 ? "%d\n" : "%d ", ans[i]);
    }
}

void dfs(int begin) {
    ans[cnt++] = begin;
    vis[begin] = 1;
    for (int i = 0; i < k; i++) {
        if (!vis[i] && gra[begin][i]) {
            dfs(i);
        }
    }
}
int main() {
    int n, u, v;
    cin >> n;
    while (n--) {
        cin >> k >> m;

        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));

        for (int i = 0; i < m; i++) {
            cin >> u >> v;
            gra[u][v] = gra[v][u] = 1;
        }
        cnt = 0;
        dfs(0);

        for (int i = 0; i < cnt; i++) {
            printf(i == cnt - 1 ? "%d\n" : "%d ", ans[i]);
        }

        // bfs(t);
    }
}

数据结构实验之图论三：判断可达性

int gra[1001][1001];
int vis[1001];
int n, m;

void dfs(int begin) {
    vis[begin] = 1;
    for (int i = 1; i <= n; i++) {
        if (!vis[i] && gra[begin][i]) {
            dfs(i);
        }
    }
}
int main() {
    int u, v;
    while (cin >> n >> m) {
        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));

        for (int i = 0; i < m; i++) {
            cin >> u >> v;
            gra[u][v] = 1;
        }
        dfs(n);
        printf(vis[1] == 1 ? "YES\n" : "NO\n");
    }
}

数据结构实验之图论四：迷宫探索

int gra[1001][1001];
int vis[1001], ans[1001];
int n, m, s, cnt;

void dfs(int begin) {
    vis[begin] = 1;
    ans[cnt++] = begin;
    for (int i = 1; i <= n; i++) {
        if (!vis[i] && gra[begin][i]) {
            dfs(i);
            ans[cnt++] = begin;  // 注意存来时候的点
        }
    }
}
int main() {
    int u, v, t;
    cin >> t;
    while (t--) {
        cin >> n >> m >> s;
        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));

        for (int i = 0; i < m; i++) {
            cin >> u >> v;
            gra[u][v] = gra[v][u] = 1;  // 注意是无向图
        }
        cnt = 0;
        dfs(s);
        for (int i = 0; i < cnt; i++) {
            printf(i == cnt - 1 ? "%d" : "%d ", ans[i]);
        }
        if (cnt != 2 * n - 1) cout << " 0";
        cout << endl;
    }
}

数据结构实验之图论五：从起始点到目标点的最短步数（BFS）

struct node {
    int data;  // 存点的编号
    int step;  // 存步数
};

int gra[1001][1001];
int vis[1001];
int n, m;

void bfs(int i) {
    queue<node> q;
    node p;      // 用结构体来存
    p.data = i;  // 开始点
    p.step = 0;
    q.push(p);
    vis[i] = 1;
    while (!q.empty()) {
        node temp = q.front();  // 队首出栈
        q.pop();
        if (temp.data == 1)  // 遍历到目的地  返回步数
        {
            cout << temp.step << endl;
            return;
        }
        for (int j = 1; j <= n; j++) {
            if (vis[j] == 0 && gra[temp.data][j] == 1) {
                node t;
                t.data = j;
                t.step = temp.step + 1;  // 下一步 在上一个节点 的基础上 +1
                vis[j] = 1;
                q.push(t);  // 入栈
            }
        }
    }
    cout << "NO" << endl;
}
int main() {
    ios::sync_with_stdio(false);
    while (cin >> n >> m) {
        int a, b;
        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < m; i++) {
            cin >> a >> b;
            gra[a][b] = 1;
        }
        bfs(n);
    }

    return 0;
}

数据结构实验之图论七：驴友计划

int n, m;
int gra[505][505];
int vis[505], money[505][505];

void dijkstra(int s, int d) {
    int dist[505];
    int mon[505];
    for (int i = 0; i < n; i++) {
        dist[i] = gra[s][i];
        mon[i] = money[s][i];
    }
    vis[s] = 1;
    for (int i = 1; i < n; i++) {
        int min = inf;
        int index = s;
        for (int j = 0; j < n; j++) {
            // 如果这个点没有被访问过，而且这个点的最短路径比min小；
            // 这个循环的作用是找出与起点v0相连的点所形成的边，哪个边的权值最小（最短路径最短））
            if (!vis[j] && dist[j] < min) {
                min = dist[j];
                index = j;
            }
        }
        vis[index] = 1;
        for (int j = 0; j < n; j++) {
            // 没有后面判断两个点之间是否连通会错
            if (!vis[j] && gra[index][j] < inf) {
                // 这个点与index点的路径+起点s到index的最短路径 <
                // 起点s到index的最短路径
                if (dist[j] > gra[index][j] + dist[index]) {
                    dist[j] = gra[index][j] + dist[index];
                    mon[j] = money[index][j] + mon[index];
                } else if (dist[j] == gra[index][j] + dist[index] &&
                           mon[index] + money[index][j] < mon[j]) {
                    mon[j] = mon[index] + money[index][j];
                }
            }
        }
    }
    printf("%d %d\n", dist[d], mon[d]);
}
int main() {
    int t, s, d, u, v, len, mon;
    cin >> t;
    while (t--) {
        cin >> n >> m >> s >> d;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                gra[i][j] = i == j ? 0 : inf;
            }
        }

        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < m; i++) {
            cin >> u >> v >> len >> mon;
            gra[u][v] = gra[v][u] = len;
            money[u][v] = money[v][u] = mon;
        }
        dijkstra(s, d);
    }
    return 0;
}

数据结构实验之图论十：判断给定图是否存在合法拓扑序列

int f[111];
int n, m;

int find(int x) {
    if (x != f[x]) f[x] = find(f[x]);
    return f[x];
}

int unionset(int u, int v) {
    int uu = find(u);
    int vv = find(v);
    if (uu != vv) {
        f[uu] = vv;
        return 0;
    } else
        return 1;
}

int main() {
    int a, b;
    while (cin >> n >> m) {
        for (int i = 0; i <= n; i++) f[i] = i;

        int flag = 1;
        for (int i = 0; i < m; i++) {
            cin >> a >> b;
            if (unionset(a, b)) {
                flag = 0;
            }
        }
        printf(flag == 1 ? "YES\n" : "NO\n");
    }
}

数据结构实验之图论九：最小生成树

sing namespace std;
int gra[3001][3001];
int vis[1001], dist[1001];

void prim(int n) {
    for (int i = 1; i <= n; i++) dist[i] = gra[1][i];
    for (int i = 1; i <= n; i++) {
        int min = inf;
        int index;
        for (int j = 1; j <= n; j++) {
            if (!vis[j] && dist[j] < min) {
                min = dist[j];
                index = j;
            }
        }
        // 找不到 相通
        if (min == inf) {
            cout << "0" << endl;
            return;
        }
        vis[index] = 1;
        for (int j = 1; j <= n; j++) {
            if (!vis[j] && gra[index][j] < dist[j]) dist[j] = gra[index][j];
        }
    }

    int ans = 0;
    for (int i = 1; i <= n; i++) ans += dist[i];
    cout << ans << endl;
}

int main() {
    int n, m, u, v, w;
    while (cin >> n >> m) {
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                if (i == j)
                    gra[i][j] = 0;
                else
                    gra[i][j] = inf;
            }
        }
        for (int i = 0; i < m; i++) {
            cin >> u >> v >> w;
            // 没有报错
            if (w < gra[u][v]) gra[u][v] = gra[v][u] = w;
        }
        if (m == 0)
            printf("0\n");
        else
            prim(n);
    }
}

数据结构实验之图论八：欧拉回路

int gra[1005][1005];
int vis[1005];
// 如果用dfs还是有顶点未被访问，就说明图不连通
void dfs(int t, int n) {
    vis[t] = 1;
    for (int i = 1; i <= n; i++) {
        if (!vis[i] && gra[t][i]) {
            dfs(i, n);
        }
    }
}

int main(void) {
    int t, n, m, i, flag;
    int u, v, p[1001];
    cin >> t;
    while (t--) {
        cin >> n >> m;
        flag = 1;
        memset(gra, 0, sizeof(gra));
        memset(vis, 0, sizeof(vis));
        memset(p, 0, sizeof(p));
        for (i = 0; i < m; i++) {
            cin >> u >> v;
            gra[u][v] = gra[v][u] = 1;
            p[u]++;
            p[v]++;
        }

        dfs(1, n);
        for (i = 1; i <= n; i++) {
            if (!vis[i] || (p[i] % 2)) {
                flag = 0;
                break;
            }
        }
        printf(flag == 1 ? "1\n" : "0\n");
    }

    return 0;
}

devhg_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构机测三

A基于邻接矩阵的广度优先搜索遍历和 B图的深度遍历int gra[101][101];int vis[101], ans[101];int k, m, t, cnt;void bfs(int begin) { vis[begin] = 1; queue<int> q; q.push(begin); while (!q.empty()) ...
复制链接

扫一扫