2018第九届蓝桥杯省赛Java A组 倍数问题

【题目描述】
众所周知，小葱同学擅长计算，尤其擅长计算一个数是否是另外一个数的倍数。但小葱只擅长两个数的情况，当有很多个数之后就会比较苦恼。现在小葱给了你 n 个数，希望你从这 n 个数中找到三个数，使得这三个数的和是 K 的倍数，且这个和最大。数据保证一定有解。

【输入格式】
从标准输入读入数据。
第一行包括 2 个正整数 n, K。
第二行 n 个正整数，代表给定的 n 个数。

【输出格式】
输出到标准输出。
输出一行一个整数代表所求的和。

【样例输入】
4 3
1 2 3 4

【样例输出】
9

【样例解释】
选择2、3、4。

【数据约定】
对于 30% 的数据，n <= 100。
对于 60% 的数据，n <= 1000。
对于另外 20% 的数据，K <= 10。
对于 100% 的数据，1 <= n <= 10^5, 1 <= K <= 10^3，给定的 n 个数均不超过 10^8。

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

分析：枚举三个下标肯定O(n^3)超时，我的思路是先把原数组arr排序后，备份一份，在备份数组mod中每一位%K，这样只需找三个下标相加为0，K和2K的数就是K的倍数。这样的下标组合有很多个，都计算一遍和然后取最大。现在问题就可以转化为给定余数再求和，比如K=3时，求余数为0，1，2的数再求和。由于原数组arr是升序，所以应把原数组arr里对K的余数相同的元素压入一个专门的栈中，这样栈顶就是最大的元素，所以要取余数为0，1，2的组合时，只需把这三个余数对应的栈各取一个栈顶加起来就是这个余数组合能凑出来的最大的和，也满足了是K的倍数。
时间复杂度：排序为O(n*logn)，枚举三个余数为O(K^2)，K的数据是1000,所以不会超时，感觉K是故意这么设置的。。。
代码略显愚蠢，请忽略

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Stack;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String[] ss=br.readLine().trim().split(" ");
		int n=Integer.parseInt(ss[0]);
		int K=Integer.parseInt(ss[1]);
		ss=br.readLine().trim().split(" ");
		int[] a=new int[n];
		for(int i=0;i<n;i++){
			a[i]=Integer.parseInt(ss[i]);
		}
		
		Arrays.sort(a);
		int[] mod=Arrays.copyOf(a,n);
		Stack<Integer>[] st=new Stack[K];
		init(st);
		for(int i=0;i<n;i++){
			mod[i]%=K;
			st[mod[i]].add(a[i]);
		}
		int sum=0;
		if(st[0].size()>2){
			Stack<Integer> temp=st[0];
			sum=temp.pop()+temp.pop()+temp.pop();
		}
		int max=sum;
		for(int i=0;i<K;i++){
			if(st[i].isEmpty())continue;
			for(int j=i;j<K;j++){
				if(st[j].isEmpty())continue;
				int p=K-i-j;
				if(p>=0&&p<K){
					if(st[p].isEmpty())continue;
					if(i==j&&j==p&&st[i].size()>=3){
						Stack<Integer> temp=st[i];
						sum=temp.pop()+temp.pop()+temp.pop();
					}else if(i==j&&j!=p&&st[i].size()>=2){
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[p];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else if(i==p&&i!=j&&st[i].size()>=2){
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[j];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else if(j==p&&i!=j&&st[j].size()>=2){
						Stack<Integer> temp=st[j];
						Stack<Integer> temp1=st[i];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else if(i!=j&&j!=p){
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[j];
						Stack<Integer> temp2=st[p];
						sum=temp.peek()+temp1.peek()+temp2.peek();
					}
					if(sum>max)max=sum;
				}
			}
		}
		for(int i=0;i<K;i++){
			if(st[i].isEmpty())continue;
			for(int j=i;j<K;j++){
				if(st[j].isEmpty())continue;
				int p=2*K-i-j;
				if(p>=0&&p<K){
					if(st[p].isEmpty())continue;
					if(i==j&&j==p&&st[i].size()>=3){
						Stack<Integer> temp=st[i];
						sum=temp.pop()+temp.pop()+temp.pop();
					}else if(i==j&&j!=p&&st[i].size()>=2){
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[p];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else if(i==p&&i!=j&&st[i].size()>=2){
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[j];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else if(j==p&&i!=j&&st[j].size()>=2){
						Stack<Integer> temp=st[j];
						Stack<Integer> temp1=st[i];
						sum=temp.pop()+temp.pop()+temp1.peek();
					}else{
						Stack<Integer> temp=st[i];
						Stack<Integer> temp1=st[j];
						Stack<Integer> temp2=st[p];
						sum=temp.peek()+temp1.peek()+temp2.peek();
					}
					if(sum>max)max=sum;
				}
			}
		}
		System.out.println(max);
	}

	private static void init(Stack<Integer>[] st) {
		for(int i=0;i<st.length;i++){
			st[i]=new Stack<Integer>();
		}
	}
}