동동 비행

주제 연결 : https://ac.nowcoder.com/acm/contest/904/D

　　절반 가격의 제한된 수의, 각각의 경우에, 그래서 모든 일, DP를 작성해야하기 때문에 운동의 유형에 대한 첫 번째 연구는, 그것을 이해하기 매우 쉽습니다 [위치]를 [번호] [도착 DP에 밀려 위치 [배] 및 DP [두 경우] + 1 [참조] 위치에 도달 한 다음에 최단 실행을 클릭

　　AC 코드 :

#INCLUDE <비트 / stdc ++ H.>
 사용  스페이스 성병; 
타입 정의 긴  긴 LL; 
타입 정의 구조체 W_W {
     INT의 eend;
    int로 무게를;
    INT 다음; 
미아오}; 
타입 정의 구조체 W_w {
     INT의 eend;
    INT의 CI; 
왕}; 
미네소타 (LL A, B의 LL) LL { 
    경우 의 (A <B) 복귀 단계;
    반환 B 단계; 
} 
미아오 X [ 100010 ];
INT의 헤드 [ 100010 ]; 
게요 DP [ 100010[ 15 ];
INT 힘 [ 100010 ] [ 15 ];
INT CNT = 0 ;
보이드 추가 ( int로 A, INT의 B, INT의 C)을 { 
    X [CNT] .eend = B; 
    X [CNT] .weight = C; 
    X [CNT] 다음 내용 = 헤드 [A]; 
    헤드 [A] = CNT ++ ; 
} 
LL의 spfa ( INT의 시작 의 INT eend, INT의 K) { 
    큐 <왕> Q1; 
    q1.push ({ 1 , 0}); 
    DP [ 1 ] [ 0 ] = 0 ;
    반면 (q1.size ()) {
         INT의 댕 = . q1.front () eend;
        INT CI = q1.front () CI.;
        // 의 printf ( "+++ % D % D % LLD \ n", 댕, CI, DP [댕 [CI]); 
        q1.pop (); 
        힘 [댕 [CI] = 0 ;
        위한 ( int로 댕] I = 헤드; 나는 =! - 1 ]의 I = X [i]는 다음 내용) {
             INT = 행의 X [I] .eend;
            경우 (DP [을] [CI] == - 1 ) { 
                [을] DP [CI]DP = [댕 [CI] + X [I] .weight;
                경우 (힘 [을] [CI] == 0 ) { 
                    q1.push ({}로 CI); 
                    힘 [을] [CI] = 1 ; 
                } 
            } 
            또 {
                 경우 (DP [을] [CI]> DP [댕 [CI] + X [I] .weight) { 
                    DP [CI]가 [회] DP를 = 댕 [CI] + X [i]를 .무게;
                    경우 (힘 [을] [CI] == 0 ) { 
                        q1.push ({}로 CI); 
                        힘 [을] [CI] = 1 ; 
                    }
                } 
            }
            경우 (Cl + 1 <= K) {
                 경우 (DP [을] [CI + 1 ] == - 1 ) { 
                    DP [발] [CI + 1 ]은 DP가 = [댕 [CI] + X [I] .weight / 2 ;
                    경우 (힘 [을] [CI + 1 ] == 0 ) { 
                        q1.push ({행, CI + 1 }); 
                        힘 [을] [CI + 1 ] = 1 ; 
                    } 
                } 
                또 {
                     경우 1(DP [을] [CI + ]> DP [댕 [CI] + X [I] .weight / 2 ) { 
                        DP [발] [CI + 1 ] = DP [댕 [CI] + X [I]. 중량 / 2 ;
                        경우 (힘 [을] [CI + 1 ] == 0 ) { 
                            q1.push ({행, CI + 1 }); 
                            힘 [을] [CI + 1 ] = 1 ; 
                        } 
                    } 
                } 
            } 
        } 
    } 
//     {위해 (; I <= eend 난 I ++ 1 = INT)
 //         대 (INT J = 0; J <= K, J ++) {
//             의 printf ( "(% d 개 %의 D) %의 LLD"I, J, DP [I] [J]);
//         }
 // 용         의 printf ( "\ n")를;
//     } 
    LL = ANS - 1 ;
    위한 ( int로 I = 0 ; i가 = K를 <; 내가 ++ ) {
        // 의 printf ( "+++ % LLD % D % D % LLD \ n", ANS, eend, I, DP [eend [I]); 
        경우 (DP [eend [I] =! - 1 ) {
             경우 (ANS == - 1 ) { 
                ANS = DP [eend [I]; 
            } 
            다른 { 
                ANS =미네소타 (DP [eend] [i]는, ANS); 
            }
        } 
    } 
    반환 ANS; 
} 
INT 의 main () 
{ 
    INT의 M, N, K; 
    scanf와 ( " % D % D % D " , m, N, K); 
    memset 함수 (머리 - 1 , 를 sizeof (헤드)); 
    memset 함수 (DP, - 1 , 를 sizeof (DP)); 
    memset 함수 (힘, 0 , 는 sizeof (힘));
    위한 ( int로 I = 0 ; I <N은, 난이 ++ ) {
         int로 를 B;
        INT의 C;
        scanf와 ( " % D % D % D ' , A, 및 B, 및 C); 
        추가 (A, B, C); 
    } 
    LL ANS = spfa ( 1 , m, k)를; 
    의 printf ( " % LLD \ 없음 " , ANS);
    반환  0 ; 
}