洛谷 P2939 [USACO09FEB]改造路Revamping Trails

题意翻译

约翰一共有N)个牧场.由M条布满尘埃的小径连接.小径可 以双向通行.每天早上约翰从牧场1出发到牧场N去给奶牛检查身体.

通过每条小径都需要消耗一定的时间.约翰打算升级其中K条小径，使之成为高 速公路.在高速公路上的通行几乎是瞬间完成的，所以高速公路的通行时间为0.

请帮助约翰决定对哪些小径进行升级，使他每天从1号牧场到第N号牧场所花的时间最短

题目描述

Farmer John dutifully checks on the cows every day. He traverses some of the M (1 <= M <= 50,000) trails conveniently numbered 1..M from pasture 1 all the way out to pasture N (a journey which is always possible for trail maps given in the test data). The N (1 <= N <= 10,000) pastures conveniently numbered 1..N on Farmer John's farm are currently connected by bidirectional dirt trails. Each trail i connects pastures P1_i and P2_i (1 <= P1_i <= N; 1 <= P2_i <= N) and requires T_i (1 <= T_i <= 1,000,000) units of time to traverse.

He wants to revamp some of the trails on his farm to save time on his long journey. Specifically, he will choose K (1 <= K <= 20) trails to turn into highways, which will effectively reduce the trail's traversal time to 0. Help FJ decide which trails to revamp to minimize the resulting time of getting from pasture 1 to N.

TIME LIMIT: 2 seconds

输入输出格式

输入格式：

* Line 1: Three space-separated integers: N, M, and K

* Lines 2..M+1: Line i+1 describes trail i with three space-separated integers: P1_i, P2_i, and T_i

输出格式：

* Line 1: The length of the shortest path after revamping no more than K edges

输入输出样例

输入样例#1：

4 4 1 
1 2 10 
2 4 10 
1 3 1 
3 4 100 

输出样例#1：

1 

说明

K is 1; revamp trail 3->4 to take time 0 instead of 100. The new shortest path is 1->3->4, total traversal time now 1.

解题报告

题意理解

就是让你从\(1\)走到\(N\),然后要求路上路径最小,且你可以让\(K\)条路的路径为0.

解题思路

一样的解题思路

首先我们一眼就可以确定这道题目是的最短路算法.毕竟题目上白纸黑字上写着要,求出最短路.

首先我们一步步分析一下,这道题目的几个关键点.

1. 这道题目的路径代价是什么?

我们发现,这里的路径不同于一般的最短路,每一条路径的最大边是这条路径的最小值

1. 题目中有些路径可以清零,这怎么办?

所有关于边的条件或者性质,其实都可以认为是一种特殊边.

这道题目中,有些边可以代价为0,那么我们不妨设置一种特殊边.

比如说\((a,b)\)是相连的边,他们代价是\(c\),那么如果说我们让它免费,不就是又多了一条边,\((a,b)\),只不过他们的代价是0?

所谓的路径可以免费,就是多了一条为0的重边.

所以这道题目的性质,转换一下就是,我们可以设置K条为权值0的边.

---

所以我们可以设置一个数组\(d[x,p]\)表示从1号节点到\(x\)号节点,途中经过\(p\)条权值为0的边,

1. 新加入的边是非0边.

那么我们面对每一条新加入的边\((x,y,z)\)我们的\(d[y,p]=max(d[x,p],z)\),其中\(z\)为\((x,y)\)权值.

1. 新加入的边是0边.

如果新加入的边是权值为0的边,显然是\(d[y,p+1]=d[x,p]\).

---

代码解释

//82分代码,SPFA他死了
#include <bits/stdc++.h>
using namespace std;
const int N=50000*3+100;
const int M=11000;
int tot,n,m,k,ver[N],Next[N],head[N],edge[N];
long long dis[M][30];
bool vis[M];
queue<int> q;
void spfa(int s)
{
    memset(dis,0x3f,sizeof(dis));
    memset(vis,false,sizeof(vis));
    dis[s][0]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for (int i=head[x]; i ; i=Next[i])
        {
            int j=edge[i],z=ver[i];
            long long w=dis[x][0]+z;
            if (dis[j][0]>w)
            {
                dis[j][0]=w;
                if(!vis[j])
                    q.push(j),vis[j]=1;
            }
            for(int p=1; p<=k; p++)
            {
                long long w=min(dis[x][p-1],dis[x][p]+z);
                if (dis[j][p]>w)
                {
                    dis[j][p]=w;
                    if(!vis[j])
                        q.push(j),vis[j]=1;
                }
            }
        }
    }
}
void add(int a,int b,int c)
{
    edge[++tot]=b;
    ver[tot]=c;
    Next[tot]=head[a];
    head[a]=tot;
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1; i<=m; i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    spfa(1);
    long long ans=1e15;
    for(int i=0; i<=k; i++)
        ans=min(ans,dis[n][i]);
    if (ans==1e15)
        printf("-1");
    else
        printf("%lld",ans);
    return 0;
}

其实Dijskra就可以Ac.

// luogu-judger-enable-o2
#include<bits/stdc++.h>
const int MAXN=1e4+20;
const int MAXM=1e5+20;
using namespace std;
typedef pair<int,int>P;
vector<P> g[MAXN];
long long dis[MAXN][22];
int n,m,k;
struct node
{
    int v,num;
    long long w;
    node() {}
    node(int a,int b,long long c)
    {
        v=a;
        num=b;
        w=c;
    }
    bool operator>(const node&cmp)const
    {
        return w>cmp.w;
    }
};
priority_queue<node,vector<node>,greater<node> >q;
void dijskra()
{
    for(int i=1; i<=n; i++)
        for(int j=0; j<=k; j++)
            dis[i][j]=0x3f3f3f3f;
    dis[1][0]=0;
    q.push(node(1,0,0));
    while(!q.empty())
    {
        node tmp=q.top();
        q.pop();
        int u=tmp.v;
        int num=tmp.num;
        long long w=tmp.w;
        for(int i=0; i<g[u].size(); i++)
        {
            int v=g[u][i].first;
            long long tw=g[u][i].second;
            if(num<k && w<dis[v][num+1])
            {
                dis[v][num+1]=w;
                q.push(node(v,num+1,w));
            }
            if(w+tw<dis[v][num])
            {
                dis[v][num]=w+tw;
                q.push(node(v,num,w+tw));
            }
        }
    }
    long long ans=dis[n][0];
    for(int i=1; i<=k; i++)
        ans=min(ans,dis[n][i]);
    printf("%lld\n",ans);
}
int main()
{
//  freopen("stdin.in","r",stdin);
    int u,v,w;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0; i<m; i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        g[u].push_back(make_pair(v,w));
        g[v].push_back(make_pair(u,w));
    }
    dijskra();
    return 0;
}

转载于:https://www.cnblogs.com/gzh-red/p/10999959.html