根堆系列之序列

146. 序列 - AcWing题库

此题不是一般的麻烦，为啥是简单题目呀！！！我不懂呀！！！

发癫结束，言归正传。

我们输入序列，假设有三个待输入的序列，我们称之为1，2，3序列。要找前n个最小和。我们先看1，2序列我们知道我们先将1，2序列拍好顺序后，我们可以发现1序列的第一个数和2序列的第一个数之和最小。我们假定f【i】【j】代表着第i个序列的第j个数。我们可以发现接下来最小的数一定在f[i+1][j]he f[i][j+1]产生，由此推广，我们可以哦得知前两个序列任意两个数的和的前n小为

我们以f【i】【j】放进小根堆里接着放入f[i+1][j]与f[i][j+1]依次类推，我们取出一个就这么干，最后前n个就是我们要求的。但是要注意，以f[1][2]与f[2][1]为例，他们皆是可以推到出f[2][2]的，所以我们加一个限制条件，使得f【1】【2】只能变为f【1】【3】类似这样的。我们开个类，类里面存上一个序列的数字序号，以及当前序列的数字序号，以及我们之前说的变化标志。根堆的比较原则就是上个序列的数字加当前序列的数字，按升序排列。前两个算完后剩下的依次类推。代码有注释

import java.awt.FontFormatException;
import java.io.BufferedReader; 
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.AnnotatedWildcardType;
import java.math.BigInteger;
import java.sql.SQLIntegrityConstraintViolationException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Spliterator.OfPrimitive;
import java.util.function.IntToDoubleFunction;
import java.util.function.LongBinaryOperator;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.management.relation.InvalidRelationTypeException;
import javax.print.attribute.standard.JobMessageFromOperator;
import javax.print.attribute.standard.JobPriority;
import javax.swing.table.TableModel;
import javax.swing.text.TabSet;
public class Main {
  public static void main(String[] args) throws IOException  {
Scanner sc=new Scanner(System.in);
BufferedReader br1=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw1=new PrintWriter(System.out);
int a=sc.nextInt();
while(a>0) {
	a--;
	int b=sc.nextInt();
	int c=sc.nextInt();
	int e,f;
	for(d=1;d<=b;d++) {
		for(e=1;e<=c;e++) {
			aa[d][e]=sc.nextInt();//依次输入每个数组的值
		}
		
		Arrays.sort(aa[d],1,c+1);//按升序排序好每一个数组
		if(d==1) {
			for(f=1;f<=c;f++) {
				dd[f]=aa[1][f];//答案数组记录第一个序列的值
			}
		}
	}
	for(d=2;d<=b;d++) {
		PriorityQueue<xulie> pq1=new PriorityQueue<>(new Comparator<xulie>() {
			@Override
			public int compare(xulie o1, xulie o2) {
				// TODO Auto-generated method stub//小根堆排序规则就是按照前两个序列按数字之和最小
				int a=(aa[d][o1.y]+dd[o1.x])-(aa[d][o2.y]+dd[o2.x]);
				return a;
			}
		});
		pq1.offer(new xulie(1, 1, true));//存入最小的和
		for(e=1;e<=c;e++) {
			xulie xl1=pq1.poll();//取出
			int x1=xl1.x;
			int y1=xl1.y;
			cc[e]=aa[d][y1]+dd[x1];//赋值
			pq1.offer(new xulie(x1+1, y1, false));//存入设置条件
			if(xl1.z==true) {
				pq1.offer(new xulie(x1, y1+1, true));//这个就允许两种移位
			}
		}
		for(f=1;f<=c;f++) {
			dd[f]=cc[f];//令答案数组更新
		}
		
		
	}
	for(int i=1;i<=c;i++) {//打印结果
		System.out.print(dd[i]+" ");
	}
	System.out.println();
	
	
	
}
  }
  public static int bb=(int)(3e3+35);
  public static int[][] aa=new int[bb][bb];//总数组，索引均从1开始
  public static int[] cc=new int[bb];//中间数组答案从1开始
  public static int[] dd=new int[bb];//答案数组索引从1开始
  public static int d=0;
}
class xulie{
	int x;//上一个序列的数字的标号
	int y;//当前序列的数字编号
	boolean z;//是否进行双移位，就是先移动上一个序列，在移动下一个序列
	public xulie(int x, int y, boolean z) {
		super();
		this.x = x;
		this.y = y;
		this.z = z;
	}
	
}