题目大意
给定
n
个排在数轴上的点对
Data Constraint
题解
对于一对点
(ai,bi)
显然将终点设在
ai+bi2
最优,所以先将所有点对按照
ai+bi2
排序,那么就能保证存在一种最优方案,可以将点对划分成
k
个连续区间,同一个区间内的点对都到同一个终点。
然后就可以设状态了
转移显然:
fi,j=min{fi−1,k+mincost(k+1,j)}
,
mincost(i,j)
表示第
i
对到第
注意到一个结论,对于一些点对,将终点设在所有点最中间的那个一定是一种最优解。
所以就可以用一个可持久化线段树来维护,每次在主席树上二分出一个最中间的点,然后计算即可。
时间复杂度: O(nklog2n)
SRC
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std ;
#define N 100000 + 10
typedef long long ll ;
const int MINV = -1e9 ;
const int MAXV = 1e9 ;
struct Segment {
int a , b ;
} Seg[N] ;
struct Tree {
int Son[2] ;
ll Sum ;
int Num ;
} T[40*N] ;
int Root[N] ;
ll f[2][N] , g[N] ;
int n , m , now , Cnt ;
ll retnum , retsum ;
bool cmp ( Segment x , Segment y ) { return x.a + x.b < y.a + y.b ; }
ll sabs( ll x ) { return x < 0 ? -x : x ; }
int Calc( int x ) {
int ret = x / 2 ;
if ( x < 0 && x % 2 != 0 ) ret -- ;
return ret ;
}
int NewNode( int last ) {
++ Cnt ;
T[Cnt] = T[last] ;
return Cnt ;
}
void Insert( int v , int l , int r , int x ) {
if ( l == r ) {
T[v].Sum += x ;
T[v].Num ++ ;
return ;
}
int mid = Calc( l + r ) ;
if ( x <= mid ) {
T[v].Son[0] = NewNode( T[v].Son[0] ) ;
Insert( T[v].Son[0] , l , mid , x ) ;
} else {
T[v].Son[1] = NewNode( T[v].Son[1] ) ;
Insert( T[v].Son[1] , mid + 1 , r , x ) ;
}
T[v].Sum = T[T[v].Son[0]].Sum + T[T[v].Son[1]].Sum ;
T[v].Num = T[T[v].Son[0]].Num + T[T[v].Son[1]].Num ;
}
int Search( int lv , int rv , int l , int r , int rank ) {
if ( l == r ) return l ;
int mid = Calc( l + r ) ;
int left = T[T[rv].Son[0]].Num - T[T[lv].Son[0]].Num ;
if ( left > rank ) return Search( T[lv].Son[0] , T[rv].Son[0] , l , mid , rank ) ;
return Search( T[lv].Son[1] , T[rv].Son[1] , mid + 1 , r , rank - left ) ;
}
void Find( int lv , int rv , int l , int r , int x , int y ) {
if ( T[rv].Num - T[lv].Num == 0 ) return ;
if ( l == x && r == y ) {
retnum += T[rv].Num - T[lv].Num ;
retsum += T[rv].Sum - T[lv].Sum ;
return ;
}
int mid = Calc( l + r ) ;
if ( y <= mid ) Find( T[lv].Son[0] , T[rv].Son[0] , l , mid , x , y ) ;
else if ( x > mid ) Find( T[lv].Son[1] , T[rv].Son[1] , mid + 1 , r , x , y ) ;
else {
Find( T[lv].Son[0] , T[rv].Son[0] , l , mid , x , mid ) ;
Find( T[lv].Son[1] , T[rv].Son[1] , mid + 1 , r , mid + 1 , y ) ;
}
}
ll Cost( int l , int r ) {
ll ret = 0 ;
int w = Search( Root[l-1] , Root[r] , MINV , MAXV , r - l + 1 ) ;
retnum = retsum = 0 ;
Find( Root[l-1] , Root[r] , MINV , MAXV , MINV , w - 1 ) ;
ret += retnum * w - retsum ;
retnum = retsum = 0 ;
Find( Root[l-1] , Root[r] , MINV , MAXV , w + 1 , MAXV ) ;
ret += retsum - retnum * w ;
return ret ;
}
void DIV( int l1 , int r1 , int l2 , int r2 ) {
if ( l1 > r1 ) return ;
int mid = (l1 + r1) >> 1 ;
g[mid] = 1e18 ;
int wz = 0 ;
for (int i = l2 ; i <= r2 ; i ++ ) {
if ( i > mid + 1 ) break ;
ll cost = Cost( i , mid ) ;
if ( f[now][i-1] + cost < g[mid] ) {
g[mid] = f[now][i-1] + cost ;
wz = i ;
}
}
if ( l1 == r1 ) return ;
DIV( l1 , mid - 1 , l2 , wz ) ;
DIV( mid + 1 , r1 , wz , r2 ) ;
}
int main() {
freopen( "shoes.in" , "r" , stdin ) ;
freopen( "shoes.out" , "w" , stdout ) ;
scanf( "%d%d" , &n , &m ) ;
for (int i = 1 ; i <= n ; i ++ ) {
scanf( "%d%d" , &Seg[i].a , &Seg[i].b ) ;
if ( Seg[i].a > Seg[i].b ) swap( Seg[i].a , Seg[i].b ) ;
}
sort( Seg + 1 , Seg + n + 1 , cmp ) ;
Root[0] = ++ Cnt ;
for (int i = 1 ; i <= n ; i ++ ) {
Root[i] = NewNode( Root[i-1] ) ;
Insert( Root[i] , MINV , MAXV , Seg[i].a ) ;
Insert( Root[i] , MINV , MAXV , Seg[i].b ) ;
}
memset( f , 63 , sizeof(f) ) ;
f[0][0] = 0 ;
Cost( 1 , 2 ) ;
for (int i = 1 ; i <= m ; i ++ ) {
DIV( 0 , n , 1 , n ) ;
for (int j = 0 ; j <= n ; j ++ ) f[!now][j] = g[j] ;
now ^= 1 ;
}
printf( "%lld\n" , f[now][n] ) ;
return 0 ;
}
以上.