dijkstra的应用

昂贵的聘礼

建立一个虚拟点，从虚拟点到每个点连一条边表示直接买某件物品的价格，所以从虚拟点走到1的最短路就是得到结果的最小价值。

对于题目的地位限制，可以对每个满足地位的区间分别做一次dijkstra取最小值即可

#include<bits/stdc++.h>
using namespace std;

const int N = 110;
const int inf = 0x3f3f3f3f;

int n,m,g[N][N],d[N],level[N];
bool st[N];

int dijkstra(int l,int r)
{
    memset(d,0x3f,sizeof(d));
    memset(st,false,sizeof(st));//多次dijkstra，所以要重置！
    d[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 || d[j] < d[t]))
                t = j;
        }

        st[t] = true;

        for(int j = 1; j <= n; j ++ )
            if(!st[j] && level[j] >= l && level[j] <= r)
                d[j] = min(d[j],d[t] + g[t][j]);
    }

    return d[1];
}

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

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

    int p,cnt;
    for(int i = 1; i <= n; i ++ )//建图
    {
        cin>>p>>level[i]>>cnt;
        g[0][i] = min(p,g[0][i]);
        while(cnt -- )
        {
            int id,pp;
            cin>>id>>pp;
            g[id][i] = min(pp,g[id][i]);
        }
    }

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

    cout<<res;
    return 0;
}

重庆城里有 n 个车站， m 条 双向 公路连接其中的某些车站。

每两个车站最多用一条公路连接，从任何一个车站出发都可以经过一条或者多条公路到达其他车站，但不同的路径需要花费的时间可能不同。

在一条路径上花费的时间等于路径上所有公路需要的时间之和。

佳佳的家在车站 1 ，他有五个亲戚，分别住在车站 a,b,c,d,e 。

过年了，他需要从自己的家出发，拜访每个亲戚（顺序任意），给他们送去节日的祝福。

怎样走，才需要最少的时间？

输入格式
第一行：包含两个整数 n,m ，分别表示车站数目和公路数目。

第二行：包含五个整数 a,b,c,d,e ，分别表示五个亲戚所在车站编号。

以下 m 行，每行三个整数 x,y,t ，表示公路连接的两个车站编号和时间。

输出格式
输出仅一行，包含一个整数 T ，表示最少的总时间。

数据范围
1≤n≤50000 ,
1≤m≤105 ,
1<a,b,c,d,e≤n ,
1≤x,y≤n ,
1≤t≤100
输入样例：
6 6
2 3 4 5 6
1 2 8
2 3 3
3 4 4
4 5 5
5 6 2
1 6 7
输出样例：
21

从起点，经过五个点的最短距离。

对五个点每个点都跑一边dijkstra，用五个d[N]数组分别记录五个点到其他点的的单源最短路，再对五个点的顺序跑dfs，答案为所有顺序路径长度和的最小值。

#include<bits/stdc++.h>
using namespace std;

typedef pair<int,int> pii;
const int N = 50010,M = 2e5 + 10;

int n,m,s[6],d[6][N];
int h[N],e[M],ne[M],w[M],idx;
bool st[N];

void add(int a,int b,int c)
{
    e[idx] = b;
    ne[idx] = h[a];
    w[idx] = c;
    h[a] = idx++;
}

void dijkstra(int start,int d[])
{
    memset(d,0x3f,4 * N);
    d[start] = 0;
    memset(st,false,sizeof(st));

    priority_queue<pii,vector<pii>,greater<pii>>q;
    q.push({0,start});

    while(q.size())
    {
        auto t = q.top();
        q.pop();

        int ver = t.second;
        if(st[ver])
            continue;
        st[ver] = true;

        for(int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];

            if(d[j] > d[ver] + w[i])
            {
                d[j] = d[ver] + w[i];
                q.push({d[j],j});
            }
        }
    }
}

int dfs(int num,int u,int len)
{
    if(num > 5)
        return len;

    int res = 0x3f3f3f3f;
    for(int i = 1; i <= 5; i ++ )
    {
        if(!st[i])
        {
            int x = s[i];
            st[i] = true;
            res = min(res,dfs(num + 1,i,len + d[u][x]));
            st[i] = false;
        }
    }
    return res;
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof(h));

    s[0] = 1;
    for(int i = 1; i <= 5; i++ )
        cin>>s[i];

    while(m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c),add(b,a,c);
    }

    for(int i = 0; i <= 5; i ++ )
        dijkstra(s[i],d[i]);

    memset(st,false,sizeof(st));
    cout<<dfs(1,0,0);

    return 0;
}

通信线路

n个点，m条边的无向图，在1到n的一条路径中，去掉最大的k条边，求剩余边里面的最长边的最小值。

求最大的最小值，可以用二分，二分这个值，如果满足，说明这个值还可以更小，r = mid。
check（x）：判断1到n的路径中边权大于x的边的数量的最小值是否大于k，如果大于则不满足，否则满足。边权大于x的边可以改为1，小于等于的改为0，所求边的数量即变为1到n的最短路，对于边权只有0和1的图的最短路可以用双端队列求解。

#include<bits/stdc++.h>
using namespace std;

const int N = 1010,M = 20010;

int n,m,k;
int h[N],ne[M],e[M],w[M],idx;
int d[N];
deque<int>q;
bool st[N];

void add(int a,int b,int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++;
}

bool check(int x)
{
    memset(st,false,sizeof(st));
    memset(d,0x3f,sizeof(d));

    q.push_back(1);
    d[1] = 0;

    while(q.size())
    {
        int t = q.front();
        q.pop_front();

        if(st[t])
            continue;
        st[t] = true;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i], dis = w[i] > x;
            if (d[j] > d[t] + dis)
            {
                d[j] = d[t] + dis;
                if (!dis) q.push_front(j);
                else q.push_back(j);
            }
        }
    }

    return d[n] <= k;
}

int main()
{
    cin>>n>>m>>k;
    memset(h,-1,sizeof(h));

    while(m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }

    int l = 0, r = 1e6 + 1;
    while(l < r)
    {
        int mid = (l + r) / 2;
        if(check(mid))
            r = mid;
        else
            l = mid + 1;
    }

    if(r == 1e6 + 1)
        cout<<-1;
    else
        cout<<r;

    return 0;
}

最优贸易

y总题解

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 10, M = 2e6 + 10;

int n,m,s[N];
int h1[N],h2[N],e[M],ne[M],idx;
int dmin[N],dmax[N];
bool st[N];

void add(int a,int b,int h[])
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

void spfa(int h[],int d[],int type)
{
    queue<int>q;
    memset(st,false,sizeof(st));
    if(type == 0)
    {
        memset(d,0x3f,sizeof(dmin));
        d[1] = s[1];
        q.push(1);
    }
    else
    {
        memset(d,-0x3f,sizeof(dmax));
        d[n] = s[n];
        q.push(n);
    }

    while(q.size())
    {
        auto t = q.front();
        q.pop();
        st[t] = false;


        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];


            //cout<<j<<" "<<d[j]<<endl;
            if(type == 0 && d[j] > min(d[t],s[j]))
            {
                d[j] = min(d[t],s[j]);
                if(!st[j])
                {
                    st[j] = true;
                    q.push(j);
                }
            }
            else if(type == 1 && d[j] < max(d[t],s[j]))
            {
                d[j] = max(d[t],s[j]);
                if(!st[j])
                {
                    st[j] = true;
                    q.push(j);
                }
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    memset(h1,-1,sizeof(h1));
    memset(h2,-1,sizeof(h2));

    for(int i = 1; i <= n; i ++ )
        cin>>s[i];

    while(m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,h1),add(b,a,h2);
        if(c == 2)
        {
            add(b,a,h1);
            add(a,b,h2);
        }
    }

    spfa(h1,dmin,0);//求最小值
    spfa(h2,dmax,1);//最大值

    int res = 0;
    for(int i = 1; i <= n; i ++ )
        res = max(res,dmax[i] - dmin[i]);

    cout<<res;
    return 0;
}

道路与航线

由于存在负权的航线，所以不能直接用dijkstra，用spfa会被卡。题目给的航线是无环的，所以可以进行拓扑排序，先在图中加入道路，跑一遍dfs，将所有的点分为若干个连通块，添加航线，以连通块为单位进行拓扑排序，对每个拓扑序列中的所有点跑dijkstra。（注意判断没有路径时用0x3f3f3f3f / 2 判断）。

#include<bits/stdc++.h>
using namespace std;

typedef pair<int,int>pii;
const int N = 25010,M = 150010;

int n,m1,m2,s,d[N];
int h[N],e[M],ne[M],w[M],idx,cnt;
bool st[N];
int id[N];//记录每个点属于哪个连通块
int ru[N];//每个连通块的入度
vector<int>block[N];//存放每个联通块中的点
queue<int>q;

void add(int a,int b,int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}

void dfs(int u)
{
    block[cnt].push_back(u);
    id[u] = cnt;
    st[u] = true;

    for(int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if(!st[j])
            dfs(j);
    }
}

void dijkstra(int u)
{
    priority_queue<pii,vector<pii>,greater<pii>>heap;
    for(auto i : block[u])
        heap.push({d[i],i});

    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int ver = t.second;

        if(st[ver])
            continue;
        st[ver] = true;

        for(int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] > d[ver] + w[i])
            {
                d[j] = d[ver] +w[i];
                if(id[j] == id[ver])
                    heap.push({d[j],j});
            }

            if(id[j] != id[ver])
            {
                ru[id[j]] --;
                if(ru[id[j]] == 0)
                    q.push(id[j]);
            }
        }
    }

}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>m1>>m2>>s;
    memset(h,-1,sizeof(h));

    while(m1 -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }

    for(int i = 1; i <= n; i ++ )
    {
        if(!st[i])
        {
            dfs(i);
            cnt ++;
        }
    }

    while(m2 -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        ru[id[b]] ++;
    }

    for(int i = 0; i < cnt; i ++ )
        if(ru[i] == 0)
            q.push(i);

    memset(st,false,sizeof(st));
    memset(d,0x3f,sizeof(d));
    d[s] = 0;

    while(q.size())
    {
        int t = q.front();
        q.pop();

        dijkstra(t);
    }

    for(int i = 1; i <= n; i ++ )
    {
        if(d[i] > 0x3f3f3f3f / 2)
            cout<<"NO PATH"<<'\n';
        else
            cout<<d[i]<<'\n';
    }

    return 0;
}