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 = ;
 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()-);
 }

 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 = ; i < B.Q.size(); i++)
         {
             int k = B.Q[i];
             if(f[k+])
             {
                   if(N_T[k+] > B.N_T[k] + t)
                   {
                     N_T[k+] = B.N_T[k] + t;
                     N_N[k+] = B.D;
                  }
             }else
             {
                 if(B.N_T[k] + t > T) continue;
                 N_T[k+] = B.N_T[k] + t;
                 N_N[k+] = B.D;
                 f[k+] = true;
                 Q.push_back(k+);
             }
         }
     }
     void clear()
     {
       Q.clear(); f.clear();
     }
 }Dp[Maxn];
 int main()
 {
     //freopen("a.txt", "r", stdin);
     memset(flag, , sizeof(flag));
     memset(R, , sizeof(R));
     int u, v, t;
     cin>>n>>m>>T;

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

     for(int i = ; i <= m; i++)
     {
         cin>>u>>v>>t;
         AddEdge(u, v, t);
     }
     for(int k = ; k <= n; k++)
     {
         for(int i = ; i <= n; i++)
         {
             if(flag[i]) continue;
             if(R[i] == )
             {
                 for(int x = ; x < G[i].size(); x++)
                   R[edges[G[i][x]].to]--;
                 Tp.push(i); flag[i] = true;
                 break;
             }
         }
     }

     Dp[].N_T[] = ; Dp[].Q.push_back();
     for(int i = ; i <= n; i++) Dp[i].D = i;

     while(!Tp.empty())
     {
         int x = Tp.front(); Tp.pop();
           for(int u = ; 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 = , x = n;
     for(int i = ; 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 != )
     {
           S.push(x);
           x = Dp[x].N_N[Max];
           Max--;
     }
     printf("1 ");
     while(!S.empty())
     {
         printf("%d ", S.top());
           S.pop();
     }
 }