UVA10599：Robots(II)（最长上升子序列）

Your company provides robots that can be used to pick up litter from fields after sporting events and

concerts. Before robots are assigned to a job, an aerial photograph of the field is marked with a grid.

Each location in the grid that contains garbage is marked. All robots begin in the Northwest corner

and end their movement in the Southeast corner. A robot can only move in two directions, either to

the East or South. Upon entering a cell that contains garbage, the robot can be programmed to pick

it up before proceeding. Once a robot reaches its destination at the Southeast corner it cannot be

repositioned or reused. Since your expenses are directly proportional to the number of robots used for

a particular job, you are interested in making the most out of them. Your task would be to use a robot

to clean the maximum number of cells containing garbage. Now there can be many ways to do this

job, so your task would be to report that number of ways and show us one such sample.

You see your robot can traverse many cells without picking up garbage, so for us a valid solution

would be the sequence of cell numbers that the robot cleans. The robots only clean cells that contain

garbage; but you can program them to avoid picking up garbage from specific cells, if you would want

to.

Figure 1: One 6 × 7 field map Figure 2: Four sample solutions

In the figure above we show a field map that has 6 rows and 7 columns. The cells in a field map

are numbered in row major order starting from 1. For the example shown here, the following 7 cells

contain garbage: 2 (1,2), 4 (1,4), 11 (2, 4), 13 (2, 6), 25 (4, 4), 28 (4, 7) and 41 (6, 7). Here cells are

presented in cell number (row, column) format. Now the maximum number of cells that can be cleaned

is 5, and there are f different ways to do that:

< 2,4,11,13,28 >

< 2,4,11,13,41 >

< 2,4,11,25,28 >

< 2,4,11,25,41 >

Input

An input file consists of one or more field maps followed by a line containing ‘-1 -1’ to signal the end

of the input data. The description of a field map starts with the number of rows and the number of

columns in the grid. Then in the subsequent lines, the garbage locations follows. The end of a field map

is signaled by ‘0 0’. Each garbage location consists of two integers, the row and column, separated by

a single space. The rows and columns are numbered as shown in Figure 1. The garbage locations will

not be given in any specific order. And a location would not be reported twice for a field map. Please

note that for all the test cases you are required to solve, the field map would be of at most 100 rows

and 100 columns.

Output

The output for each test case starts with the serial number (starting from 1) for that test case. Then

the following integers are listed on a line: N the maximum number of cells that the robot can clean, C

the number of ways that these N cells can be cleaned, and N numbers describing one possible sequence

of cell numbers that the robot will clean. As there can be C different such sequences and we are asking

for only one sequence any valid sequence would do. Make sure that all these 2 + N integers for a test

case are printed on a single line. There must be one space separating two consecutive integers and a

space between the colon and the first integer on the line. See the sample output format for a clear idea.

Sample Input

6 7

1 2

1 4

2 4

2 6

4 4

4 7

6 6

0 0

4 4

1 1

2 2

3 3

4 4

0 0

-1 -1

Sample Output

CASE#1: 5 4 2 4 11 13 28

CASE#2: 4 1 1 6 11 16

参考博客：http://blog.csdn.net/keshuai19940722/article/details/12163563

# include <stdio.h>
# include <string.h>
int n, m, k, map[101][101];
int dp[10001];//记录以i结尾的最长上升子序列长度
int pre[10001];//记录前驱节点
int cnt[10001];//保存以i结尾的最长上升子序列总数
int g[10001];//记录每个坐标的id
void init()
{
    int a, b;
    memset(map, 0, sizeof(map));
    while(scanf("%d%d",&a,&b),a+b)
        map[a][b] = 1;
    k = 0;
    for(int i=1; i<=n; ++i)
        for(int j=1; j<=m; ++j)
            if(map[i][j])
                g[k++] = (i-1)*m + j-1;//减1处理方便下面判断j点和i点的方位。
    if(!map[n][m])//将终点放进去，方便统计最长上升子序列和路径总数。
        g[k++] = n*m-1;
}

void solve()
{
    for(int i=0; i<k; ++i)
    {
        dp[i]=1, cnt[i]=1, pre[i]=-1;
        for(int j=0; j<i; ++j)
            if((g[j]%m) <= (g[i]%m))
            {
                if(dp[j]+1 == dp[i])
                    cnt[i] += cnt[j];
                else if(dp[j]+1 > dp[i])
                    dp[i] = dp[j]+1, cnt[i] = cnt[j], pre[i] = j;
            }
    }
    if(!map[n][m])
        --dp[k-1];
}

void put(int num)
{
    if(pre[num] != -1)
        put(pre[num]);
    if(num != k-1 || map[n][m])
        printf(" %d",g[num]+1);
}

int main()
{
    int cas = 1;
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==-1 && m==-1)
            break;
        init();
        solve();
        printf("CASE#%d: %d %d",cas++, dp[k-1], cnt[k-1]);
        put(k-1);
        printf("\n");

    }
    return 0;
}

转载于:https://www.cnblogs.com/junior19/p/6730084.html