[POJ1088]滑雪

描述

Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

1  2   3   4   5

16 17 18 196

15 24 25 207

14 23 22 218

13 12 11 109

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

输入

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

输出

输出最长区域的长度。

思路：简单来说就是有向无环图求经过最长路径，方法很多，而且只需要求出最多经过的点的个数而不是整条路径要简单一些。我采用的是拓扑排序，代码如下：

#include<stdio.h>
#include<iostream>
#include <string.h>
#include <stdlib.h>
#include <vector> 
 
using namespace std;
 
//顶点 属性为编号 入度 是否被删除 后继顶点 最大深度 
struct Vertice{
    int id;
    int degree;
    bool isDel;
    vector<int> cv;
    int deep;
};
 
int r, c;
int map[102][102];
Vertice* vex;
int maxDeep;
 
//拓扑排序 更新最大深度 
void TopologicalSort(){
    int index = 1;
    while(index <= r*c)
        for(int i=1; i<=r*c; i++)
            if(!vex[i].isDel && vex[i].degree == 0){
                vex[i].isDel = true;
                maxDeep = vex[i].deep > maxDeep ? vex[i].deep : maxDeep;
                for(vector<int>::iterator it = vex[i].cv.begin(); it != vex[i].cv.end(); it++){
                    vex[*it].degree--;
                    vex[*it].deep = vex[*it].deep > vex[i].deep + 1 ? vex[*it].deep : vex[i].deep + 1;
                }
                index++;
            }
}
 
 
int main(){
    std::ios::sync_with_stdio(false);
    cin >> r >> c;
    vex = new Vertice[r*c+1];
 
    //将地图其他点高度都设为最高 
    memset(map, 10001, sizeof(map)); 
 
    for(int i=1; i<=r; i++)
        for(int j=1; j<=c; j++)
            cin >> map[i][j];
 
    //初始化节点 
    for(int i=1; i<=r; i++)
        for(int j=1; j<=c; j++){
            Vertice v;
            v.id = (i-1)*c+j;
            v.isDel = false;
            v.degree = 0;
            v.deep = 1;
            vex[(i-1)*c+j] = v;
        }
 
    //计算节点入度 更新节点后继 
    for(int i=1; i<=r; i++)
        for(int j=1; j<=c; j++){
            if(map[i][j] > map[i+1][j]){
                vex[i*c+j].degree++;
                vex[(i-1)*c+j].cv.push_back(i*c+j);
            }
            if(map[i][j] > map[i-1][j]){
                vex[(i-2)*c+j].degree++;
                vex[(i-1)*c+j].cv.push_back((i-2)*c+j);
            }
            if(map[i][j] > map[i][j+1]){
                vex[(i-1)*c+j+1].degree++;
                vex[(i-1)*c+j].cv.push_back((i-1)*c+j+1);
            }
            if(map[i][j] > map[i][j-1]){
                vex[(i-1)*c+j-1].degree++;
                vex[(i-1)*c+j].cv.push_back((i-1)*c+j-1);
            }
        }
    maxDeep = 0;
    TopologicalSort();
 
    cout << maxDeep << endl;
    return 0;
}