sdut基础图论代码

已于 2022-07-08 09:52:50 修改
阅读量207 收藏
点赞数 2
文章标签： 图论 深度优先 算法
于 2022-07-04 19:22:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52358084/article/details/125606974
版权

sdut基础图论代码

// G 矩阵游戏
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 10, M = 2 * N;

int h[N], e[N], ne[N], idx, vis[N];
int match[N];

void add(int u, int v)
{
    e[idx] = v;
    ne[idx] = h[u];
    h[u] = idx++;
}

int dfs(int u)
{
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!vis[j])
        {
            vis[j] = 1;
            if (!match[j] || dfs(match[j]))
            {
                match[j] = u;
                return 1;
            }
        }
    }
    return 0;
}

signed main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        memset(match, 0, sizeof match);
        memset(h, -1, sizeof h);
        idx = 0;
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
            {
                int f;
                scanf("%d", &f);
                if (f)
                    add(i, j);
            }
    
        int ans = 0;
        for (int i = 1; i <= n; i++)
        {
            memset(vis, 0, sizeof vis);
            if (dfs(i))
                ans++;
        }
        if (ans == n)
            printf("Yes\n");
        else
            printf("No\n");
    }
}

// F Fair
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 2 * N;

int h[N], e[M], ne[M], dist[N][110], color[N];
int n, m, k, s, idx;
void add(int u, int v)
{
    e[idx] = v;
    ne[idx] = h[u];
    h[u] = idx++;
}

void bfs(int match)
{
    vector<int> vis(n + 1);
    queue<int> que;
    for (int i = 1; i <= n; i++)
    {
        if (color[i] == match)
        {
            dist[i][match] = 0;
            que.push(i);
            vis[i] = 1;
        }
    }
    while (que.size())
    {
        int ver = que.front();
        que.pop();
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (vis[j])
                continue;

            vis[j] = 1;
            que.push(j);
            dist[j][match] = dist[ver][match] + 1;
        }
    }
}

signed main()
{
    cin >> n >> m >> k >> s;
    for (int i = 1; i <= n; i++)
        cin >> color[i], h[i] = -1;

    for (int i = 0; i < m; i++)
    {
        int u, v;
        cin >> u >> v;
        add(u, v);
        add(v, u);
    }
    for (int i = 1; i <= k; i++)
        bfs(i);

    for (int i = 1; i <= n; i++)
    {
        sort(dist[i] + 1, dist[i] + 1 + k);
        int ans = 0;
        for (int j = 1; j <= s; j++)
            ans += dist[i][j];
        cout << ans << " ";
    }
}

// E Antenna Placement
#include <iostream>
#include <cstring>
using namespace std;
const int N = 5e2 + 10, M = 1e4 + 10;

typedef pair<int, int> PII;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
char a[N][N];
int h[N], e[M], ne[M], idx, vis[N][N];
PII match[N][N];
int n, m;

void add(int u, int v)
{
    e[idx] = v;
    ne[idx] = h[u];
    h[u] = idx++;
}

int dfs(int xx, int yy)
{
    for (int i = 0; i < 4; i++)
    {
        int x = dx[i] + xx;
        int y = dy[i] + yy;
        if (x < 1 || x > n || y < 1 || y > m)
            continue;
        if (!vis[x][y] && a[x][y] == '*')
        {
            vis[x][y] = 1;
            if (!match[x][y].first || dfs(match[x][y].first, match[x][y].second))
            {
                match[x][y] = make_pair(xx, yy);
                return 1;
            }
        }
    }
    return 0;
}

signed main()
{
    int T;
    cin >> T;
    while (T--)
    {
        memset(match, 0, sizeof match);

        idx = 0;
        cin >> n >> m;

        for (int i = 1; i <= n; i++)
            cin >> (a[i] + 1);

        int ans = 0, cnt = 0;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                if (a[i][j] == '*')
                {
                    cnt++;
                    memset(vis, 0, sizeof vis);
                    if (dfs(i, j))
                        ans++;
                }
        cout << cnt - ans / 2 << "\n";
    }
}

// D find the mincost route
#include <bits/stdc++.h>
using namespace std;

#define int long long
const int INF = 0x3f3f3f3f;
const int N = 200;

int w[N][N], d[N][N];

signed main()
{
    int n, m;
    while (cin >> n >> m)
    {
        for (int i = 0; i <= n; i++)
            for (int j = 0; j <= n; j++)
                w[i][j] = w[j][i] = INF;

        for (int i = 0; i < m; i++)
        {
            int u, v, ww;
            cin >> u >> v >> ww;
            w[u][v] = w[v][u] = min(w[u][v], ww);
        }

        memcpy(d, w, sizeof d);

        int ans = INF;
        for (int k = 1; k <= n; k++)
        {
            for (int i = 1; i < k; i++)
                for (int j = i + 1; j < k; j++)
                    if (d[i][j] + w[i][k] + w[j][k] < ans)
                        ans = d[i][j] + w[i][k] + w[j][k];

            for (int i = 1; i <= n; i++)
                for (int j = 1; j <= n; j++)
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
        }
        if (ans >= INF)
            cout << "It's impossible.\n";
        else
            cout << ans << "\n";
    }
}

// C Dijkstra?
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
#define int long long
const int N = 2e5 + 10;
int h[N], e[N], ne[N], w[N], path[N], n, m, idx;
vector<int> a;
void add(int u, int v, int ww)
{
    e[idx] = v;
    w[idx] = ww;
    ne[idx] = h[u];
    h[u] = idx++;
}
int dij(int sta, int en)
{
    priority_queue<PII, vector<PII>, greater<PII>> que;
    vector<int> dist(en + 1), st(en + 1);
    for (int i = 0; i <= en; i++)
        dist[i] = 1e11;
    dist[sta] = 0;
    que.push({dist[sta], sta});
    while (que.size())
    {
        PII f = que.top();
        que.pop();
        int ver = f.second;
        if (st[ver])
            continue;
        st[ver] = 1;
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                path[j] = ver;
                dist[j] = dist[ver] + w[i];
                que.push({dist[j], j});
            }
        }
    }
    return dist[en];
}
void dfs(int now, int en)
{
    if (now == en)
        return a.push_back(now);
    dfs(path[now], en);
    a.push_back(now);
}
signed main()
{
    cin >> n >> m;
    for (int i = 0; i <= n; i++)
        h[i] = -1;
    for (int i = 0; i < m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, w);
    }
    int ans = dij(1, n);
    if (ans >= 1e11)
        return cout << -1 << endl, 0;
    dfs(n, 1);
    for (auto t : a)
        cout << t << " ";
}

// B Pear-wise Voting
#include <bits/stdc++.h>
using namespace std;
const int N = 30, M = 2010;

int h[N], ne[M], e[M], vis[N], w[M], idx;
string s[M];

void add(int u, int v)
{
    e[idx] = v;
    ne[idx] = h[u];
    h[u] = idx++;
}

void dfs(int num)
{
    if (vis[num])
        return;
    vis[num] = 1;
    for (int i = h[num]; i != -1; i = ne[i])
        dfs(e[i]);
}

signed main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        h[i] = -1;
    for (int i = 0; i < m; i++)
        cin >> w[i] >> s[i];

    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
        {
            int ans = 0;
            for (int k = 0; k < m; k++)
                if (s[k].find((char)('A' + i)) < s[k].find((char)('A' + j)))
                    ans += w[k];
                else
                    ans -= w[k];
            if (ans > 0)
                add(i, j);
            else
                add(j, i);
        }

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            vis[j] = 0;
        dfs(i);
        int flag = 1;
        for (int j = 0; j < n; j++)
            if (!vis[j])
                flag = 0;
        if (flag)
            printf("%c: can win\n", (char)('A' + i));
        else
            printf("%c: can't win\n", (char)('A' + i));
    }
}

// A Phillip and Trains
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int N = 200;

map<pair<int, PII>, int> vis;
int ans = 0;
string s[5];
int n;

int check(int x, int y)
{
    return (!(x < 0 || y < 0 || x > 2 || (y < n && s[x][y] >= 'A' && s[x][y] <= 'Z')));
}

void dfs(PII sta, int cnt)
{
    if (vis[{cnt, sta}])
        return;
    vis[{cnt, sta}] = 1;

    if (sta.second + cnt * 3 >= n)
    {
        ans = 1;
        return;
    }
    if (s[sta.first][sta.second + cnt * 3 + 1] >= 'A' && s[sta.first][sta.second + cnt * 3 + 1] <= 'Z')
        return;

    for (int i = -1; i <= 1; i++)
    {
        int flag = 1;
        for (int j = 1; j <= 2; j++)
            if (!check(sta.first + i, sta.second + cnt * 3 + j))
                flag = 0;

        if (flag)
            dfs({sta.first + i, sta.second}, cnt + 1);
    }
}

signed main()
{
    int T;
    cin >> T;
    while (T--)
    {
        vis.clear();
        ans = 0;

        int k;
        cin >> n >> k;
        for (int i = 0; i < 3; i++)
            cin >> s[i];

        PII sta;
        for (int i = 0; i < 3; i++)
            if (s[i][0] == 's')
                sta = {i, 0};
        dfs(sta, 0);

        if (ans)
            cout << "YES\n";
        else
            cout << "NO\n";
    }
}
pig2687
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
P - 简单的代码生成程序 SDUT OJ 编译原理习题
Move on
12-09 573
P - 简单的代码生成程序 Description 通过三地址代码序列生成计算机的目标代码,在生成算法中,对寄存器的使用顺序为:寄存器中存有 > 空寄存器 > 内存中存有 > 以后不再使用 > 最远距离使用 Input 单组输入,给定输出的三地址代码的个数和寄存器的个数.所有的变量为大写字母,寄存器的数量不超过9 Output 参照示例格式输出,不需要将最后的寄存器中的值写回内存 不再使用变量不用写回内存 Sample Input 4 2 T:=A-B U:.
SDUT-程序设计基础-实验4-for循环（上）
m0_73303807的博客
11-07 2674
SDUT-程序设计基础-实验4-for循环
SDUT-程序设计基础-实验4-for循环（下）
m0_73303807的博客
11-07 2179
SDUT-程序设计基础-实验4-for循环
sdut_2107_数据结构实验之图论二：图的深度遍历
Xiaojk的博客
08-13 318
数据结构实验之图论二：图的深度遍历 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description 请定一个无向图，顶点编号从0到n-1，用深度优先搜索(DFS)，遍历并输出。遍历时，先遍历节点编号小的。 Input 输入第一行为整数n（0 &lt; n &lt; 100）...
图论——AOE网络及关键路径
https://github.com/ZichengCao
11-20 2249
引入 AOE网和AOV网 上一篇的拓扑排序中提到了 AOV\mathrm{AOV}AOV 网（Activity On Vertex Network），与之相对应的是 AOE\mathrm{AOE}AOE 网（Activity on edge network），即边表示活动的网。 AOV\mathrm{AOV}AOV 用顶点表示活动的网，描述活动之间的制约关系。 AOE\mathrm{AOE}AOE 是带权值的有向图，以顶点表示事件，以边表示活动，边上的权值表示活动的开销（如项目工期）。 AOE\mathr
SDUTACM基础刷题题库（实验一）
02-23
SDUTACM基础刷题题库（实验一） 本题库旨在帮助学习者巩固基础知识，通过实践基本的C语言编程题目，提高编程能力。题库涵盖了基本的顺序结构程序设计，C语言实验，输出字符串，图形输出，求两个整数之和等多个方面...
SDUTACM基础刷题题库（实验二）
02-23
SDUT ACM基础刷题题库（实验二） 本题库涵盖了选择结构程序设计的多个方面，涵盖了绝对值、时间间隔、最大值、苹果重量判断和判断对错等多个方面。下面是每个问题的详细知识点： 1. 求绝对值 在编程中，绝对值是...
SDUT基础语法2--控制语句
09-10
SDUT基础语法2--控制语句可以通过使用if语句和循环语句来实现程序的控制流程。在给出的引用中，给出了一个例子，用于计算倒数之和。该程序使用了for循环来计算从1到n的倒数，并累加求和。在每次循环中，将当前的倒数...
解题报告代码 sdut2107
07-29
根据提供的代码片段来看，这是一段用于解决图论问题中的遍历算法，很可能是深度优先搜索（Depth-First Search，简称DFS）的应用场景。代码的目标是解决一个与图的遍历相关的题目，具体来说是从某个节点出发，按照...
代码随想录算法训练营day55：图论05：并查集
weixin_65180740的博客
08-26 1068
只需要用一个一维数组来表示，即：father[A] = B，father[B] = C 这样就表述 A 与 B 与 C连通了（有向连通图）。输出一个整数，代表是否存在从节点 source 到节点 destination 的路径。后续 M 行，每行两个正整数 s 和 t，代表从节点 s 与节点 t 之间有一条边。给定一个包含 n 个节点的无向图中，节点编号从 1 到 n （含 1 和 n ）。第一行包含两个正整数 N 和 M，N 代表节点的个数，M 代表边的个数。进一步优化：合树的时候，矮树并入高树。
算法训练营|图论第6天 108.冗余连接 109.冗余连接2
qq_53125539的博客
08-29 118
【代码】算法训练营|图论第6天 108.冗余连接 109.冗余连接2。
代码随想录算法训练营第五十三天 | 图论part04
qq_43456971的博客
08-29 162
思路是要将字符串之间用线连起来，每个相邻的字符串只有一个字符不同。通过bfs来找到最短路径。要注意已经走过的路径要记录下来，包括走过的步数。但是这一题并没有建图，而是将这个过程简化了，只是记录下了path。
力扣题/图论/实现 Trie (前缀树)
温温温B的博客
08-26 636
Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补全和拼写检查。请你实现TrieTrie()初始化前缀树对象。向前缀树中插入字符串word。如果字符串word在前缀树中，返回true（即，在检索之前已经插入）；否则，返回false。如果之前已经插入的字符串word的前缀之一为prefix，返回true；否则，返回false。示例:输入输出解释// 返回 True。
打卡55天------图论(并查集)
GodLoveMe的博客
08-26 419
图论这里我学的不是很好，作为一名JavaScript前端开发工程师，我能说我基本上在工作中都没用到过吗？
C++学习/复习补充记录 --- 图论(深搜，广搜)
weixin_47059239的博客
08-29 94
数据结构与算法 | 深搜（DFS）与广搜（BFS）_深搜广搜算法-CSDN博客
代码随想录算法训练营第五十五天 | 图论part05
qq_43456971的博客
08-29 87
只需要判断是否联通，不需要知道具体路径或者路径数量，可以使用并查集。
代码随想录算法训练营第五十六天 | 图论part06
最新发布
qq_43456971的博客
08-29 115
【代码】代码随想录算法训练营第五十六天 | 图论part06。
算法训练营|图论第4天 110.字符串接龙 105.有向图的完全可达性 106.岛屿的周长
qq_53125539的博客
08-29 106
【代码】算法训练营|图论第4天 110.字符串接龙 105.有向图的完全可达性 106.岛屿的周长。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

pig2687

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

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

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

打赏作者

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

抵扣说明：

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

余额充值