Problem C

Longest Run on a Snowboard

Input: standard input

Output: standard output

Time Limit: 5 seconds

Memory Limit: 32 MB

Michael likes snowboarding. That's not very surprising, since snowboarding is really great. The bad thing is that in order to gain speed, the area must slide downwards. Another disadvantage is that when you've reached the bottom of the hill you have to walk
up again or wait for the ski-lift.

Michael would like to know how long the longest run in an area is. That area is given by a grid of numbers, defining the heights at those points. Look at this example:

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

One can slide down from one point to a connected other one if and only if the height decreases. One point is connected to another if it's at left, at right, above or below it. In the sample map, a possible slide would be 24-17-16-1 (start
at 24, end at 1). Of course if you would go 25-24-23-...-3-2-1, it would be a much longer run. In fact, it's the longest possible.

Input

The first line contains the number of test cases N. Each test case starts with a line containing the name (it's a single string), the number of rows R and the number of columns C. After that follow R lines
with C numbers each, defining the heights. R and C won't be bigger than 100, N not bigger than 15 and the heights are always in the range from 0 to 100.

For each test case, print a line containing the name of the area, a colon, a space and the length of the longest run one can slide down in that area.

Sample Input

2

Feldberg 10 5

56 14 51 58 88

26 94 24 39 41

24 16 8 51 51

76 72 77 43 10

38 50 59 84 81

5 23 37 71 77

96 10 93 53 82

94 15 96 69 9

74 0 62 38 96

37 54 55 82 38

Spiral 5 5

1 2 3 4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

Sample Output

Feldberg: 7

Spiral: 25

(Math Lovers’ Contest, Problem Setter: Stefan Pochmann)

题意：

Michael非常喜欢滑雪。

滑雪非常好玩，可是有一点比較麻烦。就是为了要获得速度，滑雪一定要由高处往低处滑。等你到了山脚时就得走路上山或等待滑雪登山缆车了。

Michael想要知道在某一个滑雪场最长的滑雪路径有多长。滑雪场区域是以数字形成的方块来表示。数字的大小代表各个点的高度。看下面的样例：

 1   2   3   4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

我们能够从一点滑到相连的还有一点。仅仅要高度是由高到低。

在这里我们说某一点与还有一点相连指的是他们互为上、下、左、右四个方向相邻。

在上面的地图中我们能够滑24-17-16-1（从24開始，1结束）。

当然。假如你想要滑25-24-23-22-....-3-2-1 也能够，这比上一条路径长多了。

其实，这也是最长的路径了。

思路：DAG上的动态规划，仅仅是方向变成了上下左右四个方向，状态转移公式没有变化。

#include<iostream>

#include<cstring>

using namespace std;

int map[110][110],vis[110][110],arry[110][110];

int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

int n,m;

int dp(int x,int y)

    {

        if(vis[x][y]) return arry[x][y];

        for(int i=0;i<4;i++)

            {

                int dx=x+dir[i][0],dy=y+dir[i][1];

                if(dx>=0&&dx<n&&dy>=0&&dy<m&&map[dx][dy]<map[x][y])

                    {

                        arry[x][y]=max(dp(dx,dy)+1,arry[x][y]);

                    }

            }

        vis[x][y]=1;

        return arry[x][y];

    }

int main()

    {

        int num;

        cin>>num;

        while(num--)

            {

                string name;

                cin>>name>>n>>m;

                memset(map, 0, sizeof(map));

                memset(vis, 0, sizeof(vis));

                for(int i=0;i<n;i++)

                    {

                        for(int j=0;j<m;j++)

                            {

                                cin>>map[i][j];

                                arry[i][j]=0;

                            }

                    }

                int maxn=0;

                for(int i=0;i<n;i++)

                    {

                        for(int j=0;j<m;j++)

                            {

                                int cnt=dp(i,j);

                                if(cnt>maxn) maxn=cnt;

                            }

                    }

                cout<<name<<": "<<maxn+1<<endl;

            }

        return 0;

    }