LeetCode 1057キャンパスバイク

貪欲最短距離に応じて直接的に行います。

プライオリティキューと、C ++より少ない<タイプ>まず大きいので、我々は<シンボル、論理その逆をオーバーライドすることができます。

クラスのソリューション{
 パブリック：
     構造体dist_pair {
         int型のDIST。
        int型の労働者。
        int型の自転車。
        ブール 演算子 <（CONST dist_pair＆A）のconst {
             場合（DIST = a.dist！）戻り DIST> a.dist。
            それ以外 の場合（労働者= a.worker！）戻り労働者> a.worker。
            戻る自転車> a.bikeを。
        } 
    }。
    
    ベクトル < int型> assignBikes（ベクトル<ベクトル< INT >>＆労働者、ベクトル<ベクトル< INT >>＆バイク）{ 
        PRIORITY_QUEUE <dist_pair> Q。
        用（int型 iは= 0 ; iが（workers.sizeを<）++ {i）が
             ため（INT J = 0 ; J <bikes.size（）; ++ J）{
                 int型、D = ABS（研究者[I] [ 0 ] -バイク[J] [ 0 ]）+ ABS（研究者[I] [ 1 ] -バイク[J] [ 1 ]）。
                q.push（{D、I、J}）。    
            } 
        } 
        
        ベクトル< 整数 >（workers.size（）、 -割り当てる1 ）。
        ベクター < BOOL > visitedBike（bikes.size（）、偽）。
        一方、（！q.empty（））{ 
            オート[D、I、J] = q.top（）。q.pop（）;
            場合 - （割り当てる[I] == 1 && visitedBike [J] == 偽{）
                visitedBike [j]は = 真。
                [i]が割り当て = J。
            }    
        } 
        戻り割り当てます。
    } 
}。

 

第二は、スペースの複雑さを保存し、構造なしで書かれていますが、それぞれの時間CMPはdistのを計算することが、時間が倍になります。

ここでは、ラムダ目的球を使用して、ラムダでPRIORITY_QUEUEの言葉遣いに注意を払っています。

クラス解決{
 パブリック：
    ベクトル < INT > assignBikes（ベクトル<ベクトル< INT >>＆労働者、ベクトル<ベクトル< INT >>＆バイク）{ 
        オートCMP = [b]（CONST対< INT、INT >＆、CONST対< INT、INT >＆B）{
             int型 dist_a = DIST（a.first、a.second、労働者、自転車）
            int型 dist_b = DIST（b.first、b.second、労働者、バイク）;
            もし（dist_a！= dist_b）リターン dist_a>dist_b;
            もし（！a.first = b.first）リターン > a.first b.first。
            返す a.second> b.second。
        }。
        PRIORITY_QUEUE <ペア< 整数、整数 >、ベクトル<ペア< INT、INT >>、decltype（CMP）> Q（CMP）。
        
        以下のために（int型 i = 0 ; iがworkers.sizeを（）<; ++ I）
             のために（int型 J = 0 ; J <bikes.size（）; ++ j）は
                q.push（{I、J}）。
        
        ベクトル < int型>割り当て（workers.size（） - 1 ）。
        ベクター < BOOL > visitedBike（bikes.size（）、偽）。
        一方、（！q.empty（））{ 
            オート[I、J] = q.top（）。q.pop（）;
            場合 - （割り当てる[I] == 1 && visitedBike [J] == 偽{）
                visitedBike [j]は = 真。
                [i]が割り当て = J。
            } 
        } 
        戻り割り当てます。
    } 
    
    int型の DIST（int型 Iを、INTJ、ベクトル<ベクトル< INT >>＆労働者、ベクトル<ベクトル< INT >>＆バイク）{
         戻り ABS（研究者[I] [ 0 ] -bikes [j] [ 0 ]）+ ABS（研究者[I] [ 1 ] [J] [-bikes 1 ]）。
    } 
}。

時間の複雑さ：mnlog（MN）、ペアのためmnをそこにしているため。