一个简单思路 package 采花生;

import java.io.BufferedInputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

// 分析得知，采花生第一次采摘的为最多的那一颗，然后次少的一颗，然后... 在时间允许的范围内返回路边

// 创建键盘录入接受对象

Scanner sc = new Scanner(new BufferedInputStream(System.in));

while (sc.hasNext()) {

// 接受录入数据

int x = sc.nextInt(); // 花生田有几排

int y = sc.nextInt(); // 花生田有几列

int totalTime = sc.nextInt(); // 限定的时间

// 创建一个哈希Map，存放花生田里有花生的植株信息

HashMap map = new HashMap();

// 接下来初始化花生田，并统计花生信息

for (int i = 0; i < x; i++) {

for (int j = 0; j < y; j++) {

int val = sc.nextInt();

if (val != 0) map.put(val, new Node(i, j, val));

}

}

// 接下来取出植株集合，并按照花生数量多少进行从大到小的排序

Comparator cmp = new Comparator() {

@Override

public int compare(Integer n1, Integer n2) {

// TODO Auto-generated method stub

return n2 - n1;

}

};

// 取出植株的花生数量集合

ArrayList list = new ArrayList(map.keySet());

if (list.isEmpty()) System.out.println(0);

else {

// 按照花生数量，从大到小进行排序

Collections.sort(list, cmp);

/* 因为采摘顺序是从大到小进行了，所以能不能采摘该植株，

是由走到这株花生的时间 moveTime

采摘时间takeTime ,

离开返回路边时间 leaveTime

如果三个时间相加在

限定时间totalTime 内，那么就能采摘该花生采摘该花生之后，

首先做限定时间

做 totalTime = totalTime - moveTime - takeTime ;

然后计算移动到下一个花生next

需要花费的时间moveTime

采摘时间takeTime 以及从这个花生next身上

离开到路边的时间leaveTime，

判断这三个时间是否在限定的时间内，

如果在就采摘这个花生，并继续下一个，

如果不在，超出了限定时间，说明不能继续采摘了。

此时就返回路边，同时返回采摘的花生数量

*/

// 取得最多那珠花生的数量

int index = 0;

int key = list.get(index++);

// 判断该花生能不能被采摘

// 获取数量最多的那个花生的植株

Node node = map.get(key);

int val = 0; // 创建一个变量，存放能采摘到的花生数量

// 计算移动时间，采摘时间，离开时间

int moveTime = node.x + 1, takeTime = 1, leavlTime = node.x + 1;

// 判断能不能采摘

while (totalTime - moveTime - takeTime - leavlTime >= 0) {

// 可以采摘，减去移动时间，采摘时间

totalTime = totalTime - moveTime - takeTime;

// 累加采摘的花生数量

val += node.val;

// 判断有无下一植株

if (index >= list.size()) break;

// 获取下一植株

Node nextNode = map.get(list.get(index++));

// 获取移动到下一植株的时间

moveTime = Math.abs(node.x - nextNode.x)

+ Math.abs(node.y - nextNode.y);

// 获取从下一植株离开的时间

leavlTime = nextNode.x + 1;

node = nextNode;

}

System.out.println(val);

}

}

}

}

class Node {

// x,y为该花生的行坐标，列坐标

int x;

int y;

// val 存放的是该植株有多少颗花生

int val;

public Node(int x, int y, int val){

super();

this.x = x;

this.y = y;

this.val = val;

}

@Override

public String toString() {

return "Node [x=" + x + ", y=" + y + ", val=" + val + "]";

}

}