滑雪 java_滑雪算法（贪心算法）的java和c的实现 | 学步园

java实现：

public class Demo {

/**

* 计算区域最长长度

*

* 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。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

*

* 思路:1、先把各点的高度按照从小到大排序

* 2、再依次从最小的点遍历,看它周围【上下左右】有没有比它高的点

* 3、一旦有,就更新比它高的点的路径长度

* 注意：最后输出的是路径长度而不是最长路径的起始高度

* 由于开始时路径长度初始化为 0,所以最后的结果要 +1

* @param all 存储所有区域高度数据

* @return 区域最长长度

*/

public int getMaxDistance(int[][] all) {

int i = 0, j = 0, n = 0;

int ilen = all.length;

int jlen = all[0].length;

int len = jlen * jlen;

int maxDistance = 0;

int[][] dirlen = new int[ilen][jlen];

int[][] dir = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };//向右、下、左、上

Point[] points = new Point[ilen * jlen];

for (i = 0; i < ilen; i++) {

for (j = 0; j < jlen; j++) {

points[n] = new Point();

points[n].x = i;

points[n].y = j;

points[n].height = all[i][j];

//System.out.println(points[n].height + ", ");

n++;

}

}

// 按照高度从小到大排序

quickSort(points, 0, points.length - 1);

for (int k = 0; k < len; k++) {

int x = points[k].x;

int y = points[k].y;

int nx, ny;

for (int d = 0; d < dir.length; d++)

{

nx = x + dir[d][0];

ny = y + dir[d][1];

if (judge(all, nx, ny) && all[nx][ny] > all[x][y]) {

if (dirlen[nx][ny] > dirlen[x][y] + 1){

dirlen[nx][ny] = dirlen[nx][ny];

}

else{

dirlen[nx][ny] = dirlen[x][y] + 1;

}

}

}

}

for (i = 0; i < ilen; i++) {

for (j = 0; j < jlen; j++) {

if (dirlen[i][j] > maxDistance){

maxDistance = dirlen[i][j];

}

}

}

//System.out.println(maxDistance + 1);

return maxDistance + 1;

}

//判断点是否超出范围

Boolean judge(int[][] all, int x, int y) {

if (x >= 0 && x < all.length && y >= 0 && y < all[0].length){

return true;

}

else{

return false;

}

}

// 用快速排序法把所有点按照高度从小到大排序

void quickSort(Point[] points, int low, int high) {

int loc = 0;

if (low < high) {

loc = partition(points, low, high);

quickSort(points, low, loc - 1);

quickSort(points, loc + 1, high);

}

}

int partition(Point[] points, int low, int high) {

Point pivot = points[low];

while (low < high) {

while (low < high && points[high].height > pivot.height){

high--;

}

points[low] = points[high];

while (low < high && points[low].height <= pivot.height){

low++;

}

points[high] = points[low];

}

points[low] = pivot;

return low;

}

}

public class Point {

int x;

int y;

int height;

}

import junit.framework.Assert;

import junit.framework.TestCase;

public class DemoTest extends TestCase {

public void testCase01() {

Demo demo =new Demo();

int [][]all={{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}};

Assert.assertEquals(25, demo.getMaxDistance(all));

}

}

c实现：

#include

#include

#include

using namespace std;

const int maxn = 110;

int map[maxn][maxn];

int dp[maxn][maxn];

int r,c;

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

struct Point{

int x,y;

int high;

}p[maxn*maxn];

bool cmp(Point a, Point b)

{

return a.high < b.high;

}

int judge(int x, int y)

{

if(x >= 1 && x <= r && y >= 1 && y <= c)

return 1;

else return 0;

}

void solve(int x, int y)

{

int nx, ny;

int m = 0;

for(int i = 0; i < 4; i++) //临近的点比当前点高

{

nx = x+dir[i][0];

ny = y+dir[i][1];

if( map[nx][ny] > map[x][y] && judge(nx,ny))

dp[nx][ny] = max(dp[nx][ny], dp[x][y]+1);

}

}

int main()

{

while(scanf("%d%d", &r,&c) != EOF)

{

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

memset(dp, 0, sizeof(dp));

int n = 0; //点的个数

for(int i = 1; i <= r; i++)

{

for(int j = 1; j <= c; j++)

{

scanf("%d", &map[i][j]);

p[n].x = i;

p[n].y = j;

p[n].high = map[i][j];

n++;

}

}

sort(p, p+n, cmp); //按照高度从小到大排序

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

{

int x = p[i].x;

int y = p[i].y;

solve(x,y);

}

/*

for(int i = 1; i <= r; i++)

{

for(int j = 1; j <= c; j++)

printf("%d ", dp[i][j]); printf("\n");

}

*/

int len = 0;

for(int i = 1; i <= r; i++)

{

for(int j = 1; j <= c; j++)

{

if(dp[i][j] > len)

{

len = dp[i][j];

}

}

}

printf("%d\n", len+1);

}

return 0;

}