初级图论

最新推荐文章于 2022-07-31 21:37:47 发布
最新推荐文章于 2022-07-31 21:37:47 发布
阅读量785 收藏 1
点赞数 4
分类专栏： 图论 文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41730082/article/details/89443217
版权

序论

  我决定开始对我所学过的知识点进行一个复习，由初级图论开始，向上学习的同时也需要巩固基础知识。

目录

图的遍历——前向星

路径问题

Dijkstra

SPFA

匹配

匈牙利算法

KM算法

树

最小生成树

Prime/Kruskal

树的直径

图的遍历——前向星

  我们知道在STL中可以用“vector<int> vt[maxN];”这样的方式去存对应的vt[u]的后面的所有的指向的点，也就是"u->v"这样的点的指向。

  但是我们不难看出对于那种需要初始化的多组输入，每次要清空vector<>的vt[]全部的数组，这是很要命的一件事，这么高的时间复杂度，还有这么大的空间复杂度，吃不消啊……

  所以，我们引入了一个叫做链式前向星的东西，算不上是一种算法，因为它太基础了。简单的说，对应的点，找之前的边，所以，我们将边存在一个struct的结构体里，然后我们不断的去新建边“u->v, 同时继承上一个边的序号”，去将边的序号更新进所存的点去。我们定义这样的存边的点，给予一个数组head[maxN]，是所有的点的上一个以它为u的边的序号。

  具体这样子的理解有点复杂，看下代码做下模拟试试。

const int maxN = 1e3 + 7, maxE = 2e5 + 7;

这些都是开始的定义的。

int cnt, head[maxN];

  这个就是初始化。时间复杂度O(N)

void init()
{
    cnt = 0;
    memset(head, -1, sizeof(head));
}

定义这样的结构体，nex是指上一个head[]这样我们就可以去找到上一条边的序号了；to是"u->v"这里的v；flow有时候并不需要这个定义，它只是用来存某种价值的东西，譬如"u->v的代价是flow"这样子的情况，用来做一些最段路之类的会用到。

struct Eddge
{
    int nex, to, flow;
    Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), flow(c) {}
}edge[maxE];

接下去就是建边的操作了，可以理解一下这个addEddge(u, v, flow)的操作（有时候不需要用到flow）。

void addEddge(int u, int v, int flow)
{
    edge[cnt] = Eddge(head[u], v, flow);
    head[u] = cnt++;
}

举个例子，下面是建立"u->v"权值为1的边。

_add(u, v, 1);

对应的从u出发的节点，我们找这样的v，就可以这样子找了。

for(int i=head[u], v, f; ~i; i=edge[i].nex)
        {
            v = edge[i].to; f = edge[i].flow;
            /*    
                这里放一些自己的操作。
            */
        }

自己多多理解啦，就讲到这里，不懂的可在评论提问。

Dijkstra

  狄杰斯特拉算法，主要就是讲解从一点出发，达到其余各点的最短路的算法。我们从一个点出发，更新它到其余各点的距离，然后我们接下去从剩下的N-1个节点中不断的找寻出被到达的最短的距离，然后取出其中被到达的最短距离，在以它开始更新它所能到达的其余点的最短距离，然后再选出一个最短的点，不断的进行这样的循环操作，我们不难发现，只需要取出N-1次的点，就能把所有的点的由起点出发到达的最短距离给求出来了。

题目链接

  这里，我引入这道题来做解释。附上了对应的注释。之后的算法讲解都是以这道题为模板展开。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define efs 1e-8
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 55;
int N;
double sx, sy, tx, ty, S, T, mp[maxN][maxN], dis[maxN];
struct node
{
    double x, y, r;
    node(double a=0, double b=0, double c=0):x(a), y(b), r(c) {}
}a[maxN];
double Get_dis(int e1, int e2) { return sqrt( (a[e1].x - a[e2].x) * (a[e1].x - a[e2].x) + (a[e1].y - a[e2].y) * (a[e1].y - a[e2].y) ) - a[e1].r - a[e2].r; }    //对应的圈的距离
bool In_round(double x, double y, double rx, double ry, double r) { return fabs( sqrt( (rx - x) * (rx - x) + (ry - y) * (ry - y) ) - r ) <= efs; }  //圈内
bool vis[maxN];
double Dijkstra(int st, int ed) //起点、终点
{
    memset(vis, false, sizeof(vis));    //所有的点只能被取出来一次，因为那时候，它一定是最小点
    vis[st] = true;
    for(int i=1; i<=N; i++) dis[i] = mp[st][i];
    int pos = 0;
    for(int line=1; line<N; line++)
    {
        double minn = 1e9 + 7.;
        for(int i=1; i<=N; i++)
        {
            if(!vis[i] && minn > dis[i])    //寻找这样的点
            {
                pos = i;
                minn = dis[i];
            }
        }
        vis[pos] = true;    //好了，取出来过了
        for(int i=1; i<=N; i++) if(!vis[i]) dis[i] = min(dis[i], dis[pos] + mp[pos][i]);    //其实可以不用判断是否被取出来过，因为每次取出来的都是最小的点，不可能能把已经取出来的点再更新
    }
    return dis[ed];
}
int main()
{
    int Cas;  scanf("%d", &Cas);
    while(Cas--)
    {
        scanf("%d", &N);
        scanf("%lf%lf%lf%lf", &sx, &sy, &tx, &ty);
        S = 0;  T = 0;
        for(int i=1; i<=N; i++)
        {
            scanf("%lf%lf%lf", &a[i].x, &a[i].y, &a[i].r);
            if(!S && In_round(sx, sy, a[i].x, a[i].y, a[i].r)) S = i;
            if(!T && In_round(tx, ty, a[i].x, a[i].y, a[i].r)) T = i;
            for(int j=1; j<i; j++)
            {
                mp[i][j] = mp[j][i] = Get_dis(i, j);    //定义距离，i<->j距离（双向边）
            }
        }
        printf("%.6lf\n", Dijkstra(S, T));
    }
    return 0;
}

  总结，Dijkstra是一个没有优化的算法，之后的Prime算法（最小生成树）与它很像，时间复杂度O(N^2)，有时候需要优化。

优先队列优化的Dijkstra

  就像是写优先队列下的BFS一样，我们在这里用在了Dijkstra上面，我们不断的去更新最短的距离，每次出队的是最短的节点，这样子就可以避免了上面那次O(N)的查询操作，我们将查询操作优化到了O(log(N))这样子的时间复杂度，使得最后的时间总和的复杂度为O(N*logN)。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define efs 1e-8
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 55;
int N;
double sx, sy, tx, ty, S, T, mp[maxN][maxN], dis[maxN];
struct node
{
    double x, y, r;
    node(double a=0, double b=0, double c=0):x(a), y(b), r(c) {}
}a[maxN];
double Get_dis(int e1, int e2) { return sqrt( (a[e1].x - a[e2].x) * (a[e1].x - a[e2].x) + (a[e1].y - a[e2].y) * (a[e1].y - a[e2].y) ) - a[e1].r - a[e2].r; }    //对应的圈的距离
bool In_round(double x, double y, double rx, double ry, double r) { return fabs( sqrt( (rx - x) * (rx - x) + (ry - y) * (ry - y) ) - r ) <= efs; }  //圈内
struct Point
{
    int id;
    double dis;
    Point(int a=0, double b=0):id(a), dis(b) {}
    friend bool operator < (Point e1, Point e2) { return e1.dis > e2.dis; }
};
priority_queue<Point> Q;
bool vis[maxN];
double Dijkstra(int st, int ed) //起点、终点
{
    while(!Q.empty()) Q.pop();
    memset(vis, false, sizeof(vis));
    Q.push(Point(st, 0));
    for(int i=1; i<=N; i++) dis[i] = 1e9 + 7.;
    dis[st] = 0.;
    while(!Q.empty())
    {
        Point tmp = Q.top();    Q.pop();
        if(vis[tmp.id]) continue;
        vis[tmp.id] = true;
        if(tmp.id == ed) return tmp.dis;
        for(int i=1; i<=N; i++)
        {
            if(!vis[i] && dis[i] > dis[tmp.id] + mp[tmp.id][i])
            {
                dis[i] = dis[tmp.id] + mp[tmp.id][i];
                Q.push(Point(i, dis[i]));
            }
        }
    }
    return 0;
}
int main()
{
    int Cas;  scanf("%d", &Cas);
    while(Cas--)
    {
        scanf("%d", &N);
        scanf("%lf%lf%lf%lf", &sx, &sy, &tx, &ty);
        S = 0;  T = 0;
        for(int i=1; i<=N; i++)
        {
            scanf("%lf%lf%lf", &a[i].x, &a[i].y, &a[i].r);
            if(!S && In_round(sx, sy, a[i].x, a[i].y, a[i].r)) S = i;
            if(!T && In_round(tx, ty, a[i].x, a[i].y, a[i].r)) T = i;
            for(int j=1; j<i; j++)
            {
                mp[i][j] = mp[j][i] = Get_dis(i, j);    //定义距离，i<->j距离（双向边）
            }
        }
        printf("%.6lf\n", Dijkstra(S, T));
    }
    return 0;
}

  这里面，我只改变了Dijkstra函数内的内容，可以自己体会一下代码。

SPFA（Shortest Path Faster Algorithm）

  同样是求最短路的算法，SPFA有时候会比Dijkstra优化，我依然是去用dis[]数组去记录每个节点的最短路径的估计值，这里放的有时候不是最短的，因为我们要去松弛它，我们假设从一开始到达的就是最短，然后不断的跑下去，遇到更短的，如果不在队列内就放进去，如果在队列内，同样要去更新它的松弛的估计值。我们需要不断的去更新它的最短路径估计值，那么什么时候会停止呢，就是在当所有点都更新成最短路的时候。所以，一定会有从松弛变成紧锁的时候。

  具体，我们看着代码这么分析一下。同样的，在这里我只改变了函数，其他各项我都保持原来的没动。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define efs 1e-8
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 55;
int N;
double sx, sy, tx, ty, S, T, mp[maxN][maxN], dis[maxN];
struct node
{
    double x, y, r;
    node(double a=0, double b=0, double c=0):x(a), y(b), r(c) {}
}a[maxN];
double Get_dis(int e1, int e2) { return sqrt( (a[e1].x - a[e2].x) * (a[e1].x - a[e2].x) + (a[e1].y - a[e2].y) * (a[e1].y - a[e2].y) ) - a[e1].r - a[e2].r; }    //对应的圈的距离
bool In_round(double x, double y, double rx, double ry, double r) { return fabs( sqrt( (rx - x) * (rx - x) + (ry - y) * (ry - y) ) - r ) <= efs; }  //圈内
struct Point
{
    int id;
    double dis;
    Point(int a=0, double b=0):id(a), dis(b) {}
    friend bool operator < (Point e1, Point e2) { return e1.dis > e2.dis; }
};
bool inque[maxN];
queue<int> Q;
double SPFA(int st, int ed) //起点、终点
{
    memset(inque, false, sizeof(inque));    //一开始都在队列外面，如果在队内，则是true
    while(!Q.empty()) Q.pop();
    for(int i=1; i<=N; i++) dis[i] = 1e9 + 7.;
    Q.push(st); inque[st] = true;   dis[st] = 0.;   //进队了
    while(!Q.empty())
    {
        int u = Q.front();  Q.pop();    inque[u] = false;   //它又出队了，不在队列内，则是false
        for(int i=1; i<=N; i++)
        {
            if(dis[i] > dis[u] + mp[u][i])  //松弛的操作，不断的去更新点
            {
                dis[i] = dis[u] + mp[u][i];
                if(!inque[i])
                {
                    inque[i] =  true;
                    Q.push(i);
                }
            }
        }
    }
    return dis[ed];
}
int main()
{
    int Cas;  scanf("%d", &Cas);
    while(Cas--)
    {
        scanf("%d", &N);
        scanf("%lf%lf%lf%lf", &sx, &sy, &tx, &ty);
        S = 0;  T = 0;
        for(int i=1; i<=N; i++)
        {
            scanf("%lf%lf%lf", &a[i].x, &a[i].y, &a[i].r);
            if(!S && In_round(sx, sy, a[i].x, a[i].y, a[i].r)) S = i;
            if(!T && In_round(tx, ty, a[i].x, a[i].y, a[i].r)) T = i;
            for(int j=1; j<i; j++)
            {
                mp[i][j] = mp[j][i] = Get_dis(i, j);    //定义距离，i<->j距离（双向边）
            }
        }
        printf("%.6lf\n", SPFA(S, T));
    }
    return 0;
}

  SPFA的时间复杂度，最坏是O(E*V)，E代表边的数目，V代表点的数目。当然，这是最坏的情况。往往得往好的方面想，不是吗～

匈牙利算法

一些概念性的问题总结在这里，可以去背，但是最好是去理解着记忆，在后继的中级甚至是高级图论中会很有用。

匈牙利算法是由匈牙利数学家Edmonds于1965年提出，因而得名。匈牙利算法是基于Hall定理中充分性证明的思想，它是部图匹配最常见的算法，该算法的核心就是寻找增广路径，它是一种用增广路径求二分图最大匹配的算法。

-------等等，看得头大？那么请看下面的版本：

 

通过数代人的努力，你终于赶上了剩男剩女的大潮，假设你是一位光荣的新世纪媒人，在你的手上有N个剩男，M个剩女，每个人都可能对多名异性有好感（惊讶-_-||暂时不考虑特殊的性取向），如果一对男女互有好感，那么你就可以把这一对撮合在一起，现在让我们无视掉所有的单相思（好忧伤的感觉快哭了），你拥有的大概就是下面这样一张关系图，每一条连线都表示互有好感。

 

本着救人一命，胜造七级浮屠的原则，你想要尽可能地撮合更多的情侣，匈牙利算法的工作模式会教你这样做：

===============================================================================

一： 先试着给1号男生找妹子，发现第一个和他相连的1号女生还名花无主，got it，连上一条蓝线

 

===============================================================================

二：接着给2号男生找妹子，发现第一个和他相连的2号女生名花无主，got it

 

===============================================================================

三：接下来是3号男生，很遗憾1号女生已经有主了，怎么办呢？

我们试着给之前1号女生匹配的男生（也就是1号男生）另外分配一个妹子。

 

(黄色表示这条边被临时拆掉)

 

与1号男生相连的第二个女生是2号女生，但是2号女生也有主了，怎么办呢？我们再试着给2号女生的原配(发火发火)重新找个妹子(注意这个步骤和上面是一样的，这是一个递归的过程)

 

 

此时发现2号男生还能找到3号女生，那么之前的问题迎刃而解了，回溯回去

 

2号男生可以找3号妹子~~~                  1号男生可以找2号妹子了~~~                3号男生可以找1号妹子

所以第三步最后的结果就是：

 

===============================================================================

四： 接下来是4号男生，很遗憾，按照第三步的节奏我们没法给4号男生腾出来一个妹子，我们实在是无能为力了……香吉士同学走好。

 

===============================================================================

这就是匈牙利算法的流程，其中找妹子是个递归的过程，最最关键的字就是“腾”字

其原则大概是：有机会上，没机会创造机会也要上

题目链接

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=505;
int line[N][N];
int girl[N],used[N];
int k,m,n;
bool found(int x)
{
    for(int i=1; i<=n; i++)
    {
        if(line[x][i]&&!used[i])
        {
            used[i]=1;
            if(girl[i]==0||found(girl[i]))
            {
                girl[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    int x,y;
    while(scanf("%d",&k)&&k)
    {
        scanf("%d %d",&m,&n);
        memset(line,0,sizeof(line));
        memset(girl,0,sizeof(girl));
        for(int i=0; i<k; i++)
        {
            scanf("%d %d",&x,&y);
            line[x][y]=1;
        }
        int sum=0;
        for(int i=1; i<=m; i++)
        {
            memset(used,0,sizeof(used));
            if(found(i)) sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

 

  匈牙利算法，就是一个不断的找可以匹配的，如果我匹配不了，那就尝试让已经匹配上的人换人这样一个霸道总裁式的算法。

最小生成树

Wuliwuliii
关注
专栏目录
离散结构：图论进阶
smilejiasmile的博客
06-25 874
离散结构：图论进阶 一、匹配 1.0 引论 设 G=(V, E) 是简单图， ME。 如果 M 中任何两条边都不邻接， 则称 M 为 G 中的一个匹配（matching）或边独立集 设顶点 v V， 若存在 e M， 使得 v 是 e 的一个端点， 则称 v 是 M-饱和的（matched or saturated） ， 否则称 v 是 M-非饱和的（unmatched）。 例子如下所示： {v2, v4, v5, v6}是M-饱和顶点 {v1, v3}是M-非饱和顶点 ...
【离散数学】图论基础知识
fjtooo的博客
06-27 5万+
文章目录1.数据结构部分2.离散数学部分2.1 图的基本概念2.2 图的连通性2.3 图的矩阵表示2.4 几种特殊的图2.4.1 二部图2.4.2 欧拉图2.4.3 哈密顿图2.4.4 平面图2.5 无向树2.6 生成树 1.数据结构部分 2.离散数学部分 2.1 图的基本概念 无向图： 简而言之，边不带方向的图就是无向图。 有向图： 简而言之，边带方向的图就是有向图。 特殊定义： 有限图：...
Dijkstra算法求由顶点a到顶点h的最短路径
weixin_47230213的博客
05-25 1981
问题 下图使用Dijkstra算法求由顶点a到顶点h的最短路径，按实验报告模板编写算法。 解析 Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。 然后，从dis数组选择最小值，
最短路算法总结
KGV093的博客
11-14 241
1. Floyd 时间复杂度： 优势：简单，代码量小，处理多源最短路 劣势：效率低 注意：中间节点在最外层枚举（等价于向原图添加节点扩大问题规模） //hdu 2544 #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using names...
老生常谈，正确使用memset
热门推荐
my_business的专栏
10-28 11万+
前段项目中发现一个问题，程序总是在某个dynamic_cast进行动态转换时出异常，查了半天才发现问题原来是出在memset的使用上，虽然问题本身显而易见，但当处于几十万行代码量级中时，就变得不太那么容易定位了。 本文归纳了下使用memset几个需要注意的地方，虽然内容很简单，但也希望对大家有所帮助。 1. memset是以字节为单位，初始化内存块。 当初始化一个字节单位的数组时，可
memset函数（）详解
AAAtang
06-16 2万+
在做网络通信编程遇到这个并且理解这个函数，发现这个函数对于较多数据变量同时初始化很有用。 下面就是对于他的一些理解： memset（）函数原型是 extern void *memset（void *buffer,int a,int count） buffer 是指针或者数组，void是要初始化的首内存的首地址；a是要初始化的变为的数据，count是buffer的长度，即大小 这函数多用于sock...
图的遍历笔试题Java-play-with-graph-algorithme:python实现的初级图论算法库:环检测问题,桥和割点,最小生成
06-17
玩转图论算法 第一个问题关于图的表示 图的表示 社交网路 图的分类算法 无向无权图 无向有权图 有向无权图 有向有权图 图的基本概念 无向无权图 没有自环边，没有平行边， 称为简单图 联通分量 一个图的所有节占不...
图论（初级）
HuiSeKongHuan的博客
02-14 777
图论基础(初级) 图论基础初级 引言 图的定义及分类 图的实现方式无权图 邻接矩阵 邻接表 小结 图的基本操作算法 DFS算法及其应用 定义 求连通分量 路径搜索无权图 BFS算法及其应用 定义 最短路径无权图 小结 总结 引言 ​ 图论(Graph theory)是数学研究领域的一大分支，它以图为研究对象，而图是一种由顶点和边构成的离散数据结构，它的...
网络流算法
Acerkoo的博客
05-21 272
EK算法模板 算法复杂度 n*m*m （n为点数，m为边数） 源点 1， 汇点 n。const int maxn=310,inf=0x7fffffff; int pre[maxn],mat[maxn][maxn]; bool vis[maxn]; int n,m; int Augment(){ int v; bool fnd=false; memset(pre,0,size...
拓扑排序 详解+最小生成树（MST）详解 【普利姆算法 + 优先队列优化 & 克鲁斯卡尔算法】
Rocky0429
09-02 2975
好基友YanBaoC的另一篇巨作，又被我剽窃
memset(s,0xff,sizeof(s));请问这是什么
molongAWM的博客
10-27 4356
今天看一道题的解题时看到一行代码 memset(s,0xff,sizeof(s)); 说是“对s数组的初始化”。但是不明白0xff是什么意思 哪位大神知道，回答一下，谢谢   【附】：原题网址：http://ybt.ssoier.cn:8088/problem_show.php?pid=1330               原题解题               ...
（部分不懂，笔记整理未完成）【图论】差分约束
gzkeylucky的博客
07-31 158
学习图论差分约束系统
2018年全国多校算法寒假训练营练习比赛（第四场） 比赛题目题解
温姑娘的博客
02-11 468
A.石油采集/******************************************************************************************************** Date : 2018/2/11 Author: Wen Yaxin 解题思路：对图中#号点进行编号并对相邻#号构建图， 然后对整个图进行一个二分图匹配，最终二分图的最大 匹...
最短路（两种常用算法！！！）
~~河*涌--湖的博客
09-20 434
https://www.cnblogs.com/chuninggao/p/7301083.html  SPFA算法（邻接表）： #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;queue&gt; #include &lt;cstring&gt; using namespace std; const int maxn...
图论算法总结
weixin_34289454的博客
08-07 261
图论小结（18.8.17） 前言 学了一星期的图论终于A穿了集训的图论专题，趁热打铁先总结一波集训出现的图论知识方便回忆 图论基础 图的种类 图由顶点和边组成，分为有向图和无向图。 通常点的符号为u和v，边用符号e表示，连接u和v两点的边记为e=(u,v)。点的集合用V表示，边的集合用E表示，以V和E表示的图记为G=(V,E)。 无向图基础术语 两点相邻：两个顶点之间有边连接，称这两点相邻。 ...
hdu 1269 迷宫城堡（强连通）
zizaimengzhongyue的专栏
10-20 413
题意：给定一个有向图，求该图是不是强连通的。 思路：从某点出发，正向和反向两次遍历图，如果都能到达所有点，则该图是强连通的。 强连通：在一个有向图G中，如果任意两点v1、v2存在v1到v2和v2到v1的路径，则称该图是强连通的。 #include #include #define N 10005 #define M 100005 int path[2][M],next[2][M],head[
【算法练习】POJ - 2723 Get Luffy Out （2-SAT）
Pengwill's Blog
08-27 158
题意 题解 题没什么难的。说一下一个坑点。 题目说的是有nnn对钥匙，就有2∗n2∗n2*n个钥匙，就有4∗n4∗n4*n个布尔变量。 被这个坑了半天。 代码 #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using namespace std; typedef double ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wuliwuliii

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

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

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

打赏作者

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

抵扣说明：

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

余额充值