public class HelloWorld {
public static void main(String[] args) {
java.util.Scanner scan = new java.util.Scanner(System.in);
int m = scan.nextInt();
int n = scan.nextInt();
int t = scan.nextInt();
int array[][] = new int[m][n];
int i=0,j=0;
for(;i<m;i++){
for(j=0;j<n;j++){
array[i][j] = scan.nextInt();
}
}
for(i=0,j=0;i<m-1 && j<n-1;){
if(array[i][j]==t || array[i+1][j]==t || array[i][j+1]==t){
System.out.println("True");return;
}else if(array[i+1][j]<t && array[i][j+1]<t){
if(array[i+1][j]>array[i][j+1]){
i++;
}else{
j++;
}
}else if(array[i+1][j]<t){
i++;
}else if(array[i][j+1]<t){
j++;
}else{
System.out.println("False");return;
}
}
System.out.println("False");
}
}
static boolean find(int[][] arr,int n) {
int row = 0,col = arr[0].length - 1;
while(row < arr.length && col >= 0){
if(arr[row][col] == n) return true;
else if (arr[row][col] < n) ++row;
else --col;
}
return false;
}
package org.test;
import java.util.Scanner;
public class YangArrayFind {
private int[][] arrays;// 数组
private int value;// 要查找的值
int m = 0;
int n = 0;
public void buildData(int m, int n) {
arrays = new int[m][n];
}
public void receiveData() {
Scanner sac = new Scanner(System.in);// 接收输入
System.out.println("输入行数：");
m = sac.nextInt();
System.out.println("输入列数：");
n = sac.nextInt();
buildData(m, n);//创建数组
// 接收查找的值
System.out.println("输入要查找的值：");
value = sac.nextInt();
// 接收数据
System.out.println("输入数据：");
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int v = sac.nextInt();
arrays[i][j] = v;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
System.out.print(arrays[i][j] + " ");
}
System.out.println();
}
}
public boolean find(int value, int row, int col) {
// 使用二分查找
for (int i = row; i < m; i++) {
int start = 0;
int end = col;
int middle = (start + end) % 2 == 0 ? (start + end) / 2
: (start + end) / 2 + 1;
while (middle < end) {
int v = arrays[i][middle];
if (value > v) {
start = middle;
} else if (value < v) {
end = middle;
} else {// 查找到
System.out.println("find data : row:" + (i + 1) + ",col:"
+ (middle + 1));
return true;
}
middle = (start + end) % 2 == 0 ? (start + end) / 2
: (start + end) / 2 + 1;
}
// 该行未查找到
if (middle == col) {// 查到该行末尾
continue;// 继续在下一行查找
} else if (middle == 0) {// 查到该行首位,则未查到
return false;
} else {// 迭代
find(value, row + 1, middle);
}
}
return false;
}
public boolean start() {
receiveData();
return find(value, 0, n);
}
public static void main(String[] args) {
YangArrayFind ya = new YangArrayFind();
ya.start();
}
}
public static void into(){
Scanner scanner=new Scanner(System.in);
int num=scanner.nextInt();
double[] arrs=new double[num];
for(int i=0;i<arrs.length;i++){
arrs[i]=scanner.nextInt();
}
double max=0;
double start=0;
double end=0;
double x=0;
for (int i=0;i<num;i++) {
x=arrs[i];
for (int j = i+1; j < num; j++) {
x*=arrs[j];
if(x>max){
max=x;
start=arrs[i];
end=arrs[j];
}
}
}
System.out.println(start+","+end+","+max);
}
public static void main(String[] args) {
into();
}
package yxh;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
/**
* 1 暂不考虑异常处理</br>
* 2 在此我们假定输入的数据中不含0元素，</br>
* 因为如果有0元素的话，输入的数据就可以以0为界进行分块，从而转化为不含0元素的子串
* @author LZC
*
*/
public class PlusArr {
/**
* 该类表示合并后的集合中的每个元素 他记录了合并的开始位置、结束位置和合并后的结果
* @author LZC
*/
class Element {
/** **记录该元素是从数组中哪个位置开始运算的*** */
public int startIndex;
/** **记录该元素是从数组中哪个位置结束运算的*** */
public int endIndex;
/** *数组中从startIndex（包含）位置到endIndex（不包含）位置连乘的结果*** */
public double value;
public Element() {
}
/**
* @param startIndex ��
* @param endIndex ��
* @param value
*/
public Element(int startIndex, int endIndex, double value) {
super();
// TODO Auto-generated constructor stub
this.endIndex = endIndex;
this.startIndex = startIndex;
this.value = value;
}
public String toString() {
return value + "(" + startIndex + "," + endIndex + ") ";
}
}
/**
* @param args
*/
//测试数据
//double[] srcArr = { 2, 6, 0.2, 0.6, 0.1, 7, 0.4, 10, 0.8, 20, 5 };
public static void main(String[] args) {
// TODO Auto-generated method stub
PlusArr plus = new PlusArr();
System.out.println("数组数组序列（用英文逗号','隔开）");
Scanner r = new Scanner(System.in);
String input = r.nextLine();
System.out.println(input);
/**在此我们假定输入的数据中不含0元素，因为如果有0元素的话，输入的数据就可以以0为界进行分块，从而转化为不含0元素的子串**/
/** *将负数作为界限，进行分块* */
String[] negativeSplit = input.split("-[\\d]*.?[\\d]*");
int len = negativeSplit.length;
/** *如果只有一块，则说明该串中不含有负数* */
if (len == 1) {
/** 将输入的数字序列进行分隔* */
String[] strArr = input.split(",");
/** 得到对应的数组* */
double[] douArr = plus.toDoubleArr(strArr);
/** 数组进行合并操作* */
List<Element> list = plus.mergerArr(douArr);
/** 计算出最大乘积的连续子串* */
double max = 0;
int index = 0;
/***找出当前集合中最大值，并记录其位置***/
for (int i = 2; i < list.size() - 2; i++) {
if (list.get(i).value > max) {
index = i;
max = list.get(i).value;
}
}
Element rsEle = plus.findMaxValue(list,index);
/**输出**/
System.out.println(rsEle);
System.out.print("最大连乘积为"+rsEle.value+"=");
for(int i=rsEle.startIndex;i<rsEle.endIndex;i++){
System.out.print(douArr[i]+" * ");
}
} else if (len > 1) {
/** *如果多于一块，则说明该串中含有负数* */
/** 这部分还没想好怎么弄** */
}
}
/**
* 将字符串数组转为double数组
* @param strArr
* @return
*/
double[] toDoubleArr(String[] strArr) {
/**暂不考虑异常情况**/
double[] douArr = new double[strArr.length];
for (int i = 0; i < strArr.length; i++) {
douArr[i] = Double.parseDouble(strArr[i]);
}
return douArr;
}
/**
*
* 复杂度 O(n) n表示数组长度
*
* @param 待处理的数组
*
* @return 合并后的结果（不含负数的 且大于1和小于1的数字间隔排列的集合）��
*/
public List<Element> mergerArr(double[] arr) {
List<Element> elementList = new LinkedList<Element>();
/** ***在elementList链表的前后各加上两个值为1的元素，方便后面的计算**** */
elementList.add(new Element(-1, -1, 1));
elementList.add(new Element(-1, -1, 1));
int tag = 2;
elementList.add(new Element(0, 0, arr[0]));
for (int i = 1; i < arr.length; i++) {
if ((arr[i] - 1) * (arr[i - 1] - 1) < 0) {
tag++;
elementList.add(new Element(i, arr.length, arr[i]));
elementList.get(tag - 1).endIndex = i;
}
/** ***如果相邻元素同大于0或同小于0，则合并为一个**** */
else {
elementList.get(tag).value = elementList.get(tag).value
* arr[i];
}
}
/** ***在elementList链表的前后各加上两个值为1的元素，方便后面的计算**** */
elementList.add(new Element(-1, -1, 1));
elementList.add(new Element(-1, -1, 1));
return elementList;
}
/**
* 复杂度 小于O（n） 因为每递归一次，list的长度减少2
* @param list 不含负数的 且大于1和小于1的数字间隔排列的集合
* @param index 当前最大元素的位置
* @return 最大元素
*/
Element findMaxValue(List<Element> list,int index) {
Element maxEle = list.get(index);
/** *****当前最大值左边两个元素的乘积******** */
double rs1 = list.get(index - 2).value * list.get(index - 1).value;
/** *****当前最大值右边两个元素的乘积******** */
double rs2 = list.get(index + 2).value * list.get(index + 1).value;
/** *****如果左右两个元素的乘积均小于1，则结果即为maxEle******** */
if (rs1 <= 1 && rs2 <= 1) {
return maxEle;
}
/** *****如果左边两个元素的乘积大于右边两个元素的乘积，</br>
*********则乘以rs1 否则乘以rs2 ******** */
if (rs1 > rs2) {
maxEle.startIndex = list.get(index - 2).startIndex;
maxEle.value = maxEle.value * rs1;
list.remove(index);
list.remove(index - 1);
list.remove(index - 2);
index = index-2;
list.add(index, maxEle);
} else {
maxEle.endIndex = list.get(index + 2).endIndex;
maxEle.value = maxEle.value * rs2;
list.remove(index + 2);
list.remove(index + 1);
list.remove(index);
list.add(index, maxEle);
}
// System.out.println(list);
/** **进行递归*** */
findMaxValue(list,index);
return maxEle;
}
}
import java.util.Scanner;
/*
* 结果封装类，保存计算结果（没办法，java只支持传值参）
*/
public class Max {
public int start=0 ,end=0;
public double total=0;
/**
* 入口
*/
public static void main(String[] args) {
//double []num={-1,2,4,0,6,-1,-10,-7,-0.1,-9,-2,100,-0.6,-19,0,110};
//输入数据
System.out.print("Please input the Array size:>");
Scanner in =new Scanner(System.in);
int N =in.nextInt();
double []num =new double[N];
System.out.print("Please input the Numbers:>");
for(int i=0;i<N;i++)
num[i] =in.nextDouble();
//回显输入
System.out.print("Your Numbers:> ");
for(int i=0;i<N;i++)
System.out.print(num[i]+" ");
System.out.println();
//定义结果集
Max result=new Max();
run(num, result); //运行计算
//打印结果
System.out.println("The MAX Product= "+result.total+" ~~~~~index range 【 "+result.start+" -> "+result.end+" 】");
}
/*因为是连续乘积，所以可以穷举 所有的计算组合，组合数量也不大；
* 然后，筛选 乘积最大的组合
* 备注：主要分析：按<=-1,-1~0,0,0~1,>=1切割分组，当这几种分组穿插组合之后，要考虑的情况实在有点复杂，所以选择穷举，简单方便；
* 如果数字很多，可以考虑先按上述分组，合并部分可合并项，例如>=1的可以合并为一项，单个分组为偶数个<=-1可合并为一项等等，然后再穷举
*/
private static void run(double[] num, Max result) {
System.out.println("开始穷举。。。。。。。。。。。。。。。。。。。。。");
for(int i=0;i<num.length;i++){ //遍历所有穷举点
double n =num[i];
System.out.println("########### "+n+" -> index = "+i+" ##########"); //打印穷举点
if(n==0) continue; //遇到0终止当前穷举，并以下一项为基准点开始新穷举，因为0乘以任何数都为0
for(int j=i+1;j<num.length;j++){
if(num[j]==0) break; //遇到0，中断组合
n*=num[j]; //计算当前组合的乘积
System.out.println("product : "+n+" index range： 【"+i+" -> "+j+"】 "); //打印穷举组合
if(result.total<n){ //当前穷举组合比已知组合乘积都大，则重置最大穷举组合为当前组合
result.start =i;
result.end =j;
result.total =n;
}
}
System.out.println();
}
}
}
