DAG上动态规划

很多动态规划问题都可以转化为DAG上的最长路，最短路，或路径计数问题。

硬币问题：

有N中硬币，面值分别为v1,v2,v3,……vn，每种都无穷多，给定非负整数S，可以选用多少个硬币，使他们的总和恰好为S。输出硬币数目的最小值和最大值。

解：每种面值看作一个点，表示：还需要凑足的面值。则开始状态为S，目标状态为0；若当前状态为i，当使用硬币j后，状态转为i-v[j].

代码说明好了。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
 #include <set>
 #include <map>
 #include <queue>
 #include <stack>
 using namespace std;
 const int INF = 0x7fffffff;
 const double EXP = 1e-;
 const int MS = ;
 int minv[MS], maxv[MS];
 int V[MS];
 int main()
 {
     fill(minv, minv + MS, INF);
     fill(maxv, maxv + MS, -INF);
     minv[] = maxv[] = ;
     int N, S;
     cin >> N >> S;
     for (int i = ; i <= N; i++)
         cin >> V[i];

     for (int i = ; i <= S; i++)
         for (int j = ; j <=N;j++)
             if (i >= V[j])
             {
                 minv[i] = min(minv[i], minv[i - V[j]] + );
                 maxv[i] = max(maxv[i], maxv[i - V[j]] + );
             }
     cout << minv[S] << " " << maxv[S] << endl;
     return ;
 }

输出字典序最小的方案：

 void print_ans(int *d, int s)
     {
         for (int i = ; i <= n;i++)
             if (s >= v[i] && d[s] == d[s - v[i]] + )
             {
                 cout << i << " ";
                 print_ans(d, s - v[i]);
                 break;
             }
     }
     print_ans(minv, S);
     cout << endl;
     print_ans(maxv, S);

另一种方法求字典序最小的方案。

用min_coin[i]来记录状态为i时，最小的j，满足d[j]+1=d[i];

code:

 for (int i = ; i <= S; i++)
         for (int j = ; j <= n; j++)
         {
             if (i > =v[j])
             {
                 if (minv[i] > minv[i - v[j]] + )  //如果j从大到小   则>=
                 {
                     minv[i] = minv[i - v[j]] + ;
                     min_coin[i] = j;
                 }
                 if (maxv[i] < maxv[i - v[j]] + )  //如果j从大到小，则<=
                 {
                     maxv[i] = maxv[i - v[j]] + ;
                     max_coin[i] = j;
                 }
             }
         }
     void print_ans(int *d, int S)
     {
         while (S)
         {
             cout << d[S] << " ";
             s -= v[d[s]];
         }
     }
     print_ans(min_coin, S);
     cout << endl;
     print_ans(max_coin, S);

问题二：矩形嵌套。

矩形的长宽为a,b；设一个矩形的长宽为a,b,另一个矩形长宽为c,d；当a<c&&b<d  或 b<c&&a<d时，两个矩形可以嵌套。

现在给出N个矩形，嵌套组合为第一个嵌套在第二个，第二个可以嵌套在第三个，第三个可以嵌套在第四个，……。

求数量多的嵌套组合的个数。

解：DAG 法。每个矩形抽象为一个点，当矩形a可以嵌套在矩形b时，我们在a,b之间连一条边。那么问题转化为求DAG上的最长路径。

设d[i]为从节点i出发的最长路径，则有d[i]=max(d[j]+1),   (i,j)是一条边。

 //记忆化搜索
     int d[MS];
     int dp(int i)
     {
         int &ans = d[i];
         if (ans > )
             return ans;
         ans = ;
         for (int j = ; j <= n; j++)
             if (G[i][j])
                 ans = max(ans, dp(j)+ );
         return ans;
     }

输出字典序最小的方案：

 void print_ans(int i)   //  d[i]==max  &&  i is smallest
     {
         cout << i << " ";
         for (int j = ; j <= n; j++)
         {
             if (G[i][j] && d[i] == d[j] + )
             {
                 print_ans(j);
                 break;
             }
         }
     }