3つの数字が0のすべての組み合わせの配列を見つける[配列] LEETCODE15アルゴリズム

// 溶液アレイをマッピングするnは、0、P 9（0,0,0）を見て3つのグループ、（N、に分割される 0、P）（N、N、P） 及び（P、P、N）の組み合わせが、繰り返されないため、そして2つのそんなにトラブルの最終的に組み合わせ、複雑さはO（N ^ 2）で、一度通過し、最後の2 TLEケース
クラスのソリューション{
 パブリック：
    ベクトル <ベクトル< int型 >> threeSum（ベクトル< INT >＆NUMS）{ 
        地図 < int型、int型 > NE; 
        地図 < int型、int型 > PO;
         int型の NNE = 0、NPO = 0、ZERO = 0 ; 
        ベクトル <ベクトル< int型 >> 答え;
         のため（int型 = Iを0 ; iは<nums.sizeを（）; iは++ ）{
             場合（NUMS [i]が> 0 ）{ 
                PO [NUMS [I]] ++ ; 
                NPO ++ ; 
            } 
            そう であれば（NUMS [I] < 0 ）{ 
                NE [NUMS [I]] ++ ; 
                NNE ++ ; 
            } 
            他のゼロ++ ; 
        } 
        であれば（ゼロ> = 3 ）{ 
            ベクトル < INT > V。
            v.push_back（0 ）。
            v.push_back（0 ）。
            v.push_back（0 ）。
            answer.push_back（V）; 
        } 
        であれば（NNE && NPO）{
             もし{（ゼロ）
                 のための（マップ< 整数、整数 > ::それはne.begin（）=イテレータ、それ= ne.end（）;！それ++ ）{
                     場合（PO [-it- > 最初]）{ 
                        ベクトル < INT > V。
                        v.push_back（それ - > 最初の）; 
                        v.push_back（0 ）。
                        v.push_back（ -it-> 第一）; 
                        answer.push_back（V）; 
                    } 
                    他 po.erase（-it-> 第一）; 
                } 
            } 
            もし（NNE> = 2 ）{
                 ため（マップ< INT、INT > ::イテレータI = ne.begin（）; I = ne.end（）; I ++は！）{
                     ため（マップ< INT、INT > ：イテレータJ = J = ne.end（）; J ++ ）{
                         場合（I->第== J =>第&& I->第二< 2）続行;
                        他{
                             INT左= - （（I->第一）+（J-> 最初））;
                            もし（PO [左]）{ 
                                ベクトル < INT > V。
                                v.push_back（I - > 最初の）; 
                                v.push_back（J - > 最初の）; 
                                v.push_back（左）。
                                answer.push_back（V）; 
                            } 
                            他po.erase（左）。
                        } 
                    } 
                } 
            }
            もし（NPO> = 2 ）{
                 のために（マップ< int型、int型 > ::イテレータ私= po.begin（）;！私= po.end（）;私は++ ）{
                     のために（マップ< int型、int型 > ::イテレータJ = J = po.end（）;！J ++ ）{
                         場合（I->第== J =>第&& I->第二< 2）続けます。
                        他{
                             INT =左- （I->第一+ J-> 第一）;
                            もし V。（NE [左]）{
                                ベクター < INT > 
                                v.push_back（I - > 最初の）; 
                                v.push_back（J - > 最初の）; 
                                v.push_back（左）。
                                answer.push_back（V）; 
                            } 
                            他ne.erase（左）。
                        } 
                    } 
                } 
            } 
        } 

        リターンの答え。
    } 
}。

// 番号を持っているそれぞれの方法2は、他の2つの予選の数を探します。配列のソート、あなたは他の2つの数のすべての組み合わせの列挙を避けるために、思考の二分法を使用することができます。O（nlogn）、O（N ^ 2）について横断後者のソート、
しかし一定の係数であり、マップは、コストされていない

クラスソリューション{
 パブリック：
    ベクトル <ベクトル< INT >> threeSum（ベクトル< INT >＆NUMS） { 
        ソート（nums.begin（）、nums.end（））; 
        ベクトル <ベクトル< INT >> 結果、
         ため（int型 I = 0 ;私は（nums.sizeを<）; Iは++ ）{
             IF >（NUMS [I] 0）BREAK ;
             IF（I> 0 && NUMS [I] == NUMS [I-1 ]）続けます。
            INT左= I + 1、右= nums.size（） - 1 ;
            一方（<左右）{
                 int型の和= NUMS [左] + NUMS [右] + [I] NUMS。
                もし（合計> 0 ）{ 
                    右 - 。
                } 
                他の 場合（和は、< 0 ）{ 
                    左 ++ 。
                } 
                他{ 
                    result.push_back（{NUMS [i]は、NUMS [左]、NUMS [右]}）。
                    int型リットル=NUMS [左]。
                    INT R = NUMS [右]。
                    一方（左<右&& NUMS [左] == lは）++左。
                    一方（右>左&&のNUMS [右] == R）right-- 。
                } 
            } 
        } 
        戻り値の結果; 
    } 
}。