DGA模型-嵌套矩形与硬币问题

问题描述：
嵌套矩形问题。 有n个矩形，每个矩形可以用两个整数a,b描述，表示它的长和宽。矩形X(a,b)可以嵌套在矩形Y(c,d）中，当且仅当 a小于c,b小于d,或者，b小于c,a小于d。例如X（1，5）能嵌套在Y（6，2）中，但不能嵌套在（3，4）中。你的任务是选出尽量多的矩形排成一行，使得除最后一个外，每一个矩形都可以嵌套在下一个矩形内。如果有多解，矩形编号的字典序应尽量小。
–摘自刘汝佳《算法竞赛入门经典》9.2章

解答思路：
矩形的“可嵌套”关系是一个典型的二元关系，可用图来构造模型求解。显然，矩形的嵌套关系可用DAG来表示。并且，本题构造出来的DAG是无环的。而我们所求能嵌套的矩阵长度则可转化为求解DAG上的最长路径问题。
而题目没有给出最长的路径明确的起点和终点，因此，每个节点都可能是最优的起点，需要遍历各个顶点一次。

输入数据及初始化：
6 //矩形个数
3 4 //每个矩形的长和宽
2 5
1 2
5 6
4 5
4 5

#include<iostream>
#include<algorithm>
using namespace std;
struct node {
    int a, b;
}arr[1024];
int x, g[1024][1024], d[1024];
int f(int m) {
    if (d[m]>0)
        return d[m];
    int p = 1;
    for(int i=0;i<x;i++)
        if (g[m][i]==1)
            p = max(p, f(i) + 1);
    d[m] = p;
    return p;
}
void prin(int i) {
    cout << i << " ";
    for (int j = 0; j < x; ++j) {
        if (g[i][j] && d[i] == d[j] + 1) {//找到匹配的上一个值
            prin(j);
            break;//打印出一个就要结束本层循环
        }
    }
}
int main(void) {
    int m; cin >> m;
    cin >> x;
    for (int i = 0; i < x; i++) {
        cin >> arr[i].a >> arr[i].b;
    }
    for (int i = 0; i < x; i++) 
        for (int j = 0; j < x; j++) 
            if (((arr[i].a > arr[j].a)&&(arr[i].b > arr[j].b))||
                ((arr[i].a > arr[j].b)&&(arr[i].b > arr[j].a))) 
                g[i][j] = 1;    

    int mm = 0;
    int best;
    for (int i = 0; i < x; i++) {
        if (mm < f(i)) {
            mm = d[i];
            best = i;//最大位置
        }
    }
    cout << mm << endl;;
    for (int i = 0; i < x; i++)
        cout << d[i] << " ";
    cout << endl;
    prin(best);
    system("pause");
    return 0;
}

【问题描述】
有n种硬币，面值分别为V1，V2，V3，…..Vn，每种都有无限多。
给定非负整数S，可以选用多少个硬币，使得面值之和恰好为S？
输出硬币数目的最小值和最大值。1<=n>=100, 0<=S<=10000,1<=Vi<=S.

【分析与思路】
思路：本题是固定终点和起点的DAG动态规划。
我们把每种面值看做一个点，表示“还需要凑足的面值”，则初始状态为S，目标状态为0。
如当前在状态i，没使用一个硬币j，状态变转移到i-Vj。
有n种硬币，面值分别为V1，V2，V3，…..Vn，每种都有无限多。
给定非负整数S，可以选用多少个硬币，使得面值之和恰好为S？
输出硬币数目的最小值和最大值。1<=n>=100, 0<=S<=10000,1<=Vi<=S.

本题是固定终点和起点的DAG动态规划。
我们把每种面值看做一个点，表示“还需要凑足的面值”，则初始状态为S，目标状态为0。
如当前在状态i，没使用一个硬币j，状态变转移到i-Vj。

递推方法实现  
#include<stdio.h>  
#include<string.h>  
#define MAX 10001  
#define INF  1000000000;  
int n, S;  
int V[MAX] ,vis[MAX], d[MAX];  
int max[MAX], min[MAX] ;  

// 输出最小字典序  
void prit_ans(int *d, int S)  
{  
    int i;  
    for( i=1; i<=n; i++)  
        if (S>=V[i] && d[S] == d[S-V[i]] +1)  
        {  
            printf("%d ", i);  
            prit_ans(d, S-V[i]) ;  
            break ;  
        }  
}  

// 主函数、递推实现最短路最长路  
int main ()  
{  
    memset(min,0,sizeof(min));  
    memset(max,0,sizeof(max));  
    memset(V,0,sizeof(V));  
    int i ,j ;  
    min[0] = max[0] = 0;  
    printf("请输入要组成的面值之和S：");  
    scanf("%d", &S) ;  
    printf("请输入不同面值的硬币的种类：");  
    scanf("%d", &n) ;  
    printf("请输入各个种类的硬币的面值：\n");  
    for (i=1; i<=n; i++)  
    {  
        scanf("%d", &V[i]);  
    }  
    // 递推算法求解最长最短路  
    for (i=1; i<=S; i++)///初始化min初始化为最大值，max初始化为最小值  
    {  
        min[i] = INF;  
        max[i] = -INF;  
    }  
    for (i=1; i <= S; i++)///表示的钱数  
        for (j=1; j<=n; j++)///对应的个数  
            if(i >= V[j])///当需要表示的钱币数大于硬币所能表示的数值时，才可以往下进行  
            {  
                ///对min和max进行更新  
                if (min[i] >= (min[i-V[j]] +1))  
                    min[i] = min[i-V[j]] +1;  
                if (max[i] <= (max[i-V[j]] +1))  
                    max[i] = max[i-V[j]] +1;  
            }  
    printf("%d %d\n", min[S], max[S]);  
    //  输出最优字典序  
    prit_ans(min, S);  
    printf("\n");  
    prit_ans(max, S) ;  
    printf("\n");  

    return 0 ;  
}  

代码摘自：http://blog.csdn.net/wuxiushu/article/details/51277810