最大乘积

public static void main(String[] args) {
        PDD1();
    }
    public static void PDD1(){
        long sum = 1;
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        List<Long> arrayList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            arrayList.add(scanner.nextLong());
        }
        arrayList.sort((o1, o2) -> {
            Long tmp = o2-o1;
            return tmp.intValue();
        }
        );
        if (arrayList.get(1)*arrayList.get(2)<arrayList.get(arrayList.size()-1)*arrayList.get(arrayList.size()-2)){
            sum = arrayList.get(0)*arrayList.get(arrayList.size()-1)*arrayList.get(arrayList.size()-2);
        }else {
            sum = arrayList.get(0)*arrayList.get(1)*arrayList.get(2);
        }
        System.out.println(sum);
    }

//利用包装类Collections提供的sort方法。  import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Main { public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); if (n < 3) { return;
        }
        ArrayList<Long> list = new ArrayList<>(); for (int i = 0; i < n; i++) {
            list.add(scanner.nextLong());
        }
        Collections.sort(list); long max = list.get(list.size() - 1) * list.get(list.size() - 3) * list.get(list.size() - 2); long min = list.get(0) * list.get(1) * list.get(list.size() - 1);
        max = max > min ? max : min;

        System.out.println(max);

    }
}

import java.util.Scanner;

public class Main {

    public static long process(long[] arr) {
        long neg1 = 0;
        long neg2 = 0;
        long pos1 = 0;
        long pos2 = 0;
        long pos3 = 0;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < 0) {
                if (arr[i] < neg1) {
                    neg2 = neg1;
                    neg1 = arr[i];
                } else if (arr[i] < neg2) {
                    neg2 = arr[i];
                }
            } else {
                if (arr[i] > pos3) {
                    pos1 = pos2;
                    pos2 = pos3;
                    pos3 = arr[i];
                } else if (arr[i] > pos2) {
                    pos1 = pos2;
                    pos2 = arr[i];
                } else if (arr[i] > pos1) {
                    pos1 = arr[i];
                }
            }
        }

        long res1 = neg1 * neg2 * pos3;
        long res2 = pos1 * pos2 * pos3;
        return res1 > res2 ? res1 : res2;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
        }
        System.out.println(process(arr));
    }
}

先自己设置数组的长度a，再通过循环a次，把每个值添加到数组中。通过Arrays.sort(数组名称); 对数组进行排序，然后再统计 数组中 值为负数的数量 是否大于等于 2 ，因为负负得正 ， 再比较 (最大的三个数的乘积) 与 (最小的两个负数和最大的整数的乘积)输出较大的值。如果 数组中 值为负数的数量 小于2，则直接输出 最大的三个正整数的乘积。

import java.util.*;
 public class Main {
 public static void main(String[] args) {
 Scanner in = new Scanner(System.in);
 int a = in.nextInt();
 int i = 0 ;
 long[] array = new long[a];
 for (; i < a ; i++) {
 array[i] = in.nextInt();
    int k = 0 ;
    for (int j = 0; j < i ; j++) {
        if (array[j] < 0){
            k++;
        }
    }
    Arrays.sort(array);
    //System.out.println(Arrays.toString(array));
    if (k >= 2){
        //System.out.println(array[0] + "," + array[1] + "," + array[i-1]);
        long x = array[0] * array[1]  * array[i-1];
        //System.out.println(x);
        long y = array[i-1] * array[i-2] * array[i-3];
        //System.out.println(y);
        if (x>y) {
            System.out.println(x);
        }else{
            System.out.println(y);
        }
    }else {
        long c = array[i-1] * array[i-2] * array[i-3];
        System.out.println(c);
    }
}
}

}

import java.util.Scanner;

public class Main{
    
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        long[] array=new long[n];
        for(int i=0;i<n;i++){
            array[i]=sc.nextLong();
        }

        getTheMostValue(array,n);
    }
    
    public static void getTheMostValue(long[] num,int len){
        long max1=0;long max2=0;long max3=0;long min1=0;long min2=0;
        
        for(int i=0;i<len;i++){
            if(num[i]>max1){
                max3=max2;
                max2=max1;
                max1=num[i];
            }else if(num[i]>max2){
                max3=max2;
                max2=num[i];
            }else if(num[i]>max3){
                max3=num[i];
            }else if(num[i]<min1){
                min2=min1;
                min1=num[i];
            }else if(num[i]>min1&&num[i]<min2){
                min2=num[i];
            }
        }
        
        long max=Math.max(max1*max2*max3,max1*min1*min2);
        System.out.println(max);
    }
}

public static void main(String[] args)throws Exception {

最大乘积

思路：

1.先排序

2.分两种情况：第一种数组中有正数也有负数，并且有两个以上负数，则排好序后前两个数和最后一个数相加；

第二种，数组后三个数相加，对比第一第二种情况那个值大就输出哪个。

3.使用长整形long定义数组防止溢出。

    importjava.util.*;
    publicclassMain{
    publicstaticvoidsort1(longb[]){
    for(inti=0;i<b.length-1;i++){
    for(intj=0;j<b.length-i-1;j++){
    if(b[j]>b[j+1]){
    longtemp;
    temp=b[j+1];
    b[j+1]=b[j];
    b[j]=temp;
        }
    }
  }
}
    publicstaticvoidmain(String[] args) {
    Scanner input = newScanner(System.in);
    intlen = input.nextInt();
    inti;
    long[] a = newlong[len];
    for( i=0;i<a.length;i++) {
    a[i]=input.nextInt();
    }
    sort1(a);
    longsum=0;
    longsum1=0;
    sum = a[a.length-1]*a[a.length-2]*a[a.length-3];
    sum1 = a[0]*a[1]*a[a.length-1];
    if(sum<sum1) {
    sum=sum1;
       }
    System.out.println(sum);
   }
}

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = in.nextInt();
        List<Integer> set = new ArrayList<>();
        for(int i=0;i<sum;i++) {
            set.add(in.nextInt());
        }
        set.sort((a,b)->{
            return a>b?1:-1;
        });
        
        BigDecimal b1=new BigDecimal(set.get(0));
        BigDecimal b2=new BigDecimal(set.get(1));
        BigDecimal b3=new BigDecimal(set.get(set.size()-1));
        BigDecimal b4=new BigDecimal(set.get(set.size()-2));
        BigDecimal b5=new BigDecimal(set.get(set.size()-3));
        BigDecimal m1=b1.multiply(b2).multiply(b3);
        BigDecimal m2=b3.multiply(b4).multiply(b5);
        if(m1.compareTo(m2)>0) {
            System.out.println(m1);
        }else {
            System.out.println(m2);
        }
    }
}

题目的意思是第一个数字不是代表有几个数字吧，第一个数字也是数组中的value
为啥大家都把第一个数字当做个数是因为那样省时间吗？