Codeforces Round #374 (Div. 2) C. Journey —— DP

关注

原创最新推荐文章于 2026-05-27 15:06:13 发布 495 阅读 AI 写同款· GEO 优化 ›

JavaScript性能优化：全链路性能优化策略 JavaScript性能优化是提升Web应用质量的核心要素，直接影响用户体验与业务成果。研究表明，页面加载延迟1秒可能导致转化率下降7%。高效的JavaScript执行能减少主线程阻塞，避免动画卡顿或操作延迟，尤其在移动端低性能设备上更为关键。优化内存管理与减少冗余计算可降低浏览器资源消耗，防止因内存泄漏导致的崩溃，提升应用稳定性。在竞争激烈的互联网环境中，性能优势已成为产品差异化的关键因素，直接影响用户留存与商业价值。因此，性能优化应作为开发全周期的核心实践，而非事后补救措施。阅读详情

题目链接：http://codeforces.com/contest/721/problem/C

Recently Irina arrived to one of the most famous cities of Berland — the Berlatov city. There are n showplaces in the city, numbered from 1 to n, and some of them are connected by one-directional roads. The roads in Berlatov are designed in a way such that there are no cyclic routes between showplaces.

Initially Irina stands at the showplace 1, and the endpoint of her journey is the showplace n. Naturally, Irina wants to visit as much showplaces as she can during her journey. However, Irina's stay in Berlatov is limited and she can't be there for more than T time units.

Help Irina determine how many showplaces she may visit during her journey from showplace 1 to showplace n within a time not exceeding T. It is guaranteed that there is at least one route from showplace 1 to showplace n such that Irina will spend no more than Ttime units passing it.

Input

The first line of the input contains three integers n, m and T (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000, 1 ≤ T ≤ 109) — the number of showplaces, the number of roads between them and the time of Irina's stay in Berlatov respectively.

The next m lines describes roads in Berlatov. i-th of them contains 3 integers ui, vi, ti (1 ≤ ui, vi ≤ n, ui ≠ vi, 1 ≤ ti ≤ 109), meaning that there is a road starting from showplace ui and leading to showplace vi, and Irina spends ti time units to pass it. It is guaranteed that the roads do not form cyclic routes.

It is guaranteed, that there is at most one road between each pair of showplaces.

Output

Print the single integer k (2 ≤ k ≤ n) — the maximum number of showplaces that Irina can visit during her journey from showplace 1 to showplace n within time not exceeding T, in the first line.

Print k distinct integers in the second line — indices of showplaces that Irina will visit on her route, in the order of encountering them.

If there are multiple answers, print any of them.

题意：

有n个点，给出m条边，每条边都有权值（可以理解为距离）。问在T距离之内，从顶点1走到顶点n，最多可以经过多少个顶点？

其中，构成的图中不会出现环，且题目至少有一个答案。

题解：

一开始以为是最短路径，很显然不是，因为题目求的不是最短路，而是在限定的起点、终点和距离的情况下，最多能经过多少个点。

然后想到应该可以用DP：

dp[len][v]：从顶点1开始，途经len个顶点（包括起点终点），终点为v所花费的最短距离。

枚举len*枚举边：在已有的dp[len-1][u]的基础上，再得出dp[len][v]，很有DP的味道。

（注：用vector存顶点之间的关系时，枚举边 = 枚举起点*枚举终点）

保存路径：

一开始是用1维数组fa[]来保存。后来发现，假设当前顶点为v，用一维存的话，存的fa[v]仅仅是路径所能达到最大时的fa[v]，而之前长度较小的路径的fa[v]会被新的fa[v]给覆盖掉。因此需要开二维数组fa[len][v]：记录在路径长度为len时，v的前一个顶点。

注意点：

if(dp[len-1][u]==INF) continue; 因为当dp[len-1][u]不合法时（其值设为2e9），如果直接把他与w（最大为1e9）相加，结果为3e9，超出了int的范围了。所以以后还是先判断其值是否合法或存在，然后再进项操作。

类似的DP：http://blog.youkuaiyun.com/dolfamingo/article/details/71024194

1.枚举长度*枚举起点*枚举终点：

#include <bits/stdc++.h>
using namespace std;
#define ms(a, b)  memset((a), (b), sizeof(a))
typedef long long LL;
const int INF = 2e9;
const LL LNF = 9e18;
const int mod = 1e9+7;
const int maxn = 5000+10;

struct node
{
    int v, w;
};

int n,m,T;
vector<node>G[maxn];
int dp[maxn][maxn], fa[maxn][maxn];

void init()
{
    scanf("%d%d%d",&n,&m,&T);

    for(int i = 1; i<=n; i++)
        G[i].clear();

    for(int i = 1; i<=m; i++)
    {
        int u;
        node e;
        scanf("%d%d%d",&u,&e.v,&e.w);
        G[u].push_back(e);
    }

    ms(fa,0);
    for(int i = 1; i<=n; i++)
    for(int j = 1; j<=n; j++)
        dp[i][j] = INF;
    dp[1][1] = 0;
}

void prt(int len, int u)
{
    if(len>1)
        prt(len-1, fa[len][u]);

    printf("%d ",u);
}

void solve()
{
    int k;
    for(int len = 2; len<=n; len++)
    {
        for(int u = 1; u<n; u++)
        {
            for(int i = 0; i<G[u].size(); i++)
            {
                int v = G[u][i].v;
                int w = G[u][i].w;

                if(dp[len-1][u]==INF) continue; //少了这步，如果继续用int，会溢出，因为INF+1e9

                int tmp = dp[len-1][u] + w;
                if(tmp<=T && dp[len][v]>tmp)
                {
                    dp[len][v] = tmp;
                    fa[len][v] = u;
                }
            }
        }
        if(dp[len][n]!=INF)
            k = len;
    }

    printf("%d\n",k);
    prt(k,n); putchar('\n');

}

int main()
{
    init();
    solve();
    return 0;
}

2.枚举长度*枚举边：

#include <bits/stdc++.h>
using namespace std;
#define ms(a, b)  memset((a), (b), sizeof(a))
typedef long long LL;
const int INF = 2e9;
const LL LNF = 9e18;
const int mod = 1e9+7;
const int maxn = 5000+10;

struct node
{
    int u, v, w;
    void read()
    {
        scanf("%d %d %d",&u, &v, &w);
    }
}edge[maxn];

int n,m,T;
int dp[maxn][maxn], fa[maxn][maxn];

void init()
{
    scanf("%d%d%d",&n,&m,&T);
    for(int i = 1; i<=m; i++)
        edge[i].read();

    ms(fa,0);
    for(int i = 1; i<=n; i++)
    for(int j = 1; j<=n; j++)
        dp[i][j] = INF;
    dp[1][1] = 0;
}

void prt(int len, int u)
{
    if(len>1)
        prt(len-1, fa[len][u]);

    printf("%d ",u);
}

void solve()
{
    int k;
    for(int len = 2; len<=n; len++)
    {
        for(int i = 1; i<=m; i++)
        {
            int u = edge[i].u;
            int v = edge[i].v;
            int w = edge[i].w;

            if(dp[len-1][u]==INF) continue;  //少了这步，如果继续用int，会溢出，因为INF+1e9

            int cost = dp[len-1][u] + w;
            if(cost<=T && cost<dp[len][v])
            {
                dp[len][v] = cost;
                fa[len][v] = u;
            }
        }

        if(dp[len][n]!=INF)
            k = len;
    }

    printf("%d\n",k);
    prt(k,n); putchar('\n');
}

int main()
{
    init();
    solve();
    return 0;
}

收录于