【洛谷】 3264 [JLOI2015] 管道连接

最新推荐文章于 2021-04-11 16:02:27 发布

原创最新推荐文章于 2021-04-11 16:02:27 发布 · 487 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#斯坦纳树 #dp

dp 同时被 2 个专栏收录

18 篇文章

订阅专栏

斯坦纳树

2 篇文章

订阅专栏

本文探讨了一种基于斯坦纳树的问题变体，通过引入频率的概念来优化连通性问题。文章详细解释了如何利用二次DP算法求解，并提供了完整的代码实现。

前言：

如果还不知道斯坦纳树的童鞋可以看这两篇博客：

我的： Mine

我一开始学习的： Which I Have Studied

这道题，在我学习斯坦纳树之前就翻到了，是在洛谷上搜状压的时候看到的。那个时候还不知道斯坦纳树是个什么玩意，不过马上进行了学习。

然而学习了之后也没有什么卵用，发现并不只是斯坦纳树这么简单呐！

题解：

由于存在相同频率之间的连通，所以和一般的斯坦纳树是不同的（发现斯坦纳树所指定的结点频率是相同的），需要二次DP。

首先跑一遍斯坦纳树的板子，这就求出了以某一个结点为树根并加入一些边使某几个点连通的最小值，那么我们可以用这个去更新另一个 DP 数组：Ans（S）。

方程：Ans（S）= minx（Ans（S），dp（i，S））；

定义 DP 数组 Ans （S），表示使状态 S 中所有点连通的最小费用，注意，这个 DP 的过程是有条件的：

首先枚举 S 集合（指定点集合），这个将这个状态 S 进行更新的条件是 S 必须：对于一个频率，要么包含该频率中的所有指定点，要么不包含于这个频率的任意结点！

接着枚举 S 的子集，这个子集 S1 也是要有条件的，也是 必须：对于一个频率，要么包含该频率中的所有指定点，要么不包含于这个频率的任意结点！

得到DP方程：Ans（S） = min（Ans（S），Ans（S1）+Ans（S^S1））；

这样最后的答案就是 Ans（1<<（p）-1）；

为什么要这样做呢？这样做不是和斯坦纳树中的 dp（i，S）数组重复了吗？

然而却有很大的区别，这样的 Ans（S）是使得 S 中相同的频率连通，而不是 S 中的所有点都连通！因为用于更新 S 的子集也满足这个条件，而子集和 子集对于 S 的补集没有联系，换句话说，两个子集内结点的连通互补干涉。

而加上频率的限制：

可以看出我们完全不用连边 2-5，因为这条边不改变相同频率的连通性！

所以带条件 Ans（S）经过DP更新后一定是最优解，并且保证没有额外边。

代码：

#include <bits/stdc++.h>

std :: queue < int >  q ;

const  int  N = 2000 + 5 ;

struct  node {
    int  id , clr ;
}
dot [ 20 ] ;

int  head [ N << 3 ] , nxt [ N << 3 ] , dis [ N << 3 ] , to [ N << 3 ] , cn ;
int  dp [ N ] [ 1 << 11 ] , ans [ 1 << 11 ] , cnt [ 30 ] , sum [ 30 ] , n , m , p , S , x , y , w , inf ;
bool  vis [ N ] , ck [ 1 << 11 ] ;

int  minx ( int  a , int  b ) {
    return  a > b ? b : a ;
}

void  create ( int  u , int  v , int  d ) {
    cn ++ ;
    to [ cn ] = v ;
    dis [ cn ] = d ;
    nxt [ cn ] = head [ u ] ;
    head [ u ] = cn ;
}

void  spfa ( int  S ) {
    for ( int  i = 1 ; i <= n ; i ++ )
        if ( dp [ i ] [ S ] < inf )
            vis [ i ] = true , q . push ( i ) ;
    while ( ! q . empty ( ) ) {
        int  v , tmp = q . front ( ) ;
        q . pop ( ) ; vis [ tmp ] = false ;
        for ( int  i = head [ tmp ] ; i ; i = nxt [ i ] ) {
            v = to [ i ] ;
            if ( dp [ v ] [ S ] > dp [ tmp ] [ S ] + dis [ i ] ) {
                dp [ v ] [ S ] = dp [ tmp ] [ S ] + dis [ i ] ;
                if ( ! vis [ v ] ) {
                    vis [ v ] = true ;
                    q . push ( v ) ;
                }
            }
        }
  	}
}

bool  check ( int  S ) {
    memset ( cnt , 0 , sizeof ( cnt ) ) ;
    for ( int  i = 1 ; i <= p ; i ++ )
        if ( S & ( 1 << ( i - 1 ) ) )
            cnt [ dot [ i ] . clr ] ++ ;
    for ( int  i = 1 ; i <= 10 ; i ++ )
        if ( cnt [ i ]  &&  cnt [ i ]  !=  sum [ i ] )
            return  0 ;
    return  1 ;
}
 
int  main ( ) {
    
    scanf ( "%d%d%d" , & n , & m , & p ) ;
    memset ( dp , 127 / 3 , sizeof ( dp ) ) ;
    inf = dp [ 0 ] [ 0 ] ;
    S = ( 1 << p ) - 1 ;
    for ( int  i = 1 ; i <= m ; i ++ ) {
        scanf ( "%d%d%d" , & x , & y , & w ) ;
        create ( x , y , w ) ;
        create ( y , x , w ) ;
    }
    for ( int  i = 1 ; i <= p ; i ++ ) {
        scanf ( "%d%d" , & dot [ i ] . clr , & dot [ i ] . id ) ;
        sum [ dot [ i ] . clr ] ++ ;
    }
    for ( int  i = 1 ; i <= p ; i ++ )
        dp [ dot [ i ] . id ] [ 1 << ( i - 1 ) ] = 0 ; 
    for ( int  s = 0 ; s <= S ; s ++ ) {
    	for ( int  i = 1 ; i <= n ; i ++ )
        	for ( int  s1 = s ; s1 ; s1 = ( s1 - 1 ) & s )
                dp [ i ] [ s ] = minx ( dp [ i ] [ s ] , dp [ i ] [ s1 ] + dp [ i ] [ s ^ s1 ] ) ;
        spfa ( s ) ;
    }
    memset ( ans , 127 / 3 , sizeof ( ans ) ) ;
    for ( int  s = 0 ; s <= S ; s ++ )
        for ( int  i = 1 ; i <= n ; i ++ )
            ans [ s ] = minx ( ans [ s ] , dp [ i ] [ s ] ) ;
    for ( int  s1 = 0 ; s1 <= S ; s1 ++ )
        if ( check ( s1 ) )
            ck [ s1 ] = true ;
    for ( int  s = 0 ; s <= S ; s ++ )
        if ( ck [ s ] ) 
            for ( int  s1 = s ; s1 ; s1 = ( s1 - 1 ) & s )
                if ( ck [ s1 ] )
                    ans [ s ] = minx ( ans [ s ] , ans [ s1 ] + ans [ s ^ s1 ] ) ;
    printf ( "%d" , ans [ S ] ) ;
    return  0 ;
}

要开O2，因为STL队列很慢。