Codeforce 721C DP+DAG拓扑序

题意

在一个DAG上，从顶点1走到顶点n，路径上需要消费时间，求在限定时间内从1到n经过城市最多的一条路径

我的做法和题解差不多，不过最近可能看primer看多了，写得比较复杂和结构化

自己做了一些小优化。。然而貌似跑得更慢了

先定义dp[i][j], 表示到第i个城市，经过j个城市所花的时间

然后转移方程比较好写，就是对于能到达i的点v

dp[i][j] = min(dp[i][j], dp[v][j-1] + e.cost)  e是(i, v)这条边

因为要输出路径，所以还要有一个记录路径的数组，伴随dp[i][j]的更新而更新

如果v能更新i，那么p[i][j] = v，这样就可以记录路径了

（在结构体里dp[i][j]是N_T, p[i][j] 是N_N）

然后我仔细一想。。如果这么写转移会有很多多余的情况

于是作死加了很多不必要的优化，我保存了那些非0的数值，记录在一个队列里，然后再用map映射一下

不过好像没什么效果

还有一点就是dp的时候要按照拓扑序来更新

我把求拓扑序和dp的过程分开了，其实也可以合并在一起（分开好蠢啊）

最后动态清了下内存，才卡着内存勉强过了

PS用题解学英语orzzz

vertice 顶点
acyclic 非循环的
recursive 递归
iterate 迭代

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using namespace std;
const int Maxn = 5050;
int n, m, T;
struct Edge
{
  int front, to, t;
};
vector <Edge> edges;
vector <short int> G[Maxn];
short int R[Maxn];
bool flag[Maxn];
queue<short int> Tp;
void AddEdge(int u, int v, int tt)
{
    edges.push_back((Edge){u, v, tt});
    R[v]++;
    G[u].push_back(edges.size()-1);
}

struct dp
{
    int N_T[Maxn], D;
    vector<int> Q;
    map<short int, short int> f, N_N;
    dp() 
    { 
        f.clear(); N_N.clear(); Q.clear(); 
    }
    void update(dp B, int t)
    {
        for(int i = 0; i < B.Q.size(); i++)
        {
            int k = B.Q[i];
            if(f[k+1])
            {
                  if(N_T[k+1] > B.N_T[k] + t)
                  {
                    N_T[k+1] = B.N_T[k] + t; 
                    N_N[k+1] = B.D;
                 }
            }else
            {
                if(B.N_T[k] + t > T) continue;
                N_T[k+1] = B.N_T[k] + t;
                N_N[k+1] = B.D;
                f[k+1] = true;
                Q.push_back(k+1);
            }
        }
    }
    void clear()
    {
      Q.clear(); f.clear();
    }
}Dp[Maxn];
int main()
{
    //freopen("a.txt", "r", stdin);
    memset(flag, 0, sizeof(flag));
    memset(R, 0, sizeof(R));
    int u, v, t;
    cin>>n>>m>>T;
    
    for(int i = 0; i < n; i++) G[i].clear(); edges.clear();

    for(int i = 1; i <= m; i++)
    {
        cin>>u>>v>>t;
        AddEdge(u, v, t);
    }
    for(int k = 1; k <= n; k++)
    {
        for(int i = 1; i <= n; i++)
        {
            if(flag[i]) continue;
            if(R[i] == 0)
            {
                for(int x = 0; x < G[i].size(); x++)
                  R[edges[G[i][x]].to]--;
                Tp.push(i); flag[i] = true;
                break;
            }
        }
    }
    
    Dp[1].N_T[1] = 0; Dp[1].Q.push_back(1);
    for(int i = 1; i <= n; i++) Dp[i].D = i;
    
    while(!Tp.empty())
    {
        int x = Tp.front(); Tp.pop();
          for(int u = 0; u < G[x].size(); u++)
          {
              Edge &e = edges[G[x][u]];
            Dp[e.to].update(Dp[x], e.t);
          }
          if(x != n) Dp[x].clear();
    }
    
    int Max = 0, x = n;
    for(int i = 0; i < Dp[n].Q.size(); i++) Max = ((Max < Dp[n].Q[i]) ? Dp[n].Q[i] : Max);
    cout<<Max<<endl;
    stack<short int> S;
    while(x != 1) 
    {
          S.push(x);
          x = Dp[x].N_N[Max];
          Max--;
    }
    printf("1 ");
    while(!S.empty())
    {
        printf("%d ", S.top());
          S.pop();
    }
}