uva_103_Stacking Boxes

想清楚了其实就是一个DAG图的最长路径问题，白书上有详细说明，能嵌套的加一条边，然后记忆话搜索，求出DAG上的最长路径,然后回溯输出路径。
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define MAXN    35
#define MAXD    11

int map[MAXN][MAXD], mark[MAXN][MAXN], used[MAXN], dp[MAXN], pre[MAXN];

void valid(const int &x, const int &y, const int &d)
{
        for(int i = 0; i < d; i ++) {
                if( map[x][i] >= map[y][i] ) {
                        return ;
                }
        }
        mark[x][y] = 1;
}

int dfs(const int &u, const int &n)
{
        int rst(0), v;
        for(int v = 0; v < n; v ++) {
                if( !mark[u][v] || used[v] ) {
                        continue;
                }
                used[v] = 1;
                if( rst < (dp[v] = (-1 == dp[v])? dfs(v, n) : dp[v]) ) {
                        rst = dp[v]; pre[u] = v;
                }
                used[v] = 0;
        }
        return rst+1;
}

void back_track(const int &u)
{
        if( -1 == pre[u] ) {
                printf("%d ", u+1); return;
        }
        printf("%d ", u+1); back_track(pre[u]);
}

int main(int argc, char const *argv[])
{
#ifndef ONLINE_JUDGE
        freopen("test.in", "r", stdin);
#endif
        int n, d, ans, idx;
        while( ~scanf("%d %d", &n, &d) ) {
                for(int i = 0; i < n; i ++) {
                        for(int j = 0; j < d; j ++) {
                                scanf("%d", &map[i][j]);
                        }
                        sort(map[i], map[i]+d);
                }
                memset(mark, 0, sizeof(mark));
                for(int i = 0; i < n; i ++) {
                        for(int j = i+1; j < n; j ++) {
                                valid(i, j, d); valid(j, i, d);
                        }
                }
                ans = idx = 0; memset(used, 0, sizeof(used));
                memset(dp, -1, sizeof(dp)); memset(pre, -1, sizeof(pre));
                for(int i = 0; i < n; i ++) {
                        used[i] = 1;
                        if( ans < (dp[i] = (-1 == dp[i])? dfs(i, n) : dp[i]) ) {
                                ans = dp[i]; idx = i;
                        }
                        used[i] = 0;
                }
                printf("%d\n", ans); back_track(idx); printf("\n");
        }
        return 0;
}