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-8;
const int MS = 100005;
int minv[MS], maxv[MS];
int V[MS];
int main()
{
    fill(minv, minv + MS, INF);
    fill(maxv, maxv + MS, -INF);
    minv[0] = maxv[0] = 0;
    int N, S;
    cin >> N >> S;
    for (int i = 1; i <= N; i++)
        cin >> V[i];

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

 输出字典序最小的方案：

void print_ans(int *d, int s)
    {
        for (int i = 1; i <= n;i++)
            if (s >= v[i] && d[s] == d[s - v[i]] + 1)
            {
                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 = 1; i <= S; i++)
        for (int j = 1; j <= n; j++)
        {
            if (i > =v[j])
            {
                if (minv[i] > minv[i - v[j]] + 1)  //如果j从大到小   则>=
                {
                    minv[i] = minv[i - v[j]] + 1;
                    min_coin[i] = j;
                }
                if (maxv[i] < maxv[i - v[j]] + 1)  //如果j从大到小，则<=
                {
                    maxv[i] = maxv[i - v[j]] + 1;
                    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 > 0)
            return ans;
        ans = 1;
        for (int j = 1; j <= n; j++)
            if (G[i][j])
                ans = max(ans, dp(j)+ 1);
        return ans;
    }

 输出字典序最小的方案：

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