图及相关算法

图

定义：

1.图是由一个顶点的集合V和一个顶点间关系间的集合E组成：记作G=（V,E）.V：顶点的有限非空集合.

E：顶点间关系的有限集合（边集）.存在一个节点V，可能含有多个前驱结点和后继节点.

2.无向图：

　　在图G=（V，E）中，如果对于任意的顶点a，b∈V，当(a，b)∈E时，必有（b，a）∈E（即关系

R对称），此图称为无向图。无向图中用不带箭头的边表示顶点的关系.

有向图：如果对于任意的顶点a，b∈V，当(a，b)∈E时，(b，a)∈E未必成立，则称此图为有向图.

在有向图中，通常用带箭头的边连接两个有关联的结点.

在无向图中：

　　顶点v的度是指与顶点v相连的边的数目D(v)。D(2)=3
在有向图中：
　　入度——以该顶点为终点的边的数目和。ID(3)=2
　　出度——以该顶点为起点的边的数目和。OD(3)=1
　　度数为奇数的顶点叫做奇点，度数为偶数的点叫做偶点。
　　度：等于该顶点的入度与出度之和。

4.带权图：

一般的图边上没有数字，边仅表示两个顶点的相连接关系。

图中的边可以加上表示某种含义的数值，数值称为边的权，此图称为带权图。也称为网。

图的相关算法（最短路）：

分类：

1.Floyd.

2.Dijkstra.

3.Bellmanford.

4.spfa.

例题：

1342：【例4-1】最短路径问题

时间限制: 1000 ms 内存限制: 65536 KB

【题目描述】

平面上有n个点（n<=100），每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。

若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点间的直线距离。现在的任务是找出从一点到另一点之间的最短路径。

【输入】

共n+m+3行，其中:

第一行为整数n。

第2行到第n+1行（共n行），每行两个整数x和y，描述了一个点的坐标。

第n+2行为一个整数m，表示图中连线的个数。

此后的m 行，每行描述一条连线，由两个整数i和j组成，表示第i个点和第j个点之间有连线。

最后一行：两个整数s和t，分别表示源点和目标点。

【输出】

一行，一个实数（保留两位小数），表示从s到t的最短路径长度。

【输入样例】

【输出样例】

3.41

【代码】

#include<bits/stdc++.h> 
using namespace std;
const int N=105;
int a[N][2];
double d[N][N],c[N];
bool f[N];
double maxx=1e30;
int main(){
    int m,n,s,e;
    cin>>n;
    for(int i=1;i<=n;i++){
        scanf("%d%d",a[i],a[i]+1);
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            d[i][j]=maxx;
    cin>>m;
    while(m--){
        int x,y;
        scanf("%d%d",&x,&y);
        d[x][y]=d[y][x]=sqrt(pow(a[x][0]-a[y][0],2)+pow(a[x][1]-a[y][1],2));
    }
    cin>>s>>e;
    for(int i=1;i<=n;i++) c[i]=d[s][i];
    memset(f,false,sizeof(f));
    f[s]=true;
    c[s]=0;
    for(int i=1;i<n;i++){
        double minn=maxx;
        int k=0;
        for(int j=1;j<=n;j++){
            if(!f[j]&&c[j]<minn){
                minn=c[j];
                k=j;
            }
        }
        if(!k)break;
        f[k]=true;
        for(int j=1;j<=n;j++)
            c[j]=min(c[j],c[k]+d[k][j]);
    }
    printf("%.2lf",c[e]);
    return 0;
}

1344：【例4-4】最小花费

时间限制: 1000 ms 内存限制: 65536 KB

【题目描述】

在n个人中，某些人的银行账号之间可以互相转账。这些人之间转账的手续费各不相同。给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问A最少需要多少钱使得转账后B收到100元。

【输入】

第一行输入两个正整数n,m，分别表示总人数和可以互相转账的人的对数。

以下m行每行输入三个正整数x,y,z，表示标号为x的人和标号为y的人之间互相转账需要扣除z%的手续费 (z<100)。

最后一行输入两个正整数A,B。数据保证A与B之间可以直接或间接地转账。

【输出】

输出A使得B到账100元最少需要的总费用。精确到小数点后8位。

【输入样例】

【输出样例】

103.07153164

【提示】

【数据规模】

1<=n<=2000

【代码】：

#include<bits/stdc++.h>
using namespace std;
double a[2001][2001],dis[2001],minn;
int f[2001],n,m,k,x,y;
void read(){
    int xx,yy,zz;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&xx,&yy);
        scanf("%lf",&a[xx][yy]);
        a[xx][yy]=(100-a[xx][yy])/100;
        a[yy][xx]=a[xx][yy];
    }
    cin>>x>>y;
}
void dijkstra(int x){
    for(int i=1;i<=n;i++)
    dis[i]=a[x][i];
    dis[x]=1;
    f[x]=1;
    for(int i=1;i<=n-1;i++){
        minn=0;
        for(int j=1;j<=n;j++)
          if(f[j]==0&&dis[j]>minn){
              k=j;
              minn=dis[j];
        }
        f[k]=1;
        if(k==y) break;
        for(int j=1;j<=n;j++)
             if(f[j]==0&&dis[k]*a[k][j]>dis[j])  dis[j]=dis[k]*a[k][j];
    }
}
int main(){
    read();
    dijkstra(x);
    printf("%.8lf",100/dis[y]);
    return 0;     

}

这里再给大家更新一下四种算法的模板：

Dijkstra.

Dijkstra求最短路

给定一个

请你求出

输入格式

第一行包含整数

接下来

输出格式

输出一个整数，表示

如果路径不存在，则输出

数据范围

输入样例：

输出样例：

3
代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m;
int g[N][N];
int dist[N];
bool st[N];
int dijkstra(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < n - 1; i ++ ){
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        st[t] = true;
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}
int main(){
    scanf("%d%d", &n, &m);
    memset(g,0x3f,sizeof g);
    while (m--){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c);
    }
    printf("%d\n", dijkstra());
    return 0;
}

Bellman-Ford：

有边数限制的最短路

给定一个

请你求出从

注意：图中可能存在负权回路。

输入格式

第一行包含三个整数

接下来

点的编号为

输出格式

输出一个整数，表示从

如果不存在满足条件的路径，则输出 impossible。

数据范围

输入样例：

输出样例：

3
代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 10010;
struct Edge{
    int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];
void bellman_ford(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < k; i ++ ){
        memcpy(last, dist, sizeof dist);
        for (int j = 0; j < m; j ++ ){
            auto e = edges[j];
            dist[e.b] = min(dist[e.b], last[e.a] + e.c);
        }
    }
}
int main(){
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < m; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        edges[i] = {a, b, c};
    }
    bellman_ford();
    if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else printf("%d\n", dist[n]);
    return 0;
}

spfa：

spfa求最短路

给定一个

请你求出

数据保证不存在负权回路。

输入格式

第一行包含整数

接下来

输出格式

输出一个整数，表示

如果路径不存在，则输出 impossible。

数据范围

输入样例：

输出样例：

2
代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int spfa(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = true;
    while (q.size()){
        int t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i]){
            int j = e[i];
            if (dist[j] > dist[t] + w[i]){
                dist[j] = dist[t] + w[i];
                if (!st[j]){
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return dist[n];
}
int main(){
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    while (m -- ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    int t = spfa();
    if (t == 0x3f3f3f3f) puts("impossible");
    else printf("%d\n", t);
    return 0;
}

Floyd：

Floyd求最短路

给定一个

再给定

数据保证图中不存在负权回路。

输入格式

第一行包含三个整数

接下来

输出格式

共

数据范围

输入样例：

输出样例：

impossible
1
代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[N][N];
void floyd(){
    for (int k = 1; k <= n; 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]);
}
int main(){
    scanf("%d%d%d", &n, &m, &Q);
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;
    while (m -- ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);
    }
    floyd();
    while (Q -- ){
        int a, b;
        scanf("%d%d", &a, &b);

        int t = d[a][b];
        if (t > INF / 2) puts("impossible");
        else printf("%d\n", t);
    }
    return 0;
}

图

posted on 2022-07-16 15:34 博然后深阅读(172) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航

图及相关算法

图

定义：

图的相关算法（最短路）：

分类：

例题：

1342：【例4-1】最短路径问题

【题目描述】

【输入】

【输出】

【输入样例】

【输出样例】

【代码】

1344：【例4-4】最小花费

【题目描述】

【输入】

【输出】

【输入样例】

【输出样例】

【提示】

【代码】：

Dijkstra.

Dijkstra求最短路

输入格式

输出格式

数据范围

输入样例：

输出样例：

Bellman-Ford：

有边数限制的最短路

输入格式

输出格式

数据范围

输入样例：

输出样例：

spfa：

spfa求最短路

输入格式

输出格式

数据范围

输入样例：

输出样例：

Floyd：

Floyd求最短路

输入格式

输出格式

数据范围

输入样例：

输出样例：