图论之存图

Posted 2023-04-26 一个愚公的笔记

图论之存图 2023.4.25

概述

• 主要有四种
• 每种都有不同的用途
• 为方便，下文记点集为 \\(|V|\\), 大小为 \\(n\\);
• 边集为 \\(|E|\\), 大小为 \\(m\\)。

01 直接存边

时间复杂度：

• 遍历（DFS，BFS） \\(\\Theta(\\infin)\\)
• 判断是否存在 \\(\\Theta(m)\\)

空间复杂度：

• \\(\\Theta(m)\\)

代码

struct Edge
    int u,v,w;
    Edge(int a,int b,int c)u=a,v=b,w=c;
edge[100010];
int cnt=1;
void addedge(int u,int v,int w)
    edge[cnt++](u,v,w);

优点

• 可能在某些算法里会用到
• 如 Krustal,Bellman-Ford

缺点

• 无法快速的判断是否存在 \\((u,v)\\) 边
• 无法DFS或BFS（即无法遍历图）

02 邻接矩阵

时间复杂度：

• 遍历（DFS，BFS） \\(\\Theta(n^2)\\)
• 判断是否存在 \\(\\Theta(1)\\)

空间复杂度：

• \\(\\Theta(n^2)\\)

代码

#define inf 0x3f3f3f3f
int d[101][101];
void addedge(int u,int v,int w)
    d[u][v]=w;

void dfs(int u,int fa)
    for(int i=1;i<=n;i++)
        if(d[u][i]!=inf)
            cout<<u<<"->"<<i<<" Val="<<d[u][i]<<endl;
            if(i!=fa)dfs(i,u);
        
    

优点

• 适合稠密图
• 可以快速判断一条 \\((u,v)\\) 边是否存在

缺点

• \\(\\Theta(n^2)\\)还是慢了些
• 不支持重边

03 vector

vector YYDS

时间复杂度：

• 遍历（DFS，BFS） \\(\\Theta(n+m)\\)
• 判断是否存在 \\(\\Theta(m)\\)

空间复杂度：

• \\(\\Theta(m)\\)

代码

struct Edge
    int v,w;
    Edge(int b,int c)v=b,w=c;
;
vector<Edge>edge[100010];
void addedge(int u,int v,int w)
    edge[u].push_back(Edge(v,w));

void bianli()//用的循环
    for(int i=1;i<=n;i++)
        if(!a[i].empty())
            for(int j=0;j<a[i].size();j++)cout<<i<<"->"<<a[i][j].to<<" in"<<a[i][j].val<<endl;
            cout<<endl;
        
        else cout<<i<<endl;
    

优点

• 适合稀疏图
• 时间复杂度优秀
• 好写 （最主要的

缺点

• 无法快速的判断是否存在 \\((u,v)\\) 边

04 链式前向星（邻接表）

好多种叫法。

时间复杂度：

• 遍历（DFS，BFS） \\(\\Theta(n+m)\\)
• 判断是否存在 \\(\\Theta(m)\\)

空间复杂度：

• \\(\\Theta(m+n)\\)

代码

const int maxn=1001,maxm=100001;
struct Edge
    int next;//后继结点
    int v;
    int val;
;
Edge edge[maxm*2+5];
int first[maxn];//头指针
int vis[maxn];
int cnt,ans,n,m;
void addedge(int u,int v,int w)
    cnt++;
    edge[cnt].next=first[u];//(1)
    edge[cnt].v=v;
    edge[cnt].val=w;
    first[u]=cnt;//(2)

这里其实是和 vector 差不多的链表思路，但是这里使用了定长数组实现。代码中巧妙的地方在于他插入时插入了链表的头部而不是尾部（ (1),(2) 处），避免了遍历整个链表的时间。

优点

• 速度快
• 如果是无向图，则 \\(\\texttt这条边的编号\\oplus1=\\texttt这条边的反边编号\\)

缺点

• 还是稍微复杂了点
• 没有 vector 简洁

本文作者：wangyishan，转载请注明原文链接：https://www.cnblogs.com/wang-yishan/p/17353990.html

HDU 4318 图论之最短路变形

点击打开链接

题意：看样例说把，一共4个点，接下来输入一个数，代表当前点连接的点的数量，然后那几个点，样例里面就是1->2消耗50%的能量，1->3消耗70%的能量，2->1消耗30%的能量，2->4消耗20%的能量，一次类推，最后一行输入起始位置，重点位置，开始时的能量，问从起点走到终点，消耗的能量最少。

思路：很明显的最短路变形，我们可以将求出从起点到终点剩余的最多的能量，用总能量减去它，就是消耗的最少的能量，这就好办了，将最短路改成最长路即可，但是每次比较时就是比较乘积而不是加和了，看代码把

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=50010;
struct edge{
    int to;
    double cost;
    edge(){}
    edge(int a,double b){to=a;cost=b;}
};
typedef pair<double,int> P;
vector<edge> G[maxn];
double dis[maxn];
void dijkstra(int st,double val){
    priority_queue<P,vector<P>,less<P> >que;
    for(int i=0;i<maxn;i++) dis[i]=-1.0;
    dis[st]=val;
    que.push(P(dis[st],st));
    while(!que.empty()){
        P p=que.top();que.pop();
        int v=p.second;
        if(dis[v]>p.first) continue;
        for(unsigned int i=0;i<G[v].size();i++){
            edge e=G[v][i];
            if(dis[e.to]<dis[v]*e.cost){
                dis[e.to]=dis[v]*e.cost;
                que.push(P(dis[e.to],e.to));
            }
        }
    }
}
int main(){
    int n,a,b;
    double c,val;
    while(scanf("%d",&n)!=-1){
        for(int i=0;i<maxn;i++) G[i].clear();
        for(int i=1;i<=n;i++){
            scanf("%d",&a);
            while(a--){
                scanf("%d%lf",&b,&c);
                G[i].push_back(edge(b,(100.0-c)/100.0));
            }
        }
        int st,en;
        scanf("%d%d%lf",&st,&en,&val);
        dijkstra(st,(double)val);
        if(dis[en]==-1) printf("IMPOSSIBLE!\n");
        else printf("%.2lf\n",val-dis[en]);
    }
    return 0;
}