UVA - 10599 Robots(II)（最长上升自序列）

题意：

给出一个矩阵N行M列，指定点上有垃圾，我们有一个机器人可以清理这些垃圾，

它从(1,1)点出发，运动的方向只能是向下或者向右走，途中它要捡垃圾，目的是要令它捡的垃圾数最多，然后在能保证捡到的垃圾数最多的情况下，统计出有多少种方法，然后输出其中任意的一种方案。

另外，这里面要给所有的格子编号，从第1行开始从左往右编号1,2,3…然后接着下一行，所以所有的编号分别是1,2,3…n*m。

输出捡的垃圾最多的数量，有多少条道路，字典序最小的路径。

解析：

因为路径数只跟带有垃圾的格子有关，机器人又只能向下和向右走，走到最后路径一定是升序的，但一串垃圾标号的升序序列不一定可以走到，这与LIS中的判断条件有所不同，y(i) <= y(j)，只有前面垃圾的y在当前垃圾y的左面才可以走到，每走一步记录前驱。

[code]#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 10005;

struct Point {
    int y;
    int id;
    Point() {}
    Point(int _y,int _id) {
        y = _y, id = _id;
    }
}p
;

int row, col, n;
int grid[105][105];
int dp
 ,f
 ,fa
;
void print_path(int cur) {
    if(fa[cur] != -1) {
        print_path(fa[cur]);
    }
    if(cur != n-1 || grid[row][col]) {
        printf(" %d",p[cur].id);
    }
}
int main() {
    int x, y;
    int cas = 1;
    while(scanf("%d%d", &row ,&col) != EOF) {
        if(row == -1 && col == -1) {
            break;
        }
        memset(grid,0,sizeof(grid));
        while(true) {
            scanf("%d%d",&x ,&y);
            if(!x && !y) {
                break;
            }
            grid[x][y]++;
        }

        n = 0;
        for(int i = 1; i <= row; i++) {
            for(int j = 1; j <= col; j++) {
                if(grid[i][j]) {
                    p[n++] = Point(j, (i-1)*col + j);
                }
            }
        }
        if(!grid[row][col]) {
            p[n++] = Point(col, row*col);
        }
        for(int i = 0; i < n; i++) {
            dp[i] = f[i] = 1;
            fa[i] = -1;
            for(int j = 0; j < i; j++) {
                if(p[j].y <= p[i].y) {
                    if(dp[i] < dp[j] + 1) {
                        dp[i] = dp[j] + 1;
                        f[i] = f[j];
                        fa[i] = j;
                    }else if(dp[i] == dp[j] + 1) {
                        f[i] += f[j];
                    }
                }
            }
        }

        if(!grid[row][col])
            dp[n-1]--;

        printf("CASE#%d: %d %d",cas++,dp[n-1], f[n-1]);
        print_path(n-1);
        printf("\n");
    }
    return 0;
}