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

最新推荐文章于 2025-10-31 21:11:32 发布

原创最新推荐文章于 2025-10-31 21:11:32 发布 · 628 阅读

0 ·

CC 4.0 BY-SA版权

最长上升子序列（LIS）专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种利用动态规划算法解决机器人在特定矩阵中清理垃圾的问题。机器人从左上角出发，仅能向右或向下移动，目标是清理尽可能多的垃圾，并找到达到此目标的不同路径数量及字典序最小的路径。

题意：
给出一个矩阵N行M列，指定点上有垃圾，我们有一个机器人可以清理这些垃圾，
它从(1,1)点出发，运动的方向只能是向下或者向右走，途中它要捡垃圾，目的是要令它捡的垃圾数最多，然后在能保证捡到的垃圾数最多的情况下，统计出有多少种方法，然后输出其中任意的一种方案。
另外，这里面要给所有的格子编号，从第1行开始从左往右编号1,2,3…然后接着下一行，所以所有的编号分别是1,2,3…n*m。
输出捡的垃圾最多的数量，有多少条道路，字典序最小的路径。

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

#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[N];

int row, col, n;
int grid[105][105];
int dp[N] ,f[N] ,fa[N];
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;
}