图论数据结构（入门）（更新中）

最新推荐文章于 2024-10-19 00:55:21 发布
最新推荐文章于 2024-10-19 00:55:21 发布
阅读量507 收藏 1
点赞数 1
分类专栏： 代码菜鸡之陈锋练习题 文章标签： 图论 数据结构 深度搜索 广度搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxayt/article/details/122007501
版权

文章目录

图论数据结构

01 UVa11902 Dominator

  • 题目链接：UVA11902 Dominator

  • 题目：查找有向树中必须经过某一节点才能到达的节点有哪些

  • 思路：要求必须到达某一节点 a a a ，那么将节点 a a a 删除后原本能到但是现在不能到达的节点便是 a a a 唯一控制的节点。由于数据较小，于是可以依次删除每一节点后， d f s dfs dfs 查看各自不能到达哪些节点即可。

    #include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long
#define db double
#define VI vector<int>
#define PII pair<int, int>
const db Pi = 3.141592653589793;
const int INF = 0x7fffffff;
const int N = 1e2 + 5;
const db eps = 1e-10;
int cas, n, m, no[N][N], vis[N]; //no[i][j]表示删除节点 i 时，是否可到达 j 节点
VI g[N];
string s;
void init(){
    memset(no, 0, sizeof(no));
    rep(i, 1, n) g[i].clear();
}
void creatfence(){
    s = "+";
    rep(i, 1, 2 * n - 1) s += "-";
    s += "+";
}
void dfs(int root, int without){
    vis[root] = 1;
    if(root == without) return;
    no[without][root] = 1;
    for(auto j : g[root]) if(!vis[j]) dfs(j, without);
}
int main(){
    cin >> cas;
    rep(k, 1, cas){
        cin >> n;
        init();
        rep(i, 1, n) rep(j, 1, n){
            int x; scanf("%d", &x);
            if(x && i != j) g[i].push_back(j);
        }
        rep(i, 0, n){ //删除 i 节点时，i = 0 时表示什么都不删
            memset(vis, 0, sizeof(vis));
            dfs(1, i);
        }
        printf("Case %d:\n", k);
        creatfence();
        rep(i, 1, n){
            cout << s << endl;
            rep(j, 1, n) printf("|%c", ((no[0][j] && !no[i][j]) ? 'Y' : 'N'));
            printf("|\n");
        }
        cout << s << endl;
    }
}
/*
2
5
0 1 1 0 0
0 0 0 1 0
0 0 0 1 0
0 0 0 0 1
0 0 0 0 0
1
1
*/

02 UVa11906 Knight in a War Grid

  • 题目链接：UVA11906 Knight in a War Grid

  • 题目：求在所有可到达的点中，对于每个点，可一步到达的操作数量的奇偶分类

  • 思路：这道题 d f s dfs dfs 和 b f s bfs bfs 都可以做

    • 记忆化 d f s dfs dfs：遍历一遍标记出所有可到达的点，再对这些每个点查找可一步到达此点的点的数量
    • b f s bfs bfs：在搜索时直接记录当前点由哪些点到达，累计记录。

    注意当 m = n m=n m=n 或 m = 0 ∣ ∣ n = 0 m=0 || n=0 m=0∣∣n=0 时，不是八个方位均可到达，而是四个方位。于是需要去重(这里用 s e t set set 去重)

    //统计每个点可以由几个不同点一步跳到
#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long
#define db double
#define VI vector<int>
#define PII pair<int, int>
const db Pi = 3.141592653589793;
const int INF = 0x7fffffff;
const int N = 1e2 + 5;
const db eps = 1e-10;
int cas, n, m, r, c, w;
int g[N][N], vis[N][N], ans[N][N];
int odd, even;
queue<PII> q;
set<PII> st;
set<PII>::iterator iter1;
void init(){
    memset(g, 0, sizeof(g));
    memset(vis, 0, sizeof(vis));
    memset(ans, 0, sizeof(ans));
    while(q.size()) q.pop();
    even = odd = 0;
}
void bfs(){
    int dx[10] = {n, m, n, -1 * m, -1 * n, m, -1 * n, -1 * m};
    int dy[10] = {m, n, -1 * m, n, m, -1 * n, -1 * m, -1 * n};
    q.push({0, 0});
    vis[0][0] = 1;
    while(q.size()){
        PII top = q.front(); q.pop();
        st.clear();
        rep(i, 0, 7){
            int nx = top.first + dx[i], ny = top.second + dy[i];
            if(nx < 0 || ny < 0 || nx > r - 1 || ny > c - 1 || g[nx][ny] == -1) continue;
            st.insert({nx, ny}); //防止重复计算 
        }
        for(iter1 = st.begin(); iter1 != st.end(); iter1++){
            PII now = *iter1;
            int nx = now.first, ny = now.second;
            ans[nx][ny]++;  //累计每个点的答案
            if(!vis[nx][ny]){
                vis[nx][ny] = 1;
                q.push({nx, ny});
            }
        }
    }
}
int main(){
    cin >> cas;
    rep(k, 1, cas){
        init();
        cin >> r >> c >> m >> n >> w;
        rep(i, 1, w){
            int x, y; cin >> x >> y;
            g[x][y] = -1;
        }
        bfs();
        rep(i, 0, r - 1) rep(j, 0, c - 1){
            if(vis[i][j]) ans[i][j] % 2 ? odd++ : even++;
        }
        printf("Case %d: %d %d\n", k, even, odd);
    }
}
/*
2
3 3 2 1
0
4 4 1 2
2
3 3
1 1 
*/

03 UVA12442 Forwarding Emails

  • 题目链接：UVA12442 Forwarding Emails

  • 思路：注意每个人只能指向唯一一个人，即每个点只有一条有向边指出，于是边数等于点数，则一定有环。

    • 用数组 d e e p deep deep 记录每个人可到达人的数量。要计算节点 x x x 的 d e e p [ x ] deep[x] deep[x]，考虑从 x x x 不断深搜下一节点，直到遇到环(过去已到达的节点)。
    • 剪枝：若一个点 y y y 在之前节点的深搜过程中遇到过，那么之前一定有一个节点指向点 y y y，于是点 y y y 一定不是可遍历最多点的答案，那么可跳过。
    //每个点只有一条有向边指出
#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long
#define db double
#define VI vector<int>
#define PII pair<int, int>
const db Pi = 3.141592653589793;
const int INF = 0x7fffffff;
const int N = 5e4 + 5;
const db eps = 1e-10;
int cas, n, ans, maxn, nxt[N], vis[N], deep[N], st[N];
void init(){
    memset(nxt, 0, sizeof(nxt));
    memset(st, 0, sizeof(st));
    memset(vis, 0, sizeof(vis));
    ans = maxn = 0;
}
int dfs(int now){
    st[now] = 1;  //用作剪枝
    int tmpdeep;
    vis[now] = 1, tmpdeep = 1;
    if(!vis[nxt[now]]) tmpdeep = dfs(nxt[now]) + 1;
    vis[now] = 0;
    return deep[now] = tmpdeep;
}
int main(){
    scanf("%d", &cas);
    rep(k, 1, cas){
        scanf("%d", &n);
        init();
        rep(i, 1, n){
            int u, v; scanf("%d%d", &u, &v);
            nxt[u] = v;
        }
        rep(i, 1, n){
            if(st[i]) continue;  //若之前经过此点，则说明一定不是最优解
            dfs(i);
            if(maxn < deep[i]){
                maxn = deep[i];
                ans = i;
            }
        }
        printf("Case %d: %d\n", k, ans);
    }
}
/*
3
3
1 2
2 3
3 1
4
1 2
2 1
4 3
3 2
5
1 2
2 1
5 3
3 4
4 5
*/

04 UVA572 Oil Deposit

  • 题目链接：UVA572 油田 Oil Deposits

  • 思路：经典洪水问题，依次在每个块中遍历所有连通区域，记录已到达和连通块数量。

    #include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define per(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long
#define db double
#define VI vector<int>
#define PII pair<int, int>
const db Pi = 3.141592653589793;
const int INF = 0x7fffffff;
const int N = 1e2 + 5;
const db eps = 1e-10;
int n, m, vis[N][N], ans;
string s[N];
int dx[10] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[10] = {1, -1, 0, 0, 1, -1, 1, -1};
void dfs(int x, int y){
    vis[x][y] = 1;
    rep(i, 0, 7){
        int nx = x + dx[i], ny = y + dy[i];
        if(nx < 0 || nx > n - 1 || ny < 0 || ny > m - 1) continue;
        if(s[nx][ny] == '*' || vis[nx][ny]) continue;
        dfs(nx, ny);
    }
}
int main(){
    while(cin >> n >> m){
        if(!n && !m) break;
        rep(i, 0, n - 1) cin >> s[i];
        ans = 0;
        memset(vis, 0, sizeof(vis));
        rep(i, 0, n - 1) rep(j, 0, m - 1){
            if(s[i][j] == '*') continue;
            if(vis[i][j]) continue;
            dfs(i, j);
            ans++;
        }
        cout << ans << endl;
    }

}
/*
1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5
****@
*@@*@
*@**@
@@@*@
@@**@
0 0
*/
xxatz
关注
专栏目录
UVA - 11902 （有向图的关节点）
__ElemenT
05-22 976
链接 ：  http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=18888 题意 ： 一个有向图，如果从0点出发到达某一点必须经过某些点 题目就是求出这些点。 点数不多 可以删点然后dfs搜索，之前能搜到的点 但是删了该点之后搜不到了 那么这个删点就是从起始点搜不到的必经之路。 #include #
ACM Plan UVa - 11902 Dominator(图的遍历，深度优先)
殇尘的博客
02-09 369
题目原文： In graph theory, a node X dominates a node Y if every path from the predefined start node to Y must go through X. If Y is not reachable from the start node then node Y does not have any dominato...
uva 11902 - Dominator
勿忘初衷
05-07 1206
D Dominator In graph theory, a node X dominates a node Y if every path from the predefined start node to Y must go through X. If Y is not reachable from the start node then node Y does
图论入门（完结）
cqbzliuhongyi的博客
10-12 9617
- 图的基本概念（已更） - 图的存储结构（邻接矩阵、邻接表、链式前向星）（已更） - 图的遍历（深度优先、广度优先）（已更） - 一笔画问题（欧拉回路，已更） - 哈密顿路问题（已更） - 最短路径（已更） - 最小生成树(已更)
【数据结构】图论入门
2301_79828182的博客
06-07 1463
完全图：任意两个点都有一条边相连无向完全图：n个结点就有n * (n - 1) / 2 条边有向完全图：n个结点就有n * (n - 1) 条边稀疏图：有很少的边或者弧的图（通常 m 远小于nlog(n)）稠密图：有较多的边或者弧的图（通常 m 大于nlog(n)）连通图：在无（有）向图G = (V,{E})中，若对任意两个顶点v、u，都存在v到u的路径，则称G是连通图（强连通图）建立一个顶点表（记录各个顶点信息）和一个邻接矩阵（表示各个顶点之间的关系）
数据结构——图论
爱思考的小伙
05-23 823
文章目录图论入门 计蒜客 - T1325p节点 计蒜客 - T1421下午茶时间 计蒜客 - T1726 图论入门 计蒜客 - T1325 问题描述 假设用一个 n×n 的数组 a 来描述一个有向图的邻接矩阵： （1）编写一个函数确定一个顶点的出度 （2）编写一个函数确定一个顶点的入度 （3）编写一个函数确定图中边的数目 输入格式 第一行：节点总数 n、指定节点 m；下面 n 行：有向图的邻接矩阵 输出格式 第一行包括三个数据：节点编号 m、m 的出度、m的入度（之间用一个空格隔开）。 第二行包括一个数据
关于数据结构和图论的一些入门攻略
HJY
08-12 2140
我是负责我们队数据结构和图论的，在集训队做了一个多月的题，应该算是图论和数据结构入门了吧，这里我推荐一些图论和数据结构的算法学习顺序（我的见解），如果对这一方面有兴趣的可以看一看。（日常菜的抠脚不想去刷题）
数据结构（C++）图论基础
weixin_63967970的博客
02-02 686
图是由顶点的有穷非空集合和顶点之间边的集合组成，表示为G=（V，E）。G表示一个图，V是顶点的集合，E是顶点之间边的集合。，如果顶点vi和vj之间存在路径，则称vi和vj是连通的。若任意顶点vi和vj之间均有路径，则称该图是连通图。：在有向图中，如果任意两顶点之间都存在方向互为相反的两条弧，则称为有向完全图。重要公式：在具有n个顶点e条边的无向图中，度数之和等于边数的两倍。，对任意顶点vi和vj，若从顶点vi到vj均有路径，则称该图是。通常情况下，路径指的都是简单路径，回路指的都是简单回路。
程序员的数学4：图论入门.pptx
10-14
在编程中，我们通常会使用节点和边来表示数据结构，例如树、图等。 图论的基本概念包括图、节点、边、度数等。图可以分为有向图和无向图两种，边的两端连接到两个节点。在有向图中，边的两端连接到两个节点，但方向...
算法与数据结构入门基础1
08-08
第十章作为结束语，对整个课程进行了总结，强调了算法设计和思维的重要性，鼓励学习者继续在算法与数据结构的世界中探索和进步。 通过这个课程，初学者将掌握一系列基础和进阶的算法与数据结构，为解决实际编程问题...
数据结构从入门到精通-队列
03-10
4. 广度优先搜索（BFS）：在图论和算法中，队列是实现广度优先搜索的关键数据结构。 在C语言中实现队列操作的具体代码涉及很多细节，包括初始化队列、判断队列状态、入队、出队等函数的编写。这些函数需要考虑边界...
图论基础：数据结构入门介绍
在"图的相关概念-数据结构第一章"中，我们探讨了图这一重要的数据结构在计算机科学中的基础概念。图是由顶点和边组成的抽象数据结构，广泛应用于各种实际问题中，如网络分析、地理信息系统和社交网络等。图可以分为...
2-SAT 问题详解：逻辑约束与图论的结合
缪语博的博客
10-12 1155
2-SAT 是 SAT 问题的一种特殊情况，其中每个子句（clause）都由两个文字（literal）组成，文字可以是某个变量或者该变量的否定形式。这里，𝑥 表示布尔变量，¬𝑥 表示该变量的否定。2-SAT 问题是 SAT 问题的一个特殊但非常重要的子集，它结合了布尔逻辑和图论思想。通过构造隐含图并求解图的强连通分量，我们可以高效地判断 2-SAT 问题的可满足性。由于它的广泛应用，理解 2-SAT 及其解决算法在实际问题中的运用至关重要。
day48 图论章节刷题Part01（深搜理论基础、98. 所有可达路径、广搜理论基础）
最新发布
m0_51007517的博客
10-19 585
二叉树的递归法就是dfs，而二叉树的迭代法就是bfs（广度优先搜索）与二叉树中的递归三部曲和回溯算法中的回溯三部曲一样，深搜也可以以三部曲的形式进行分析：1、确认递归函数，参数一般情况，深搜需要 二维数组数组结构保存所有路径，需要一维数组保存单一路径，这种保存结果的数组可以定义一个全局变量，避免让我们的函数参数过多。2、确认终止条件终止条件很重要，死循环，栈溢出等这些问题都是因为终止条件没有想清楚。终止添加不仅是结束本层递归，同时也是收获结果的时候。
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 501
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
数据结构(8.1)——排序的基本概念
m0_65240792的博客
10-16 271
排序的定义 排序算法的评价指标 排序算法的分类 总结：
数据结构编程实践20讲(Python版)—14邻接矩阵
AnFany
10-16 1234
数据结构编程实践20讲(Python版)—14邻接矩阵
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 579
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——广义表
2302_80420838的博客
10-16 194
注：广义表的元素既可以是一个元素（原子），也可以又是一个表（子表），（）为原子是空元素，（（））为子表是一个无元素的表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值