单源最短路的建图方式

1.最小花费（0<边权<1，且乘积而非加和）

思路：一个数乘以一个小于一的正数，就相当于加一个负数，因此我们可以得到一个结论

：当边权>1时用dijkstra，当0<边权时用spfa

本题由于边权均为0到1，固相当于边权都为负数，但我们仍然可以用dijkstra，因为如果在每个数都取个负号，那么就相当于加个正权边。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 2010;
double dist[N];
bool st[N];
double g[N][N];
int n,m,S,T;
void dijkstra()
{
    //memset(dist,0x3f,sizeof dist);
    dist[S]=1;
    //st[S]=true;
    for(int i=0;i<n;++i){
        int t=-1;
        for(int j=1;j<=n;++j){
            if((!st[j])&&(t==-1||dist[t]<dist[j]))
            t=j;
        }
        st[t]=true;
        for(int j=1;j<=n;++j){
            dist[j]=max(dist[j],dist[t]*g[t][j]);
        }
    }
}
int main()
{
    scanf("%d%d", &n, &m);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        double z = (100.0 - c) / 100;
        g[a][b] = g[b][a] = max(g[a][b], z);
    }

    cin >> S >> T;

    dijkstra();

    printf("%.8lf\n", 100 / dist[T]);
}

2.用BFS解决边权为1的图（最小乘车次数）

注意：题中点出所有点都至少有辆车经过,故可以用BFS

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <sstream>
using namespace std;
const int N = 1010;
int g[N][N],d[N],stop[N];
int m,n,idx;

void bfs()
{
    for (int i = 1;i <= n;i ++ ) d[i] = 1e9;
    d[1] = 0;
    queue<int> q;
    q.push(1);

    while (q.size()) {
        int t = q.front();
        q.pop();
        for (int i = 1; i <= n; i ++ ) {//该牌车的行程
            if (g[t][i] && d[i] == 1e9) {//指不是同一牌车但这两种车都经过此站点，若是同一种车时跳过，并且还可以去重，防止重复遍历，让最开始遍历的值为最小值
                d[i] = d[t] + 1;
                q.push(i);
            }
        }
    }
}
int main()
{   
    cin >> m >> n;
    string s;
    getline(cin,s);//因为getline回车一次就读一次会造成第一次读入为空
    while (m -- ) {
        string s;
        getline(cin,s);
        stringstream ssin(s);//可以自动分割字符串的字符串流(也是一个容器)，
        int cnt = 0,p;
        while (ssin >> p) stop[cnt ++] = p;//移出字符串流后会自动类型转换
        for (int i = 0;i < cnt - 1;i ++ ) 
            for (int j = i + 1;j < cnt;j ++ ) 
                g[stop[i]][stop[j]] = 1;//比如1-3-6-2-5，那么g[1][3]=1,g[1][6]=1,g[1][2]=1,g[1][5]=1
    }
    bfs();
    if (d[n] == 1e9) puts("NO");
    else cout << d[n] - 1 << '\n';
    return 0;
}

 3.昂贵的聘礼（建立虚拟源点）

//这个题目算是我第三次写了吧一个很有趣的题目考察的知识点也很综合
//我们看到这个题目的时候就该大致想到这是一个最短路的题目
//我们可以按有一个物品还需要多少钱可以买他连着的物品来建立图
//这样起点太多了我们要进行最短路算法很麻烦
//遇到多起点的最短路问题我们可以用一个虚拟源点向这些点建立边
//就可以把多起点问题转化为单源点最短路径
//如果没有阶级限制那我们可以直接从虚拟源点向所有点连边边权为这些点的距离
//然后跑一遍最短路径这样就可以得到我们最小花费的金币数
//但是如果有了阶级限制我们该怎么解决呢？
//答案是我们可以枚举所有包涵1的阶级区间
//然后在这些区间跑最短路然后整体取最小值，这样就可以得到我们要花费的最小金币数了
//我们可以总结一个经验
//当我们发现在某一个算法上加了某种限制那么我们可以考虑枚举这个限制然后去跑对应的算法
//最后整体取我们要的答案

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int w[N][N], level[N];
int dist[N];
bool st[N];

int dijkstra(int down, int up)
{
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);

    dist[0] = 0;
    for (int i = 1; i <= n + 1; i ++ )
    {
        int t = -1;
        for (int j = 0; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                 t = j;

        st[t] = true;
        for (int j = 1; j <= n; j ++ )
            if (level[j] >= down && level[j] <= up)
                dist[j] = min(dist[j], dist[t] + w[t][j]);
    }

    return dist[1];
}

int main()
{
    cin >> m >> n;

    memset(w, 0x3f, sizeof w);
    for (int i = 1; i <= n; i ++ ) w[i][i] = 0;

    for (int i = 1; i <= n; i ++ )
    {
        int price, cnt;
        cin >> price >> level[i] >> cnt;
        w[0][i] = min(price, w[0][i]);
        while (cnt -- )
        {
            int id, cost;
            cin >> id >> cost;
            w[id][i] = min(w[id][i], cost);
        }
    }

    int res = INF;
    for (int i = level[1] - m; i <= level[1]; i ++ ) res = min(res, dijkstra(i, i + m));

    cout << res << endl;

    return 0;
}

//法二

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 150, M = 2e4;

int n, m;
int dist[N];
int Rank[N];  //代表每个编号对应的等级
int value[N]; //代表每个点的物品需要的钱
int h[N], ne[M], e[M], w[M], idx;
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 dijkstra(int l, int r)
{
    //以下是堆优化版迪杰斯特拉的模板
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st); //由于要做多次迪杰斯特拉，所以务必记得每次初始化
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});
    dist[1] = 0;
    while (heap.size())
    {
        int ver = heap.top().second;
        heap.pop();
        if (st[ver])
            continue;
        st[ver] = true;

        for (int i = h[ver]; ~i; i = ne[i])
        {
            int j = e[i];
            //在入队时多了一个条件判断当前点的等级是否在允许的范围内
            if (dist[j] > dist[ver] + w[i] && Rank[j] <= r && Rank[j] >= l)
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    //在计算答案时，真实的答案值为到达该点的最短路径+该点的物品价值
    int res = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++)
        res = min(res, dist[i] + value[i]);
    return res;
}

int main()
{
    cin >> m >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i++)
    {
        int x;
        cin >> value[i] >> Rank[i] >> x;
        while (x--)
        {
            int b, c;
            cin >> b >> c;
            add(i, b, c); //反向建图，只能从高等级->低等级
        }
    }

    int res = 0x3f3f3f3f;
    //题意是有等级限制，因此需要枚举酋长所在的等级区间，每次用迪杰斯特拉跑一遍最短路
    //最终求出的最小的值即为答案
    for (int i = Rank[1]; i <= Rank[1] + m; i++)
        res = min(res, dijkstra(i - m, i));
    cout << res;
    return 0;
}