[] 크루스 칼 최소 스패닝 트리 꼼꼼한 템플릿 템플릿

크루스 칼

#INCLUDE <비트 / stdc ++ H.>
 사용  스페이스 성병;
CONST  INT 맥스 = 0x3f3f3f3f ;
CONST  INT maxn = 10000 ;
구조체 노드 
{ 
    int로 U, V, L;
    부울  연산자 <( CONST 노드 a) CONST 
    { 
        복귀 L < 알루미늄; 
    } 
} 에지 [maxn]; 
INT의 아버지 [maxn];
INT NODENUM, edgenum;
무효화 INIT를 () 
{ 
    위해 ( int로 I = 0 ; I <NODENUM; I ++  )
    {
        아버지 [I] = I; 
    } 
} 
의 INT (존재 의 INT (X)) 
{ 
    경우 (X == 아버지 [X]) 복귀 X;
    반환 [X] = 아버지 찾기 (아버지 [X]); 
} 
공극 연합 ( INT의 X, INT의 Y) 
{ 
    INT temp_x = 찾기 (X);
    INT temp_y = 찾기 (Y);
    경우 (이 temp_x =! temp_y) 
    { 
        아버지 [temp_x] = temp_y; 
    } 
} 
INT 크루스 칼 ()  
{
    정렬 (에지, 에지 + edgenum); 
    초기화 (); 
    이제 노드; 
    INT ANS = 0 ;
    위한 ( int로 I = 0 ; I는 <edgenum; 내가 ++ ) 
    { 
        지금 = 에지 [I];
        경우 () (now.u 찾기! = 찾기 (now.v)) 
        { 
            연합 (now.u, now.v); 
            ANS + = 드릴수; 
        } 
    } 
    반환 ANS; 
} 
INT 의 main () 
{ 
    동안 (는 scanf ( " %의 D % d에 " , edgenum, NODENUM) && edgenum) 
    { 
        대 (int로 I = 0 ; I <edgenum; ++ I) 
        { 
            는 scanf ( " % D % D % D " , 에지 [I] .u, 에지 [I] .V, 에지 [I] 펜닐); 
        } 
        INT ANS = 크루스 칼 ();
        부울 플래그 = 0 ;
        위한 ( int로 I = 2 ; I <= NODENUM; 내가 ++ ) 
        { 
            경우 (찾기 ( 1 )! = 찾기 (I)) 
            { 
                플래그 = 1 ;
                휴식 ; 
            }
        } 
         (플래그)만약
        { 
            COUT << " ? " << " \ n을 ' ; 
        } 
        다른 
        { 
            COUT << ANS << ' \ 않음을 ' ; 
        } 
    } 
    반환  0 ; 
}

꼼꼼한

#INCLUDE <비트 / stdc ++ H.>
 #DEFINE의 INF 0x7f7f7f7f
 사용  스페이스 성병;
INT의 MP [ 150 ] [ 150 ];
int로 DIS [ 150 ];
INT 힘 [ 150 ];
INT NODENUM, edgenum;
INT 프림 ( INT의 SRC) 
{ 
    위해 ( int로 I = 1 ; I <= NODENUM; 내가 ++ ) 
    { 
        DIS [I] = MP [SRC] [I]; 
    } 
    INT의 합 = 0 ; 
    힘 [SRC] = 1 ;
    DIS [SRC] = 0 ;
    위한 ( int로 I = 2 ; I <= NODENUM; I ++ ) 
    { 
        INT의 POS = - 1 ;
        int로 MIN = INF 단계;
        대 ( INT의 J = 1 ; J <= NODENUM, J ++ ) 
        { 
            경우 (DIS [J] <MIN &&! 힘 [J]) 
            { 
                POS = J; 
                MIN = DIS [J] 
            } 
        } 
        경우 (포스 == - 1 ) 
        { 
            창- 1 ; 
        } 
        합 + = MIN; 
        힘 [POS는] = 1 ;
        대 ( INT의 J = 1 ; J <= NODENUM, J ++ ) 
        { 
            경우 (힘 [J] && DIS [J]!> MP [POS] [J]) 
            { 
                DIS [J] = MP [POS] [J]; 
            } 
        } 
    } 
    리턴 합; 
} 
INT 의 main () 
{ 
    int로 A, B, C를;
    반면 (는 scanf ( " %의 D % d에 " , edgenum, NODENUM) &&edgenum) 
    { 
        memset 함수 (MP, INF, 는 sizeof (MP)); 
        memset 함수 (DIS, INF, 는 sizeof (DIS)); 
        memset 함수 (힘, 0 , 는 sizeof (힘));
        위한 ( int로 I = 0 ; I는 <edgenum 난 ++ ) 
        { 
            는 scanf ( " % D % D % D ' , A, 및 B, 및 C)를; 
            MP는 [A]는 [B] = min의 MP ([A], [B, C)를 
            MP [B] [A] = 분 (MP [A] [B], c); 
        } 
        INT ANS = 프림 ( 1 );
        경우 (ANS == -1 ) 
        { 
            COUT << " ? " << " \ n을 ' ; 
        } 
        다른 
        { 
            COUT << ANS << ' \ 않음을 ' ; 
        } 
    } 
}