Leetcode - W4,5

ツリー：

递归（110）：110。平衡2分木 https://leetcode.com/problems/balanced-binary-tree/description/

パブリックブール（ツリーノードのルート）{isBalanced 
         （ルート== NULL）がtrueを返す場合。
         IF（Math.abs（深さ（root.left）-depth（root.right））> 1）、falseを返します。
         isBalanced（root.left）&& isBalanced（root.right）を返します。
    } 
パブリックstatic int型深さ（ツリーノードのルート）{ 
       IF（ルート== NULL）戻り0; 
        Math.max（深さ（root.left）、深さ（root.right））+ 1を返します。
    }

レベル（513）トラバース：513 F INDツリー左下価値 https://leetcode.com/problems/find-bottom-left-tree-value/description/

クラスソリューション{ 
    INT MAXDEPTH = -1。
    int型の値= 0; 
    公共INT findBottomLeftValue（ツリーノードのルート）{ 
        INORDER（根、0）; 
        値を返します。
    } 
    
    公共ボイドINORDER（ツリーノードのルート、INT深さ）{ 
        （ルート== NULL）が{場合に
            返します。
        } 
        IF（MAXDEPTH <深さ）{ 
            MAXDEPTH =深度。
            値= root.val。
        }   
        INORDER（root.left、深さ+ 1）。
        INORDER（root.right、深さ+ 1）。
    } 
}

 

プリオーダートラバース（144）の後https://leetcode.com/problems/binary-tree-preorder-traversal/description/

一覧<整数>結果=新しいのArrayList <Integer型>（）; 
    公衆リスト<整数> preorderTraversal（ツリーノードのルート）{ 
        IF（ルート== NULL）戻り結果。
        （もし！ルート= null）のresult.add（root.val）。
        （もし！root.left = null）のpreorderTraversal（root.left）。
        （もし！root.right = null）のpreorderTraversal（root.right）。
        結果を返します。
    }

 

公衆リスト<整数> preorderTraversal（ツリーノードのルート）{ 
        リスト<整数>リスト=新規のArrayList <>（）; 
        もし（ルート== nullの）リターンリスト。
        スタック<のTreeNode>スタック=新しいスタック<>（）; 
        
        ツリーノードのノード=ルート。
        （！stack.empty（）||ノード= NULL）{しばらく
            するif（！ノード= NULL）{ 
                stack.push（ノード）。
                list.add（node.val）。
                ノード= node.left。
            } {他
                ノード= stack.pop（）。
                ノード= node.right。
            } 
        } 
        リストを返します。
    }

BST（230）：https://leetcode.com/problems/kth-smallest-element-in-a-bst/description/

公共INT kthSmallest（ツリーノードのルート、int型K）{ 
        スタックS =新しいスタック<>（）; 
        （！ルート= NULL || s.empty（））{一方
            ながら（！ルート= NULL）{ 
            s.add（ルート）。
            ルート= root.left。} 
        ルート=（ツリーノード）s.pop（）; 
        もし（--k == 0）ブレーク。
        ルート= root.right。
            } 
        戻りroot.val。
    }

 

INT、N = 0。
    公共INT kthSmallest（ツリーノードのルート、int型K）{ 
        .val DFS（ルート、k）を返します。
    } 
    
    プライベートツリーノードDFS（ツリーノードのルート、int型K）{ 
        IF（ルート== NULL）{ 
            戻りヌル。
        } 
        ツリーノードのノード= DFS（root.left、K）。
        （！ノード= null）のリターンノードであれば、
        N ++; 
        IF（N == K）{ 
            戻りルート。
        } 
        DFS（root.right、k）を返します。
    }

 

トライ（208）：https://leetcode.com/problems/implement-trie-prefix-tree/description/

 

図：

二分图（785）：785。グラフ二部のですか？ https://leetcode.com/problems/is-graph-bipartite/description/

パブリックブールisBipartite（INT [] []のグラフ）{ 
        int型R = graph.length。
        INT []色=新しいINT [R]。
        色[0] = 1; 
        {ため（; I <graph.length I ++は、I = 0 INT）
            のための（int型J = 0; J <グラフ[I] .LENGTH; J ++）{ 
                IF（色[グラフ[I] [J]] == 0 ）色[グラフ[I] [J] =〜色[I]。
                それ以外の場合（色[グラフ[I] [J]] ==色[i]）とfalseを返します。
            } 
        } 
        trueを返します。
    }

クラスのソリューション{ 
    
    プライベート列挙型カラー{ 
        NONE、BLUE、WHITE; 
    } 
    
    パブリックブールisBipartite（INT [] []グラフ）{ 
        地図<整数、カラー>マップ=新しいHashMapの<>（）; 
        
        以下のために（INT i = 0; I <graph.length; ++ I）map.put（I、Color.NONE）。
        
        {（; iがgraph.lengthを<++ I I = 0をINT）のための
            IF（map.get（I）== Color.NONE）{ 
                IF（！DFS（I、グラフ、地図、Color.BLUE））リターン偽; 
            } 
        } 
        
        trueを返します。
    } 
    
    プライベートブールDFS（INTルートは、INT [] []、グラフ、地図<整数、カラー>訪問、カラーdesiredColor）{ 
        IF（visited.get（ルート）！= Color.NONE）戻りvisited.get（ルート）== desiredColor;
        
        visited.put（根、desiredColor）。
        
        ブール二部=はtrue。
        用（INTエッジ：グラフ[ルート]）{ 
            二分＆= DFS（エッジ、グラフ、訪問、desiredColor == Color.BLUE Color.WHITE：Color.BLUE）。
        } 
        
        二部返します。
    } 
} 
//更通用的版本

 

トポロジカルソート（207）:.コース、207スケジュールhttps://leetcode.com/problems/course-schedule/description/

パブリックブールcanFinish（INT numCourses、INT [] []前提条件）{//找环、若存在、则条件不满足、カーンのアルゴリズム
        のint [] reqCnt =新しいINT [numCourses]。
        スタック<整数> ST =新しいスタック<>（）; 
        int型totalCountプロパティ= 0; 
        
        {ため（iは++; iはprerequisites.length <I = 0 INT）
            ++ reqCnt [I] [0]の前提条件[]。
        } 
        
        ため（INT i = 0; iはnumCoursesを<; iは++）{ 
            IF（reqCnt [I] == 0）{ 
                st.push（I）。
                totalCountプロパティ++; 
            } 
        } // ST存储的是入度为0的点
        
        （st.isEmpty（））の場合は
            falseを返します。
            
        （！st.isEmptyは（））{ながら 
            int型st.popヴァル=（）;
            のために（int型私= 0;私はprerequisites.lengthを<;私は++します）{
                IF（前提条件[I] [1] ==ヴァル）{ 
                    reqCnt [前提条件[I] [0]] - 。
                    IF（reqCnt [前提条件[I] [0]] == 0）{ 
                        st.push（前提条件[I] [0]）。
                        totalCountプロパティ++; 
                    } 
                } 
            } 
        } 
        
        （totalCountプロパティ== numCourses）であれば
            真を返します。
        falseを返します。
    }

 

并查集（684）：684。冗長接続 https://leetcode.com/problems/redundant-connection/description/

クラスソリューション{ 
    公共のint [] findRedundantConnection（INT [] []エッジ）{ 
        INT []父親=新しいINT [1001]。
        以下のために（INT i = 1; iは= 1000 <; iは++）{ 
            父[I] = I。
        } 
        ため（INT i = 0; I <edges.length; iは++）{ 
            int型rootA = findFather（父、エッジ[I] [0]）。
            INT rootB = findFather（父、エッジ[I] [1]）。
            （rootA == rootB）もし[i]はエッジを返します。
            父[rootA] = rootB。
        } 
        新しいINT [2]を返します。
    } 
   
    公共INT findFather（INT []父、INT X）{ 
        IF（X ==父[X]）戻りX。
        父を返す[X] = findFather（父、父[X]）。
    } 
}

検索：

BFS（279）：https://leetcode.com/problems/perfect-squares/description/

公共INT numSquares（int型N）{ 
        INT []と題さ=新しいINT [N + 1]。
        Arrays.fill（右Integer.MAX_VALUEの）; 
        ; [0] = 0と題します 
        ; [1] = 1と題します 
        以下のために{（INT i = 1; iは++; iが= N <）
            {ため（J ++のint J = 1; jは* jの<= I）
                + -右の[I] = Math.min（右[j個* jのI] 1、右の[I]）。
            } 
        } 
        右[n]を返します。
    }

 

DFS（695）：https://leetcode.com/problems/max-area-of-island/description/

クラスソリューション{//サイズ函数能够传递地址
    パブリックstatic int型maxAreaOfIsland（INT [] []グリッド）{ 
        IF（グリッド== NULL || grid.length == 0 ||グリッド[0] .LENGTH == 0）
            リターン0; 
        INTサイズ[] = {0}。
        int型maxSizeの= 0; 
        INT、M = grid.length。
        INT、N =グリッド[0] .LENGTH。

        以下のために（INT i = 0; iがm <; iは++）{ 
            ための（int型J = 0であり、j <N; J ++）{ 
                IF（グリッド[I] [J] == 1）{ 
                    サイズ[0] = 0; 
                    
                    DFS（グリッド、M、N、I、J、サイズ）。
                    
                    maxSizeの= Math.max（maxSizeの、サイズ[0]）。
                } 
            } 
        } 
        maxSizeのを返します。
    } 

    プライベート静的ボイドDFS {（[] []グリッド、INT M、整数nは、int型I、INT J、INT []サイズINT）

        IF（isSafe（グリッド、M、N、i、j）は！）
            リターン; 
        
        グリッド[i] [j]は0 =。
        
        サイズ[0] ++; 
        
        DFS（グリッド、M、N、I + 1、J、サイズ）。
        DFS（グリッド、M、N、I - 1、J、サイズ）。
        DFS（グリッド、M、N、I、J + 1、サイズ）
        DFS（グリッド、M、N、I、J - 1、サイズ）。

    } 

    プライベート静的ブールisSafe（INT [] []グリッド、INT mは、n個のint R、int型のCをINT）{ 
        IF（R> = 0 && C> = 0 && R <M && C <N &&格子[R] [C] == 1）
            trueを返します。
        falseを返します。
    } 
}

 

バックトラック（17）：17。電話番号の文字の組み合わせ https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/

クラスのソリューション{ 
    公共の一覧<文字列> letterCombinations（文字列の数字）{ 
        リスト<文字列>リスト=新しいArrayListを<>（）; 
        文字列[]地図= { ""、 ""、 "ABC"、 "DEF"、 "GHI"、 "JKL"、 "MNO"、 "PQRS"、 "TUV"、 "WXYZ"}。
        letterCombinations（数字、 ""、リスト、マップ）; 
        リストを返します。
    } 
    
    プライベートボイドletterCombinations（文字列の数字、文字列の接頭辞、リストの<string>リスト、文字列[]地図）{ 
        IF（digits.length（）== prefix.length（））{ 
            IF（prefix.length（）> 0）
                のリスト.add（接頭辞）。
            返します。
        } 
        int型の桁= digits.charAt（prefix.length（）） - '0'。
        ため（チャーCマップ[桁] .toCharArray（））{
            letterCombinations（桁、接頭辞+ C、リスト、マップ）; 
        } 
    } 
}

 

 

動的計画：

フィボナッチ数（70）：70段の階段を登る。Https://leetcode.com/problems/climbing-stairs/description/

公共INT climbStairs（int型N）{ 
        IF（N == 0 || N == 1）リターン1。
        IF（N == 2）リターン2。
        INT P = 1、T = 1。
        （; N> 0; N - ）のために{ 
            T + = P。
            P = T - P; 
        } 
        Pを返します。
    }

 

行列のルート（64）:.最小64パス合計 https://leetcode.com/problems/minimum-path-sum/description/

公共INT minPathSum（INT [] []グリッド）{ 
        行INT = grid.length。
        INT COLS =グリッド[0] .LENGTH。
        INT [] [] DP =新しいint型[行] [colsの]。
        {（; iが行を<I ++はiが0 = INT）のための
            （INT J = 0; J <COLS; J ++）のために{ 
                （I == 0 && jの== 0）{場合
                    DP [I] [J] =グリッド[I] [J]。
                } 
                そうなら（I == 0）{ 
                    DP [I] [J] =グリッド[I] [J] + DP [I]、[J-1]。
                } 
                そうであれば（j == 0）{ 
                    DP [I] [J] =グリッド[I] [J] + DP [I-1]〜[J]。
                } 
                他{
                    DP [I] [J] =グリッド[I] [J] + Math.min（DP [I]、[J-1]、DP [I-1]〜[J]）。
                } 
            } 
        } 
        
        戻りDP [行-1] [COLS-1]。
    }

 

アレイ部（303）：303合計範囲クエリ-不変 https://leetcode.com/problems/range-sum-query-immutable/description/

クラスNumArray { 

    INT []和。
    公共NumArray（INT [] NUMS）{ 
        合計=新しいINT [nums.length + 1]。
        和[0] = 0。
        {（; iがnums.lengthを<I ++は、I = 0 INT）のため
            和[I + 1] =和[i]は[I] + NUMS。
        } 
    } 
    
    公共のint sumRange {（I、INT J INT）
        戻り和[J + 1] - [I]の和を、
    } 
}

 

整数除算（343）:. 343ブレーク整数H TTPS：//leetcode.com/problems/integer-break/description/

公共INT integerBreak（int型N）{ 
        IF（N == 2）リターン1。
        IF（N == 3）リターン2。
        3 = N / 3 int型、
        2 = 0をint型。
        IF（（N - 3 * 3）== 1）{2 = 2。3 - = 1;} 
        そうでなければ2 =（N - 3 * 3）/ 2。
        リターン（INT）（Math.pow（3、3）* Math.pow（2、2））。
    }

 

最長の増加シーケンス（300）:. 300最長のサブシーケンス増加 https://leetcode.com/problems/longest-increasing-subsequence/description/ EGを [10,9,2,5,3,7,101,18]----> 4

公共INT lengthOfLIS（INT [] NUMS）{ 
        IF（NUMS == NULL）戻り0; 
        IF（nums.length <= 1）戻りnums.length。
        [nums.length] []トップ=新しいint型をint型。
        int型のサイズ= 0; 
        {ため（; iはnums.length <I ++は、I = 0 INT）
            INT IDX = binarySearch（上部、NUMS [i]は、サイズ）。
            トップ[IDX] =のNUMS [I]。
            （IDX ==サイズ）サイズ++であれば、
        } 
        のサイズを返します。
    } 
    プライベートINT binarySearch（INT [] NUMS、int型のVal、INT端）{ 
        int型左= 0、右= END; 
        IF（NUMS [左]> = val）でリターン左; 
        一方（左+ 1 <右）{ 
            int型ミッド=左+（右-左）/ 2。
            IF（NUMS [中間]> = val）で右=ミッド。
            他に左=ミッド; 
        } 
        右返します。
    }

0-1背包（416）：416。パーティション均等サブセット合計 https://leetcode.com/problems/partition-equal-subset-sum/description/例えば【1,2,3,4】

パブリックブールcanPartition（INT [] NUMS）{ 
        int型の和= 0。
        （int型NUM：NUMS）のための合計+ = NUM; 
        もし（合計％2！= 0）はfalseを返します。
        和/ = 2。
        // DP [i]はiの結果を得ることができるかどうかである
        [] DP =新しいブール[合計+ 1]ブール。
        DP [0] =真。
        （int型NUM：NUMS）のために{//使用の番号num 
            のためには、（i int型=合計を、私は> = 0; I - ）{ 
                //まだ私が取得するために残っていますか？
                IF（I> = NUM）{// DP [NUM]真为
                    DP [I] [I] DPを= || DP [I-NUM]。
                } 
            } 
        } 
        戻りDP [和]。
    }

 

股票交易（309）：https://leetcode.com/probl9ems/best-time-to-buy-and-sell-stock-with-cooldown/description/

字符串编辑（583）：https://leetcode.com/problems/delete-operation-for-two-strings/description/