【Luogu】P1631 Sequence Merge

topic description

There are two length The Monotonous Non-decreasingSequenceof $N$ $A, B$ ，in $A, Take a number in B$ and add them together to get $N^2$ sums, find this $N^2$ Smallest $^{among 2 sums}$ $N.$ _

input format

The first line is a positive integer $N$ ;
second line $N$ integers $A_1,A_2,…,A_N$ .
The third row $N$ integers $B_1,B_2,…,B_N$ 。

output format

a row of $N$ integers, representing the $N$ smallest sums.

Sample Input #1

3
2 6 6
1 4 8

Sample output #1
3 6 7
hint

For $50\%$ of the data, $\le 10^3$ .
For $100\%$ of the data, $\le N \le 10^5$ , $\le a_i,b_i \le 10^9$ 。

answer

$A=\{a_i | i=1,2,…N$ \ $},B=\{b_i | i=1,2,…N\}$ , the most straightforward way is to use a specification of $N \times An array of N$ to store all $a_i +b_j$ , and then the idea based on selection sorting can be used to select the top $The N$ smallest values. But the time complexity of this solution is $O(N^3 )$ , it will be difficult to pass all test data. So we need to think of other ways.

If you are sensitive enough, you should immediately think of a data structure - the heap. The heap is a built-in $O (n)$ level, both insertion and deletion are $O (l o g n)$ level data structure. Obviously, in the face of $N \times When there are N$ data, use them to directly establish the specification as $N \times The heap of N$ may still time out (the time complexity at this time is $O(N^2)$ ), so other methods need to be considered. Just imagine, can we use this fast-modifying data structure of the heap to dynamically build a data structure with a length of $The data structure of N$ through a relatively fast way of value $N \times N$ data are quickly scanned and valued to update the data structure. To do this, introduce a poset:

Constructing a poset requires that the input arrays be ordered. Observe the two arrays in the question: $a_1,a_2,…,a_N], [b_1,b_2,…, b_N]$ , their length is $N$ , the time complexity (fastest) to sort these two arrays separately is $O (Nl o g N)$ , which is acceptable. When the two input arrays are ordered, all $a_i +b_j$ Then the following $N$ 个偏序集：
${ a_1+b_1, a_1+b_2, … ,a_1+b_N \} \\ \{ a_2+b_1, a_2+b_2, … ,a_2+b_N \} \\ …… \\ \{ a_N+b_1, a_N+b_2, … ,a_N+b_N \}$

Obviously, in this $N$ posets are ordered (monotonically increasing), so for each individual poset, it always satisfies:
$a_i+b_j≤ a_i+b_{(j+1)}$

At the same time, it can be asserted that $a_1+b_1$ for all $a_i+b_j$ Minimum value in combination; $a_N+b_N$ for all $a_i+b_j$ The maximum value in the combination; the minimum value in each partial order set is $a_i+b_1 (i=1,2,…,N)$ , maximum reduction $a_i+b_N (i=1,2,…,N)$ ; elements of the same column corresponding to different partial orders always have $a_i+b_j≤ a_{(i+1)}+b_j$ 。

Based on this property of a partially ordered set, we can do it in Within the time complexity of $O$ $($ $1$ $) , take out the current minimum value from the constructed partial order set.$ The specific value strategy is as follows (assuming that there is a constructed length of $N$ 's small root $h e a p$ ）：

1. Add the smallest element in each partial order set to the small root $h e a p$ 中，即 $heap=\{a_1+b_1,a_2+b_1,…,a_N+b_1\}$ ；
2. $Take out the root element (that is, the minimum value in the current heap) from h e a p$ , assuming that the taken out element is $a_i+b_j$ , record the pop-up number + 1;
3. From the partially ordered set where the extracted element is located, extract the element that is only smaller than it (ie $a_i+b_{(j+1)}$ ), insert it into the small root $h e a p$ ;
4. If the pop-up number is not $N$ , then continue to execute 2; otherwise, end the value collection.

When this algorithm ends, we take out all $a_i+b_j$ in combination $N$ small value.

proof of correctness

The order in which elements are added to the partially ordered set enables us to ensure that the currently added element is the smallest in the partially ordered set, and the small root heap $h e a p$ can guarantee that the elements taken out each time areThe smallest of the smallest elements not taken in the N partial order sets, so the correctness is proved $.$

Use of STL templates

It should be noted that in actual coding, we don't have to build a heap manually, but can use it directly by calling template functions and data structures in STL. The priority queue priority_queueis just a template container provided by STL. The queue has all the functions of the ordinary queue. The difference is that the priority queue adopts the data structure of "heap", which ensures that the first element in the queue is always Is the largest (or smallest) element in the entire priority queue (default is the large root heap).
priority_queueThe class's template parameter list has three parameters:

class T, T is the type of elements stored in the priority queue;
class Container = vector<T>, Container is the storage structure used at the bottom of the priority queue. It can be seen that the default is vector;
class Compare = less<typename Container::value_type> Compar, is the class that defines how elements in the priority queue are compared. What is the way elements in the priority queue are compared? As mentioned earlier, the underlying container of the priority queue is actually a heap, and the elements in the heap have a size relationship. For example, the big root heap: the value of each node is not greater than its parent node, so the top element of the heap is the largest. When we define some classes ourselves, and store the objects instantiated by the class into the heap (at this time, the elements in the heap are certain objects), then the comparison method of the elements in the heap will naturally change. The comparison class in the compiler can only compare built-in types, so the user needs to provide a size comparison mode (that is, the comparison method of the custom class), and fill it in the position of the Compare parameter.

Note: class CompareWhat follows less<typename Container::value_type>is the default comparison class. The default is to compare by less than (less). This comparison method creates a large root heap (so the priority queue defaults to a large root heap). If you need to create a small heap, you need to change less to greater.

less<typename Container::value_type>is defined as follows:

template <class T> 
struct less: binary_function <T,T,bool> {
    
    
	bool operator() (const T& x, const T& y) const {
    
    return x<y;}
};

greater<typename Container::value_type>is defined as follows:

template <class T> 
struct greater: binary_function <T,T,bool> {
    
    
	bool operator() (const T& x, const T& y) const {
    
    return x>y;}
};

"( )" is overloaded inside these two functions to form a functor for use.

method one

The previous algorithm mentioned one point: when an element $a_i+b_j is taken out from the priority queue$ $a_i+b_{(j+1)} that is$ second (smaller) to this element needs to be taken from the partially ordered set where the element is located $a_{i} + b_{(j + 1)}$ Fill into the priority queue. Theoretically, this is the way to get the value, but in actual operation, it is impossible for us to really create a $N \times A two-dimensional array of N$ (as a partially ordered set), because there is a possibility of bursting memory. So how to accomplish this function?
Looking back at the fetch operation of the partial order set, it is not difficult to find one point: when an element $a_i+b_j$ , the element has two indices (i.e. $i$ and $j$ ), where the first index $i$ indicates the index of the next value in the A array, and the second index is executing $j + 1$ indicates the next index to get the value in the B array. Therefore, we actually only need to build $N$ number pairs (one for each element in the priority queue with a length of N) can complete the demand for obtaining the required value from the partial order set.
For this structure (including: the value of the current number, the corresponding index ida in A, and the index idb in B, a total of three attributes), because it is simple enough, we can build the structure by ourselves. But one thing needs to be noted: since this type of data will be put into the priority queue, it is necessary to specify a way to compare the size of the structure (of course, the comparison here must be value), which requires overloading the comparison operator; Going a step further, we require this priority queue to be a "small root heap", so the operator to be overloaded is ">". The AC code written based on this idea is given below:

#include<bits/stdc++.h>
using namespace std;

// 数据声明 
const int N = 100005;
int n,k,a[N],b[N];

// 自定义数据结构 
struct NODE {
    
    
    int value, ida, idb;
	
	// 重载运算符
    bool operator>(const NODE &obj) const {
    
     return value > obj.value;}
}node;

// 定义优先队列 
priority_queue<NODE,vector<NODE>,greater<NODE> > q;

int main(){
    
    
	
	// 录入数据 
    cin>>n;
    for (int i=0; i<n; i++) cin>>a[i];
    for (int i=0; i<n; i++) cin>>b[i];
    
    // 对数组排序 
    sort(a, a+n);
    sort(b, b+n);
    
	// 初始化优先队列 
    for (int i = 0; i<n; i++)
        q.push({
    
    a[i]+b[0], i, 0});
        
    while(n--){
    
    
    	// 取出当前队列的最小值 
        node=q.top(), q.pop();
        
        // 输出 
        cout<<node.value<<" ";
        
        // 从取出元素所在偏序集中选出其次元素（并更改索引 idb 值） 
        node.value = a[node.ida] + b[++node.idb];
        
        // 入队列 
        q.push(node);
    }
    return 0;
}

Method Two

It is said that STL is a warm man, and this question provides sufficient evidence for this.
STL provides a data structure that expresses the meaning of "number pair" pair, and its related properties and functions are defined as follows:

Constructor pair<type1, type2>obj(value1, value2): This function can declare and define a pair object;
Matryoshka function make_pair( obj1, obj2): This function can construct two existing objects into a new pair type;
firstAttribute: pair_obj.first can take out the first attribute value in the object pair_ obj;
secondAttribute: pair_obj.second can take out the second attribute value in the object pair_ obj.

According to the previous analysis, we know that now we need a data structure composed of three int types, and the pairstructure can create a class with two elements. Therefore, in order to add one more element, we can create one more pair (just like a nesting doll) pair, that is, create: pair<int, pair<int, int>> obj. In this way, we can set the meanings expressed by the attributes of each layer as follows:

obj.first // represents value
obj.second.first; // means ida
obj.second.second // display idb

In this way, the complete code to solve this problem can be written according to the previous ideas:

#include<bits/stdc++.h>
using namespace std;

// 数据声明 
const int MAX = 100005;
int a[MAX], b[MAX];

priority_queue<pair<int,pair<int,int> >,vector< pair<int,pair<int,int> > >,greater< pair<int,pair<int,int> > > > q;

int main(){
    
    
	int n, tmpa, tmpb;
	
	// 录入数据 
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	for(int i=0;i<n;i++) cin>>b[i];
	
	// 对数组排序
	sort(a, a+n);
	sort(b, b+n); 
	
	for(int i=0;i<n;i++) q.push(make_pair(a[i]+b[0], pair<int,int>(i, 0)));
	
	// 查找前 k 小值 
	while(n--){
    
    
		// 输出 
		cout<<q.top().first<<" ";
		
		// 取出 ida 和 idb 索引 
		tmpa = q.top().second.first;
		tmpb = q.top().second.second;
		
		// 第一个元素出栈 
		q.pop();
		
		// 更改取出元素所在偏序集中的次元素入栈 
		q.push(make_pair(a[tmpa]+b[tmpb+1], pair<int,int>(tmpa, tmpb+1)));
	}
	return 0;
}