2018.4.3 遇到一個很有意思的題目

題目：遞增三元組

給定三個整數陣列 
A = [A1, A2, … AN], 
B = [B1, B2, … BN], 
C = [C1, C2, … CN]， 
請你統計有多少個三元組(i, j, k) 滿足： 
1. 1 <= i, j, k <= N 
2. Ai < Bj < Ck

【輸入格式】 
第一行包含一個整數N。 
第二行包含N個整數A1, A2, … AN。 
第三行包含N個整數B1, B2, … BN。 
第四行包含N個整數C1, C2, … CN。

對於30%的資料，1 <= N <= 100 
對於60%的資料，1 <= N <= 1000 
對於100%的資料，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

【輸出格式】 
一個整數表示答案

【樣例輸入】 
3 
1 1 1 
2 2 2 
3 3 3

【樣例輸出】 
27

因為是 100000 的資料，如果暴力三重 for 迴圈只能過 30% 

O( N ) 的做法（1）

可以利用字首和，也就是類似於桶排序的標記法，每次出現一個元素，就在這個元素的桶上做標記，例如

2 4 7 8 9 2

那麼形成的桶就是 

1 2 3 4 5 6 7 8 9

0 2 0 1 0 0 1 1 1

很明顯就是統計每一個出現的元素的次數

然後，問小於 5 的數有多少個 ？

不就是 2 個 2 ， 1 個 4 嗎，恰好 3 個數 < 5 

問小於 6 的數有多少 ？

2 + 1 = 3 個

用字首和的思想看這些桶

1 2 3 4 5 6 7 8 9

0 2 2 3 3 3 4 5 6

問，多少個數 < 5 

就是 5-1 = 4 ，小於等於 4 的數有 3 個，也就是 小於 5 的數有 3 個

同理，字尾和

這道題目，可以先看 B 行，對B行每一個元素， pre[ B[i]-1 ] 這個地方就是A 行中有多少個比 B[i] 小的, Net[ B[i]+1 ] 就是C行中有多少個比 B[i] 大的。

很奇妙，複雜度 O( N ) 

#include <bits/stdc++.h>
using namespace std ;
#define rep( i , j , n ) for ( int i = int(j) ; i <= int(n) ; ++i )
#define dew( i , j , n ) for ( int i = int(n-1) ; i >= int(j) ; --i )
const int N = 1e6 + 7 ;
int A[N] , B[N] , C[N] ;
int pre[N] , Net[N] ;

int main () {
	    int n ;
        while ( ~scanf ( "%d" , &n ) ) {

    	memset ( pre , 0 , sizeof ( pre ) ) ;
    	memset ( Net , 0 , sizeof ( Net ) ) ;

		rep ( i , 1 , n )  scanf ( "%d" , &A[i] ) , ++pre[ A[i] ] ;
		rep ( i , 1 , n )  scanf ( "%d" , &B[i] ) ;
		rep ( i , 1 , n )  scanf ( "%d" , &C[i] ) , ++Net[ C[i] ] ;
		
		rep ( i , 1 , *max_element ( A + 1 , A + n + 1 ) )  
			pre[i] += pre[i-1] ;
		dew ( i , 1 , *max_element ( C + 1 , C + n + 1 ) )
			Net[i] += Net[i+1] ;

		long long ans = 0 ;
		rep ( i , 1 , n )  
		    ans += pre[ B[i] - 1 ] * Net[ B[i] + 1 ] ;
		cout << ans << endl ;
    }
    return 0 ;
}
 

時間複雜度 O (N) ,不過會受到資料大小的限制，因為，如果資料可以是 long long , 或者說 10000000000 這樣的數字，是開不出 pre , Net 陣列的。

O( N ) 的做法（2）

還有一種 O(N) 的解法。

和上面的類似。不過這裡是直接利用桶排序，因為資料 < 100000, 用桶排序複雜度穩穩的 O(N)。

對 A ， B ， C 排序之後

同樣是以 B 行為出發點，在 A 行設定一個指標（不一定是指標，某個遞增量即可），在 C 行也設定一個指標，對 B 的每一個元素，比較 A ， C 當前指標處的值，移動到適當位置，使得A指標以前的都比 B[i] 小，C指標以後的值都比 B[i] 大，既然分好區了，那就直接區間長度相乘。

因為最多就是訪問完三個陣列，複雜度 3N，也就是 O( N ) 。

#include <bits/stdc++.h>
using namespace std ;
#define rep( i , j , n ) for ( int i = int(j) ; i <= int(n) ; ++i )
#define dew( i , j , n ) for ( int i = int(n-1) ; i >= int(j) ; --i )
const int N = 1e6 + 7 ;
const int M = 1e5 + 7 ;
int A[N] , B[N] , C[N] ;
int n , A_cnt , C_cnt ;
int book[M] ; ;

void Bucket_sort ( int *a , int n ) {   // 桶排序, 資料不大的情況, 複雜度 O(N)
	int top = 0 ;
	int max_one = *max_element ( a + 1 , a + n + 1 ) ;
	int min_one = *min_element ( a + 1 , a + n + 1 ) ;
	memset ( book , 0 , sizeof ( book ) ) ;
	rep ( i , 1 , n ) ++book[ a[i] ] ;
	rep ( i , min_one , max_one )     
	    rep ( j , 1 , book[i] )      // 看 i 這個數出現了多少次
			a[++top] = i ;           // 出現過的數字直接放進原陣列
}

int main () {
    while ( ~scanf ( "%d" , &n ) ) {
    	rep ( i , 1 , n )  scanf ( "%d" , &A[i] ) ;
		rep ( i , 1 , n )  scanf ( "%d" , &B[i] ) ;
		rep ( i , 1 , n )  scanf ( "%d" , &C[i] ) ;

		Bucket_sort ( A , n ) ;
		Bucket_sort ( B , n ) ;
		Bucket_sort ( C , n ) ;

        long long ans = 0 ;
        A_cnt = C_cnt = 1 ;
		rep ( i , 1 , n )  {
			while ( A_cnt < n && A[A_cnt] < B[i] )  ++A_cnt ;
			while ( C_cnt < n && C[C_cnt] <= B[i] ) ++C_cnt ;
		    int less = B[i] > A[n] ? n : A_cnt - 1 ;
		    int more = B[i] > C[n] ? 0 : n + 1 - C_cnt ;
		    ans += less * more ;
		}
		cout << ans << endl ; 
    }
	return 0 ;
}

O ( N log N ) 解法

從 B 行開始，每一個元素，在 A 行二分搜尋找到最後一個小於自己的數的位置

在 C行二分搜尋第一個大於自己的數的位置

根據 Ai < Bj < Ck 

複雜度 O( N log N ) 

#include <bits/stdc++.h>
using namespace std ;
#define rep( i , j , n ) for ( int i = int(j) ; i <= int(n) ; ++i )
#define dew( i , j , n ) for ( int i = int(n-1) ; i >= int(j) ; --i )
const int N = 1e6 + 7 ;
int A[N] , B[N] , C[N] ;
int n ;

int Binary_less ( int *a , int len , int key ) {
	int l = 1 , r = len ;
	while ( l <= r ) {
		int mid = ( l + r ) >> 1 ;
		if ( key <= a[mid] )
			r = mid - 1 ;
		else
			l = mid + 1 ;
	}
	return r ;
}

int Binary_more ( int *a , int len , int key ) {
	int l = 1 , r = len ;
	while ( l <= r ) {
		int mid = ( l + r ) >> 1 ;
		if ( key < a[mid] )
			r = mid - 1 ;
		else
			l = mid + 1 ;
	}
	return l ;
}

int main () {
    while ( ~scanf ( "%d" , &n ) ) {
    	rep ( i , 1 , n )  scanf ( "%d" , &A[i] ) ;
		rep ( i , 1 , n )  scanf ( "%d" , &B[i] ) ;
		rep ( i , 1 , n )  scanf ( "%d" , &C[i] ) ;

		sort ( A+1 , A+n+1 ) ;
		sort ( C+1 , C+n+1 ) ;

        long long ans = 0 ;
		rep ( i , 1 , n )  {
			int less = Binary_less ( A , n , B[i] ) ;
			int more = n + 1 - Binary_more ( C , n , B[i] ) ;
			ans += less * more ;
		}
		cout << ans << endl ;
    }
	return 0 ;
}

和三重迴圈相比，O ( N ) 和 O( N logN ) 的演算法，很重要的一點就是，從第二行出發，然後在第一行找更小的，在第三行找更大的，這樣降了一級的複雜度。