【Codeforces Round 859 (Div. 4)】G2. Subsequence Addition (Hard Version)题解

题目大意
The only difference between the two versions is that in this version, the constraints are higher.

Initially, array $a$ contains just the number $1$. You can perform several operations in order to change the array. In an operation, you can select some subsequence${}^{†}$ of $a$ and add into $a$ an element equal to the sum of all elements of the subsequence.

You are given a final array $c$. Check if $c$ can be obtained from the initial array $a$ by performing some number (possibly 0) of operations on the initial array.

${}^{†}$ A sequence $b$ is a subsequence of a sequence $a$ if $b$ can be obtained from $a$ by the deletion of several (possibly zero, but not all) elements. In other words, select $k$ ($1\le k\le |a|$) distinct indices $i_1,i_2,\dots ,i_k$ and insert anywhere into $a$ a new element with the value equal to $a_{i_1}+a_{i_2}+\cdots +a_{i_k}$.

Input

The first line of the input contains an integer $t$ ($1\le t\le 1000$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer $n$ ($1\le n\le 2\cdot 10^5$) — the number of elements the final array $c$ should have.

The second line of each test case contains $n$ space-separated integers $c_i$ ($1\le c_i\le 2\cdot 10^5$) — the elements of the final array $c$ that should be obtained from the initial array $a$.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.

Output

For each test case, output “YES” (without quotes) if such a sequence of operations exists, and “NO” (without quotes) otherwise.

You can output the answer in any case (for example, the strings “yEs”, “yes”, “Yes” and “YES” will be recognized as a positive answer).
Example
input

6
1
1
1
2
5
5 1 3 2 1
5
7 1 5 2 1
3
1 1 1
5
1 1 4 2 1

output

YES
NO
YES
NO
YES
YES

Note

For the first test case, the initial array $a$ is already equal to $[1]$, so the answer is “YES”.

For the second test case, performing any amount of operations will change $a$ to an array of size at least two which doesn’t only have the element $2$, thus obtaining the array $[2]$ is impossible and the answer is “NO”.

For the third test case, we can perform the following operations in order to obtain the final given array $c$:

• Initially, $a=[1]$.
• By choosing the subsequence $[1]$, and inserting $1$ in the array, $a$ changes to $[1,1]$.
• By choosing the subsequence $[1,1]$, and inserting $1+1=2$ in the middle of the array, $a$ changes to $[1,2,1]$.
• By choosing the subsequence $[1,2]$, and inserting $1+2=3$ after the first $1$ of the array, $a$ changes to $[1,3,2,1]$.
• By choosing the subsequence $[1,3,1]$ and inserting $1+3+1=5$ at the beginning of the array, $a$ changes to $[5,1,3,2,1]$ (which is the array we needed to obtain).

Topic to the effect

answer

One
<<<<<Thoughts

Let's first talk about the orthodox problem solution, using the method of mathematical conclusions, we know that this number starts from 1, and the special judgment is 1, and the subsequent numbers are all part of the previous number. We only know that it has at least two 1s and one 2 , 1, 2, 3, 4 can be represented, and it is not easy to represent 8 when we take the largest value. . . Mathematical induction finally shows that the maximum value in this array can always be established as long as it does not exceed the sum

<<<<<<代码

    #include <iostream>
    #include <algorithm> 
    using namespace std ;
     
    const int N = 200010 ;
     
    void work() 
    {
    
    	int q[N] ;
    	int n ;
    	cin >> n ;
    	for(int i = 0 ; i < n ; i ++ )
    		cin >> q[i] ;
    	sort (q, q + n) ;
    	if(q[0] != 1) 
    	{
    
    
    		cout << "NO" << endl ;
    		return ;
    	}
    	long long  sum = 1 ;
    	for(int i = 1 ; i < n ; i ++  )
    	{
    
    
     
    		if(sum < q[i])
    		{
    
    
    			
    			cout <<"NO" << endl ;
    			return ;
    		}
    		sum = sum + q[i] ;
    	}
    	cout << "YES" <<endl ;
    	return ;
    	
     
    }
     
    int main ()
    {
    
    
    	int T ;
    	cin >> T ;
    	while ( T -- )
    	{
    
    
    		work() ;
    	}
    	return 0 ;
    }

<<<<< The above idea is the positive solution to the problem, but here is another idea that can solve similar problems, but the idea is different and the time is longer.
2
The solution to this problem is designed to the data structure bitset , please see for details. But this is not the correct answer. I know TLE in G2, but if I understand this data structure, I can directly A G1 when the rules are not summarized.

#include <iostream>
#include <bitset>
#include <algorithm>
using namespace std ;
const int N = 6000 ; 

bitset <N> b ;
int q[N] ;
void work() 
{
    
    
	int n ;
	cin >> n ;
	for(int i = 0 ; i < n ;  i++ )
	{
    
    
		cin >> q[i] ;
	}	
	sort(q , q + n ) ;
	if( q[0] != 1 )
	{
    
    
		cout << "NO" << endl ;
		return ;
	}
	int sum = 1 ;
	for(int i = 1 ; i < n ; i ++ )
	{
    
    
		if(sum < q[i])
		{
    
    
			cout << "NO" << endl ;
			return ;
		}
		sum += q[i] ;
	}
	cout << "YES" << endl ;
	return ;

}

int main () 
{
    
    
	int n ;
	cin >>  n ;
	while ( n -- )
	{
    
    
		work() ;
	}
	return 0 ;
}