{"id":113435,"date":"2026-10-06T10:49:46","date_gmt":"2026-10-06T02:49:46","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/113435.html"},"modified":"2026-10-06T10:49:46","modified_gmt":"2026-10-06T02:49:46","slug":"java%e7%89%88%e3%80%8a%e7%ae%97%e6%b3%95%e5%88%86%e6%9e%90%e4%b8%8e%e8%ae%be%e8%ae%a1%e3%80%8b%e6%9c%9f%e6%9c%ab%e4%bb%a3%e7%a0%81%e9%a2%98%ef%bc%9a%e5%85%a8%e9%83%a8%e8%80%83%e7%82%b9%e9%a2%98","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/113435.html","title":{"rendered":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09"},"content":{"rendered":"

Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898：\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3（\u4e07\u5b57\u8be6\u89e3，\u9644\u5b8c\u6574\u4ee3\u7801）<\/h2>\n
\n

\u9002\u7528\u5bf9\u8c61：\u672c\u79d1\u8ba1\u7b97\u673a\u4e13\u4e1a\u671f\u672b\u8003\u8bd5\u590d\u4e60 \u4fa7\u91cd\u70b9：\u624b\u5199Java\u4ee3\u7801，\u4e0d\u8003\u590d\u6742\u5e95\u5c42\u8bc1\u660e \u6838\u5fc3\u8003\u70b9：\u9012\u5f52\u3001\u5206\u6cbb\u3001\u8d2a\u5fc3\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u3001\u56fe\u7b97\u6cd5\u3001\u67e5\u627e\u6392\u5e8f \u5206\u503c\u5206\u5e03：\u4ee3\u7801\u9898\u4e00\u822c6～10\u5206\u4e00\u9898，\u8981\u6c42\u5199\u65b9\u6cd5\/\u5b8c\u6574\u7c7b\u3001\u8f93\u51fa\u7ed3\u679c\u3001\u5206\u6790\u590d\u6742\u5ea6 \u672c\u6587\u7279\u8272：\u6bcf\u4e2a\u8003\u70b9\u5747\u9644\u5b8c\u6574\u53ef\u8fd0\u884cJava\u4ee3\u7801 + \u590d\u6742\u5ea6\u5206\u6790 + \u8003\u8bd5\u5751\u70b9\u63d0\u9192<\/p>\n

\n

\u76ee\u5f55<\/h3>\n
  • \u524d\u8a00：\u671f\u672b\u8003\u8bd5\u5230\u5e95\u8003\u4ec0\u4e48？<\/li>\n
  • \u4e00\u3001\u5206\u6cbb\u7b97\u6cd5（\u5fc5\u8003\u9ad8\u9891）<\/li>\n
  • \u4e8c\u3001\u8d2a\u5fc3\u7b97\u6cd5（\u4e2d\u7b49\u9891\u7387）<\/li>\n
  • \u4e09\u3001\u52a8\u6001\u89c4\u5212（\u671f\u672b\u4ee3\u7801\u5927\u9898TOP1）<\/li>\n
  • \u56db\u3001\u56de\u6eaf\u7b97\u6cd5（\u975e\u5e38\u9ad8\u9891\u4ee3\u7801\u9898）<\/li>\n
  • \u4e94\u3001\u56fe\u7b97\u6cd5（\u4ee3\u7801\u5927\u9898，\u4e2d\u9ad8\u6982\u7387）<\/li>\n
  • \u516d\u3001\u67e5\u627e\u4e0e\u6392\u5e8f（\u57fa\u7840\u5c0f\u9898）<\/li>\n
  • \u4e03\u3001\u5b57\u7b26\u4e32\u7b97\u6cd5（KMP）<\/li>\n
  • \u516b\u3001\u671f\u672b\u51fa\u9898\u5957\u8def\u4e0e\u5e94\u8bd5\u6280\u5de7<\/li>\n
  • \u4e5d\u3001\u590d\u4e60\u4f18\u5148\u7ea7\u4e0e\u603b\u7ed3<\/li>\n
    \n

    \u524d\u8a00：\u671f\u672b\u8003\u8bd5\u5230\u5e95\u8003\u4ec0\u4e48？<\/h3>\n

    \u6bcf\u5230\u671f\u672b，\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u8fd9\u95e8\u8bfe\u603b\u662f\u8ba9\u65e0\u6570\u8ba1\u7b97\u673a\u4e13\u4e1a\u7684\u540c\u5b66\u5934\u75bc\u3002\u4e0d\u540c\u4e8e\u6570\u636e\u7ed3\u6784\u4fa7\u91cd"\u4f1a\u7528"，\u7b97\u6cd5\u8bfe\u66f4\u5f3a\u8c03 \u7406\u89e3\u601d\u60f3 \u548c \u624b\u5199\u4ee3\u7801 \u7684\u80fd\u529b\u3002<\/p>\n

    \u6839\u636e\u591a\u5e74\u671f\u672b\u8003\u8bd5\u7684\u7ecf\u9a8c\u603b\u7ed3，\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u7684\u671f\u672b\u4ee3\u7801\u9898\u6709\u4ee5\u4e0b\u89c4\u5f8b：<\/p>\n

      \n
    • \u57fa\u7840\u5c0f\u9898（5\u5206\u5de6\u53f3）：\u4e8c\u5206\u67e5\u627e\u3001\u5e76\u67e5\u96c6\u3001\u5f52\u5e76merge\u51fd\u6570\u3001\u5feb\u6392partition\u51fd\u6570\u2014\u2014\u5199\u6838\u5fc3\u51fd\u6570\u5373\u53ef<\/li>\n
    • \u4e2d\u6863\u5927\u9898（8～12\u5206）：01\u80cc\u5305\u3001\u6700\u957f\u516c\u5171\u5b50\u5e8f\u5217（LCS）\u3001\u56de\u6eaf\u5168\u6392\u5217\u3001Dijkstra\u6700\u77ed\u8def\u5f84\u3001Floyd\u591a\u6e90\u6700\u77ed\u8def\u5f84<\/li>\n
    • \u62d4\u9ad8\u9898（10\u5206\u4ee5\u4e0a）：N\u7687\u540e\u3001\u5f52\u5e76\u6392\u5e8f\u6c42\u9006\u5e8f\u5bf9\u3001\u7f16\u8f91\u8ddd\u79bb\u3001\u62d3\u6251\u6392\u5e8f\u5224\u73af<\/li>\n<\/ul>\n

      \u8003\u8bd5\u5199Java\u4ee3\u7801\u7684\u901a\u7528\u8981\u6c42：<\/p>\n

    • \u4f18\u5148\u5199\u8fed\u4ee3\u7248\u672cDP，\u9012\u5f52\u5bb9\u6613\u6808\u6ea2\u51fa\u3001\u8d85\u65f6<\/li>\n
    • \u65b9\u6cd5\u5c3d\u91cf\u72ec\u7acb，\u4e0d\u8981\u4f9d\u8d56\u989d\u5916\u590d\u6742\u5305，java.util.* \u5141\u8bb8\u5bfc\u5165<\/li>\n
    • \u5199\u5b8c\u6700\u597d\u6807\u6ce8\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6（\u901a\u5e38\u67091～2\u5206）<\/li>\n
    • \u6ce8\u610f\u8fb9\u754c\u6761\u4ef6：\u7a7a\u6570\u7ec4\u3001\u957f\u5ea6\u4e3a1\u7684\u6570\u7ec4\u3001\u7a7a\u5b57\u7b26\u4e32<\/li>\n

      \u4e0b\u9762\u6211\u4eec\u5c31\u6309\u7167\u8003\u70b9\u9010\u4e00\u5c55\u5f00，\u6bcf\u4e2a\u8003\u70b9\u90fd\u7ed9\u51fa\u5b8c\u6574\u53ef\u8fd0\u884c\u7684Java\u4ee3\u7801\u3001\u8be6\u7ec6\u7684\u601d\u8def\u5206\u6790\u3001\u590d\u6742\u5ea6\u8ba1\u7b97\u4ee5\u53ca\u8003\u8bd5\u4e2d\u5bb9\u6613\u8e29\u7684\u5751\u3002<\/p>\n

      \n

      \u4e00\u3001\u5206\u6cbb\u7b97\u6cd5（\u5fc5\u8003\u9ad8\u9891）<\/h3>\n

      1.1 \u6838\u5fc3\u601d\u60f3<\/h4>\n

      \u5206\u6cbb（Divide and Conquer）\u7684\u6838\u5fc3\u601d\u60f3\u53ef\u4ee5\u7528\u4e09\u6b65\u6982\u62ec：<\/p>\n

    • \u5206\u89e3（Divide）：\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u82e5\u5e72\u4e2a\u89c4\u6a21\u66f4\u5c0f\u7684\u5b50\u95ee\u9898<\/li>\n
    • \u6c42\u89e3（Conquer）：\u9012\u5f52\u5730\u6c42\u89e3\u5404\u4e2a\u5b50\u95ee\u9898<\/li>\n
    • \u5408\u5e76（Combine）：\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u5408\u5e76\u4e3a\u539f\u95ee\u9898\u7684\u89e3<\/li>\n

      \u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u7684\u6838\u5fc3\u5de5\u5177\u662f\u4e3b\u5b9a\u7406（Master Theorem）：<\/p>\n

      \u5bf9\u4e8e\u9012\u63a8\u5f0f <\/p>\n

      T<\/p>\n

      (<\/p>\n

      n<\/p>\n

      )<\/p>\n

      =<\/p>\n

      a<\/p>\n

      T<\/p>\n

      (<\/p>\n

      n<\/p>\n

      \/<\/p>\n

      b<\/p>\n

      )<\/p>\n

      +<\/p>\n

      f<\/p>\n

      (<\/p>\n

      n<\/p>\n

      )<\/p>\n

      T(n) = aT(n\/b) + f(n)<\/p>\n

      <\/span><\/span>T<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>a<\/span>T<\/span>(<\/span>n<\/span>\/<\/span>b<\/span>)<\/span><\/span>+<\/span><\/span><\/span><\/span>f<\/span>(<\/span>n<\/span>)<\/span><\/span><\/span><\/span><\/span>：<\/p>\n

        \n
      • \u82e5 \n

        f<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        O<\/p>\n

        (<\/p>\n

        n<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        b<\/p>\n

        a<\/p>\n

        \u2212<\/p>\n

        \u03f5<\/p>\n

        )<\/p>\n

        f(n) = O(n^{\\\\log_b a – \\\\epsilon})<\/p>\n

        <\/span><\/span>f<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>O<\/span>(<\/span>n<\/span><\/span>l<\/span>o<\/span>g<\/span><\/span><\/span>b<\/span><\/span><\/span><\/span>\u200b<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>a<\/span>\u2212<\/span>\u03f5<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>)<\/span><\/span><\/span><\/span><\/span>，\u5219 <\/p>\n

        T<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        \u0398<\/p>\n

        (<\/p>\n

        n<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        b<\/p>\n

        a<\/p>\n

        )<\/p>\n

        T(n) = \\\\Theta(n^{\\\\log_b a})<\/p>\n

        <\/span><\/span>T<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>\u0398<\/span>(<\/span>n<\/span><\/span>l<\/span>o<\/span>g<\/span><\/span><\/span>b<\/span><\/span><\/span><\/span>\u200b<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>a<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>)<\/span><\/span><\/span><\/span><\/span><\/li>\n

      • \u82e5 \n

        f<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        \u0398<\/p>\n

        (<\/p>\n

        n<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        b<\/p>\n

        a<\/p>\n

        )<\/p>\n

        f(n) = \\\\Theta(n^{\\\\log_b a})<\/p>\n

        <\/span><\/span>f<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>\u0398<\/span>(<\/span>n<\/span><\/span>l<\/span>o<\/span>g<\/span><\/span><\/span>b<\/span><\/span><\/span><\/span>\u200b<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>a<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>)<\/span><\/span><\/span><\/span><\/span>，\u5219 <\/p>\n

        T<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        \u0398<\/p>\n

        (<\/p>\n

        n<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        b<\/p>\n

        a<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        n<\/p>\n

        )<\/p>\n

        T(n) = \\\\Theta(n^{\\\\log_b a} \\\\log n)<\/p>\n

        <\/span><\/span>T<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>\u0398<\/span>(<\/span>n<\/span><\/span>l<\/span>o<\/span>g<\/span><\/span><\/span>b<\/span><\/span><\/span><\/span>\u200b<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>a<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>log<\/span><\/span><\/span>n<\/span>)<\/span><\/span><\/span><\/span><\/span><\/li>\n

      • \u82e5 \n

        f<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        \u03a9<\/p>\n

        (<\/p>\n

        n<\/p>\n

        log<\/p>\n

        \u2061<\/p>\n

        b<\/p>\n

        a<\/p>\n

        +<\/p>\n

        \u03f5<\/p>\n

        )<\/p>\n

        f(n) = \\\\Omega(n^{\\\\log_b a + \\\\epsilon})<\/p>\n

        <\/span><\/span>f<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>\u03a9<\/span>(<\/span>n<\/span><\/span>l<\/span>o<\/span>g<\/span><\/span><\/span>b<\/span><\/span><\/span><\/span>\u200b<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>a<\/span>+<\/span>\u03f5<\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span><\/span>)<\/span><\/span><\/span><\/span><\/span>，\u5219 <\/p>\n

        T<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        =<\/p>\n

        \u0398<\/p>\n

        (<\/p>\n

        f<\/p>\n

        (<\/p>\n

        n<\/p>\n

        )<\/p>\n

        )<\/p>\n

        T(n) = \\\\Theta(f(n))<\/p>\n

        <\/span><\/span>T<\/span>(<\/span>n<\/span>)<\/span><\/span>=<\/span><\/span><\/span><\/span>\u0398<\/span>(<\/span>f<\/span>(<\/span>n<\/span>))<\/span><\/span><\/span><\/span><\/span><\/li>\n<\/ul>\n

        1.2 \u4e8c\u5206\u67e5\u627e（\u6700\u57fa\u7840，\u5fc5\u4f1a）<\/h4>\n

        \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4 nums \u548c\u76ee\u6807\u503c target，\u67e5\u627e target \u5728\u6570\u7ec4\u4e2d\u7684\u4e0b\u6807，\u4e0d\u5b58\u5728\u5219\u8fd4\u56de -1\u3002<\/p>\n

        \u975e\u9012\u5f52\u7248\u672c：<\/p>\n

        public<\/span> class<\/span> BinarySearch<\/span> {<\/span><\/p>\n

        \/**
        \n * \u57fa\u7840\u4e8c\u5206\u67e5\u627e – \u975e\u9012\u5f52\u7248\u672c
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(log n)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> binarySearch<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> target)<\/span> {<\/span>
        \n if<\/span> (<\/span>nums ==<\/span> null<\/span> ||<\/span> nums.<\/span>length ==<\/span> 0<\/span>)<\/span> return<\/span> –<\/span>1<\/span>;<\/span><\/p>\n

        int<\/span> left =<\/span> 0<\/span>,<\/span> right =<\/span> nums.<\/span>length –<\/span> 1<\/span>;<\/span>
        \n while<\/span> (<\/span>left <=<\/span> right)<\/span> {<\/span>
        \n int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span> \/\/ \u9632\u6b62\u6ea2\u51fa！\u4e0d\u8981\u5199 (left + right) \/ 2<\/span>
        \n if<\/span> (<\/span>nums[<\/span>mid]<\/span> ==<\/span> target)<\/span> {<\/span>
        \n return<\/span> mid;<\/span>
        \n }<\/span> else<\/span> if<\/span> (<\/span>nums[<\/span>mid]<\/span> <<\/span> target)<\/span> {<\/span>
        \n left =<\/span> mid +<\/span> 1<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n right =<\/span> mid –<\/span> 1<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n return<\/span> –<\/span>1<\/span>;<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u4e8c\u5206\u67e5\u627e – \u9012\u5f52\u7248\u672c
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(log n)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(log n)（\u9012\u5f52\u6808）
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> binarySearchRecursive<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> target,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>left ><\/span> right)<\/span> return<\/span> –<\/span>1<\/span>;<\/span><\/p>\n

        int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span>
        \n if<\/span> (<\/span>nums[<\/span>mid]<\/span> ==<\/span> target)<\/span> {<\/span>
        \n return<\/span> mid;<\/span>
        \n }<\/span> else<\/span> if<\/span> (<\/span>nums[<\/span>mid]<\/span> <<\/span> target)<\/span> {<\/span>
        \n return<\/span> binarySearchRecursive<\/span>(<\/span>nums,<\/span> target,<\/span> mid +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n return<\/span> binarySearchRecursive<\/span>(<\/span>nums,<\/span> target,<\/span> left,<\/span> mid –<\/span> 1<\/span>)<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u8fdb\u9636：\u67e5\u627e\u7b2c\u4e00\u4e2a\u7b49\u4e8etarget\u7684\u4f4d\u7f6e（\u9ad8\u9891\u53d8\u4f53）
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(log n)
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> findFirst<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> target)<\/span> {<\/span>
        \n int<\/span> left =<\/span> 0<\/span>,<\/span> right =<\/span> nums.<\/span>length –<\/span> 1<\/span>;<\/span>
        \n int<\/span> result =<\/span> –<\/span>1<\/span>;<\/span>
        \n while<\/span> (<\/span>left <=<\/span> right)<\/span> {<\/span>
        \n int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span>
        \n if<\/span> (<\/span>nums[<\/span>mid]<\/span> ==<\/span> target)<\/span> {<\/span>
        \n result =<\/span> mid;<\/span> \/\/ \u8bb0\u5f55\u5f53\u524d\u4f4d\u7f6e<\/span>
        \n right =<\/span> mid –<\/span> 1<\/span>;<\/span> \/\/ \u7ee7\u7eed\u5f80\u5de6\u627e<\/span>
        \n }<\/span> else<\/span> if<\/span> (<\/span>nums[<\/span>mid]<\/span> <<\/span> target)<\/span> {<\/span>
        \n left =<\/span> mid +<\/span> 1<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n right =<\/span> mid –<\/span> 1<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n return<\/span> result;<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u8fdb\u9636：\u67e5\u627e\u6700\u540e\u4e00\u4e2a\u7b49\u4e8etarget\u7684\u4f4d\u7f6e（\u9ad8\u9891\u53d8\u4f53）
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(log n)
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> findLast<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> target)<\/span> {<\/span>
        \n int<\/span> left =<\/span> 0<\/span>,<\/span> right =<\/span> nums.<\/span>length –<\/span> 1<\/span>;<\/span>
        \n int<\/span> result =<\/span> –<\/span>1<\/span>;<\/span>
        \n while<\/span> (<\/span>left <=<\/span> right)<\/span> {<\/span>
        \n int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span>
        \n if<\/span> (<\/span>nums[<\/span>mid]<\/span> ==<\/span> target)<\/span> {<\/span>
        \n result =<\/span> mid;<\/span> \/\/ \u8bb0\u5f55\u5f53\u524d\u4f4d\u7f6e<\/span>
        \n left =<\/span> mid +<\/span> 1<\/span>;<\/span> \/\/ \u7ee7\u7eed\u5f80\u53f3\u627e<\/span>
        \n }<\/span> else<\/span> if<\/span> (<\/span>nums[<\/span>mid]<\/span> <<\/span> target)<\/span> {<\/span>
        \n left =<\/span> mid +<\/span> 1<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n right =<\/span> mid –<\/span> 1<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n return<\/span> result;<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> nums =<\/span> {<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 2<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u57fa\u7840\u67e5\u627e: "<\/span> +<\/span> binarySearch<\/span>(<\/span>nums,<\/span> 2<\/span>)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: \u67d0\u4e2a2\u7684\u4e0b\u6807<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7b2c\u4e00\u4e2a2: "<\/span> +<\/span> findFirst<\/span>(<\/span>nums,<\/span> 2<\/span>)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: 1<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u540e\u4e00\u4e2a2: "<\/span> +<\/span> findLast<\/span>(<\/span>nums,<\/span> 2<\/span>)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: 3<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u67e5\u627e6: "<\/span> +<\/span> binarySearch<\/span>(<\/span>nums,<\/span> 6<\/span>)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: -1<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        \u26a0\ufe0f \u8003\u8bd5\u5751\u70b9：<\/p>\n

      • mid = left + (right – left) \/ 2 \u9632\u6b62 left + right \u6574\u578b\u6ea2\u51fa，\u5199\u8fd9\u4e2a\u8001\u5e08\u4f1a\u52a0\u5206<\/li>\n
      • \u5faa\u73af\u6761\u4ef6\u662f left <= right \u4e0d\u662f left < right<\/li>\n
      • "\u67e5\u627e\u7b2c\u4e00\u4e2a\/\u6700\u540e\u4e00\u4e2a\u7b49\u4e8etarget"\u662f\u671f\u672b\u9ad8\u9891\u53d8\u4f53，\u6ce8\u610f\u627e\u5230\u540e\u4e0d\u80fd\u76f4\u63a5return，\u8981\u7ee7\u7eed\u641c\u7d22<\/li>\n

        1.3 \u5f52\u5e76\u6392\u5e8f（\u8d85\u7ea7\u9ad8\u9891，\u5c24\u5176\u662f\u6c42\u9006\u5e8f\u5bf9）<\/h4>\n

        \u9898\u76ee\u63cf\u8ff0：\u4f7f\u7528\u5206\u6cbb\u601d\u60f3\u5bf9\u6570\u7ec4\u8fdb\u884c\u6392\u5e8f\u3002<\/p>\n

        public<\/span> class<\/span> MergeSort<\/span> {<\/span><\/p>\n

        \/**
        \n * \u5f52\u5e76\u6392\u5e8f\u4e3b\u65b9\u6cd5
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
        \n *\/<\/span>
        \n public<\/span> static<\/span> void<\/span> mergeSort<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>left >=<\/span> right)<\/span> return<\/span>;<\/span> \/\/ \u9012\u5f52\u7ec8\u6b62\u6761\u4ef6<\/span><\/p>\n

        int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span>
        \n mergeSort<\/span>(<\/span>arr,<\/span> left,<\/span> mid)<\/span>;<\/span> \/\/ \u9012\u5f52\u6392\u5e8f\u5de6\u534a\u90e8\u5206<\/span>
        \n mergeSort<\/span>(<\/span>arr,<\/span> mid +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span> \/\/ \u9012\u5f52\u6392\u5e8f\u53f3\u534a\u90e8\u5206<\/span>
        \n merge<\/span>(<\/span>arr,<\/span> left,<\/span> mid,<\/span> right)<\/span>;<\/span> \/\/ \u5408\u5e76\u4e24\u4e2a\u6709\u5e8f\u5b50\u6570\u7ec4<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u5408\u5e76\u4e24\u4e2a\u6709\u5e8f\u5b50\u6570\u7ec4 arr[left..mid] \u548c arr[mid+1..right]
        \n *\/<\/span>
        \n private<\/span> static<\/span> void<\/span> merge<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> mid,<\/span> int<\/span> right)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> temp =<\/span> new<\/span> int<\/span>[<\/span>right –<\/span> left +<\/span> 1<\/span>]<\/span>;<\/span>
        \n int<\/span> i =<\/span> left,<\/span> j =<\/span> mid +<\/span> 1<\/span>,<\/span> k =<\/span> 0<\/span>;<\/span><\/p>\n

        while<\/span> (<\/span>i <=<\/span> mid &&<\/span> j <=<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>arr[<\/span>i]<\/span> <=<\/span> arr[<\/span>j]<\/span>)<\/span> {<\/span>
        \n temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>i++<\/span>]<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>j++<\/span>]<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n \/\/ \u5904\u7406\u5269\u4f59\u5143\u7d20<\/span>
        \n while<\/span> (<\/span>i <=<\/span> mid)<\/span> temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>i++<\/span>]<\/span>;<\/span>
        \n while<\/span> (<\/span>j <=<\/span> right)<\/span> temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>j++<\/span>]<\/span>;<\/span><\/p>\n

        \/\/ \u5c06temp\u590d\u5236\u56de\u539f\u6570\u7ec4<\/span>
        \n for<\/span> (<\/span>int<\/span> p =<\/span> 0<\/span>;<\/span> p <<\/span> temp.<\/span>length;<\/span> p++<\/span>)<\/span> {<\/span>
        \n arr[<\/span>left +<\/span> p]<\/span> =<\/span> temp[<\/span>p]<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>38<\/span>,<\/span> 27<\/span>,<\/span> 43<\/span>,<\/span> 3<\/span>,<\/span> 9<\/span>,<\/span> 82<\/span>,<\/span> 10<\/span>}<\/span>;<\/span>
        \n mergeSort<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>)<\/span>;<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6392\u5e8f\u7ed3\u679c: "<\/span> +<\/span> java.<\/span>util.<\/span><\/span>Arrays<\/span>.<\/span>toString<\/span>(<\/span>arr)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: [3, 9, 10, 27, 38, 43, 82]<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        \u2b50 \u5f52\u5e76\u6392\u5e8f\u6539\u9020：\u6c42\u9006\u5e8f\u5bf9\u6570\u91cf（\u671f\u672b\u8d85\u7ea7\u9ad8\u9891！）<\/h5>\n

        \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a\u4e00\u4e2a\u6570\u7ec4，\u6c42\u5176\u4e2d\u9006\u5e8f\u5bf9\u7684\u603b\u6570\u3002\u9006\u5e8f\u5bf9\u5373 i < j \u4e14 arr[i] > arr[j]\u3002<\/p>\n

        \u6838\u5fc3\u601d\u8def：\u5728\u5f52\u5e76\u6392\u5e8f\u7684 merge \u8fc7\u7a0b\u4e2d，\u5f53\u5de6\u534a\u90e8\u5206\u7684 arr[i] > arr[j] \u65f6，\u8bf4\u660e arr[i] \u53ca\u5176\u540e\u9762\u7684\u6240\u6709\u5143\u7d20\u90fd\u5927\u4e8e arr[j]，\u56e0\u6b64\u9006\u5e8f\u5bf9\u6570\u91cf\u589e\u52a0 mid – i + 1\u3002<\/p>\n

        public<\/span> class<\/span> InversionCount<\/span> {<\/span><\/p>\n

        private<\/span> static<\/span> int<\/span> count =<\/span> 0<\/span>;<\/span> \/\/ \u9006\u5e8f\u5bf9\u8ba1\u6570\u5668<\/span><\/p>\n

        \/**
        \n * \u6c42\u9006\u5e8f\u5bf9\u6570\u91cf（\u57fa\u4e8e\u5f52\u5e76\u6392\u5e8f\u6539\u9020）
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> countInversions<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>left >=<\/span> right)<\/span> return<\/span> 0<\/span>;<\/span><\/p>\n

        int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span>
        \n countInversions<\/span>(<\/span>arr,<\/span> left,<\/span> mid)<\/span>;<\/span>
        \n countInversions<\/span>(<\/span>arr,<\/span> mid +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span>
        \n mergeAndCount<\/span>(<\/span>arr,<\/span> left,<\/span> mid,<\/span> right)<\/span>;<\/span>
        \n return<\/span> count;<\/span>
        \n }<\/span><\/p>\n

        private<\/span> static<\/span> void<\/span> mergeAndCount<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> mid,<\/span> int<\/span> right)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> temp =<\/span> new<\/span> int<\/span>[<\/span>right –<\/span> left +<\/span> 1<\/span>]<\/span>;<\/span>
        \n int<\/span> i =<\/span> left,<\/span> j =<\/span> mid +<\/span> 1<\/span>,<\/span> k =<\/span> 0<\/span>;<\/span><\/p>\n

        while<\/span> (<\/span>i <=<\/span> mid &&<\/span> j <=<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>arr[<\/span>i]<\/span> <=<\/span> arr[<\/span>j]<\/span>)<\/span> {<\/span>
        \n temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>i++<\/span>]<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n \/\/ arr[i] > arr[j]，\u4ea7\u751f\u9006\u5e8f\u5bf9<\/span>
        \n \/\/ \u5de6\u534a\u90e8\u5206\u4ecei\u5230mid\u7684\u6240\u6709\u5143\u7d20\u90fd\u5927\u4e8earr[j]<\/span>
        \n count +=<\/span> (<\/span>mid –<\/span> i +<\/span> 1<\/span>)<\/span>;<\/span> \/\/ \u2605\u2605\u2605 \u6838\u5fc3\u516c\u5f0f \u2605\u2605\u2605<\/span>
        \n temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>j++<\/span>]<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n while<\/span> (<\/span>i <=<\/span> mid)<\/span> temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>i++<\/span>]<\/span>;<\/span>
        \n while<\/span> (<\/span>j <=<\/span> right)<\/span> temp[<\/span>k++<\/span>]<\/span> =<\/span> arr[<\/span>j++<\/span>]<\/span>;<\/span><\/p>\n

        for<\/span> (<\/span>int<\/span> p =<\/span> 0<\/span>;<\/span> p <<\/span> temp.<\/span>length;<\/span> p++<\/span>)<\/span> {<\/span>
        \n arr[<\/span>left +<\/span> p]<\/span> =<\/span> temp[<\/span>p]<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>7<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>}<\/span>;<\/span> \/\/ \u9006\u5e8f\u5bf9: (7,5),(7,6),(7,4),(5,4),(6,4) = 5<\/span>
        \n count =<\/span> 0<\/span>;<\/span> \/\/ \u91cd\u7f6e<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u9006\u5e8f\u5bf9\u6570\u91cf: "<\/span> +<\/span> countInversions<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: 5<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        \u26a0\ufe0f \u8003\u8bd5\u5751\u70b9：<\/p>\n

      • count += (mid – i + 1) \u8fd9\u4e2a\u516c\u5f0f\u5fc5\u987b\u8bb0\u4f4f，\u662f\u5de6\u534a\u90e8\u5206\u5269\u4f59\u5143\u7d20\u4e2a\u6570<\/li>\n
      • \u5168\u5c40\u53d8\u91cf count \u6bcf\u6b21\u4f7f\u7528\u524d\u8981\u91cd\u7f6e\u4e3a0<\/li>\n
      • \u5982\u679c\u8003\u8bd5\u8981\u6c42\u8fd4\u56de long \u7c7b\u578b（\u9632\u6ea2\u51fa），\u6ce8\u610f\u4fee\u6539<\/li>\n

        1.4 \u5feb\u901f\u6392\u5e8f<\/h4>\n

        public<\/span> class<\/span> QuickSort<\/span> {<\/span><\/p>\n

        \/**
        \n * \u5feb\u901f\u6392\u5e8f\u4e3b\u65b9\u6cd5
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：\u5e73\u5747O(n log n)，\u6700\u574fO(n\u00b2)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(log n)（\u9012\u5f52\u6808）
        \n *\/<\/span>
        \n public<\/span> static<\/span> void<\/span> quickSort<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>left >=<\/span> right)<\/span> return<\/span>;<\/span><\/p>\n

        int<\/span> pivotIndex =<\/span> partition<\/span>(<\/span>arr,<\/span> left,<\/span> right)<\/span>;<\/span>
        \n quickSort<\/span>(<\/span>arr,<\/span> left,<\/span> pivotIndex –<\/span> 1<\/span>)<\/span>;<\/span>
        \n quickSort<\/span>(<\/span>arr,<\/span> pivotIndex +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u5206\u533a\u51fd\u6570：\u9009\u6700\u53f3\u5143\u7d20\u4e3a\u57fa\u51c6，\u5c06\u5c0f\u4e8epivot\u7684\u653e\u5de6\u8fb9，\u5927\u4e8e\u7684\u653e\u53f3\u8fb9
        \n * \u8fd4\u56depivot\u7684\u6700\u7ec8\u4f4d\u7f6e
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> partition<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n int<\/span> pivot =<\/span> arr[<\/span>right]<\/span>;<\/span> \/\/ \u9009\u6700\u53f3\u8fb9\u7684\u5143\u7d20\u4f5c\u4e3a\u57fa\u51c6<\/span>
        \n int<\/span> i =<\/span> left –<\/span> 1<\/span>;<\/span> \/\/ i\u6307\u5411\u5c0f\u4e8epivot\u7684\u6700\u540e\u4e00\u4e2a\u5143\u7d20<\/span><\/p>\n

        for<\/span> (<\/span>int<\/span> j =<\/span> left;<\/span> j <<\/span> right;<\/span> j++<\/span>)<\/span> {<\/span>
        \n if<\/span> (<\/span>arr[<\/span>j]<\/span> <=<\/span> pivot)<\/span> {<\/span>
        \n i++<\/span>;<\/span>
        \n swap<\/span>(<\/span>arr,<\/span> i,<\/span> j)<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n swap<\/span>(<\/span>arr,<\/span> i +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span> \/\/ \u628apivot\u653e\u5230\u6b63\u786e\u4f4d\u7f6e<\/span>
        \n return<\/span> i +<\/span> 1<\/span>;<\/span>
        \n }<\/span><\/p>\n

        private<\/span> static<\/span> void<\/span> swap<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> i,<\/span> int<\/span> j)<\/span> {<\/span>
        \n int<\/span> temp =<\/span> arr[<\/span>i]<\/span>;<\/span>
        \n arr[<\/span>i]<\/span> =<\/span> arr[<\/span>j]<\/span>;<\/span>
        \n arr[<\/span>j]<\/span> =<\/span> temp;<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>10<\/span>,<\/span> 7<\/span>,<\/span> 8<\/span>,<\/span> 9<\/span>,<\/span> 1<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
        \n quickSort<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>)<\/span>;<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6392\u5e8f\u7ed3\u679c: "<\/span> +<\/span> java.<\/span>util.<\/span><\/span>Arrays<\/span>.<\/span>toString<\/span>(<\/span>arr)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: [1, 5, 7, 8, 9, 10]<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        \u2b50 \u5feb\u901f\u9009\u62e9：\u6c42\u7b2cK\u5927\/\u7b2cK\u5c0f\u5143\u7d20<\/h5>\n

        public<\/span> class<\/span> QuickSelect<\/span> {<\/span><\/p>\n

        \/**
        \n * \u6c42\u6570\u7ec4\u4e2d\u7b2ck\u5c0f\u7684\u5143\u7d20（\u4e0d\u7528\u5b8c\u5168\u6392\u5e8f）
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：\u5e73\u5747O(n)，\u6700\u574fO(n\u00b2)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(log n)
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> findKthSmallest<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right,<\/span> int<\/span> k)<\/span> {<\/span>
        \n if<\/span> (<\/span>left ==<\/span> right)<\/span> return<\/span> arr[<\/span>left]<\/span>;<\/span><\/p>\n

        int<\/span> pivotIndex =<\/span> partition<\/span>(<\/span>arr,<\/span> left,<\/span> right)<\/span>;<\/span><\/p>\n

        if<\/span> (<\/span>k –<\/span> 1<\/span> ==<\/span> pivotIndex)<\/span> {<\/span>
        \n return<\/span> arr[<\/span>pivotIndex]<\/span>;<\/span>
        \n }<\/span> else<\/span> if<\/span> (<\/span>k –<\/span> 1<\/span> <<\/span> pivotIndex)<\/span> {<\/span>
        \n return<\/span> findKthSmallest<\/span>(<\/span>arr,<\/span> left,<\/span> pivotIndex –<\/span> 1<\/span>,<\/span> k)<\/span>;<\/span>
        \n }<\/span> else<\/span> {<\/span>
        \n return<\/span> findKthSmallest<\/span>(<\/span>arr,<\/span> pivotIndex +<\/span> 1<\/span>,<\/span> right,<\/span> k)<\/span>;<\/span>
        \n }<\/span>
        \n }<\/span><\/p>\n

        private<\/span> static<\/span> int<\/span> partition<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n int<\/span> pivot =<\/span> arr[<\/span>right]<\/span>;<\/span>
        \n int<\/span> i =<\/span> left –<\/span> 1<\/span>;<\/span>
        \n for<\/span> (<\/span>int<\/span> j =<\/span> left;<\/span> j <<\/span> right;<\/span> j++<\/span>)<\/span> {<\/span>
        \n if<\/span> (<\/span>arr[<\/span>j]<\/span> <=<\/span> pivot)<\/span> {<\/span>
        \n i++<\/span>;<\/span>
        \n int<\/span> temp =<\/span> arr[<\/span>i]<\/span>;<\/span> arr[<\/span>i]<\/span> =<\/span> arr[<\/span>j]<\/span>;<\/span> arr[<\/span>j]<\/span> =<\/span> temp;<\/span>
        \n }<\/span>
        \n }<\/span>
        \n int<\/span> temp =<\/span> arr[<\/span>i +<\/span> 1<\/span>]<\/span>;<\/span> arr[<\/span>i +<\/span> 1<\/span>]<\/span> =<\/span> arr[<\/span>right]<\/span>;<\/span> arr[<\/span>right]<\/span> =<\/span> temp;<\/span>
        \n return<\/span> i +<\/span> 1<\/span>;<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>3<\/span>,<\/span> 2<\/span>,<\/span> 1<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>}<\/span>;<\/span>
        \n \/\/ \u7b2c2\u5c0f\u7684\u5143\u7d20<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7b2c2\u5c0f: "<\/span> +<\/span> findKthSmallest<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>,<\/span> 2<\/span>)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: 2<\/span><\/p>\n

        \/\/ \u7b2c2\u5927 = \u7b2c(n-2+1)\u5c0f = \u7b2c5\u5c0f<\/span>
        \n int<\/span> k =<\/span> 2<\/span>;<\/span> \/\/ \u7b2ck\u5927<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7b2c2\u5927: "<\/span> +<\/span> findKthSmallest<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>,<\/span> arr.<\/span>length –<\/span> k +<\/span> 1<\/span>)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: 5<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        1.5 \u6700\u5927\u5b50\u6570\u7ec4（\u5206\u6cbb\u7248\u672c）<\/h4>\n

        public<\/span> class<\/span> MaxSubarrayDivideConquer<\/span> {<\/span><\/p>\n

        \/**
        \n * \u5206\u6cbb\u6cd5\u6c42\u6700\u5927\u5b50\u6570\u7ec4\u548c
        \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)
        \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(log n)
        \n * \u6ce8\u610f：\u6b64\u9898DP\u7248\u672c（Kadane\u7b97\u6cd5）\u66f4\u4f18，\u4e3aO(n)，\u89c1\u52a8\u6001\u89c4\u5212\u90e8\u5206
        \n *\/<\/span>
        \n public<\/span> static<\/span> int<\/span> maxSubArray<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> right)<\/span> {<\/span>
        \n if<\/span> (<\/span>left ==<\/span> right)<\/span> return<\/span> arr[<\/span>left]<\/span>;<\/span><\/p>\n

        int<\/span> mid =<\/span> left +<\/span> (<\/span>right –<\/span> left)<\/span> \/<\/span> 2<\/span>;<\/span><\/p>\n

        \/\/ \u4e09\u79cd\u60c5\u51b5\u53d6\u6700\u5927\u503c<\/span>
        \n int<\/span> leftMax =<\/span> maxSubArray<\/span>(<\/span>arr,<\/span> left,<\/span> mid)<\/span>;<\/span> \/\/ \u6700\u5927\u5b50\u6570\u7ec4\u5728\u5de6\u534a\u90e8\u5206<\/span>
        \n int<\/span> rightMax =<\/span> maxSubArray<\/span>(<\/span>arr,<\/span> mid +<\/span> 1<\/span>,<\/span> right)<\/span>;<\/span> \/\/ \u6700\u5927\u5b50\u6570\u7ec4\u5728\u53f3\u534a\u90e8\u5206<\/span>
        \n int<\/span> crossMax =<\/span> maxCrossingSum<\/span>(<\/span>arr,<\/span> left,<\/span> mid,<\/span> right)<\/span>;<\/span> \/\/ \u6700\u5927\u5b50\u6570\u7ec4\u8de8\u8d8a\u4e2d\u70b9<\/span><\/p>\n

        return<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>Math<\/span>.<\/span>max<\/span>(<\/span>leftMax,<\/span> rightMax)<\/span>,<\/span> crossMax)<\/span>;<\/span>
        \n }<\/span><\/p>\n

        \/**
        \n * \u6c42\u8de8\u8d8a\u4e2d\u70b9\u7684\u6700\u5927\u5b50\u6570\u7ec4\u548c
        \n *\/<\/span>
        \n private<\/span> static<\/span> int<\/span> maxCrossingSum<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> left,<\/span> int<\/span> mid,<\/span> int<\/span> right)<\/span> {<\/span>
        \n \/\/ \u5411\u5de6\u5ef6\u4f38\u7684\u6700\u5927\u548c<\/span>
        \n int<\/span> leftSum =<\/span> Integer<\/span>.<\/span>MIN_VALUE<\/span>;<\/span>
        \n int<\/span> sum =<\/span> 0<\/span>;<\/span>
        \n for<\/span> (<\/span>int<\/span> i =<\/span> mid;<\/span> i >=<\/span> left;<\/span> i—<\/span>)<\/span> {<\/span>
        \n sum +=<\/span> arr[<\/span>i]<\/span>;<\/span>
        \n leftSum =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>leftSum,<\/span> sum)<\/span>;<\/span>
        \n }<\/span><\/p>\n

        \/\/ \u5411\u53f3\u5ef6\u4f38\u7684\u6700\u5927\u548c<\/span>
        \n int<\/span> rightSum =<\/span> Integer<\/span>.<\/span>MIN_VALUE<\/span>;<\/span>
        \n sum =<\/span> 0<\/span>;<\/span>
        \n for<\/span> (<\/span>int<\/span> i =<\/span> mid +<\/span> 1<\/span>;<\/span> i <=<\/span> right;<\/span> i++<\/span>)<\/span> {<\/span>
        \n sum +=<\/span> arr[<\/span>i]<\/span>;<\/span>
        \n rightSum =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>rightSum,<\/span> sum)<\/span>;<\/span>
        \n }<\/span><\/p>\n

        return<\/span> leftSum +<\/span> rightSum;<\/span>
        \n }<\/span><\/p>\n

        public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
        \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>–<\/span>2<\/span>,<\/span> 1<\/span>,<\/span> –<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> –<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 1<\/span>,<\/span> –<\/span>5<\/span>,<\/span> 4<\/span>}<\/span>;<\/span>
        \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u5927\u5b50\u6570\u7ec4\u548c: "<\/span> +<\/span> maxSubArray<\/span>(<\/span>arr,<\/span> 0<\/span>,<\/span> arr.<\/span>length –<\/span> 1<\/span>)<\/span>)<\/span>;<\/span>
        \n \/\/ \u8f93\u51fa: 6（\u5b50\u6570\u7ec4 [4, -1, 2, 1]）<\/span>
        \n }<\/span>
        \n}<\/span><\/p>\n

        \u5206\u6cbb\u90e8\u5206\u5c0f\u7ed3：\u5206\u6cbb\u7b97\u6cd5\u5728\u671f\u672b\u8003\u8bd5\u4e2d\u51fa\u9898\u6982\u7387\u6781\u9ad8，\u5c24\u5176\u662f\u5f52\u5e76\u6392\u5e8f\u6c42\u9006\u5e8f\u5bf9\u548c\u5feb\u901f\u6392\u5e8f\u7684partition\u51fd\u6570\u3002\u5199\u4ee3\u7801\u65f6\u4e00\u5b9a\u8981\u6ce8\u610f\u6570\u7ec4\u8fb9\u754c\u548c\u9012\u5f52\u7ec8\u6b62\u6761\u4ef6，\u8fd9\u4e24\u4e2a\u662f\u6700\u5bb9\u6613\u6263\u5206\u7684\u5730\u65b9\u3002<\/p>\n

        \n

        \u4e8c\u3001\u8d2a\u5fc3\u7b97\u6cd5（\u4e2d\u7b49\u9891\u7387）<\/h3>\n

        2.1 \u6838\u5fc3\u601d\u60f3<\/h4>\n

        \u8d2a\u5fc3\u7b97\u6cd5\u7684\u6838\u5fc3\u662f：\u6bcf\u4e00\u6b65\u90fd\u9009\u62e9\u5f53\u524d\u770b\u6765\u6700\u4f18\u7684\u65b9\u6848，\u671f\u671b\u5c40\u90e8\u6700\u4f18\u80fd\u63a8\u51fa\u5168\u5c40\u6700\u4f18\u3002<\/p>\n

        \u8d2a\u5fc3\u7b97\u6cd5\u7684\u4ee3\u7801\u7279\u70b9：<\/p>\n

          \n
        • \u4e00\u822c\u4e0d\u9700\u8981\u9012\u5f52，\u6392\u5e8f+\u4e00\u6b21\u904d\u5386\u5373\u53ef<\/li>\n
        • \u4ee3\u7801\u901a\u5e38\u6bd4\u8f83\u77ed，\u4f46\u6b63\u786e\u6027\u8bc1\u660e（\u7b80\u7b54\u9898）\u9700\u8981\u5355\u72ec\u5206\u6790<\/li>\n
        • \u8003\u8bd5\u4e2d\u8d2a\u5fc3\u4ee3\u7801\u9898\u4e00\u822c\u53ea\u9700\u8981\u5199\u5b9e\u73b0，\u8bc1\u660e\u4e00\u822c\u51fa\u7b80\u7b54\u9898<\/li>\n<\/ul>\n

          2.2 \u6d3b\u52a8\u9009\u62e9\u95ee\u9898<\/h4>\n

          \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a n \u4e2a\u6d3b\u52a8\u7684\u5f00\u59cb\u65f6\u95f4\u548c\u7ed3\u675f\u65f6\u95f4，\u9009\u62e9\u5c3d\u53ef\u80fd\u591a\u7684\u4e92\u4e0d\u91cd\u53e0\u7684\u6d3b\u52a8\u3002<\/p>\n

          \u8d2a\u5fc3\u7b56\u7565：\u6309\u7ed3\u675f\u65f6\u95f4\u5347\u5e8f\u6392\u5e8f，\u6bcf\u6b21\u9009\u7ed3\u675f\u65f6\u95f4\u6700\u65e9\u4e14\u4e0e\u5df2\u9009\u6d3b\u52a8\u4e0d\u51b2\u7a81\u7684\u6d3b\u52a8\u3002<\/p>\n

          import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

          public<\/span> class<\/span> ActivitySelection<\/span> {<\/span><\/p>\n

          \/**
          \n * \u6d3b\u52a8\u9009\u62e9\u95ee\u9898 – \u8d2a\u5fc3\u7b97\u6cd5
          \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)（\u6392\u5e8f）
          \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
          \n *\/<\/span>
          \n public<\/span> static<\/span> List<\/span><<\/span>int<\/span>[<\/span>]<\/span>><\/span> selectActivities<\/span>(<\/span>int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> activities)<\/span> {<\/span>
          \n \/\/ \u6309\u7ed3\u675f\u65f6\u95f4\u5347\u5e8f\u6392\u5e8f<\/span>
          \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>activities,<\/span> (<\/span>a,<\/span> b)<\/span> -><\/span> a[<\/span>1<\/span>]<\/span> –<\/span> b[<\/span>1<\/span>]<\/span>)<\/span>;<\/span><\/p>\n

          List<\/span><<\/span>int<\/span>[<\/span>]<\/span>><\/span> selected =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
          \n int<\/span> lastEndTime =<\/span> –<\/span>1<\/span>;<\/span><\/p>\n

          for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> activity :<\/span> activities)<\/span> {<\/span>
          \n if<\/span> (<\/span>activity[<\/span>0<\/span>]<\/span> >=<\/span> lastEndTime)<\/span> {<\/span>
          \n \/\/ \u5f53\u524d\u6d3b\u52a8\u7684\u5f00\u59cb\u65f6\u95f4 >= \u4e0a\u4e00\u4e2a\u9009\u4e2d\u6d3b\u52a8\u7684\u7ed3\u675f\u65f6\u95f4<\/span>
          \n selected.<\/span>add<\/span>(<\/span>activity)<\/span>;<\/span>
          \n lastEndTime =<\/span> activity[<\/span>1<\/span>]<\/span>;<\/span>
          \n }<\/span>
          \n }<\/span><\/p>\n

          return<\/span> selected;<\/span>
          \n }<\/span><\/p>\n

          public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
          \n \/\/ \u6bcf\u4e2a\u6d3b\u52a8: {\u5f00\u59cb\u65f6\u95f4, \u7ed3\u675f\u65f6\u95f4}<\/span>
          \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> activities =<\/span> {<\/span>
          \n {<\/span>1<\/span>,<\/span> 4<\/span>}<\/span>,<\/span> {<\/span>3<\/span>,<\/span> 5<\/span>}<\/span>,<\/span> {<\/span>0<\/span>,<\/span> 6<\/span>}<\/span>,<\/span> {<\/span>5<\/span>,<\/span> 7<\/span>}<\/span>,<\/span> {<\/span>3<\/span>,<\/span> 9<\/span>}<\/span>,<\/span> {<\/span>5<\/span>,<\/span> 9<\/span>}<\/span>,<\/span>
          \n {<\/span>6<\/span>,<\/span> 10<\/span>}<\/span>,<\/span> {<\/span>8<\/span>,<\/span> 11<\/span>}<\/span>,<\/span> {<\/span>8<\/span>,<\/span> 12<\/span>}<\/span>,<\/span> {<\/span>2<\/span>,<\/span> 14<\/span>}<\/span>,<\/span> {<\/span>12<\/span>,<\/span> 16<\/span>}<\/span>
          \n }<\/span>;<\/span><\/p>\n

          List<\/span><<\/span>int<\/span>[<\/span>]<\/span>><\/span> result =<\/span> selectActivities<\/span>(<\/span>activities)<\/span>;<\/span>
          \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u591a\u9009\u62e9 "<\/span> +<\/span> result.<\/span>size<\/span>(<\/span>)<\/span> +<\/span> " \u4e2a\u6d3b\u52a8:"<\/span>)<\/span>;<\/span>
          \n for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> act :<\/span> result)<\/span> {<\/span>
          \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>" \u6d3b\u52a8 ["<\/span> +<\/span> act[<\/span>0<\/span>]<\/span> +<\/span> ", "<\/span> +<\/span> act[<\/span>1<\/span>]<\/span> +<\/span> ")"<\/span>)<\/span>;<\/span>
          \n }<\/span>
          \n \/\/ \u8f93\u51fa: 4\u4e2a\u6d3b\u52a8<\/span>
          \n }<\/span>
          \n}<\/span><\/p>\n

          2.3 \u54c8\u592b\u66fc\u7f16\u7801（\u4f18\u5148\u961f\u5217\u6784\u9020\u54c8\u592b\u66fc\u6811）<\/h4>\n

          \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a\u4e00\u7ec4\u5b57\u7b26\u53ca\u5176\u9891\u7387，\u6784\u9020\u54c8\u592b\u66fc\u6811，\u8ba1\u7b97\u5e26\u6743\u8def\u5f84\u957f\u5ea6（WPL）\u3002<\/p>\n

          import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

          public<\/span> class<\/span> HuffmanCoding<\/span> {<\/span><\/p>\n

          \/\/ \u54c8\u592b\u66fc\u6811\u8282\u70b9<\/span>
          \n static<\/span> class<\/span> HuffmanNode<\/span> implements<\/span> Comparable<\/span><<\/span>HuffmanNode<\/span>><\/span><\/span> {<\/span>
          \n char<\/span> ch;<\/span>
          \n int<\/span> freq;<\/span>
          \n HuffmanNode<\/span> left,<\/span> right;<\/span><\/p>\n

          HuffmanNode<\/span>(<\/span>char<\/span> ch,<\/span> int<\/span> freq)<\/span> {<\/span>
          \n this<\/span>.<\/span>ch =<\/span> ch;<\/span>
          \n this<\/span>.<\/span>freq =<\/span> freq;<\/span>
          \n }<\/span><\/p>\n

          @Override<\/span>
          \n public<\/span> int<\/span> compareTo<\/span>(<\/span>HuffmanNode<\/span> other)<\/span> {<\/span>
          \n return<\/span> this<\/span>.<\/span>freq –<\/span> other.<\/span>freq;<\/span> \/\/ \u6309\u9891\u7387\u5347\u5e8f<\/span>
          \n }<\/span>
          \n }<\/span><\/p>\n

          \/**
          \n * \u6784\u9020\u54c8\u592b\u66fc\u6811，\u8fd4\u56de\u6839\u8282\u70b9
          \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)
          \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
          \n *\/<\/span>
          \n public<\/span> static<\/span> HuffmanNode<\/span> buildHuffmanTree<\/span>(<\/span>char<\/span>[<\/span>]<\/span> chars,<\/span> int<\/span>[<\/span>]<\/span> freqs)<\/span> {<\/span>
          \n PriorityQueue<\/span><<\/span>HuffmanNode<\/span>><\/span><\/span> pq =<\/span> new<\/span> PriorityQueue<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span><\/p>\n

          for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> chars.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
          \n pq.<\/span>offer<\/span>(<\/span>new<\/span> HuffmanNode<\/span>(<\/span>chars[<\/span>i]<\/span>,<\/span> freqs[<\/span>i]<\/span>)<\/span>)<\/span>;<\/span>
          \n }<\/span><\/p>\n

          while<\/span> (<\/span>pq.<\/span>size<\/span>(<\/span>)<\/span> ><\/span> 1<\/span>)<\/span> {<\/span>
          \n HuffmanNode<\/span> left =<\/span> pq.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u53d6\u51fa\u9891\u7387\u6700\u5c0f\u7684\u4e24\u4e2a\u8282\u70b9<\/span>
          \n HuffmanNode<\/span> right =<\/span> pq.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span><\/p>\n

          HuffmanNode<\/span> parent =<\/span> new<\/span> HuffmanNode<\/span>(<\/span>'\\\\0'<\/span>,<\/span> left.<\/span>freq +<\/span> right.<\/span>freq)<\/span>;<\/span>
          \n parent.<\/span>left =<\/span> left;<\/span>
          \n parent.<\/span>right =<\/span> right;<\/span><\/p>\n

          pq.<\/span>offer<\/span>(<\/span>parent)<\/span>;<\/span> \/\/ \u65b0\u8282\u70b9\u5165\u961f<\/span>
          \n }<\/span><\/p>\n

          return<\/span> pq.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span> \/\/ \u6839\u8282\u70b9<\/span>
          \n }<\/span><\/p>\n

          \/**
          \n * \u8ba1\u7b97\u5e26\u6743\u8def\u5f84\u957f\u5ea6（WPL）
          \n *\/<\/span>
          \n public<\/span> static<\/span> int<\/span> calculateWPL<\/span>(<\/span>HuffmanNode<\/span> root,<\/span> int<\/span> depth)<\/span> {<\/span>
          \n if<\/span> (<\/span>root ==<\/span> null<\/span>)<\/span> return<\/span> 0<\/span>;<\/span>
          \n \/\/ \u53f6\u5b50\u8282\u70b9<\/span>
          \n if<\/span> (<\/span>root.<\/span>left ==<\/span> null<\/span> &&<\/span> root.<\/span>right ==<\/span> null<\/span>)<\/span> {<\/span>
          \n return<\/span> root.<\/span>freq *<\/span> depth;<\/span>
          \n }<\/span>
          \n return<\/span> calculateWPL<\/span>(<\/span>root.<\/span>left,<\/span> depth +<\/span> 1<\/span>)<\/span> +<\/span> calculateWPL<\/span>(<\/span>root.<\/span>right,<\/span> depth +<\/span> 1<\/span>)<\/span>;<\/span>
          \n }<\/span><\/p>\n

          \/**
          \n * \u6253\u5370\u54c8\u592b\u66fc\u7f16\u7801
          \n *\/<\/span>
          \n public<\/span> static<\/span> void<\/span> printCodes<\/span>(<\/span>HuffmanNode<\/span> root,<\/span> String<\/span> code)<\/span> {<\/span>
          \n if<\/span> (<\/span>root ==<\/span> null<\/span>)<\/span> return<\/span>;<\/span>
          \n if<\/span> (<\/span>root.<\/span>left ==<\/span> null<\/span> &&<\/span> root.<\/span>right ==<\/span> null<\/span>)<\/span> {<\/span>
          \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>" \u5b57\u7b26 '"<\/span> +<\/span> root.<\/span>ch +<\/span> "': "<\/span> +<\/span> code +<\/span> " (\u9891\u7387="<\/span> +<\/span> root.<\/span>freq +<\/span> ")"<\/span>)<\/span>;<\/span>
          \n }<\/span>
          \n printCodes<\/span>(<\/span>root.<\/span>left,<\/span> code +<\/span> "0"<\/span>)<\/span>;<\/span>
          \n printCodes<\/span>(<\/span>root.<\/span>right,<\/span> code +<\/span> "1"<\/span>)<\/span>;<\/span>
          \n }<\/span><\/p>\n

          public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
          \n char<\/span>[<\/span>]<\/span> chars =<\/span> {<\/span>'a'<\/span>,<\/span> 'b'<\/span>,<\/span> 'c'<\/span>,<\/span> 'd'<\/span>,<\/span> 'e'<\/span>,<\/span> 'f'<\/span>}<\/span>;<\/span>
          \n int<\/span>[<\/span>]<\/span> freqs =<\/span> {<\/span>45<\/span>,<\/span> 13<\/span>,<\/span> 12<\/span>,<\/span> 16<\/span>,<\/span> 9<\/span>,<\/span> 5<\/span>}<\/span>;<\/span><\/p>\n

          HuffmanNode<\/span> root =<\/span> buildHuffmanTree<\/span>(<\/span>chars,<\/span> freqs)<\/span>;<\/span><\/p>\n

          System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u54c8\u592b\u66fc\u7f16\u7801:"<\/span>)<\/span>;<\/span>
          \n printCodes<\/span>(<\/span>root,<\/span> ""<\/span>)<\/span>;<\/span>
          \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"WPL = "<\/span> +<\/span> calculateWPL<\/span>(<\/span>root,<\/span> 0<\/span>)<\/span>)<\/span>;<\/span>
          \n }<\/span>
          \n}<\/span><\/p>\n

          2.4 \u96f6\u94b1\u5151\u6362（\u8d2a\u5fc3\u7248\u672c）<\/h4>\n

          public<\/span> class<\/span> CoinChangeGreedy<\/span> {<\/span><\/p>\n

          \/**
          \n * \u96f6\u94b1\u5151\u6362 – \u8d2a\u5fc3\u7b97\u6cd5（\u4ec5\u9002\u7528\u4e8e\u89c4\u8303\u5e01\u503c，\u59821,5,10,25,50,100）
          \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n)
          \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)
          \n *
          \n * \u6ce8\u610f：\u8d2a\u5fc3\u6cd5\u4e0d\u662f\u901a\u7528\u89e3\u6cd5！\u5bf9\u4e8e\u5e01\u503c{1,3,4}\u51d16\u5143，\u8d2a\u5fc3\u7ed9\u51fa4+1+1=3\u679a，
          \n * \u4f46\u6700\u4f18\u89e3\u662f3+3=2\u679a\u3002\u8003\u8bd5\u65f6\u8001\u5e08\u4f1a\u8bf4\u660e\u786c\u5e01\u6ee1\u8db3\u8d2a\u5fc3\u6761\u4ef6\u3002
          \n *\/<\/span>
          \n public<\/span> static<\/span> int<\/span> coinChangeGreedy<\/span>(<\/span>int<\/span>[<\/span>]<\/span> coins,<\/span> int<\/span> amount)<\/span> {<\/span>
          \n \/\/ \u5047\u8bbecoins\u5df2\u7ecf\u6309\u964d\u5e8f\u6392\u5217（\u6216\u5148\u6392\u5e8f）<\/span>
          \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>coins)<\/span>;<\/span>
          \n int<\/span> count =<\/span> 0<\/span>;<\/span><\/p>\n

          for<\/span> (<\/span>int<\/span> i =<\/span> coins.<\/span>length –<\/span> 1<\/span>;<\/span> i >=<\/span> 0<\/span>;<\/span> i—<\/span>)<\/span> {<\/span>
          \n if<\/span> (<\/span>amount <=<\/span> 0<\/span>)<\/span> break<\/span>;<\/span>
          \n count +=<\/span> amount \/<\/span> coins[<\/span>i]<\/span>;<\/span>
          \n amount %=<\/span> coins[<\/span>i]<\/span>;<\/span>
          \n }<\/span><\/p>\n

          return<\/span> amount ==<\/span> 0<\/span> ?<\/span> count :<\/span> –<\/span>1<\/span>;<\/span>
          \n }<\/span><\/p>\n

          public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
          \n int<\/span>[<\/span>]<\/span> coins =<\/span> {<\/span>1<\/span>,<\/span> 5<\/span>,<\/span> 10<\/span>,<\/span> 25<\/span>}<\/span>;<\/span>
          \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u51d1 63 \u5206\u9700\u8981: "<\/span> +<\/span> coinChangeGreedy<\/span>(<\/span>coins,<\/span> 63<\/span>)<\/span> +<\/span> " \u679a\u786c\u5e01"<\/span>)<\/span>;<\/span>
          \n \/\/ 25*2 + 10*1 + 1*3 = 6\u679a<\/span>
          \n }<\/span>
          \n}<\/span><\/p>\n

          \u8d2a\u5fc3\u90e8\u5206\u5c0f\u7ed3：\u8d2a\u5fc3\u7b97\u6cd5\u4ee3\u7801\u4e00\u822c\u8f83\u77ed，\u6838\u5fc3\u662f\u6392\u5e8f+\u4e00\u6b21\u904d\u5386\u3002\u671f\u672b\u8003\u8bd5\u4e2d\u8d2a\u5fc3\u4ee3\u7801\u9898\u51fa\u73b0\u9891\u7387\u4e2d\u7b49，\u4f46\u8d2a\u5fc3\u7b56\u7565\u7684\u8bc1\u660e（\u7b80\u7b54\/\u9009\u62e9\u9898）\u51fa\u73b0\u9891\u7387\u8f83\u9ad8\u3002<\/p>\n

          \n

          \u4e09\u3001\u52a8\u6001\u89c4\u5212（\u671f\u672b\u4ee3\u7801\u5927\u9898TOP1，\u91cd\u4e2d\u4e4b\u91cd）<\/h3>\n

          3.1 \u6838\u5fc3\u601d\u60f3<\/h4>\n

          \u52a8\u6001\u89c4\u5212（Dynamic Programming, DP）\u662f\u671f\u672b\u8003\u8bd5\u4e2d\u51fa\u9898\u9891\u7387\u6700\u9ad8\u3001\u5206\u503c\u6700\u5927\u7684\u8003\u70b9\u3002<\/p>\n

          DP\u89e3\u9898\u56db\u6b65\u6cd5：<\/p>\n

        • \u72b6\u6001\u5b9a\u4e49：dp[i] \u6216 dp[i][j] \u4ee3\u8868\u4ec0\u4e48\u542b\u4e49<\/li>\n
        • \u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b：dp[i] \u5982\u4f55\u4ece\u524d\u9762\u7684\u72b6\u6001\u63a8\u5bfc\u51fa\u6765<\/li>\n
        • \u521d\u59cb\u5316：base case，\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3<\/li>\n
        • \u586b\u8868\u987a\u5e8f：\u4e00\u7ef4\u4ece\u5de6\u5230\u53f3，\u4e8c\u7ef4\u4ece\u5de6\u5230\u53f3\u3001\u4ece\u4e0a\u5230\u4e0b<\/li>\n

          \u8003\u8bd5\u5173\u952e\u63d0\u9192：<\/p>\n

            \n
          • \u5fc5\u987b\u5199\u8fed\u4ee3\u7248\u672c，\u4e0d\u8981\u5199\u9012\u5f52（\u9012\u5f52\u4f1a\u8d85\u65f6，\u800c\u4e14\u8001\u5e08\u4f1a\u6263\u5206）<\/li>\n
          • 01\u80cc\u5305\u9006\u5e8f\u904d\u5386\u5bb9\u91cf，\u5b8c\u5168\u80cc\u5305\u6b63\u5e8f\u904d\u5386\u5bb9\u91cf\u2014\u2014\u8fd9\u4e2a\u5faa\u73af\u987a\u5e8f\u662f\u9ad8\u9891\u6263\u5206\u70b9！<\/li>\n<\/ul>\n

            3.2 \u4e00\u7ef4DP<\/h4>\n

            3.2.1 \u722c\u697c\u68af<\/h5>\n

            \u9898\u76ee\u63cf\u8ff0：\u6bcf\u6b21\u53ef\u4ee5\u722c1\u62162\u4e2a\u53f0\u9636，\u6c42\u5230\u8fbe\u7b2cn\u9636\u6709\u591a\u5c11\u79cd\u65b9\u6cd5\u3002<\/p>\n

            public<\/span> class<\/span> ClimbingStairs<\/span> {<\/span><\/p>\n

            \/**
            \n * \u722c\u697c\u68af – \u52a8\u6001\u89c4\u5212
            \n * \u72b6\u6001\u5b9a\u4e49：dp[i] = \u5230\u8fbe\u7b2ci\u9636\u7684\u65b9\u6cd5\u6570
            \n * \u72b6\u6001\u8f6c\u79fb：dp[i] = dp[i-1] + dp[i-2]
            \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n)
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)（\u7a7a\u95f4\u4f18\u5316\u540e）
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> climbStairs<\/span>(<\/span>int<\/span> n)<\/span> {<\/span>
            \n if<\/span> (<\/span>n <=<\/span> 2<\/span>)<\/span> return<\/span> n;<\/span><\/p>\n

            \/\/ \u7a7a\u95f4\u4f18\u5316：\u53ea\u9700\u8981\u524d\u4e24\u4e2a\u72b6\u6001<\/span>
            \n int<\/span> prev2 =<\/span> 1<\/span>;<\/span> \/\/ dp[1]<\/span>
            \n int<\/span> prev1 =<\/span> 2<\/span>;<\/span> \/\/ dp[2]<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> i =<\/span> 3<\/span>;<\/span> i <=<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
            \n int<\/span> current =<\/span> prev1 +<\/span> prev2;<\/span>
            \n prev2 =<\/span> prev1;<\/span>
            \n prev1 =<\/span> current;<\/span>
            \n }<\/span><\/p>\n

            return<\/span> prev1;<\/span>
            \n }<\/span><\/p>\n

            \/\/ \u672a\u4f18\u5316\u7248\u672c（\u8003\u8bd5\u5efa\u8bae\u5148\u5199\u8fd9\u4e2a，\u66f4\u6e05\u6670）<\/span>
            \n public<\/span> static<\/span> int<\/span> climbStairsFullDP<\/span>(<\/span>int<\/span> n)<\/span> {<\/span>
            \n if<\/span> (<\/span>n <=<\/span> 2<\/span>)<\/span> return<\/span> n;<\/span>
            \n int<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>;<\/span>
            \n dp[<\/span>1<\/span>]<\/span> =<\/span> 1<\/span>;<\/span>
            \n dp[<\/span>2<\/span>]<\/span> =<\/span> 2<\/span>;<\/span>
            \n for<\/span> (<\/span>int<\/span> i =<\/span> 3<\/span>;<\/span> i <=<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
            \n dp[<\/span>i]<\/span> =<\/span> dp[<\/span>i –<\/span> 1<\/span>]<\/span> +<\/span> dp[<\/span>i –<\/span> 2<\/span>]<\/span>;<\/span>
            \n }<\/span>
            \n return<\/span> dp[<\/span>n]<\/span>;<\/span>
            \n }<\/span><\/p>\n

            public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
            \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u722c5\u9636\u697c\u68af: "<\/span> +<\/span> climbStairs<\/span>(<\/span>5<\/span>)<\/span> +<\/span> " \u79cd\u65b9\u6cd5"<\/span>)<\/span>;<\/span>
            \n \/\/ \u8f93\u51fa: 8<\/span>
            \n }<\/span>
            \n}<\/span><\/p>\n

            3.2.2 \u6700\u5927\u8fde\u7eed\u5b50\u6570\u7ec4\u548c（Kadane\u7b97\u6cd5）<\/h5>\n

            public<\/span> class<\/span> MaxSubArrayDP<\/span> {<\/span><\/p>\n

            \/**
            \n * \u6700\u5927\u8fde\u7eed\u5b50\u6570\u7ec4\u548c – \u52a8\u6001\u89c4\u5212（Kadane\u7b97\u6cd5）
            \n * \u72b6\u6001\u5b9a\u4e49：dp[i] = \u4ee5arr[i]\u7ed3\u5c3e\u7684\u6700\u5927\u8fde\u7eed\u5b50\u6570\u7ec4\u548c
            \n * \u72b6\u6001\u8f6c\u79fb：dp[i] = max(arr[i], dp[i-1] + arr[i])
            \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n)
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)（\u7a7a\u95f4\u4f18\u5316\u540e）
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> maxSubArray<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr)<\/span> {<\/span>
            \n if<\/span> (<\/span>arr ==<\/span> null<\/span> ||<\/span> arr.<\/span>length ==<\/span> 0<\/span>)<\/span> return<\/span> 0<\/span>;<\/span><\/p>\n

            int<\/span> currentMax =<\/span> arr[<\/span>0<\/span>]<\/span>;<\/span>
            \n int<\/span> globalMax =<\/span> arr[<\/span>0<\/span>]<\/span>;<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <<\/span> arr.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
            \n currentMax =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>arr[<\/span>i]<\/span>,<\/span> currentMax +<\/span> arr[<\/span>i]<\/span>)<\/span>;<\/span>
            \n globalMax =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>globalMax,<\/span> currentMax)<\/span>;<\/span>
            \n }<\/span><\/p>\n

            return<\/span> globalMax;<\/span>
            \n }<\/span><\/p>\n

            public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
            \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>–<\/span>2<\/span>,<\/span> 1<\/span>,<\/span> –<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> –<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 1<\/span>,<\/span> –<\/span>5<\/span>,<\/span> 4<\/span>}<\/span>;<\/span>
            \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u5927\u5b50\u6570\u7ec4\u548c: "<\/span> +<\/span> maxSubArray<\/span>(<\/span>arr)<\/span>)<\/span>;<\/span>
            \n \/\/ \u8f93\u51fa: 6（\u5b50\u6570\u7ec4 [4, -1, 2, 1]）<\/span>
            \n }<\/span>
            \n}<\/span><\/p>\n

            3.2.3 \u6253\u5bb6\u52ab\u820d<\/h5>\n

            \u9898\u76ee\u63cf\u8ff0：\u76f8\u90bb\u623f\u5c4b\u4e0d\u80fd\u540c\u65f6\u5077，\u6c42\u80fd\u5077\u5230\u7684\u6700\u5927\u91d1\u989d\u3002<\/p>\n

            public<\/span> class<\/span> HouseRobber<\/span> {<\/span><\/p>\n

            \/**
            \n * \u6253\u5bb6\u52ab\u820d – \u52a8\u6001\u89c4\u5212
            \n * \u72b6\u6001\u5b9a\u4e49：dp[i] = \u5077\u5230\u7b2ci\u4e2a\u623f\u5c4b\u65f6\u80fd\u83b7\u5f97\u7684\u6700\u5927\u91d1\u989d
            \n * \u72b6\u6001\u8f6c\u79fb：dp[i] = max(dp[i-1], dp[i-2] + nums[i])
            \n * – \u4e0d\u5077\u7b2ci\u4e2a：dp[i-1]
            \n * – \u5077\u7b2ci\u4e2a：dp[i-2] + nums[i]
            \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n)
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> rob<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums)<\/span> {<\/span>
            \n if<\/span> (<\/span>nums ==<\/span> null<\/span> ||<\/span> nums.<\/span>length ==<\/span> 0<\/span>)<\/span> return<\/span> 0<\/span>;<\/span>
            \n if<\/span> (<\/span>nums.<\/span>length ==<\/span> 1<\/span>)<\/span> return<\/span> nums[<\/span>0<\/span>]<\/span>;<\/span><\/p>\n

            int<\/span> prev2 =<\/span> 0<\/span>;<\/span> \/\/ dp[i-2]<\/span>
            \n int<\/span> prev1 =<\/span> 0<\/span>;<\/span> \/\/ dp[i-1]<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> num :<\/span> nums)<\/span> {<\/span>
            \n int<\/span> current =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>prev1,<\/span> prev2 +<\/span> num)<\/span>;<\/span>
            \n prev2 =<\/span> prev1;<\/span>
            \n prev1 =<\/span> current;<\/span>
            \n }<\/span><\/p>\n

            return<\/span> prev1;<\/span>
            \n }<\/span><\/p>\n

            public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
            \n int<\/span>[<\/span>]<\/span> nums =<\/span> {<\/span>2<\/span>,<\/span> 7<\/span>,<\/span> 9<\/span>,<\/span> 3<\/span>,<\/span> 1<\/span>}<\/span>;<\/span>
            \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u5927\u5077\u7a83\u91d1\u989d: "<\/span> +<\/span> rob<\/span>(<\/span>nums)<\/span>)<\/span>;<\/span>
            \n \/\/ \u8f93\u51fa: 12（\u5077\u623f\u5c4b0(2) + \u623f\u5c4b2(9) + \u623f\u5c4b4(1) = 12）<\/span>
            \n }<\/span>
            \n}<\/span><\/p>\n

            3.3 \u4e8c\u7ef4DP（\u5927\u9898\u9ad8\u9891\u533a）<\/h4>\n

            \u2b50 3.3.1 01\u80cc\u5305（\u5fc5\u8003！！！）<\/h5>\n

            \u9898\u76ee\u63cf\u8ff0：\u6709 n \u4e2a\u7269\u54c1，\u6bcf\u4e2a\u7269\u54c1\u6709\u91cd\u91cf weight[i] \u548c\u4ef7\u503c value[i]，\u80cc\u5305\u5bb9\u91cf\u4e3a W\u3002\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u4e00\u6b21，\u6c42\u80fd\u88c5\u5165\u80cc\u5305\u7684\u6700\u5927\u4ef7\u503c\u3002<\/p>\n

            public<\/span> class<\/span> ZeroOneKnapsack<\/span> {<\/span><\/p>\n

            \/**
            \n * 01\u80cc\u5305 – \u52a8\u6001\u89c4\u5212（\u4e8c\u7ef4DP\u6570\u7ec4\u7248\u672c，\u8003\u8bd5\u63a8\u8350）
            \n *
            \n * \u72b6\u6001\u5b9a\u4e49：dp[i][j] = \u524di\u4e2a\u7269\u54c1，\u80cc\u5305\u5bb9\u91cf\u4e3aj\u65f6\u7684\u6700\u5927\u4ef7\u503c
            \n * \u72b6\u6001\u8f6c\u79fb：
            \n * \u4e0d\u9009\u7b2ci\u4e2a\u7269\u54c1：dp[i][j] = dp[i-1][j]
            \n * \u9009\u7b2ci\u4e2a\u7269\u54c1：dp[i][j] = dp[i-1][j-weight[i-1]] + value[i-1] （\u9700j >= weight[i-1]）
            \n * dp[i][j] = max(\u4e0d\u9009, \u9009)
            \n *
            \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n * W)
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n * W)
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> knapsack01<\/span>(<\/span>int<\/span>[<\/span>]<\/span> weights,<\/span> int<\/span>[<\/span>]<\/span> values,<\/span> int<\/span> W<\/span>)<\/span> {<\/span>
            \n int<\/span> n =<\/span> weights.<\/span>length;<\/span>
            \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>[<\/span>W<\/span> +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

            \/\/ \u521d\u59cb\u5316：dp[0][j] = 0（0\u4e2a\u7269\u54c1，\u4ef7\u503c\u4e3a0），dp[i][0] = 0（\u5bb9\u91cf\u4e3a0，\u4ef7\u503c\u4e3a0）<\/span>
            \n \/\/ Java\u6570\u7ec4\u9ed8\u8ba4\u521d\u59cb\u5316\u4e3a0，\u6240\u4ee5\u53ef\u4ee5\u7701\u7565<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <=<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
            \n for<\/span> (<\/span>int<\/span> j =<\/span> 1<\/span>;<\/span> j <=<\/span> W<\/span>;<\/span> j++<\/span>)<\/span> {<\/span>
            \n if<\/span> (<\/span>j >=<\/span> weights[<\/span>i –<\/span> 1<\/span>]<\/span>)<\/span> {<\/span>
            \n \/\/ \u53ef\u4ee5\u9009\u6216\u4e0d\u9009\u7b2ci\u4e2a\u7269\u54c1<\/span>
            \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>
            \n dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span>,<\/span> \/\/ \u4e0d\u9009<\/span>
            \n dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> weights[<\/span>i –<\/span> 1<\/span>]<\/span>]<\/span> +<\/span> values[<\/span>i –<\/span> 1<\/span>]<\/span> \/\/ \u9009<\/span>
            \n )<\/span>;<\/span>
            \n }<\/span> else<\/span> {<\/span>
            \n \/\/ \u5bb9\u91cf\u4e0d\u591f，\u4e0d\u80fd\u9009<\/span>
            \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span>;<\/span>
            \n }<\/span>
            \n }<\/span>
            \n }<\/span><\/p>\n

            return<\/span> dp[<\/span>n]<\/span>[<\/span>W<\/span>]<\/span>;<\/span>
            \n }<\/span><\/p>\n

            \/**
            \n * 01\u80cc\u5305 – \u7a7a\u95f4\u4f18\u5316\u7248\u672c（\u4e00\u7ef4DP\u6570\u7ec4）
            \n * \u2605\u2605\u2605 \u6ce8\u610f：\u5bb9\u91cfj\u5fc5\u987b\u9006\u5e8f\u904d\u5386！\u2605\u2605\u2605
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(W)
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> knapsack01Optimized<\/span>(<\/span>int<\/span>[<\/span>]<\/span> weights,<\/span> int<\/span>[<\/span>]<\/span> values,<\/span> int<\/span> W<\/span>)<\/span> {<\/span>
            \n int<\/span> n =<\/span> weights.<\/span>length;<\/span>
            \n int<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>W<\/span> +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
            \n \/\/ \u2605\u2605\u2605 \u5173\u952e：\u9006\u5e8f\u904d\u5386\u5bb9\u91cf \u2605\u2605\u2605<\/span>
            \n \/\/ \u539f\u56e0：\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u4e00\u6b21，\u9006\u5e8f\u4fdd\u8bc1\u4e0d\u4f1a\u91cd\u590d\u9009\u53d6<\/span>
            \n for<\/span> (<\/span>int<\/span> j =<\/span> W<\/span>;<\/span> j >=<\/span> weights[<\/span>i]<\/span>;<\/span> j—<\/span>)<\/span> {<\/span>
            \n dp[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>dp[<\/span>j]<\/span>,<\/span> dp[<\/span>j –<\/span> weights[<\/span>i]<\/span>]<\/span> +<\/span> values[<\/span>i]<\/span>)<\/span>;<\/span>
            \n }<\/span>
            \n }<\/span><\/p>\n

            return<\/span> dp[<\/span>W<\/span>]<\/span>;<\/span>
            \n }<\/span><\/p>\n

            public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
            \n int<\/span>[<\/span>]<\/span> weights =<\/span> {<\/span>2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
            \n int<\/span>[<\/span>]<\/span> values =<\/span> {<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>}<\/span>;<\/span>
            \n int<\/span> W<\/span> =<\/span> 8<\/span>;<\/span><\/p>\n

            System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"01\u80cc\u5305\u6700\u5927\u4ef7\u503c（\u4e8c\u7ef4）: "<\/span> +<\/span> knapsack01<\/span>(<\/span>weights,<\/span> values,<\/span> W<\/span>)<\/span>)<\/span>;<\/span>
            \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"01\u80cc\u5305\u6700\u5927\u4ef7\u503c（\u4e00\u7ef4\u4f18\u5316）: "<\/span> +<\/span> knapsack01Optimized<\/span>(<\/span>weights,<\/span> values,<\/span> W<\/span>)<\/span>)<\/span>;<\/span>
            \n \/\/ \u8f93\u51fa: 10（\u9009\u7269\u54c10(\u91cd\u91cf2,\u4ef7\u503c3) + \u7269\u54c13(\u91cd\u91cf5,\u4ef7\u503c6) = \u4ef7\u503c9… <\/span>
            \n \/\/ \u6216\u9009\u7269\u54c11(\u91cd\u91cf3,\u4ef7\u503c4) + \u7269\u54c12(\u91cd\u91cf4,\u4ef7\u503c5) = \u4ef7\u503c9… \u4e0d\u5bf9<\/span>
            \n \/\/ \u9009\u7269\u54c10(2,3) + \u7269\u54c12(4,5) = \u91cd\u91cf6, \u4ef7\u503c8<\/span>
            \n \/\/ \u9009\u7269\u54c11(3,4) + \u7269\u54c13(5,6) = \u91cd\u91cf8, \u4ef7\u503c10 \u2713）<\/span>
            \n }<\/span>
            \n}<\/span><\/p>\n

            \u26a0\ufe0f \u8d85\u7ea7\u91cd\u8981\u5751\u70b9：01\u80cc\u5305\u7a7a\u95f4\u4f18\u5316\u7248\u672c\u4e2d，\u5bb9\u91cf j \u5fc5\u987b\u4ece\u5927\u5230\u5c0f（\u9006\u5e8f）\u904d\u5386！\u5982\u679c\u6b63\u5e8f\u904d\u5386，\u540c\u4e00\u4e2a\u7269\u54c1\u53ef\u80fd\u88ab\u91cd\u590d\u9009\u53d6，\u5c31\u53d8\u6210\u4e86\u5b8c\u5168\u80cc\u5305\u3002\u8fd9\u4e2a\u5faa\u73af\u987a\u5e8f\u662f\u671f\u672b\u8003\u8bd5\u4e2d\u6700\u5e38\u89c1\u7684\u6263\u5206\u70b9！<\/p>\n

            \u2b50 3.3.2 \u5b8c\u5168\u80cc\u5305<\/h5>\n

            \u9898\u76ee\u63cf\u8ff0：\u4e0e01\u80cc\u5305\u76f8\u540c，\u4f46\u6bcf\u4e2a\u7269\u54c1\u53ef\u4ee5\u65e0\u9650\u6b21\u9009\u53d6\u3002<\/p>\n

            public<\/span> class<\/span> CompleteKnapsack<\/span> {<\/span><\/p>\n

            \/**
            \n * \u5b8c\u5168\u80cc\u5305 – \u52a8\u6001\u89c4\u5212（\u4e00\u7ef4DP\u6570\u7ec4）
            \n * \u72b6\u6001\u8f6c\u79fb：dp[j] = max(dp[j], dp[j – weights[i]] + values[i])
            \n *
            \n * \u2605\u2605\u2605 \u5173\u952e\u533a\u522b：\u5bb9\u91cfj\u6b63\u5e8f\u904d\u5386！\u2605\u2605\u2605
            \n * \u539f\u56e0：\u7269\u54c1\u53ef\u4ee5\u91cd\u590d\u9009\u53d6，\u6b63\u5e8f\u904d\u5386\u5141\u8bb8\u540c\u4e00\u7269\u54c1\u88ab\u591a\u6b21\u4f7f\u7528
            \n *
            \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n * W)
            \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(W)
            \n *\/<\/span>
            \n public<\/span> static<\/span> int<\/span> completeKnapsack<\/span>(<\/span>int<\/span>[<\/span>]<\/span> weights,<\/span> int<\/span>[<\/span>]<\/span> values,<\/span> int<\/span> W<\/span>)<\/span> {<\/span>
            \n int<\/span> n =<\/span> weights.<\/span>length;<\/span>
            \n int<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>W<\/span> +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

            for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
            \n \/\/ \u2605\u2605\u2605 \u5173\u952e：\u6b63\u5e8f\u904d\u5386\u5bb9\u91cf \u2605\u2605\u2605（\u4e0e01\u80cc\u5305\u76f8\u53cd）<\/span>
            \n for<\/span> (<\/span>int<\/span> j =<\/span> weights[<\/span>i]<\/span>;<\/span> j <=<\/span> W<\/span>;<\/span> j++<\/span>)<\/span> {<\/span>
            \n dp[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>dp[<\/span>j]<\/span>,<\/span> dp[<\/span>j –<\/span> weights[<\/span>i]<\/span>]<\/span> +<\/span> values[<\/span>i]<\/span>)<\/span>;<\/span>
            \n }<\/span>
            \n }<\/span><\/p>\n

            return<\/span> dp[<\/span>W<\/span>]<\/span>;<\/span>
            \n }<\/span><\/p>\n

            public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
            \n int<\/span>[<\/span>]<\/span> weights =<\/span> {<\/span>2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>}<\/span>;<\/span>
            \n int<\/span>[<\/span>]<\/span> values =<\/span> {<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
            \n int<\/span> W<\/span> =<\/span> 8<\/span>;<\/span><\/p>\n

            System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u5b8c\u5168\u80cc\u5305\u6700\u5927\u4ef7\u503c: "<\/span> +<\/span> completeKnapsack<\/span>(<\/span>weights,<\/span> values,<\/span> W<\/span>)<\/span>)<\/span>;<\/span>
            \n \/\/ \u90094\u6b21\u7269\u54c10(\u91cd\u91cf2*4=8, \u4ef7\u503c3*4=12) = 12<\/span>
            \n }<\/span>
            \n}<\/span><\/p>\n

            01\u80cc\u5305 vs \u5b8c\u5168\u80cc\u5305 \u5faa\u73af\u987a\u5e8f\u5bf9\u6bd4：<\/p>\n

              \n
            • 01\u80cc\u5305（\u4e00\u7ef4\u4f18\u5316）：for (int j = W; j >= weights[i]; j–) \u9006\u5e8f<\/li>\n
            • \u5b8c\u5168\u80cc\u5305（\u4e00\u7ef4\u4f18\u5316）：for (int j = weights[i]; j <= W; j++) \u6b63\u5e8f<\/li>\n<\/ul>\n

              \u8bb0\u4f4f\u8fd9\u4e2a\u533a\u522b，\u8003\u8bd5\u5fc5\u8003！<\/p>\n

              \u2b50 3.3.3 \u6700\u957f\u516c\u5171\u5b50\u5e8f\u5217 LCS<\/h5>\n

              \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a\u4e24\u4e2a\u5b57\u7b26\u4e32 s1 \u548c s2，\u6c42\u5b83\u4eec\u7684\u6700\u957f\u516c\u5171\u5b50\u5e8f\u5217\u7684\u957f\u5ea6\u3002<\/p>\n

              public<\/span> class<\/span> LCS<\/span> {<\/span><\/p>\n

              \/**
              \n * \u6700\u957f\u516c\u5171\u5b50\u5e8f\u5217 – \u52a8\u6001\u89c4\u5212
              \n * \u72b6\u6001\u5b9a\u4e49：dp[i][j] = s1\u524di\u4e2a\u5b57\u7b26\u548cs2\u524dj\u4e2a\u5b57\u7b26\u7684LCS\u957f\u5ea6
              \n * \u72b6\u6001\u8f6c\u79fb：
              \n * \u82e5 s1[i-1] == s2[j-1]：dp[i][j] = dp[i-1][j-1] + 1
              \n * \u5426\u5219：dp[i][j] = max(dp[i-1][j], dp[i][j-1])
              \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(m * n)
              \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(m * n)
              \n *\/<\/span>
              \n public<\/span> static<\/span> int<\/span> lcsLength<\/span>(<\/span>String<\/span> s1,<\/span> String<\/span> s2)<\/span> {<\/span>
              \n int<\/span> m =<\/span> s1.<\/span>length<\/span>(<\/span>)<\/span>,<\/span> n =<\/span> s2.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
              \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>m +<\/span> 1<\/span>]<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

              for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <=<\/span> m;<\/span> i++<\/span>)<\/span> {<\/span>
              \n for<\/span> (<\/span>int<\/span> j =<\/span> 1<\/span>;<\/span> j <=<\/span> n;<\/span> j++<\/span>)<\/span> {<\/span>
              \n if<\/span> (<\/span>s1.<\/span>charAt<\/span>(<\/span>i –<\/span> 1<\/span>)<\/span> ==<\/span> s2.<\/span>charAt<\/span>(<\/span>j –<\/span> 1<\/span>)<\/span>)<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span> +<\/span> 1<\/span>;<\/span>
              \n }<\/span> else<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span>,<\/span> dp[<\/span>i]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>)<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              return<\/span> dp[<\/span>m]<\/span>[<\/span>n]<\/span>;<\/span>
              \n }<\/span><\/p>\n

              \/**
              \n * \u8f93\u51faLCS\u7684\u5177\u4f53\u5b50\u5e8f\u5217（\u52a0\u5206\u9879，\u90e8\u5206\u8003\u8bd5\u8981\u6c42）
              \n * \u901a\u8fc7\u56de\u6eafdp\u6570\u7ec4\u8fd8\u539f
              \n *\/<\/span>
              \n public<\/span> static<\/span> String<\/span> lcsString<\/span>(<\/span>String<\/span> s1,<\/span> String<\/span> s2)<\/span> {<\/span>
              \n int<\/span> m =<\/span> s1.<\/span>length<\/span>(<\/span>)<\/span>,<\/span> n =<\/span> s2.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
              \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>m +<\/span> 1<\/span>]<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

              for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <=<\/span> m;<\/span> i++<\/span>)<\/span> {<\/span>
              \n for<\/span> (<\/span>int<\/span> j =<\/span> 1<\/span>;<\/span> j <=<\/span> n;<\/span> j++<\/span>)<\/span> {<\/span>
              \n if<\/span> (<\/span>s1.<\/span>charAt<\/span>(<\/span>i –<\/span> 1<\/span>)<\/span> ==<\/span> s2.<\/span>charAt<\/span>(<\/span>j –<\/span> 1<\/span>)<\/span>)<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span> +<\/span> 1<\/span>;<\/span>
              \n }<\/span> else<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>max<\/span>(<\/span>dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span>,<\/span> dp[<\/span>i]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>)<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              \/\/ \u56de\u6eaf\u6784\u9020LCS\u5b57\u7b26\u4e32<\/span>
              \n StringBuilder<\/span> sb =<\/span> new<\/span> StringBuilder<\/span>(<\/span>)<\/span>;<\/span>
              \n int<\/span> i =<\/span> m,<\/span> j =<\/span> n;<\/span>
              \n while<\/span> (<\/span>i ><\/span> 0<\/span> &&<\/span> j ><\/span> 0<\/span>)<\/span> {<\/span>
              \n if<\/span> (<\/span>s1.<\/span>charAt<\/span>(<\/span>i –<\/span> 1<\/span>)<\/span> ==<\/span> s2.<\/span>charAt<\/span>(<\/span>j –<\/span> 1<\/span>)<\/span>)<\/span> {<\/span>
              \n sb.<\/span>append<\/span>(<\/span>s1.<\/span>charAt<\/span>(<\/span>i –<\/span> 1<\/span>)<\/span>)<\/span>;<\/span>
              \n i—<\/span>;<\/span> j—<\/span>;<\/span>
              \n }<\/span> else<\/span> if<\/span> (<\/span>dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span> ><\/span> dp[<\/span>i]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>)<\/span> {<\/span>
              \n i—<\/span>;<\/span>
              \n }<\/span> else<\/span> {<\/span>
              \n j—<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              return<\/span> sb.<\/span>reverse<\/span>(<\/span>)<\/span>.<\/span>toString<\/span>(<\/span>)<\/span>;<\/span>
              \n }<\/span><\/p>\n

              public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
              \n String<\/span> s1 =<\/span> "ABCBDAB"<\/span>;<\/span>
              \n String<\/span> s2 =<\/span> "BDCAB"<\/span>;<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"LCS\u957f\u5ea6: "<\/span> +<\/span> lcsLength<\/span>(<\/span>s1,<\/span> s2)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: 4<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"LCS\u5b50\u5e8f\u5217: "<\/span> +<\/span> lcsString<\/span>(<\/span>s1,<\/span> s2)<\/span>)<\/span>;<\/span> \/\/ \u8f93\u51fa: BCAB<\/span>
              \n }<\/span>
              \n}<\/span><\/p>\n

              3.3.4 \u6700\u957f\u56de\u6587\u5b50\u4e32<\/h5>\n

              public<\/span> class<\/span> LongestPalindrome<\/span> {<\/span><\/p>\n

              \/**
              \n * \u6700\u957f\u56de\u6587\u5b50\u4e32 – \u52a8\u6001\u89c4\u5212
              \n * \u72b6\u6001\u5b9a\u4e49：dp[i][j] = s[i..j] \u662f\u5426\u4e3a\u56de\u6587\u4e32（boolean）
              \n * \u72b6\u6001\u8f6c\u79fb：
              \n * \u82e5 s[i] == s[j]：dp[i][j] = dp[i+1][j-1]（\u5f53j-i<=2\u65f6\u4e3atrue）
              \n * \u5426\u5219：dp[i][j] = false
              \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n\u00b2)
              \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n\u00b2)
              \n *\/<\/span>
              \n public<\/span> static<\/span> String<\/span> longestPalindrome<\/span>(<\/span>String<\/span> s)<\/span> {<\/span>
              \n if<\/span> (<\/span>s ==<\/span> null<\/span> ||<\/span> s.<\/span>length<\/span>(<\/span>)<\/span> <<\/span> 2<\/span>)<\/span> return<\/span> s;<\/span><\/p>\n

              int<\/span> n =<\/span> s.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
              \n boolean<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>[<\/span>n]<\/span>;<\/span>
              \n int<\/span> maxLen =<\/span> 1<\/span>,<\/span> start =<\/span> 0<\/span>;<\/span><\/p>\n

              \/\/ \u5355\u4e2a\u5b57\u7b26\u90fd\u662f\u56de\u6587<\/span>
              \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>i]<\/span> =<\/span> true<\/span>;<\/span>
              \n }<\/span><\/p>\n

              \/\/ \u6ce8\u610f\u904d\u5386\u987a\u5e8f：\u5148\u679a\u4e3e\u957f\u5ea6，\u518d\u679a\u4e3e\u8d77\u70b9<\/span>
              \n for<\/span> (<\/span>int<\/span> len =<\/span> 2<\/span>;<\/span> len <=<\/span> n;<\/span> len++<\/span>)<\/span> {<\/span>
              \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <=<\/span> n –<\/span> len;<\/span> i++<\/span>)<\/span> {<\/span>
              \n int<\/span> j =<\/span> i +<\/span> len –<\/span> 1<\/span>;<\/span><\/p>\n

              if<\/span> (<\/span>s.<\/span>charAt<\/span>(<\/span>i)<\/span> ==<\/span> s.<\/span>charAt<\/span>(<\/span>j)<\/span>)<\/span> {<\/span>
              \n if<\/span> (<\/span>len <=<\/span> 3<\/span>)<\/span> {<\/span> \/\/ \u957f\u5ea62\u62163\u4e14\u9996\u5c3e\u76f8\u540c，\u4e00\u5b9a\u662f\u56de\u6587<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> true<\/span>;<\/span>
              \n }<\/span> else<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dp[<\/span>i +<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              if<\/span> (<\/span>dp[<\/span>i]<\/span>[<\/span>j]<\/span> &&<\/span> len ><\/span> maxLen)<\/span> {<\/span>
              \n maxLen =<\/span> len;<\/span>
              \n start =<\/span> i;<\/span>
              \n }<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              return<\/span> s.<\/span>substring<\/span>(<\/span>start,<\/span> start +<\/span> maxLen)<\/span>;<\/span>
              \n }<\/span><\/p>\n

              public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u957f\u56de\u6587\u5b50\u4e32: "<\/span> +<\/span> longestPalindrome<\/span>(<\/span>"babad"<\/span>)<\/span>)<\/span>;<\/span>
              \n \/\/ \u8f93\u51fa: "bab" \u6216 "aba"<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u957f\u56de\u6587\u5b50\u4e32: "<\/span> +<\/span> longestPalindrome<\/span>(<\/span>"cbbd"<\/span>)<\/span>)<\/span>;<\/span>
              \n \/\/ \u8f93\u51fa: "bb"<\/span>
              \n }<\/span>
              \n}<\/span><\/p>\n

              3.3.5 \u7f16\u8f91\u8ddd\u79bb<\/h5>\n

              \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9a\u4e24\u4e2a\u5b57\u7b26\u4e32 word1 \u548c word2，\u8ba1\u7b97\u5c06 word1 \u8f6c\u6362\u6210 word2 \u6240\u4f7f\u7528\u7684\u6700\u5c11\u64cd\u4f5c\u6570（\u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362）\u3002<\/p>\n

              public<\/span> class<\/span> EditDistance<\/span> {<\/span><\/p>\n

              \/**
              \n * \u7f16\u8f91\u8ddd\u79bb – \u52a8\u6001\u89c4\u5212
              \n * \u72b6\u6001\u5b9a\u4e49：dp[i][j] = word1\u524di\u4e2a\u5b57\u7b26\u8f6c\u6362\u4e3aword2\u524dj\u4e2a\u5b57\u7b26\u7684\u6700\u5c11\u64cd\u4f5c\u6570
              \n * \u72b6\u6001\u8f6c\u79fb：
              \n * \u82e5 word1[i-1] == word2[j-1]：dp[i][j] = dp[i-1][j-1]（\u4e0d\u9700\u8981\u64cd\u4f5c）
              \n * \u5426\u5219：dp[i][j] = min(
              \n * dp[i-1][j] + 1, \/\/ \u5220\u9664word1[i-1]
              \n * dp[i][j-1] + 1, \/\/ \u5728word1\u4e2d\u63d2\u5165word2[j-1]
              \n * dp[i-1][j-1] + 1 \/\/ \u5c06word1[i-1]\u66ff\u6362\u4e3aword2[j-1]
              \n * )
              \n * \u521d\u59cb\u5316：dp[i][0] = i（\u5168\u5220\u9664），dp[0][j] = j（\u5168\u63d2\u5165）
              \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(m * n)
              \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(m * n)
              \n *\/<\/span>
              \n public<\/span> static<\/span> int<\/span> minDistance<\/span>(<\/span>String<\/span> word1,<\/span> String<\/span> word2)<\/span> {<\/span>
              \n int<\/span> m =<\/span> word1.<\/span>length<\/span>(<\/span>)<\/span>,<\/span> n =<\/span> word2.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
              \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>m +<\/span> 1<\/span>]<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

              \/\/ \u521d\u59cb\u5316<\/span>
              \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <=<\/span> m;<\/span> i++<\/span>)<\/span> dp[<\/span>i]<\/span>[<\/span>0<\/span>]<\/span> =<\/span> i;<\/span> \/\/ word1\u524di\u4e2a\u5b57\u7b26\u53d8\u4e3a\u7a7a\u4e32，\u9700i\u6b21\u5220\u9664<\/span>
              \n for<\/span> (<\/span>int<\/span> j =<\/span> 0<\/span>;<\/span> j <=<\/span> n;<\/span> j++<\/span>)<\/span> dp[<\/span>0<\/span>]<\/span>[<\/span>j]<\/span> =<\/span> j;<\/span> \/\/ \u7a7a\u4e32\u53d8\u4e3aword2\u524dj\u4e2a\u5b57\u7b26，\u9700j\u6b21\u63d2\u5165<\/span><\/p>\n

              for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <=<\/span> m;<\/span> i++<\/span>)<\/span> {<\/span>
              \n for<\/span> (<\/span>int<\/span> j =<\/span> 1<\/span>;<\/span> j <=<\/span> n;<\/span> j++<\/span>)<\/span> {<\/span>
              \n if<\/span> (<\/span>word1.<\/span>charAt<\/span>(<\/span>i –<\/span> 1<\/span>)<\/span> ==<\/span> word2.<\/span>charAt<\/span>(<\/span>j –<\/span> 1<\/span>)<\/span>)<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>;<\/span> \/\/ \u5b57\u7b26\u76f8\u540c，\u4e0d\u9700\u8981\u64cd\u4f5c<\/span>
              \n }<\/span> else<\/span> {<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>min<\/span>(<\/span>
              \n Math<\/span>.<\/span>min<\/span>(<\/span>dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span>,<\/span> dp[<\/span>i]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span>)<\/span>,<\/span> \/\/ \u5220\u9664\u3001\u63d2\u5165<\/span>
              \n dp[<\/span>i –<\/span> 1<\/span>]<\/span>[<\/span>j –<\/span> 1<\/span>]<\/span> \/\/ \u66ff\u6362<\/span>
              \n )<\/span> +<\/span> 1<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              return<\/span> dp[<\/span>m]<\/span>[<\/span>n]<\/span>;<\/span>
              \n }<\/span><\/p>\n

              public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7f16\u8f91\u8ddd\u79bb(horse, ros): "<\/span> +<\/span> minDistance<\/span>(<\/span>"horse"<\/span>,<\/span> "ros"<\/span>)<\/span>)<\/span>;<\/span>
              \n \/\/ \u8f93\u51fa: 3 (horse -> rorse -> rose -> ros)<\/span><\/p>\n

              System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7f16\u8f91\u8ddd\u79bb(intention, execution): "<\/span> +<\/span> minDistance<\/span>(<\/span>"intention"<\/span>,<\/span> "execution"<\/span>)<\/span>)<\/span>;<\/span>
              \n \/\/ \u8f93\u51fa: 5<\/span>
              \n }<\/span>
              \n}<\/span><\/p>\n

              3.3.6 \u77e9\u9635\u94fe\u4e58\u6cd5<\/h5>\n

              \u9898\u76ee\u63cf\u8ff0：\u7ed9\u5b9an\u4e2a\u77e9\u9635\u7684\u7ef4\u5ea6，\u786e\u5b9a\u77e9\u9635\u76f8\u4e58\u7684\u987a\u5e8f，\u4f7f\u5f97\u6807\u91cf\u4e58\u6cd5\u6b21\u6570\u6700\u5c11\u3002<\/p>\n

              public<\/span> class<\/span> MatrixChainMultiplication<\/span> {<\/span><\/p>\n

              \/**
              \n * \u77e9\u9635\u94fe\u4e58\u6cd5 – \u52a8\u6001\u89c4\u5212
              \n * \u72b6\u6001\u5b9a\u4e49：dp[i][j] = \u77e9\u9635Ai\u5230Aj\u76f8\u4e58\u7684\u6700\u5c0f\u6807\u91cf\u4e58\u6cd5\u6b21\u6570
              \n * \u72b6\u6001\u8f6c\u79fb：dp[i][j] = min{ dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j] }，i <= k < j
              \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n\u00b3)
              \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n\u00b2)
              \n *\/<\/span>
              \n public<\/span> static<\/span> int<\/span> matrixChainOrder<\/span>(<\/span>int<\/span>[<\/span>]<\/span> p)<\/span> {<\/span>
              \n int<\/span> n =<\/span> p.<\/span>length –<\/span> 1<\/span>;<\/span> \/\/ n\u4e2a\u77e9\u9635<\/span>
              \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dp =<\/span> new<\/span> int<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>[<\/span>n +<\/span> 1<\/span>]<\/span>;<\/span><\/p>\n

              \/\/ dp[i][i] = 0，\u5355\u4e2a\u77e9\u9635\u4e0d\u9700\u8981\u4e58\u6cd5<\/span><\/p>\n

              \/\/ len: \u94fe\u7684\u957f\u5ea6，\u4ece2\u5f00\u59cb<\/span>
              \n for<\/span> (<\/span>int<\/span> len =<\/span> 2<\/span>;<\/span> len <=<\/span> n;<\/span> len++<\/span>)<\/span> {<\/span>
              \n for<\/span> (<\/span>int<\/span> i =<\/span> 1<\/span>;<\/span> i <=<\/span> n –<\/span> len +<\/span> 1<\/span>;<\/span> i++<\/span>)<\/span> {<\/span>
              \n int<\/span> j =<\/span> i +<\/span> len –<\/span> 1<\/span>;<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>;<\/span><\/p>\n

              for<\/span> (<\/span>int<\/span> k =<\/span> i;<\/span> k <<\/span> j;<\/span> k++<\/span>)<\/span> {<\/span>
              \n int<\/span> cost =<\/span> dp[<\/span>i]<\/span>[<\/span>k]<\/span> +<\/span> dp[<\/span>k +<\/span> 1<\/span>]<\/span>[<\/span>j]<\/span> +<\/span> p[<\/span>i –<\/span> 1<\/span>]<\/span> *<\/span> p[<\/span>k]<\/span> *<\/span> p[<\/span>j]<\/span>;<\/span>
              \n dp[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> Math<\/span>.<\/span>min<\/span>(<\/span>dp[<\/span>i]<\/span>[<\/span>j]<\/span>,<\/span> cost)<\/span>;<\/span>
              \n }<\/span>
              \n }<\/span>
              \n }<\/span><\/p>\n

              return<\/span> dp[<\/span>1<\/span>]<\/span>[<\/span>n]<\/span>;<\/span>
              \n }<\/span><\/p>\n

              public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
              \n \/\/ \u77e9\u9635\u7ef4\u5ea6：A1=10×30, A2=30×5, A3=5×60<\/span>
              \n int<\/span>[<\/span>]<\/span> p =<\/span> {<\/span>10<\/span>,<\/span> 30<\/span>,<\/span> 5<\/span>,<\/span> 60<\/span>}<\/span>;<\/span>
              \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6700\u5c0f\u4e58\u6cd5\u6b21\u6570: "<\/span> +<\/span> matrixChainOrder<\/span>(<\/span>p)<\/span>)<\/span>;<\/span>
              \n \/\/ \u8f93\u51fa: 4500 ((A1*A2)*A3 = 10*30*5 + 10*5*60 = 1500 + 3000 = 4500)<\/span>
              \n }<\/span>
              \n}<\/span><\/p>\n

              \u52a8\u6001\u89c4\u5212\u90e8\u5206\u5c0f\u7ed3：DP\u662f\u671f\u672b\u8003\u8bd5\u7684\u7edd\u5bf9\u6838\u5fc3，01\u80cc\u5305\u548cLCS\u662f\u6700\u9ad8\u9891\u8003\u70b9\u3002\u5199DP\u4ee3\u7801\u65f6\u8981\u7262\u8bb0\u56db\u6b65\u6cd5（\u72b6\u6001\u5b9a\u4e49\u3001\u8f6c\u79fb\u65b9\u7a0b\u3001\u521d\u59cb\u5316\u3001\u586b\u8868\u987a\u5e8f），\u5199\u5b8c\u540e\u4e00\u5b9a\u8981\u6807\u6ce8\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u3002<\/p>\n

              \n

              \u56db\u3001\u56de\u6eaf\u7b97\u6cd5（\u975e\u5e38\u9ad8\u9891\u4ee3\u7801\u9898）<\/h3>\n

              4.1 \u6838\u5fc3\u601d\u60f3<\/h4>\n

              \u56de\u6eaf\u7b97\u6cd5\u7684\u672c\u8d28\u662f\u9012\u5f52 + \u526a\u679d，\u901a\u8fc7\u679a\u4e3e\u6240\u6709\u53ef\u80fd\u7684\u89e3，\u5e76\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u53ca\u65f6\u6392\u9664\u4e0d\u7b26\u5408\u6761\u4ef6\u7684\u5206\u652f\u3002<\/p>\n

              Java\u56de\u6eaf\u7b97\u6cd5\u7684\u901a\u7528\u6a21\u677f：<\/p>\n

              void<\/span> backtrack<\/span>(<\/span>\u8def\u5f84,<\/span> \u9009\u62e9\u5217\u8868)<\/span> {<\/span>
              \n if<\/span> (<\/span>\u6ee1\u8db3\u7ed3\u675f\u6761\u4ef6)<\/span> {<\/span>
              \n \u7ed3\u679c.<\/span>add<\/span>(<\/span>\u8def\u5f84)<\/span>;<\/span>
              \n return<\/span>;<\/span>
              \n }<\/span><\/p>\n

              for<\/span> (<\/span>\u9009\u62e9 :<\/span> \u9009\u62e9\u5217\u8868)<\/span> {<\/span>
              \n \u505a\u9009\u62e9;<\/span> \/\/ path.add(choice)<\/span>
              \n backtrack<\/span>(<\/span>\u8def\u5f84,<\/span> \u9009\u62e9\u5217\u8868)<\/span>;<\/span>
              \n \u64a4\u9500\u9009\u62e9;<\/span> \/\/ path.remove(choice) \u2605\u2605\u2605 \u56de\u6eaf\u6838\u5fc3 \u2605\u2605\u2605<\/span>
              \n }<\/span>
              \n}<\/span><\/p>\n

              \u5173\u952e\u8981\u70b9：<\/p>\n

                \n
              • Java\u4e2d\u4e00\u822c\u7528 List<List<Integer>> \u4fdd\u5b58\u7ed3\u679c\u96c6<\/li>\n
              • \u56de\u6eaf\u65f6 add \u4e4b\u540e，\u9012\u5f52\u8fd4\u56de\u4e00\u5b9a\u8981 remove（\u64a4\u9500\u9009\u62e9）<\/li>\n
              • \u526a\u679d\u662f\u5f97\u5206\u70b9，\u80fd\u5199\u526a\u679d\u4e00\u5b9a\u8981\u5199<\/li>\n<\/ul>\n

                4.2 \u5b50\u96c6\u95ee\u9898<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> Subsets<\/span> {<\/span><\/p>\n

                \/**
                \n * \u5b50\u96c6 – \u56de\u6eaf\u7b97\u6cd5
                \n * \u7ed9\u5b9a\u4e00\u4e2a\u4e0d\u542b\u91cd\u590d\u5143\u7d20\u7684\u6570\u7ec4，\u8fd4\u56de\u6240\u6709\u53ef\u80fd\u7684\u5b50\u96c6
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n * 2^n)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)（\u9012\u5f52\u6808\u6df1\u5ea6）
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> subsets<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums)<\/span> {<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> nums,<\/span> 0<\/span>)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> startIndex)<\/span> {<\/span>
                \n \/\/ \u6bcf\u4e2a\u8282\u70b9\u90fd\u662f\u4e00\u4e2a\u6709\u6548\u5b50\u96c6（\u4e0d\u9700\u8981\u5224\u65ad\u7ec8\u6b62\u6761\u4ef6）<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span> \/\/ \u6ce8\u610f：\u5fc5\u987bnew ArrayList\u590d\u5236！<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> startIndex;<\/span> i <<\/span> nums.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n path.<\/span>add<\/span>(<\/span>nums[<\/span>i]<\/span>)<\/span>;<\/span> \/\/ \u505a\u9009\u62e9<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> path,<\/span> nums,<\/span> i +<\/span> 1<\/span>)<\/span>;<\/span> \/\/ \u9012\u5f52<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span> \/\/ \u64a4\u9500\u9009\u62e9（\u56de\u6eaf）<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> nums =<\/span> {<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>}<\/span>;<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> subsets<\/span>(<\/span>nums)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6240\u6709\u5b50\u96c6: "<\/span> +<\/span> result)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[], [1], [1,2], [1,2,3], [1,3], [2], [2,3], [3]]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                4.3 \u5b50\u96c6II（\u542b\u91cd\u590d\u5143\u7d20，\u53bb\u91cd）<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> SubsetsII<\/span> {<\/span><\/p>\n

                \/**
                \n * \u5b50\u96c6II – \u542b\u91cd\u590d\u5143\u7d20，\u9700\u8981\u53bb\u91cd
                \n * \u5173\u952e：\u5148\u6392\u5e8f，\u7136\u540e\u5728\u540c\u4e00\u5c42\u4e2d\u8df3\u8fc7\u91cd\u590d\u5143\u7d20
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n * 2^n)
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> subsetsWithDup<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums)<\/span> {<\/span>
                \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>nums)<\/span>;<\/span> \/\/ \u2605 \u5fc5\u987b\u5148\u6392\u5e8f！<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> nums,<\/span> 0<\/span>)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> nums,<\/span> int<\/span> startIndex)<\/span> {<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> startIndex;<\/span> i <<\/span> nums.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n \/\/ \u2605 \u526a\u679d\u53bb\u91cd：\u540c\u4e00\u5c42\u4e2d，\u5982\u679c\u5f53\u524d\u5143\u7d20\u548c\u524d\u4e00\u4e2a\u76f8\u540c，\u8df3\u8fc7<\/span>
                \n if<\/span> (<\/span>i ><\/span> startIndex &&<\/span> nums[<\/span>i]<\/span> ==<\/span> nums[<\/span>i –<\/span> 1<\/span>]<\/span>)<\/span> {<\/span>
                \n continue<\/span>;<\/span>
                \n }<\/span>
                \n path.<\/span>add<\/span>(<\/span>nums[<\/span>i]<\/span>)<\/span>;<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> path,<\/span> nums,<\/span> i +<\/span> 1<\/span>)<\/span>;<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> nums =<\/span> {<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 2<\/span>}<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u53bb\u91cd\u5b50\u96c6: "<\/span> +<\/span> subsetsWithDup<\/span>(<\/span>nums)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[], [1], [1,2], [1,2,2], [2], [2,2]]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                4.4 \u5168\u6392\u5217<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> Permutations<\/span> {<\/span><\/p>\n

                \/**
                \n * \u5168\u6392\u5217 – \u56de\u6eaf\u7b97\u6cd5
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n * n!)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> permute<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums)<\/span> {<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> used =<\/span> new<\/span> boolean<\/span>[<\/span>nums.<\/span>length]<\/span>;<\/span> \/\/ \u6807\u8bb0\u5143\u7d20\u662f\u5426\u5df2\u4f7f\u7528<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> nums,<\/span> used)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> nums,<\/span> boolean<\/span>[<\/span>]<\/span> used)<\/span> {<\/span>
                \n \/\/ \u7ec8\u6b62\u6761\u4ef6：\u8def\u5f84\u957f\u5ea6\u7b49\u4e8e\u6570\u7ec4\u957f\u5ea6<\/span>
                \n if<\/span> (<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> ==<\/span> nums.<\/span>length)<\/span> {<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> nums.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>used[<\/span>i]<\/span>)<\/span> continue<\/span>;<\/span> \/\/ \u5df2\u4f7f\u7528\u7684\u5143\u7d20\u8df3\u8fc7<\/span><\/p>\n

                used[<\/span>i]<\/span> =<\/span> true<\/span>;<\/span> \/\/ \u505a\u9009\u62e9<\/span>
                \n path.<\/span>add<\/span>(<\/span>nums[<\/span>i]<\/span>)<\/span>;<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> path,<\/span> nums,<\/span> used)<\/span>;<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span> \/\/ \u64a4\u9500\u9009\u62e9<\/span>
                \n used[<\/span>i]<\/span> =<\/span> false<\/span>;<\/span> \/\/ \u64a4\u9500\u6807\u8bb0<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u5168\u6392\u5217II – \u542b\u91cd\u590d\u5143\u7d20，\u53bb\u91cd
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> permuteUnique<\/span>(<\/span>int<\/span>[<\/span>]<\/span> nums)<\/span> {<\/span>
                \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>nums)<\/span>;<\/span> \/\/ \u2605 \u5148\u6392\u5e8f<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> used =<\/span> new<\/span> boolean<\/span>[<\/span>nums.<\/span>length]<\/span>;<\/span>
                \n backtrackUnique<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> nums,<\/span> used)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrackUnique<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> nums,<\/span> boolean<\/span>[<\/span>]<\/span> used)<\/span> {<\/span>
                \n if<\/span> (<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> ==<\/span> nums.<\/span>length)<\/span> {<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> nums.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>used[<\/span>i]<\/span>)<\/span> continue<\/span>;<\/span>
                \n \/\/ \u2605 \u53bb\u91cd\u526a\u679d：\u540c\u4e00\u5c42\u4e2d，\u524d\u4e00\u4e2a\u76f8\u540c\u5143\u7d20\u672a\u88ab\u4f7f\u7528\u65f6\u8df3\u8fc7<\/span>
                \n if<\/span> (<\/span>i ><\/span> 0<\/span> &&<\/span> nums[<\/span>i]<\/span> ==<\/span> nums[<\/span>i –<\/span> 1<\/span>]<\/span> &&<\/span> !<\/span>used[<\/span>i –<\/span> 1<\/span>]<\/span>)<\/span> {<\/span>
                \n continue<\/span>;<\/span>
                \n }<\/span><\/p>\n

                used[<\/span>i]<\/span> =<\/span> true<\/span>;<\/span>
                \n path.<\/span>add<\/span>(<\/span>nums[<\/span>i]<\/span>)<\/span>;<\/span>
                \n backtrackUnique<\/span>(<\/span>result,<\/span> path,<\/span> nums,<\/span> used)<\/span>;<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span>
                \n used[<\/span>i]<\/span> =<\/span> false<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> nums =<\/span> {<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>}<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u5168\u6392\u5217: "<\/span> +<\/span> permute<\/span>(<\/span>nums)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]<\/span><\/p>\n

                int<\/span>[<\/span>]<\/span> nums2 =<\/span> {<\/span>1<\/span>,<\/span> 1<\/span>,<\/span> 2<\/span>}<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u53bb\u91cd\u5168\u6392\u5217: "<\/span> +<\/span> permuteUnique<\/span>(<\/span>nums2)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[1,1,2], [1,2,1], [2,1,1]]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                4.5 N\u7687\u540e（\u7ecf\u5178\u5927\u9898）<\/h4>\n

                \u9898\u76ee\u63cf\u8ff0：\u5728 n\u00d7n \u7684\u68cb\u76d8\u4e0a\u653e\u7f6e n \u4e2a\u7687\u540e，\u4f7f\u5f97\u5b83\u4eec\u4e92\u4e0d\u653b\u51fb（\u4e0d\u5728\u540c\u4e00\u884c\u3001\u540c\u4e00\u5217\u3001\u540c\u4e00\u5bf9\u89d2\u7ebf）\u3002<\/p>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> NQueens<\/span> {<\/span><\/p>\n

                private<\/span> static<\/span> int<\/span> solutionCount =<\/span> 0<\/span>;<\/span><\/p>\n

                \/**
                \n * N\u7687\u540e – \u56de\u6eaf\u7b97\u6cd5
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n!)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>String<\/span>><\/span>><\/span><\/span> solveNQueens<\/span>(<\/span>int<\/span> n)<\/span> {<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>String<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n char<\/span>[<\/span>]<\/span>[<\/span>]<\/span> board =<\/span> new<\/span> char<\/span>[<\/span>n]<\/span>[<\/span>n]<\/span>;<\/span>
                \n for<\/span> (<\/span>char<\/span>[<\/span>]<\/span> row :<\/span> board)<\/span> {<\/span>
                \n Arrays<\/span>.<\/span>fill<\/span>(<\/span>row,<\/span> '.'<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> board,<\/span> 0<\/span>,<\/span> n)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>String<\/span>><\/span>><\/span><\/span> result,<\/span> char<\/span>[<\/span>]<\/span>[<\/span>]<\/span> board,<\/span> int<\/span> row,<\/span> int<\/span> n)<\/span> {<\/span>
                \n if<\/span> (<\/span>row ==<\/span> n)<\/span> {<\/span>
                \n \/\/ \u627e\u5230\u4e00\u79cd\u89e3\u6cd5<\/span>
                \n List<\/span><<\/span>String<\/span>><\/span><\/span> solution =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>char<\/span>[<\/span>]<\/span> r :<\/span> board)<\/span> {<\/span>
                \n solution.<\/span>add<\/span>(<\/span>new<\/span> String<\/span>(<\/span>r)<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n result.<\/span>add<\/span>(<\/span>solution)<\/span>;<\/span>
                \n solutionCount++<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> col =<\/span> 0<\/span>;<\/span> col <<\/span> n;<\/span> col++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>isValid<\/span>(<\/span>board,<\/span> row,<\/span> col,<\/span> n)<\/span>)<\/span> {<\/span>
                \n board[<\/span>row]<\/span>[<\/span>col]<\/span> =<\/span> 'Q'<\/span>;<\/span> \/\/ \u653e\u7f6e\u7687\u540e<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> board,<\/span> row +<\/span> 1<\/span>,<\/span> n)<\/span>;<\/span>
                \n board[<\/span>row]<\/span>[<\/span>col]<\/span> =<\/span> '.'<\/span>;<\/span> \/\/ \u64a4\u9500\u653e\u7f6e（\u56de\u6eaf）<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u68c0\u67e5\u5728 (row, col) \u4f4d\u7f6e\u653e\u7f6e\u7687\u540e\u662f\u5426\u5408\u6cd5
                \n * \u53ea\u9700\u8981\u68c0\u67e5\u4e0a\u65b9（\u56e0\u4e3a\u4e0b\u65b9\u8fd8\u6ca1\u653e）
                \n *\/<\/span>
                \n private<\/span> static<\/span> boolean<\/span> isValid<\/span>(<\/span>char<\/span>[<\/span>]<\/span>[<\/span>]<\/span> board,<\/span> int<\/span> row,<\/span> int<\/span> col,<\/span> int<\/span> n)<\/span> {<\/span>
                \n \/\/ \u68c0\u67e5\u5217<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> row;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>board[<\/span>i]<\/span>[<\/span>col]<\/span> ==<\/span> 'Q'<\/span>)<\/span> return<\/span> false<\/span>;<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u68c0\u67e5\u5de6\u4e0a\u5bf9\u89d2\u7ebf<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> row –<\/span> 1<\/span>,<\/span> j =<\/span> col –<\/span> 1<\/span>;<\/span> i >=<\/span> 0<\/span> &&<\/span> j >=<\/span> 0<\/span>;<\/span> i—<\/span>,<\/span> j—<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>board[<\/span>i]<\/span>[<\/span>j]<\/span> ==<\/span> 'Q'<\/span>)<\/span> return<\/span> false<\/span>;<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u68c0\u67e5\u53f3\u4e0a\u5bf9\u89d2\u7ebf<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> row –<\/span> 1<\/span>,<\/span> j =<\/span> col +<\/span> 1<\/span>;<\/span> i >=<\/span> 0<\/span> &&<\/span> j <<\/span> n;<\/span> i—<\/span>,<\/span> j++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>board[<\/span>i]<\/span>[<\/span>j]<\/span> ==<\/span> 'Q'<\/span>)<\/span> return<\/span> false<\/span>;<\/span>
                \n }<\/span><\/p>\n

                return<\/span> true<\/span>;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u7b80\u5316\u7248：\u53ea\u6c42N\u7687\u540e\u7684\u89e3\u6cd5\u6570\u91cf（\u8003\u8bd5\u66f4\u5e38\u8003）
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span> totalNQueens<\/span>(<\/span>int<\/span> n)<\/span> {<\/span>
                \n solutionCount =<\/span> 0<\/span>;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> cols =<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>;<\/span> \/\/ \u5217\u662f\u5426\u88ab\u5360\u7528<\/span>
                \n boolean<\/span>[<\/span>]<\/span> diag1 =<\/span> new<\/span> boolean<\/span>[<\/span>2<\/span> *<\/span> n]<\/span>;<\/span> \/\/ \u4e3b\u5bf9\u89d2\u7ebf (row – col + n)<\/span>
                \n boolean<\/span>[<\/span>]<\/span> diag2 =<\/span> new<\/span> boolean<\/span>[<\/span>2<\/span> *<\/span> n]<\/span>;<\/span> \/\/ \u526f\u5bf9\u89d2\u7ebf (row + col)<\/span>
                \n backtrackCount<\/span>(<\/span>0<\/span>,<\/span> n,<\/span> cols,<\/span> diag1,<\/span> diag2)<\/span>;<\/span>
                \n return<\/span> solutionCount;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrackCount<\/span>(<\/span>int<\/span> row,<\/span> int<\/span> n,<\/span> boolean<\/span>[<\/span>]<\/span> cols,<\/span>
                \n boolean<\/span>[<\/span>]<\/span> diag1,<\/span> boolean<\/span>[<\/span>]<\/span> diag2)<\/span> {<\/span>
                \n if<\/span> (<\/span>row ==<\/span> n)<\/span> {<\/span>
                \n solutionCount++<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> col =<\/span> 0<\/span>;<\/span> col <<\/span> n;<\/span> col++<\/span>)<\/span> {<\/span>
                \n int<\/span> d1 =<\/span> row –<\/span> col +<\/span> n;<\/span>
                \n int<\/span> d2 =<\/span> row +<\/span> col;<\/span><\/p>\n

                if<\/span> (<\/span>cols[<\/span>col]<\/span> ||<\/span> diag1[<\/span>d1]<\/span> ||<\/span> diag2[<\/span>d2]<\/span>)<\/span> continue<\/span>;<\/span> \/\/ \u526a\u679d<\/span><\/p>\n

                cols[<\/span>col]<\/span> =<\/span> true<\/span>;<\/span> diag1[<\/span>d1]<\/span> =<\/span> true<\/span>;<\/span> diag2[<\/span>d2]<\/span> =<\/span> true<\/span>;<\/span>
                \n backtrackCount<\/span>(<\/span>row +<\/span> 1<\/span>,<\/span> n,<\/span> cols,<\/span> diag1,<\/span> diag2)<\/span>;<\/span>
                \n cols[<\/span>col]<\/span> =<\/span> false<\/span>;<\/span> diag1[<\/span>d1]<\/span> =<\/span> false<\/span>;<\/span> diag2[<\/span>d2]<\/span> =<\/span> false<\/span>;<\/span> \/\/ \u56de\u6eaf<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span> n =<\/span> 4<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>n +<\/span> "\u7687\u540e\u7684\u89e3\u6cd5\u6570\u91cf: "<\/span> +<\/span> totalNQueens<\/span>(<\/span>n)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: 2<\/span><\/p>\n

                List<\/span><<\/span>List<\/span><<\/span>String<\/span>><\/span>><\/span><\/span> solutions =<\/span> solveNQueens<\/span>(<\/span>n)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u5177\u4f53\u89e3\u6cd5:"<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>List<\/span><<\/span>String<\/span>><\/span><\/span> sol :<\/span> solutions)<\/span> {<\/span>
                \n for<\/span> (<\/span>String<\/span> row :<\/span> sol)<\/span> {<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>" "<\/span> +<\/span> row)<\/span>;<\/span>
                \n }<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                4.6 \u7ec4\u5408\u6c42\u548c<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> CombinationSum<\/span> {<\/span><\/p>\n

                \/**
                \n * \u7ec4\u5408\u6c42\u548c – \u5143\u7d20\u53ef\u91cd\u590d\u9009
                \n * \u7ed9\u5b9a\u5019\u9009\u6570\u7ec4\u548c\u76ee\u6807\u503c，\u627e\u51fa\u6240\u6709\u548c\u4e3atarget\u7684\u7ec4\u5408（\u5143\u7d20\u53ef\u91cd\u590d\u4f7f\u7528）
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：\u53d6\u51b3\u4e8e\u89e3\u7684\u6570\u91cf
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> combinationSum<\/span>(<\/span>int<\/span>[<\/span>]<\/span> candidates,<\/span> int<\/span> target)<\/span> {<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>candidates)<\/span>;<\/span> \/\/ \u6392\u5e8f\u6709\u5229\u4e8e\u526a\u679d<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> candidates,<\/span> target,<\/span> 0<\/span>)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> candidates,<\/span> int<\/span> remain,<\/span> int<\/span> startIndex)<\/span> {<\/span>
                \n if<\/span> (<\/span>remain <<\/span> 0<\/span>)<\/span> return<\/span>;<\/span> \/\/ \u526a\u679d<\/span>
                \n if<\/span> (<\/span>remain ==<\/span> 0<\/span>)<\/span> {<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> startIndex;<\/span> i <<\/span> candidates.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n \/\/ \u526a\u679d\u4f18\u5316：\u5982\u679c\u5f53\u524d\u5143\u7d20\u5df2\u7ecf\u5927\u4e8e\u5269\u4f59\u503c，\u540e\u9762\u66f4\u5927\u7684\u4e5f\u4e0d\u7528\u8bd5\u4e86<\/span>
                \n if<\/span> (<\/span>candidates[<\/span>i]<\/span> ><\/span> remain)<\/span> break<\/span>;<\/span><\/p>\n

                path.<\/span>add<\/span>(<\/span>candidates[<\/span>i]<\/span>)<\/span>;<\/span>
                \n \/\/ \u6ce8\u610f：startIndex\u4f20i（\u4e0d\u662fi+1），\u56e0\u4e3a\u5143\u7d20\u53ef\u4ee5\u91cd\u590d\u9009<\/span>
                \n backtrack<\/span>(<\/span>result,<\/span> path,<\/span> candidates,<\/span> remain –<\/span> candidates[<\/span>i]<\/span>,<\/span> i)<\/span>;<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u7ec4\u5408\u6c42\u548cII – \u5143\u7d20\u4e0d\u53ef\u91cd\u590d\u9009，\u6570\u7ec4\u53ef\u80fd\u6709\u91cd\u590d\u5143\u7d20
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> combinationSum2<\/span>(<\/span>int<\/span>[<\/span>]<\/span> candidates,<\/span> int<\/span> target)<\/span> {<\/span>
                \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>candidates)<\/span>;<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n backtrack2<\/span>(<\/span>result,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>,<\/span> candidates,<\/span> target,<\/span> 0<\/span>)<\/span>;<\/span>
                \n return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                private<\/span> static<\/span> void<\/span> backtrack2<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> result,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> path,<\/span>
                \n int<\/span>[<\/span>]<\/span> candidates,<\/span> int<\/span> remain,<\/span> int<\/span> startIndex)<\/span> {<\/span>
                \n if<\/span> (<\/span>remain ==<\/span> 0<\/span>)<\/span> {<\/span>
                \n result.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>path)<\/span>)<\/span>;<\/span>
                \n return<\/span>;<\/span>
                \n }<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> startIndex;<\/span> i <<\/span> candidates.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>candidates[<\/span>i]<\/span> ><\/span> remain)<\/span> break<\/span>;<\/span> \/\/ \u526a\u679d<\/span>
                \n \/\/ \u53bb\u91cd：\u540c\u4e00\u5c42\u4e2d\u8df3\u8fc7\u91cd\u590d\u5143\u7d20<\/span>
                \n if<\/span> (<\/span>i ><\/span> startIndex &&<\/span> candidates[<\/span>i]<\/span> ==<\/span> candidates[<\/span>i –<\/span> 1<\/span>]<\/span>)<\/span> continue<\/span>;<\/span><\/p>\n

                path.<\/span>add<\/span>(<\/span>candidates[<\/span>i]<\/span>)<\/span>;<\/span>
                \n backtrack2<\/span>(<\/span>result,<\/span> path,<\/span> candidates,<\/span> remain –<\/span> candidates[<\/span>i]<\/span>,<\/span> i +<\/span> 1<\/span>)<\/span>;<\/span> \/\/ i+1: \u4e0d\u53ef\u91cd\u590d\u9009<\/span>
                \n path.<\/span>remove<\/span>(<\/span>path.<\/span>size<\/span>(<\/span>)<\/span> –<\/span> 1<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> candidates =<\/span> {<\/span>2<\/span>,<\/span> 3<\/span>,<\/span> 6<\/span>,<\/span> 7<\/span>}<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7ec4\u5408\u6c42\u548c(target=7): "<\/span> +<\/span> combinationSum<\/span>(<\/span>candidates,<\/span> 7<\/span>)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[2,2,3], [7]]<\/span><\/p>\n

                int<\/span>[<\/span>]<\/span> candidates2 =<\/span> {<\/span>10<\/span>,<\/span> 1<\/span>,<\/span> 2<\/span>,<\/span> 7<\/span>,<\/span> 6<\/span>,<\/span> 1<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u7ec4\u5408\u6c42\u548cII(target=8): "<\/span> +<\/span> combinationSum2<\/span>(<\/span>candidates2,<\/span> 8<\/span>)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [[1,1,6], [1,2,5], [1,7], [2,6]]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                \u56de\u6eaf\u90e8\u5206\u5c0f\u7ed3：\u56de\u6eaf\u7b97\u6cd5\u662f\u671f\u672b\u8003\u8bd5\u4e2d\u975e\u5e38\u9ad8\u9891\u7684\u4ee3\u7801\u9898\u3002\u8bb0\u4f4f\u901a\u7528\u6a21\u677f（\u505a\u9009\u62e9\u2192\u9012\u5f52\u2192\u64a4\u9500\u9009\u62e9），\u6ce8\u610f\u7ed3\u679c\u96c6\u4e2d\u8981 new ArrayList<>(path) \u505a\u6df1\u62f7\u8d1d\u3002\u53bb\u91cd\u526a\u679d\u662f\u52a0\u5206\u9879，\u5148\u6392\u5e8f\u518d\u53bb\u91cd\u662f\u56fa\u5b9a\u5957\u8def\u3002<\/p>\n

                \n

                \u4e94\u3001\u56fe\u7b97\u6cd5（\u4ee3\u7801\u5927\u9898，\u4e2d\u9ad8\u6982\u7387）<\/h3>\n

                5.1 \u56fe\u7684\u5b58\u50a8<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> GraphRepresentation<\/span> {<\/span><\/p>\n

                \/**
                \n * \u90bb\u63a5\u77e9\u9635\u8868\u793a（\u9002\u5408\u7a20\u5bc6\u56fe）
                \n * adjMatrix[i][j] = 1 \u8868\u793a\u5b58\u5728\u8fb9 i->j（\u6709\u6743\u56fe\u5219\u5b58\u6743\u91cd）
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> createAdjMatrix<\/span>(<\/span>int<\/span> n,<\/span> int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> edges)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> adjMatrix =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>[<\/span>n]<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> edge :<\/span> edges)<\/span> {<\/span>
                \n adjMatrix[<\/span>edge[<\/span>0<\/span>]<\/span>]<\/span>[<\/span>edge[<\/span>1<\/span>]<\/span>]<\/span> =<\/span> 1<\/span>;<\/span>
                \n \/\/ adjMatrix[edge[1]][edge[0]] = 1; \/\/ \u65e0\u5411\u56fe\u9700\u8981\u53cc\u5411\u8bbe\u7f6e<\/span>
                \n }<\/span>
                \n return<\/span> adjMatrix;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u90bb\u63a5\u8868\u8868\u793a（\u9002\u5408\u7a00\u758f\u56fe，Java\u4e2d\u63a8\u8350）
                \n * \u4f7f\u7528 List<List<Integer>> \u5b9e\u73b0
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> createAdjList<\/span>(<\/span>int<\/span> n,<\/span> int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> edges)<\/span> {<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adjList =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n adjList.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> edge :<\/span> edges)<\/span> {<\/span>
                \n adjList.<\/span>get<\/span>(<\/span>edge[<\/span>0<\/span>]<\/span>)<\/span>.<\/span>add<\/span>(<\/span>edge[<\/span>1<\/span>]<\/span>)<\/span>;<\/span>
                \n \/\/ adjList.get(edge[1]).add(edge[0]); \/\/ \u65e0\u5411\u56fe<\/span>
                \n }<\/span>
                \n return<\/span> adjList;<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                5.2 DFS\u548cBFS\u904d\u5386<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> GraphTraversal<\/span> {<\/span><\/p>\n

                \/**
                \n * DFS\u6df1\u5ea6\u4f18\u5148\u904d\u5386（\u9012\u5f52\u7248）
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V)
                \n *\/<\/span>
                \n public<\/span> static<\/span> void<\/span> dfs<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj,<\/span> int<\/span> node,<\/span> boolean<\/span>[<\/span>]<\/span> visited,<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> result)<\/span> {<\/span>
                \n visited[<\/span>node]<\/span> =<\/span> true<\/span>;<\/span>
                \n result.<\/span>add<\/span>(<\/span>node)<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> neighbor :<\/span> adj.<\/span>get<\/span>(<\/span>node)<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>visited[<\/span>neighbor]<\/span>)<\/span> {<\/span>
                \n dfs<\/span>(<\/span>adj,<\/span> neighbor,<\/span> visited,<\/span> result)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * BFS\u5e7f\u5ea6\u4f18\u5148\u904d\u5386
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V)
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> bfs<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj,<\/span> int<\/span> start)<\/span> {<\/span>
                \n List<\/span><<\/span>Integer<\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> visited =<\/span> new<\/span> boolean<\/span>[<\/span>adj.<\/span>size<\/span>(<\/span>)<\/span>]<\/span>;<\/span>
                \n Queue<\/span><<\/span>Integer<\/span>><\/span><\/span> queue =<\/span> new<\/span> LinkedList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span><\/p>\n

                visited[<\/span>start]<\/span> =<\/span> true<\/span>;<\/span>
                \n queue.<\/span>offer<\/span>(<\/span>start)<\/span>;<\/span><\/p>\n

                while<\/span> (<\/span>!<\/span>queue.<\/span>isEmpty<\/span>(<\/span>)<\/span>)<\/span> {<\/span>
                \n int<\/span> node =<\/span> queue.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span>
                \n result.<\/span>add<\/span>(<\/span>node)<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> neighbor :<\/span> adj.<\/span>get<\/span>(<\/span>node)<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>visited[<\/span>neighbor]<\/span>)<\/span> {<\/span>
                \n visited[<\/span>neighbor]<\/span> =<\/span> true<\/span>;<\/span>
                \n queue.<\/span>offer<\/span>(<\/span>neighbor)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u6c42\u8fde\u901a\u5206\u91cf\u6570\u91cf（DFS\u5e94\u7528）
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span> countComponents<\/span>(<\/span>int<\/span> n,<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj)<\/span> {<\/span>
                \n boolean<\/span>[<\/span>]<\/span> visited =<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>;<\/span>
                \n int<\/span> count =<\/span> 0<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>visited[<\/span>i]<\/span>)<\/span> {<\/span>
                \n dfs<\/span>(<\/span>adj,<\/span> i,<\/span> visited,<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>)<\/span>;<\/span>
                \n count++<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> count;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span> n =<\/span> 5<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> edges =<\/span> {<\/span>{<\/span>0<\/span>,<\/span>1<\/span>}<\/span>,<\/span> {<\/span>0<\/span>,<\/span>2<\/span>}<\/span>,<\/span> {<\/span>1<\/span>,<\/span>3<\/span>}<\/span>,<\/span> {<\/span>2<\/span>,<\/span>4<\/span>}<\/span>}<\/span>;<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> adj.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> e :<\/span> edges)<\/span> {<\/span>
                \n adj.<\/span>get<\/span>(<\/span>e[<\/span>0<\/span>]<\/span>)<\/span>.<\/span>add<\/span>(<\/span>e[<\/span>1<\/span>]<\/span>)<\/span>;<\/span>
                \n adj.<\/span>get<\/span>(<\/span>e[<\/span>1<\/span>]<\/span>)<\/span>.<\/span>add<\/span>(<\/span>e[<\/span>0<\/span>]<\/span>)<\/span>;<\/span>
                \n }<\/span><\/p>\n

                List<\/span><<\/span>Integer<\/span>><\/span><\/span> dfsResult =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n dfs<\/span>(<\/span>adj,<\/span> 0<\/span>,<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>,<\/span> dfsResult)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"DFS\u904d\u5386: "<\/span> +<\/span> dfsResult)<\/span>;<\/span> \/\/ [0, 1, 3, 2, 4]<\/span><\/p>\n

                System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"BFS\u904d\u5386: "<\/span> +<\/span> bfs<\/span>(<\/span>adj,<\/span> 0<\/span>)<\/span>)<\/span>;<\/span> \/\/ [0, 1, 2, 3, 4]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                5.3 Dijkstra\u6700\u77ed\u8def\u5f84<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> Dijkstra<\/span> {<\/span><\/p>\n

                \/**
                \n * Dijkstra\u5355\u6e90\u6700\u77ed\u8def\u5f84（\u4f18\u5148\u961f\u5217\u4f18\u5316\u7248）
                \n * \u9002\u7528\u6761\u4ef6：\u65e0\u8d1f\u6743\u8fb9
                \n *
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O((V + E) log V)（\u4f7f\u7528\u4f18\u5148\u961f\u5217）
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span>[<\/span>]<\/span> dijkstra<\/span>(<\/span>List<\/span><<\/span>List<\/span><<\/span>int<\/span>[<\/span>]<\/span>>><\/span> adj,<\/span> int<\/span> start)<\/span> {<\/span>
                \n int<\/span> n =<\/span> adj.<\/span>size<\/span>(<\/span>)<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span> dist =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span>
                \n Arrays<\/span>.<\/span>fill<\/span>(<\/span>dist,<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>)<\/span>;<\/span>
                \n dist[<\/span>start]<\/span> =<\/span> 0<\/span>;<\/span><\/p>\n

                \/\/ \u4f18\u5148\u961f\u5217：{\u8ddd\u79bb, \u8282\u70b9}，\u6309\u8ddd\u79bb\u5347\u5e8f<\/span>
                \n PriorityQueue<\/span><<\/span>int<\/span>[<\/span>]<\/span>><\/span> pq =<\/span> new<\/span> PriorityQueue<\/span><<\/span>><\/span><\/span>(<\/span>(<\/span>a,<\/span> b)<\/span> -><\/span> a[<\/span>0<\/span>]<\/span> –<\/span> b[<\/span>0<\/span>]<\/span>)<\/span>;<\/span>
                \n pq.<\/span>offer<\/span>(<\/span>new<\/span> int<\/span>[<\/span>]<\/span>{<\/span>0<\/span>,<\/span> start}<\/span>)<\/span>;<\/span><\/p>\n

                while<\/span> (<\/span>!<\/span>pq.<\/span>isEmpty<\/span>(<\/span>)<\/span>)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> curr =<\/span> pq.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span>
                \n int<\/span> d =<\/span> curr[<\/span>0<\/span>]<\/span>,<\/span> u =<\/span> curr[<\/span>1<\/span>]<\/span>;<\/span><\/p>\n

                if<\/span> (<\/span>d ><\/span> dist[<\/span>u]<\/span>)<\/span> continue<\/span>;<\/span> \/\/ \u5df2\u7ecf\u627e\u5230\u66f4\u77ed\u8def\u5f84，\u8df3\u8fc7<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> edge :<\/span> adj.<\/span>get<\/span>(<\/span>u)<\/span>)<\/span> {<\/span>
                \n int<\/span> v =<\/span> edge[<\/span>0<\/span>]<\/span>,<\/span> weight =<\/span> edge[<\/span>1<\/span>]<\/span>;<\/span>
                \n if<\/span> (<\/span>dist[<\/span>u]<\/span> +<\/span> weight <<\/span> dist[<\/span>v]<\/span>)<\/span> {<\/span>
                \n dist[<\/span>v]<\/span> =<\/span> dist[<\/span>u]<\/span> +<\/span> weight;<\/span>
                \n pq.<\/span>offer<\/span>(<\/span>new<\/span> int<\/span>[<\/span>]<\/span>{<\/span>dist[<\/span>v]<\/span>,<\/span> v}<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> dist;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * Dijkstra – \u90bb\u63a5\u77e9\u9635\u7248\u672c（\u9002\u5408\u7a20\u5bc6\u56fe，\u8003\u8bd5\u66f4\u5e38\u8003）
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V\u00b2)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V)
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span>[<\/span>]<\/span> dijkstraMatrix<\/span>(<\/span>int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph,<\/span> int<\/span> start)<\/span> {<\/span>
                \n int<\/span> n =<\/span> graph.<\/span>length;<\/span>
                \n int<\/span>[<\/span>]<\/span> dist =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> visited =<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>;<\/span>
                \n Arrays<\/span>.<\/span>fill<\/span>(<\/span>dist,<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>)<\/span>;<\/span>
                \n dist[<\/span>start]<\/span> =<\/span> 0<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> count =<\/span> 0<\/span>;<\/span> count <<\/span> n;<\/span> count++<\/span>)<\/span> {<\/span>
                \n \/\/ \u627e\u672a\u8bbf\u95ee\u4e2d\u8ddd\u79bb\u6700\u5c0f\u7684\u8282\u70b9<\/span>
                \n int<\/span> u =<\/span> –<\/span>1<\/span>;<\/span>
                \n int<\/span> minDist =<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>visited[<\/span>i]<\/span> &&<\/span> dist[<\/span>i]<\/span> <<\/span> minDist)<\/span> {<\/span>
                \n minDist =<\/span> dist[<\/span>i]<\/span>;<\/span>
                \n u =<\/span> i;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                if<\/span> (<\/span>u ==<\/span> –<\/span>1<\/span>)<\/span> break<\/span>;<\/span>
                \n visited[<\/span>u]<\/span> =<\/span> true<\/span>;<\/span><\/p>\n

                \/\/ \u66f4\u65b0\u90bb\u5c45\u8ddd\u79bb<\/span>
                \n for<\/span> (<\/span>int<\/span> v =<\/span> 0<\/span>;<\/span> v <<\/span> n;<\/span> v++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>visited[<\/span>v]<\/span> &&<\/span> graph[<\/span>u]<\/span>[<\/span>v]<\/span> !=<\/span> 0<\/span> &&<\/span>
                \n dist[<\/span>u]<\/span> +<\/span> graph[<\/span>u]<\/span>[<\/span>v]<\/span> <<\/span> dist[<\/span>v]<\/span>)<\/span> {<\/span>
                \n dist[<\/span>v]<\/span> =<\/span> dist[<\/span>u]<\/span> +<\/span> graph[<\/span>u]<\/span>[<\/span>v]<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> dist;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n \/\/ \u90bb\u63a5\u77e9\u9635：0\u8868\u793a\u65e0\u8fb9<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph =<\/span> {<\/span>
                \n {<\/span>0<\/span>,<\/span> 4<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 8<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>4<\/span>,<\/span> 0<\/span>,<\/span> 8<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 11<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 8<\/span>,<\/span> 0<\/span>,<\/span> 7<\/span>,<\/span> 0<\/span>,<\/span> 4<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 2<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 7<\/span>,<\/span> 0<\/span>,<\/span> 9<\/span>,<\/span> 14<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 9<\/span>,<\/span> 0<\/span>,<\/span> 10<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 4<\/span>,<\/span> 14<\/span>,<\/span> 10<\/span>,<\/span> 0<\/span>,<\/span> 2<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 2<\/span>,<\/span> 0<\/span>,<\/span> 1<\/span>,<\/span> 6<\/span>}<\/span>,<\/span>
                \n {<\/span>8<\/span>,<\/span> 11<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 1<\/span>,<\/span> 0<\/span>,<\/span> 7<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 0<\/span>,<\/span> 2<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 6<\/span>,<\/span> 7<\/span>,<\/span> 0<\/span>}<\/span>
                \n }<\/span>;<\/span><\/p>\n

                int<\/span>[<\/span>]<\/span> dist =<\/span> dijkstraMatrix<\/span>(<\/span>graph,<\/span> 0<\/span>)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u4ece\u8282\u70b90\u51fa\u53d1\u7684\u6700\u77ed\u8ddd\u79bb:"<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> dist.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>" \u5230\u8282\u70b9"<\/span> +<\/span> i +<\/span> ": "<\/span> +<\/span> dist[<\/span>i]<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                5.4 Floyd\u591a\u6e90\u6700\u77ed\u8def\u5f84<\/h4>\n

                public<\/span> class<\/span> Floyd<\/span> {<\/span><\/p>\n

                \/**
                \n * Floyd-Warshall \u591a\u6e90\u6700\u77ed\u8def\u5f84
                \n * \u6838\u5fc3：\u4e09\u91cd\u5faa\u73af，\u679a\u4e3e\u4e2d\u95f4\u8282\u70b9k
                \n *
                \n * \u72b6\u6001\u8f6c\u79fb：dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
                \n *
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V\u00b3)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V\u00b2)
                \n *
                \n * \u7279\u70b9：\u4ee3\u7801\u6781\u77ed，\u671f\u672b\u975e\u5e38\u7231\u8003！
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> floyd<\/span>(<\/span>int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph)<\/span> {<\/span>
                \n int<\/span> n =<\/span> graph.<\/span>length;<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dist =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>[<\/span>n]<\/span>;<\/span><\/p>\n

                \/\/ \u521d\u59cb\u5316dist\u6570\u7ec4<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n for<\/span> (<\/span>int<\/span> j =<\/span> 0<\/span>;<\/span> j <<\/span> n;<\/span> j++<\/span>)<\/span> {<\/span>
                \n dist[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> graph[<\/span>i]<\/span>[<\/span>j]<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u2605\u2605\u2605 Floyd\u6838\u5fc3：\u4e09\u91cd\u5faa\u73af，k\u5fc5\u987b\u5728\u6700\u5916\u5c42！\u2605\u2605\u2605<\/span>
                \n for<\/span> (<\/span>int<\/span> k =<\/span> 0<\/span>;<\/span> k <<\/span> n;<\/span> k++<\/span>)<\/span> {<\/span> \/\/ \u4e2d\u95f4\u8282\u70b9<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span> \/\/ \u8d77\u70b9<\/span>
                \n for<\/span> (<\/span>int<\/span> j =<\/span> 0<\/span>;<\/span> j <<\/span> n;<\/span> j++<\/span>)<\/span> {<\/span> \/\/ \u7ec8\u70b9<\/span>
                \n if<\/span> (<\/span>dist[<\/span>i]<\/span>[<\/span>k]<\/span> !=<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span> &&<\/span>
                \n dist[<\/span>k]<\/span>[<\/span>j]<\/span> !=<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span> &&<\/span>
                \n dist[<\/span>i]<\/span>[<\/span>k]<\/span> +<\/span> dist[<\/span>k]<\/span>[<\/span>j]<\/span> <<\/span> dist[<\/span>i]<\/span>[<\/span>j]<\/span>)<\/span> {<\/span>
                \n dist[<\/span>i]<\/span>[<\/span>j]<\/span> =<\/span> dist[<\/span>i]<\/span>[<\/span>k]<\/span> +<\/span> dist[<\/span>k]<\/span>[<\/span>j]<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> dist;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span> INF<\/span> =<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph =<\/span> {<\/span>
                \n {<\/span>0<\/span>,<\/span> 3<\/span>,<\/span> INF<\/span>,<\/span> 5<\/span> }<\/span>,<\/span>
                \n {<\/span>2<\/span>,<\/span> 0<\/span>,<\/span> INF<\/span>,<\/span> 4<\/span> }<\/span>,<\/span>
                \n {<\/span>INF<\/span>,<\/span> 1<\/span>,<\/span> 0<\/span>,<\/span> INF<\/span>}<\/span>,<\/span>
                \n {<\/span>INF<\/span>,<\/span> INF<\/span>,<\/span> 2<\/span>,<\/span> 0<\/span> }<\/span>
                \n }<\/span>;<\/span><\/p>\n

                int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> dist =<\/span> floyd<\/span>(<\/span>graph)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"Floyd\u6700\u77ed\u8def\u5f84\u77e9\u9635:"<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> dist.<\/span>length;<\/span> i++<\/span>)<\/span> {<\/span>
                \n for<\/span> (<\/span>int<\/span> j =<\/span> 0<\/span>;<\/span> j <<\/span> dist.<\/span>length;<\/span> j++<\/span>)<\/span> {<\/span>
                \n System<\/span>.<\/span>out.<\/span>printf<\/span>(<\/span>"%6s"<\/span>,<\/span> dist[<\/span>i]<\/span>[<\/span>j]<\/span> ==<\/span> INF<\/span> ?<\/span> "INF"<\/span> :<\/span> dist[<\/span>i]<\/span>[<\/span>j]<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                \u26a0\ufe0f Floyd\u8003\u8bd5\u5751\u70b9：\u4e2d\u95f4\u8282\u70b9 k \u5fc5\u987b\u5728\u6700\u5916\u5c42\u5faa\u73af！\u5982\u679c k \u653e\u5728\u6700\u5185\u5c42，\u7ed3\u679c\u662f\u9519\u8bef\u7684\u3002\u8fd9\u662f\u671f\u672b\u8003\u8bd5\u4e2d\u6700\u5bb9\u6613\u72af\u7684\u9519\u8bef\u3002<\/p>\n

                5.5 Prim\u6700\u5c0f\u751f\u6210\u6811<\/h4>\n

                public<\/span> class<\/span> Prim<\/span> {<\/span><\/p>\n

                \/**
                \n * Prim\u6700\u5c0f\u751f\u6210\u6811（\u90bb\u63a5\u77e9\u9635\u7248\u672c，\u9002\u5408\u7a20\u5bc6\u56fe）
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V\u00b2)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V)
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span> prim<\/span>(<\/span>int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph)<\/span> {<\/span>
                \n int<\/span> n =<\/span> graph.<\/span>length;<\/span>
                \n boolean<\/span>[<\/span>]<\/span> inMST =<\/span> new<\/span> boolean<\/span>[<\/span>n]<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span> key =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span> \/\/ \u5230MST\u7684\u6700\u5c0f\u8fb9\u6743<\/span>
                \n Arrays<\/span>.<\/span>fill<\/span>(<\/span>key,<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>)<\/span>;<\/span><\/p>\n

                key[<\/span>0<\/span>]<\/span> =<\/span> 0<\/span>;<\/span> \/\/ \u4ece\u8282\u70b90\u5f00\u59cb<\/span>
                \n int<\/span> totalWeight =<\/span> 0<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> count =<\/span> 0<\/span>;<\/span> count <<\/span> n;<\/span> count++<\/span>)<\/span> {<\/span>
                \n \/\/ \u627e\u4e0d\u5728MST\u4e2dkey\u503c\u6700\u5c0f\u7684\u8282\u70b9<\/span>
                \n int<\/span> u =<\/span> –<\/span>1<\/span>;<\/span>
                \n int<\/span> minKey =<\/span> Integer<\/span>.<\/span>MAX_VALUE<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>!<\/span>inMST[<\/span>i]<\/span> &&<\/span> key[<\/span>i]<\/span> <<\/span> minKey)<\/span> {<\/span>
                \n minKey =<\/span> key[<\/span>i]<\/span>;<\/span>
                \n u =<\/span> i;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                inMST[<\/span>u]<\/span> =<\/span> true<\/span>;<\/span>
                \n totalWeight +=<\/span> key[<\/span>u]<\/span>;<\/span><\/p>\n

                \/\/ \u66f4\u65b0\u90bb\u5c45\u7684key\u503c<\/span>
                \n for<\/span> (<\/span>int<\/span> v =<\/span> 0<\/span>;<\/span> v <<\/span> n;<\/span> v++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>graph[<\/span>u]<\/span>[<\/span>v]<\/span> !=<\/span> 0<\/span> &&<\/span> !<\/span>inMST[<\/span>v]<\/span> &&<\/span> graph[<\/span>u]<\/span>[<\/span>v]<\/span> <<\/span> key[<\/span>v]<\/span>)<\/span> {<\/span>
                \n key[<\/span>v]<\/span> =<\/span> graph[<\/span>u]<\/span>[<\/span>v]<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> totalWeight;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> graph =<\/span> {<\/span>
                \n {<\/span>0<\/span>,<\/span> 2<\/span>,<\/span> 0<\/span>,<\/span> 6<\/span>,<\/span> 0<\/span>}<\/span>,<\/span>
                \n {<\/span>2<\/span>,<\/span> 0<\/span>,<\/span> 3<\/span>,<\/span> 8<\/span>,<\/span> 5<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 3<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 7<\/span>}<\/span>,<\/span>
                \n {<\/span>6<\/span>,<\/span> 8<\/span>,<\/span> 0<\/span>,<\/span> 0<\/span>,<\/span> 9<\/span>}<\/span>,<\/span>
                \n {<\/span>0<\/span>,<\/span> 5<\/span>,<\/span> 7<\/span>,<\/span> 9<\/span>,<\/span> 0<\/span>}<\/span>
                \n }<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"Prim\u6700\u5c0f\u751f\u6210\u6811\u603b\u6743\u503c: "<\/span> +<\/span> prim<\/span>(<\/span>graph)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: 16 (\u8fb9: 0-1(2), 1-2(3), 0-3(6), 1-4(5))<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                5.6 Kruskal\u6700\u5c0f\u751f\u6210\u6811 + \u5e76\u67e5\u96c6<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> Kruskal<\/span> {<\/span><\/p>\n

                \/**
                \n * \u5e76\u67e5\u96c6（Union-Find）\u2014\u2014 \u72ec\u7acb\u8003\u70b9！
                \n *\/<\/span>
                \n static<\/span> class<\/span> UnionFind<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> parent;<\/span>
                \n int<\/span>[<\/span>]<\/span> rank;<\/span> \/\/ \u6309\u79e9\u5408\u5e76<\/span><\/p>\n

                UnionFind<\/span>(<\/span>int<\/span> n)<\/span> {<\/span>
                \n parent =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span>
                \n rank =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n parent[<\/span>i]<\/span> =<\/span> i;<\/span> \/\/ \u521d\u59cb\u65f6\u6bcf\u4e2a\u8282\u70b9\u662f\u81ea\u5df1\u7684\u6839<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u67e5\u627e\u6839\u8282\u70b9 + \u8def\u5f84\u538b\u7f29
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：\u63a5\u8fd1O(1)（\u644a\u8fd8\u5206\u6790）
                \n *\/<\/span>
                \n int<\/span> find<\/span>(<\/span>int<\/span> x)<\/span> {<\/span>
                \n if<\/span> (<\/span>parent[<\/span>x]<\/span> !=<\/span> x)<\/span> {<\/span>
                \n parent[<\/span>x]<\/span> =<\/span> find<\/span>(<\/span>parent[<\/span>x]<\/span>)<\/span>;<\/span> \/\/ \u8def\u5f84\u538b\u7f29<\/span>
                \n }<\/span>
                \n return<\/span> parent[<\/span>x]<\/span>;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u5408\u5e76\u4e24\u4e2a\u96c6\u5408 + \u6309\u79e9\u5408\u5e76
                \n *\/<\/span>
                \n boolean<\/span> union<\/span>(<\/span>int<\/span> x,<\/span> int<\/span> y)<\/span> {<\/span>
                \n int<\/span> rootX =<\/span> find<\/span>(<\/span>x)<\/span>;<\/span>
                \n int<\/span> rootY =<\/span> find<\/span>(<\/span>y)<\/span>;<\/span><\/p>\n

                if<\/span> (<\/span>rootX ==<\/span> rootY)<\/span> return<\/span> false<\/span>;<\/span> \/\/ \u5df2\u5728\u540c\u4e00\u96c6\u5408<\/span><\/p>\n

                \/\/ \u6309\u79e9\u5408\u5e76<\/span>
                \n if<\/span> (<\/span>rank[<\/span>rootX]<\/span> <<\/span> rank[<\/span>rootY]<\/span>)<\/span> {<\/span>
                \n parent[<\/span>rootX]<\/span> =<\/span> rootY;<\/span>
                \n }<\/span> else<\/span> if<\/span> (<\/span>rank[<\/span>rootX]<\/span> ><\/span> rank[<\/span>rootY]<\/span>)<\/span> {<\/span>
                \n parent[<\/span>rootY]<\/span> =<\/span> rootX;<\/span>
                \n }<\/span> else<\/span> {<\/span>
                \n parent[<\/span>rootY]<\/span> =<\/span> rootX;<\/span>
                \n rank[<\/span>rootX]<\/span>++<\/span>;<\/span>
                \n }<\/span>
                \n return<\/span> true<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * Kruskal\u6700\u5c0f\u751f\u6210\u6811
                \n * \u601d\u8def：\u8fb9\u6309\u6743\u503c\u6392\u5e8f，\u4ece\u5c0f\u5230\u5927\u9009\u8fb9，\u7528\u5e76\u67e5\u96c6\u5224\u65ad\u662f\u5426\u6210\u73af
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(E log E)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span> kruskal<\/span>(<\/span>int<\/span> n,<\/span> int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> edges)<\/span> {<\/span>
                \n \/\/ edges: {u, v, weight}<\/span>
                \n Arrays<\/span>.<\/span>sort<\/span>(<\/span>edges,<\/span> (<\/span>a,<\/span> b)<\/span> -><\/span> a[<\/span>2<\/span>]<\/span> –<\/span> b[<\/span>2<\/span>]<\/span>)<\/span>;<\/span> \/\/ \u6309\u6743\u503c\u5347\u5e8f\u6392\u5e8f<\/span><\/p>\n

                UnionFind<\/span> uf =<\/span> new<\/span> UnionFind<\/span>(<\/span>n)<\/span>;<\/span>
                \n int<\/span> totalWeight =<\/span> 0<\/span>;<\/span>
                \n int<\/span> edgeCount =<\/span> 0<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span>[<\/span>]<\/span> edge :<\/span> edges)<\/span> {<\/span>
                \n int<\/span> u =<\/span> edge[<\/span>0<\/span>]<\/span>,<\/span> v =<\/span> edge[<\/span>1<\/span>]<\/span>,<\/span> w =<\/span> edge[<\/span>2<\/span>]<\/span>;<\/span><\/p>\n

                if<\/span> (<\/span>uf.<\/span>union<\/span>(<\/span>u,<\/span> v)<\/span>)<\/span> {<\/span> \/\/ \u4e0d\u6210\u73af，\u52a0\u5165MST<\/span>
                \n totalWeight +=<\/span> w;<\/span>
                \n edgeCount++<\/span>;<\/span>
                \n if<\/span> (<\/span>edgeCount ==<\/span> n –<\/span> 1<\/span>)<\/span> break<\/span>;<\/span> \/\/ MST\u6709n-1\u6761\u8fb9<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> totalWeight;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n \/\/ \u8fb9: {u, v, weight}<\/span>
                \n int<\/span>[<\/span>]<\/span>[<\/span>]<\/span> edges =<\/span> {<\/span>
                \n {<\/span>0<\/span>,<\/span> 1<\/span>,<\/span> 2<\/span>}<\/span>,<\/span> {<\/span>0<\/span>,<\/span> 3<\/span>,<\/span> 6<\/span>}<\/span>,<\/span> {<\/span>1<\/span>,<\/span> 2<\/span>,<\/span> 3<\/span>}<\/span>,<\/span> {<\/span>1<\/span>,<\/span> 3<\/span>,<\/span> 8<\/span>}<\/span>,<\/span>
                \n {<\/span>1<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>}<\/span>,<\/span> {<\/span>2<\/span>,<\/span> 4<\/span>,<\/span> 7<\/span>}<\/span>,<\/span> {<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> 9<\/span>}<\/span>
                \n }<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"Kruskal\u6700\u5c0f\u751f\u6210\u6811\u603b\u6743\u503c: "<\/span> +<\/span> kruskal<\/span>(<\/span>5<\/span>,<\/span> edges)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: 16<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                5.7 \u62d3\u6251\u6392\u5e8f（\u5224\u65ad\u6709\u5411\u56fe\u662f\u5426\u6709\u73af）<\/h4>\n

                import<\/span> java.<\/span>util.<\/span><\/span>*<\/span><\/span>;<\/span><\/p>\n

                public<\/span> class<\/span> TopologicalSort<\/span> {<\/span><\/p>\n

                \/**
                \n * \u62d3\u6251\u6392\u5e8f – BFS（Kahn\u7b97\u6cd5）
                \n * \u601d\u8def：\u7ef4\u62a4\u5165\u5ea6\u6570\u7ec4，\u6bcf\u6b21\u53d6\u5165\u5ea6\u4e3a0\u7684\u8282\u70b9
                \n *
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(V + E)
                \n *
                \n * \u5e94\u7528：\u5224\u65ad\u6709\u5411\u56fe\u662f\u5426\u6709\u73af（\u5982\u679c\u6392\u5e8f\u7ed3\u679c\u5305\u542b\u6240\u6709\u8282\u70b9\u5219\u65e0\u73af）
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> topologicalSort<\/span>(<\/span>int<\/span> n,<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> inDegree =<\/span> new<\/span> int<\/span>[<\/span>n]<\/span>;<\/span> \/\/ \u5165\u5ea6\u6570\u7ec4<\/span><\/p>\n

                \/\/ \u8ba1\u7b97\u6bcf\u4e2a\u8282\u70b9\u7684\u5165\u5ea6<\/span>
                \n for<\/span> (<\/span>int<\/span> u =<\/span> 0<\/span>;<\/span> u <<\/span> n;<\/span> u++<\/span>)<\/span> {<\/span>
                \n for<\/span> (<\/span>int<\/span> v :<\/span> adj.<\/span>get<\/span>(<\/span>u)<\/span>)<\/span> {<\/span>
                \n inDegree[<\/span>v]<\/span>++<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u5c06\u6240\u6709\u5165\u5ea6\u4e3a0\u7684\u8282\u70b9\u5165\u961f<\/span>
                \n Queue<\/span><<\/span>Integer<\/span>><\/span><\/span> queue =<\/span> new<\/span> LinkedList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>inDegree[<\/span>i]<\/span> ==<\/span> 0<\/span>)<\/span> {<\/span>
                \n queue.<\/span>offer<\/span>(<\/span>i)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                List<\/span><<\/span>Integer<\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n while<\/span> (<\/span>!<\/span>queue.<\/span>isEmpty<\/span>(<\/span>)<\/span>)<\/span> {<\/span>
                \n int<\/span> u =<\/span> queue.<\/span>poll<\/span>(<\/span>)<\/span>;<\/span>
                \n result.<\/span>add<\/span>(<\/span>u)<\/span>;<\/span><\/p>\n

                for<\/span> (<\/span>int<\/span> v :<\/span> adj.<\/span>get<\/span>(<\/span>u)<\/span>)<\/span> {<\/span>
                \n inDegree[<\/span>v]<\/span>—<\/span>;<\/span>
                \n if<\/span> (<\/span>inDegree[<\/span>v]<\/span> ==<\/span> 0<\/span>)<\/span> {<\/span>
                \n queue.<\/span>offer<\/span>(<\/span>v)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u5982\u679c\u7ed3\u679c\u6570\u91cf\u4e0d\u7b49\u4e8e\u8282\u70b9\u6570，\u8bf4\u660e\u6709\u73af<\/span>
                \n if<\/span> (<\/span>result.<\/span>size<\/span>(<\/span>)<\/span> !=<\/span> n)<\/span> {<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u56fe\u4e2d\u5b58\u5728\u73af！\u65e0\u6cd5\u5b8c\u6210\u62d3\u6251\u6392\u5e8f"<\/span>)<\/span>;<\/span>
                \n return<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n }<\/span><\/p>\n

                return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * \u5224\u65ad\u6709\u5411\u56fe\u662f\u5426\u6709\u73af（\u62d3\u6251\u6392\u5e8f\u5e94\u7528）
                \n *\/<\/span>
                \n public<\/span> static<\/span> boolean<\/span> hasCycle<\/span>(<\/span>int<\/span> n,<\/span> List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj)<\/span> {<\/span>
                \n return<\/span> topologicalSort<\/span>(<\/span>n,<\/span> adj)<\/span>.<\/span>isEmpty<\/span>(<\/span>)<\/span> &&<\/span> n ><\/span> 0<\/span>;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span> n =<\/span> 6<\/span>;<\/span>
                \n List<\/span><<\/span>List<\/span><<\/span>Integer<\/span>><\/span>><\/span><\/span> adj =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> 0<\/span>;<\/span> i <<\/span> n;<\/span> i++<\/span>)<\/span> adj.<\/span>add<\/span>(<\/span>new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>)<\/span>;<\/span><\/p>\n

                \/\/ \u6709\u5411\u8fb9<\/span>
                \n adj.<\/span>get<\/span>(<\/span>5<\/span>)<\/span>.<\/span>add<\/span>(<\/span>2<\/span>)<\/span>;<\/span> adj.<\/span>get<\/span>(<\/span>5<\/span>)<\/span>.<\/span>add<\/span>(<\/span>0<\/span>)<\/span>;<\/span>
                \n adj.<\/span>get<\/span>(<\/span>4<\/span>)<\/span>.<\/span>add<\/span>(<\/span>0<\/span>)<\/span>;<\/span> adj.<\/span>get<\/span>(<\/span>4<\/span>)<\/span>.<\/span>add<\/span>(<\/span>1<\/span>)<\/span>;<\/span>
                \n adj.<\/span>get<\/span>(<\/span>2<\/span>)<\/span>.<\/span>add<\/span>(<\/span>3<\/span>)<\/span>;<\/span> adj.<\/span>get<\/span>(<\/span>3<\/span>)<\/span>.<\/span>add<\/span>(<\/span>1<\/span>)<\/span>;<\/span><\/p>\n

                List<\/span><<\/span>Integer<\/span>><\/span><\/span> order =<\/span> topologicalSort<\/span>(<\/span>n,<\/span> adj)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u62d3\u6251\u6392\u5e8f: "<\/span> +<\/span> order)<\/span>;<\/span>
                \n \/\/ \u53ef\u80fd\u7684\u8f93\u51fa: [4, 5, 2, 0, 3, 1]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                \u56fe\u7b97\u6cd5\u90e8\u5206\u5c0f\u7ed3：\u56fe\u7b97\u6cd5\u5728\u671f\u672b\u8003\u8bd5\u4e2d\u5c5e\u4e8e\u5927\u9898\u7ea7\u522b，Dijkstra\u548cFloyd\u662f\u6700\u9ad8\u9891\u8003\u70b9\u3002\u5e76\u67e5\u96c6\u7ecf\u5e38\u4f5c\u4e3a\u72ec\u7acb\u5c0f\u4ee3\u7801\u9898\u51fa\u73b0（5\u5206\u5de6\u53f3）\u3002\u5199Floyd\u65f6\u8bb0\u4f4f k\u5728\u6700\u5916\u5c42，\u5199Dijkstra\u65f6\u6ce8\u610f\u4f18\u5148\u961f\u5217\u7684\u4f7f\u7528\u3002\u62d3\u6251\u6392\u5e8f\u5e38\u548c"\u5224\u65ad\u6709\u73af"\u7ed3\u5408\u51fa\u9898\u3002<\/p>\n

                \n

                \u516d\u3001\u67e5\u627e\u4e0e\u6392\u5e8f（\u57fa\u7840\u5c0f\u9898）<\/h3>\n

                6.1 \u5806\u6392\u5e8f<\/h4>\n

                public<\/span> class<\/span> HeapSort<\/span> {<\/span><\/p>\n

                \/**
                \n * \u5806\u6392\u5e8f（\u5927\u6839\u5806，\u5347\u5e8f\u6392\u5217）
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n log n)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(1)（\u539f\u5730\u6392\u5e8f）
                \n *\/<\/span>
                \n public<\/span> static<\/span> void<\/span> heapSort<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr)<\/span> {<\/span>
                \n int<\/span> n =<\/span> arr.<\/span>length;<\/span><\/p>\n

                \/\/ \u7b2c\u4e00\u6b65：\u5efa\u5806（\u4ece\u6700\u540e\u4e00\u4e2a\u975e\u53f6\u5b50\u8282\u70b9\u5f00\u59cb）<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> n \/<\/span> 2<\/span> –<\/span> 1<\/span>;<\/span> i >=<\/span> 0<\/span>;<\/span> i—<\/span>)<\/span> {<\/span>
                \n heapify<\/span>(<\/span>arr,<\/span> n,<\/span> i)<\/span>;<\/span>
                \n }<\/span><\/p>\n

                \/\/ \u7b2c\u4e8c\u6b65：\u4f9d\u6b21\u53d6\u51fa\u5806\u9876\u5143\u7d20（\u6700\u5927\u503c），\u653e\u5230\u6570\u7ec4\u672b\u5c3e<\/span>
                \n for<\/span> (<\/span>int<\/span> i =<\/span> n –<\/span> 1<\/span>;<\/span> i ><\/span> 0<\/span>;<\/span> i—<\/span>)<\/span> {<\/span>
                \n \/\/ \u4ea4\u6362\u5806\u9876\u548c\u6700\u540e\u4e00\u4e2a\u5143\u7d20<\/span>
                \n int<\/span> temp =<\/span> arr[<\/span>0<\/span>]<\/span>;<\/span>
                \n arr[<\/span>0<\/span>]<\/span> =<\/span> arr[<\/span>i]<\/span>;<\/span>
                \n arr[<\/span>i]<\/span> =<\/span> temp;<\/span><\/p>\n

                \/\/ \u5bf9\u65b0\u7684\u5806\u9876\u505aheapify（\u6ce8\u610f\u5806\u7684\u5927\u5c0f\u53d8\u4e3ai）<\/span>
                \n heapify<\/span>(<\/span>arr,<\/span> i,<\/span> 0<\/span>)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * heapify：\u5c06\u4ee5i\u4e3a\u6839\u7684\u5b50\u6811\u8c03\u6574\u4e3a\u5927\u6839\u5806
                \n * @param arr \u6570\u7ec4
                \n * @param heapSize \u5f53\u524d\u5806\u7684\u5927\u5c0f
                \n * @param i \u5f53\u524d\u8282\u70b9\u4e0b\u6807
                \n *\/<\/span>
                \n private<\/span> static<\/span> void<\/span> heapify<\/span>(<\/span>int<\/span>[<\/span>]<\/span> arr,<\/span> int<\/span> heapSize,<\/span> int<\/span> i)<\/span> {<\/span>
                \n int<\/span> largest =<\/span> i;<\/span> \/\/ \u5047\u8bbe\u5f53\u524d\u8282\u70b9\u6700\u5927<\/span>
                \n int<\/span> left =<\/span> 2<\/span> *<\/span> i +<\/span> 1<\/span>;<\/span> \/\/ \u5de6\u5b69\u5b50<\/span>
                \n int<\/span> right =<\/span> 2<\/span> *<\/span> i +<\/span> 2<\/span>;<\/span> \/\/ \u53f3\u5b69\u5b50<\/span><\/p>\n

                if<\/span> (<\/span>left <<\/span> heapSize &&<\/span> arr[<\/span>left]<\/span> ><\/span> arr[<\/span>largest]<\/span>)<\/span> {<\/span>
                \n largest =<\/span> left;<\/span>
                \n }<\/span>
                \n if<\/span> (<\/span>right <<\/span> heapSize &&<\/span> arr[<\/span>right]<\/span> ><\/span> arr[<\/span>largest]<\/span>)<\/span> {<\/span>
                \n largest =<\/span> right;<\/span>
                \n }<\/span><\/p>\n

                if<\/span> (<\/span>largest !=<\/span> i)<\/span> {<\/span>
                \n \/\/ \u4ea4\u6362\u5e76\u7ee7\u7eedheapify<\/span>
                \n int<\/span> temp =<\/span> arr[<\/span>i]<\/span>;<\/span>
                \n arr[<\/span>i]<\/span> =<\/span> arr[<\/span>largest]<\/span>;<\/span>
                \n arr[<\/span>largest]<\/span> =<\/span> temp;<\/span><\/p>\n

                heapify<\/span>(<\/span>arr,<\/span> heapSize,<\/span> largest)<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>4<\/span>,<\/span> 10<\/span>,<\/span> 3<\/span>,<\/span> 5<\/span>,<\/span> 1<\/span>}<\/span>;<\/span>
                \n heapSort<\/span>(<\/span>arr)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u5806\u6392\u5e8f\u7ed3\u679c: "<\/span> +<\/span> java.<\/span>util.<\/span><\/span>Arrays<\/span>.<\/span>toString<\/span>(<\/span>arr)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [1, 3, 4, 5, 10]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                \u6392\u5e8f\u7b97\u6cd5\u590d\u6742\u5ea6\u5bf9\u6bd4\u8868（\u8003\u8bd5\u5fc5\u80cc）：<\/p>\n\n\u6392\u5e8f\u7b97\u6cd5\u5e73\u5747\u65f6\u95f4\u6700\u574f\u65f6\u95f4\u7a7a\u95f4\u7a33\u5b9a\u6027<\/tr>\n\n\n\n\n\n\n\n
                \u5192\u6ce1\u6392\u5e8f<\/td>\nO(n\u00b2)<\/td>\nO(n\u00b2)<\/td>\nO(1)<\/td>\n\u7a33\u5b9a<\/td>\n<\/tr>\n
                \u9009\u62e9\u6392\u5e8f<\/td>\nO(n\u00b2)<\/td>\nO(n\u00b2)<\/td>\nO(1)<\/td>\n\u4e0d\u7a33\u5b9a<\/td>\n<\/tr>\n
                \u63d2\u5165\u6392\u5e8f<\/td>\nO(n\u00b2)<\/td>\nO(n\u00b2)<\/td>\nO(1)<\/td>\n\u7a33\u5b9a<\/td>\n<\/tr>\n
                \u5feb\u901f\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(n\u00b2)<\/td>\nO(log n)<\/td>\n\u4e0d\u7a33\u5b9a<\/td>\n<\/tr>\n
                \u5f52\u5e76\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(n log n)<\/td>\nO(n)<\/td>\n\u7a33\u5b9a<\/td>\n<\/tr>\n
                \u5806\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(n log n)<\/td>\nO(1)<\/td>\n\u4e0d\u7a33\u5b9a<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \n

                \u4e03\u3001\u5b57\u7b26\u4e32\u7b97\u6cd5（KMP）<\/h3>\n

                7.1 KMP\u5b57\u7b26\u4e32\u5339\u914d<\/h4>\n

                public<\/span> class<\/span> KMP<\/span> {<\/span><\/p>\n

                \/**
                \n * \u6784\u5efanext\u6570\u7ec4（\u90e8\u5206\u5339\u914d\u8868 \/ \u5931\u914d\u6307\u9488）
                \n * next[i] = \u6a21\u5f0f\u4e32\u524di+1\u4e2a\u5b57\u7b26\u7ec4\u6210\u7684\u5b50\u4e32\u4e2d，
                \n * \u6700\u957f\u76f8\u7b49\u524d\u540e\u7f00\u7684\u957f\u5ea6
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(m)，m\u4e3a\u6a21\u5f0f\u4e32\u957f\u5ea6
                \n *\/<\/span>
                \n public<\/span> static<\/span> int<\/span>[<\/span>]<\/span> buildNext<\/span>(<\/span>String<\/span> pattern)<\/span> {<\/span>
                \n int<\/span> m =<\/span> pattern.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span> next =<\/span> new<\/span> int<\/span>[<\/span>m]<\/span>;<\/span>
                \n next[<\/span>0<\/span>]<\/span> =<\/span> 0<\/span>;<\/span><\/p>\n

                int<\/span> len =<\/span> 0<\/span>;<\/span> \/\/ \u5f53\u524d\u6700\u957f\u76f8\u7b49\u524d\u540e\u7f00\u957f\u5ea6<\/span>
                \n int<\/span> i =<\/span> 1<\/span>;<\/span><\/p>\n

                while<\/span> (<\/span>i <<\/span> m)<\/span> {<\/span>
                \n if<\/span> (<\/span>pattern.<\/span>charAt<\/span>(<\/span>i)<\/span> ==<\/span> pattern.<\/span>charAt<\/span>(<\/span>len)<\/span>)<\/span> {<\/span>
                \n len++<\/span>;<\/span>
                \n next[<\/span>i]<\/span> =<\/span> len;<\/span>
                \n i++<\/span>;<\/span>
                \n }<\/span> else<\/span> {<\/span>
                \n if<\/span> (<\/span>len !=<\/span> 0<\/span>)<\/span> {<\/span>
                \n len =<\/span> next[<\/span>len –<\/span> 1<\/span>]<\/span>;<\/span> \/\/ \u56de\u9000<\/span>
                \n }<\/span> else<\/span> {<\/span>
                \n next[<\/span>i]<\/span> =<\/span> 0<\/span>;<\/span>
                \n i++<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> next;<\/span>
                \n }<\/span><\/p>\n

                \/**
                \n * KMP\u5b57\u7b26\u4e32\u5339\u914d
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(n + m)，n\u4e3a\u6587\u672c\u4e32\u957f\u5ea6，m\u4e3a\u6a21\u5f0f\u4e32\u957f\u5ea6
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(m)（next\u6570\u7ec4）
                \n *\/<\/span>
                \n public<\/span> static<\/span> List<\/span><<\/span>Integer<\/span>><\/span><\/span> kmpSearch<\/span>(<\/span>String<\/span> text,<\/span> String<\/span> pattern)<\/span> {<\/span>
                \n List<\/span><<\/span>Integer<\/span>><\/span><\/span> result =<\/span> new<\/span> ArrayList<\/span><<\/span>><\/span><\/span>(<\/span>)<\/span>;<\/span>
                \n if<\/span> (<\/span>pattern.<\/span>isEmpty<\/span>(<\/span>)<\/span>)<\/span> return<\/span> result;<\/span><\/p>\n

                int<\/span> n =<\/span> text.<\/span>length<\/span>(<\/span>)<\/span>,<\/span> m =<\/span> pattern.<\/span>length<\/span>(<\/span>)<\/span>;<\/span>
                \n int<\/span>[<\/span>]<\/span> next =<\/span> buildNext<\/span>(<\/span>pattern)<\/span>;<\/span><\/p>\n

                int<\/span> i =<\/span> 0<\/span>;<\/span> \/\/ \u6587\u672c\u4e32\u6307\u9488<\/span>
                \n int<\/span> j =<\/span> 0<\/span>;<\/span> \/\/ \u6a21\u5f0f\u4e32\u6307\u9488<\/span><\/p>\n

                while<\/span> (<\/span>i <<\/span> n)<\/span> {<\/span>
                \n if<\/span> (<\/span>text.<\/span>charAt<\/span>(<\/span>i)<\/span> ==<\/span> pattern.<\/span>charAt<\/span>(<\/span>j)<\/span>)<\/span> {<\/span>
                \n i++<\/span>;<\/span>
                \n j++<\/span>;<\/span>
                \n }<\/span><\/p>\n

                if<\/span> (<\/span>j ==<\/span> m)<\/span> {<\/span>
                \n \/\/ \u627e\u5230\u5339\u914d，\u8bb0\u5f55\u8d77\u59cb\u4f4d\u7f6e<\/span>
                \n result.<\/span>add<\/span>(<\/span>i –<\/span> j)<\/span>;<\/span>
                \n j =<\/span> next[<\/span>j –<\/span> 1<\/span>]<\/span>;<\/span> \/\/ \u7ee7\u7eed\u641c\u7d22<\/span>
                \n }<\/span> else<\/span> if<\/span> (<\/span>i <<\/span> n &&<\/span> text.<\/span>charAt<\/span>(<\/span>i)<\/span> !=<\/span> pattern.<\/span>charAt<\/span>(<\/span>j)<\/span>)<\/span> {<\/span>
                \n if<\/span> (<\/span>j !=<\/span> 0<\/span>)<\/span> {<\/span>
                \n j =<\/span> next[<\/span>j –<\/span> 1<\/span>]<\/span>;<\/span> \/\/ \u5229\u7528next\u6570\u7ec4\u56de\u9000<\/span>
                \n }<\/span> else<\/span> {<\/span>
                \n i++<\/span>;<\/span>
                \n }<\/span>
                \n }<\/span>
                \n }<\/span><\/p>\n

                return<\/span> result;<\/span>
                \n }<\/span><\/p>\n

                public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                \n String<\/span> text =<\/span> "ABABDABACDABABCABAB"<\/span>;<\/span>
                \n String<\/span> pattern =<\/span> "ABABCABAB"<\/span>;<\/span><\/p>\n

                List<\/span><<\/span>Integer<\/span>><\/span><\/span> positions =<\/span> kmpSearch<\/span>(<\/span>text,<\/span> pattern)<\/span>;<\/span>
                \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\u6a21\u5f0f\u4e32\u5728\u6587\u672c\u4e32\u4e2d\u7684\u8d77\u59cb\u4f4d\u7f6e: "<\/span> +<\/span> positions)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [9]<\/span><\/p>\n

                System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"next\u6570\u7ec4: "<\/span> +<\/span> java.<\/span>util.<\/span><\/span>Arrays<\/span>.<\/span>toString<\/span>(<\/span>buildNext<\/span>(<\/span>pattern)<\/span>)<\/span>)<\/span>;<\/span>
                \n \/\/ \u8f93\u51fa: [0, 0, 1, 2, 0, 1, 2, 3, 4]<\/span>
                \n }<\/span>
                \n}<\/span><\/p>\n

                \n

                \u516b\u3001\u671f\u672b\u51fa\u9898\u5957\u8def\u4e0e\u5e94\u8bd5\u6280\u5de7<\/h3>\n

                8.1 \u51fa\u9898\u5957\u8def\u603b\u7ed3<\/h4>\n\n\u96be\u5ea6\u5206\u503c\u5e38\u89c1\u9898\u578b\u8981\u6c42<\/tr>\n\n\n\n\n
                \u57fa\u7840<\/td>\n5\u5206<\/td>\n\u4e8c\u5206\u67e5\u627e\u3001\u5e76\u67e5\u96c6\u3001\u5f52\u5e76merge\u3001\u5feb\u6392partition<\/td>\n\u5199\u6838\u5fc3\u51fd\u6570<\/td>\n<\/tr>\n
                \u4e2d\u6863<\/td>\n8-12\u5206<\/td>\n01\u80cc\u5305\u3001LCS\u3001\u56de\u6eaf\u5168\u6392\u5217\u3001Dijkstra\u3001Floyd<\/td>\n\u5199\u5b8c\u6574\u65b9\u6cd5\/\u7c7b<\/td>\n<\/tr>\n
                \u62d4\u9ad8<\/td>\n10+\u5206<\/td>\nN\u7687\u540e\u3001\u9006\u5e8f\u5bf9\u3001\u7f16\u8f91\u8ddd\u79bb\u3001\u62d3\u6251\u6392\u5e8f\u5224\u73af<\/td>\n\u5b8c\u6574\u4ee3\u7801+\u5206\u6790<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                8.2 \u5e94\u8bd5\u6280\u5de7<\/h4>\n

                \u6280\u5de7\u4e00：\u4ee3\u7801\u7ed3\u6784\u6e05\u6670<\/h5>\n

                \u8003\u8bd5\u5199\u4ee3\u7801\u65f6，\u5efa\u8bae\u6309\u7167\u4ee5\u4e0b\u7ed3\u6784：<\/p>\n

                \/**
                \n * \u65b9\u6cd5\u8bf4\u660e
                \n * \u65f6\u95f4\u590d\u6742\u5ea6：O(?)
                \n * \u7a7a\u95f4\u590d\u6742\u5ea6：O(?)
                \n *\/<\/span>
                \npublic<\/span> static<\/span> returnType methodName<\/span>(<\/span>parameters)<\/span> {<\/span>
                \n \/\/ 1. \u8fb9\u754c\u5904\u7406<\/span>
                \n if<\/span> (<\/span>input ==<\/span> null<\/span> ||<\/span> input.<\/span>length ==<\/span> 0<\/span>)<\/span> return<\/span> defaultValue;<\/span><\/p>\n

                \/\/ 2. \u521d\u59cb\u5316<\/span><\/p>\n

                \/\/ 3. \u6838\u5fc3\u903b\u8f91<\/span><\/p>\n

                \/\/ 4. \u8fd4\u56de\u7ed3\u679c<\/span>
                \n}<\/span><\/p>\n

                \u6280\u5de7\u4e8c：\u5148\u5199\u6846\u67b6\u518d\u8865\u7ec6\u8282<\/h5>\n

                \u62ff\u5230\u9898\u76ee\u540e，\u5148\u5199\u51fa\u4ee3\u7801\u6846\u67b6（\u65b9\u6cd5\u7b7e\u540d\u3001\u53d8\u91cf\u5b9a\u4e49\u3001\u5faa\u73af\u7ed3\u6784），\u518d\u586b\u5145\u5177\u4f53\u903b\u8f91\u3002\u5373\u4f7f\u6700\u540e\u6ca1\u65f6\u95f4\u5199\u5b8c，\u6846\u67b6\u5206\u4e5f\u80fd\u62ff\u5230\u3002<\/p>\n

                \u6280\u5de7\u4e09：\u8fb9\u754c\u6761\u4ef6\u4e00\u5b9a\u8981\u5904\u7406<\/h5>\n

                \u4ee5\u4e0b\u8fb9\u754c\u6761\u4ef6\u5728\u8003\u8bd5\u4e2d\u5fc5\u987b\u68c0\u67e5：<\/p>\n

                  \n
                • \u6570\u7ec4\u4e3a null \u6216\u957f\u5ea6\u4e3a0<\/li>\n
                • \u5b57\u7b26\u4e32\u4e3a\u7a7a<\/li>\n
                • \u6570\u7ec4\u53ea\u67091\u4e2a\u5143\u7d20<\/li>\n
                • n=0 \u6216 n=1 \u7684\u7279\u6b8a\u60c5\u51b5<\/li>\n<\/ul>\n
                  \u6280\u5de7\u56db：\u590d\u6742\u5ea6\u5206\u6790\u5fc5\u5199<\/h5>\n

                  \u5199\u5b8c\u4ee3\u7801\u540e，\u4e00\u5b9a\u8981\u5728\u4ee3\u7801\u65c1\u8fb9\u6807\u6ce8\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6，\u901a\u5e38\u53601-2\u5206\u3002\u683c\u5f0f\u5982\u4e0b：<\/p>\n

                  \/\/ \u65f6\u95f4\u590d\u6742\u5ea6：O(n\u00b2)，\u4e24\u5c42\u5faa\u73af
                  \n\/\/ \u7a7a\u95f4\u590d\u6742\u5ea6：O(n)，dp\u6570\u7ec4<\/p>\n

                  \u6280\u5de7\u4e94：\u4e0d\u4f1a\u5199\u5c31\u5199\u66b4\u529b<\/h5>\n

                  \u5982\u679c\u5b9e\u5728\u60f3\u4e0d\u51fa\u6700\u4f18\u89e3，\u5148\u5199\u66b4\u529b\u89e3\u6cd5（\u5982\u9012\u5f52\u679a\u4e3e），\u81f3\u5c11\u80fd\u62ff\u5230\u90e8\u5206\u5206\u6570\u3002\u7136\u540e\u518d\u5c1d\u8bd5\u4f18\u5316\u3002<\/p>\n

                  8.3 \u5e38\u89c1\u6263\u5206\u70b9\u6c47\u603b<\/h4>\n
                • 01\u80cc\u5305\u5faa\u73af\u987a\u5e8f\u5199\u9519（\u9006\u5e8f\u5199\u6210\u6b63\u5e8f）\u2192 \u62632-3\u5206<\/li>\n
                • Floyd\u7684k\u5faa\u73af\u4e0d\u5728\u6700\u5916\u5c42 \u2192 \u7ed3\u679c\u5168\u9519，\u6263\u5927\u91cf\u5206<\/li>\n
                • \u4e8c\u5206\u67e5\u627e\u7684 mid \u8ba1\u7b97\u6ea2\u51fa \u2192 \u62631\u5206<\/li>\n
                • \u56de\u6eaf\u5fd8\u8bb0\u64a4\u9500\u9009\u62e9 \u2192 \u7ed3\u679c\u5168\u9519<\/li>\n
                • DP\u6570\u7ec4\u521d\u59cb\u5316\u9519\u8bef \u2192 \u7ed3\u679c\u5168\u9519<\/li>\n
                • \u9012\u5f52\u6ca1\u6709\u7ec8\u6b62\u6761\u4ef6 \u2192 \u6808\u6ea2\u51fa，0\u5206<\/li>\n
                • \u56fe\u7684DFS\/BFS\u5fd8\u8bb0\u6807\u8bb0visited \u2192 \u6b7b\u5faa\u73af<\/li>\n
                • \u5e76\u67e5\u96c6\u5fd8\u8bb0\u8def\u5f84\u538b\u7f29 \u2192 \u53ef\u80fd\u8d85\u65f6<\/li>\n
                  \n

                  \u4e5d\u3001\u590d\u4e60\u4f18\u5148\u7ea7\u4e0e\u603b\u7ed3<\/h3>\n

                  9.1 \u6027\u4ef7\u6bd4\u590d\u4e60\u987a\u5e8f<\/h4>\n

                  \u6309\u7167\u8003\u8bd5\u51fa\u9898\u9891\u7387\u548c\u5206\u503c，\u63a8\u8350\u7684\u590d\u4e60\u987a\u5e8f\u5982\u4e0b（\u4ece\u9ad8\u5230\u4f4e）：<\/p>\n\n\u4f18\u5148\u7ea7\u8003\u70b9\u9884\u8ba1\u5206\u503c\u96be\u5ea6\u5efa\u8bae\u7528\u65f6<\/tr>\n\n\n\n\n\n\n\n\n\n\n\n\n
                  \u2605\u2605\u2605<\/td>\n01\u80cc\u5305（DP）<\/td>\n10-12\u5206<\/td>\n\u4e2d<\/td>\n2\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2605<\/td>\nLCS\u6700\u957f\u516c\u5171\u5b50\u5e8f\u5217<\/td>\n8-10\u5206<\/td>\n\u4e2d<\/td>\n1.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2605<\/td>\n\u56de\u6eaf\u5168\u6392\u5217\/\u5b50\u96c6<\/td>\n8-10\u5206<\/td>\n\u4e2d<\/td>\n1.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2606<\/td>\n\u4e8c\u5206\u67e5\u627e\u53ca\u53d8\u4f53<\/td>\n5-8\u5206<\/td>\n\u4f4e<\/td>\n1\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2606<\/td>\n\u5f52\u5e76\u6392\u5e8f\u6c42\u9006\u5e8f\u5bf9<\/td>\n8-10\u5206<\/td>\n\u4e2d<\/td>\n1.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2606<\/td>\nDijkstra\u6700\u77ed\u8def\u5f84<\/td>\n8-10\u5206<\/td>\n\u4e2d\u9ad8<\/td>\n1.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2606<\/td>\nFloyd\u591a\u6e90\u6700\u77ed\u8def\u5f84<\/td>\n8-10\u5206<\/td>\n\u4f4e<\/td>\n1\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2605\u2606<\/td>\n\u5e76\u67e5\u96c6<\/td>\n5-8\u5206<\/td>\n\u4f4e<\/td>\n1\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2606\u2606<\/td>\nN\u7687\u540e<\/td>\n10-12\u5206<\/td>\n\u9ad8<\/td>\n1.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2606\u2606<\/td>\n\u6d3b\u52a8\u9009\u62e9（\u8d2a\u5fc3）<\/td>\n5-8\u5206<\/td>\n\u4f4e<\/td>\n0.5\u5c0f\u65f6<\/td>\n<\/tr>\n
                  \u2605\u2606\u2606<\/td>\nKMP\u5b57\u7b26\u4e32\u5339\u914d<\/td>\n5-8\u5206<\/td>\n\u9ad8<\/td>\n1\u5c0f\u65f6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                  9.2 \u5404\u7b97\u6cd5\u590d\u6742\u5ea6\u901f\u67e5\u8868<\/h4>\n\n\u7b97\u6cd5\u65f6\u95f4\u590d\u6742\u5ea6\u7a7a\u95f4\u590d\u6742\u5ea6\u6838\u5fc3\u601d\u60f3<\/tr>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                  \u4e8c\u5206\u67e5\u627e<\/td>\nO(log n)<\/td>\nO(1)<\/td>\n\u5206\u6cbb<\/td>\n<\/tr>\n
                  \u5f52\u5e76\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(n)<\/td>\n\u5206\u6cbb<\/td>\n<\/tr>\n
                  \u5feb\u901f\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(log n)<\/td>\n\u5206\u6cbb<\/td>\n<\/tr>\n
                  \u5806\u6392\u5e8f<\/td>\nO(n log n)<\/td>\nO(1)<\/td>\n\u6392\u5e8f<\/td>\n<\/tr>\n
                  01\u80cc\u5305<\/td>\nO(nW)<\/td>\nO(nW)\u6216O(W)<\/td>\nDP<\/td>\n<\/tr>\n
                  LCS<\/td>\nO(mn)<\/td>\nO(mn)<\/td>\nDP<\/td>\n<\/tr>\n
                  \u7f16\u8f91\u8ddd\u79bb<\/td>\nO(mn)<\/td>\nO(mn)<\/td>\nDP<\/td>\n<\/tr>\n
                  \u5168\u6392\u5217<\/td>\nO(n\u00b7n!)<\/td>\nO(n)<\/td>\n\u56de\u6eaf<\/td>\n<\/tr>\n
                  N\u7687\u540e<\/td>\nO(n!)<\/td>\nO(n)<\/td>\n\u56de\u6eaf<\/td>\n<\/tr>\n
                  Dijkstra<\/td>\nO((V+E)logV)<\/td>\nO(V+E)<\/td>\n\u8d2a\u5fc3+\u56fe<\/td>\n<\/tr>\n
                  Floyd<\/td>\nO(V\u00b3)<\/td>\nO(V\u00b2)<\/td>\nDP+\u56fe<\/td>\n<\/tr>\n
                  Kruskal<\/td>\nO(ElogE)<\/td>\nO(V+E)<\/td>\n\u8d2a\u5fc3+\u5e76\u67e5\u96c6<\/td>\n<\/tr>\n
                  \u62d3\u6251\u6392\u5e8f<\/td>\nO(V+E)<\/td>\nO(V+E)<\/td>\nBFS+\u56fe<\/td>\n<\/tr>\n
                  KMP<\/td>\nO(n+m)<\/td>\nO(m)<\/td>\n\u5b57\u7b26\u4e32<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                  9.3 \u8003\u524d\u4e00\u5929\u901f\u89c8\u6e05\u5355<\/h4>\n

                  \u5982\u679c\u53ea\u5269\u4e00\u5929\u590d\u4e60\u65f6\u95f4，\u8bf7\u91cd\u70b9\u638c\u63e1\u4ee5\u4e0b\u5185\u5bb9：<\/p>\n

                • \u624b\u519901\u80cc\u5305（\u4e8c\u7ef4DP\u7248\u672c + \u4e00\u7ef4\u4f18\u5316\u7248\u672c，\u8bb0\u4f4f\u9006\u5e8f\u904d\u5386）<\/li>\n
                • \u624b\u5199LCS（\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b + \u56de\u6eaf\u8f93\u51fa\u5b50\u5e8f\u5217）<\/li>\n
                • \u624b\u5199\u56de\u6eaf\u5168\u6392\u5217（\u901a\u7528\u6a21\u677f + \u53bb\u91cd\u7248\u672c）<\/li>\n
                • \u624b\u5199\u4e8c\u5206\u67e5\u627e（\u57fa\u7840\u7248 + \u67e5\u627e\u7b2c\u4e00\u4e2a\/\u6700\u540e\u4e00\u4e2a）<\/li>\n
                • \u624b\u5199\u5f52\u5e76\u6392\u5e8f + \u6c42\u9006\u5e8f\u5bf9<\/li>\n
                • \u624b\u5199Dijkstra（\u90bb\u63a5\u77e9\u9635\u7248\u672c）<\/li>\n
                • \u624b\u5199Floyd（\u8bb0\u4f4fk\u5728\u6700\u5916\u5c42）<\/li>\n
                • \u624b\u5199\u5e76\u67e5\u96c6（find + \u8def\u5f84\u538b\u7f29 + union + \u6309\u79e9\u5408\u5e76）<\/li>\n
                • \u80cc\u8bf5\u6392\u5e8f\u7b97\u6cd5\u590d\u6742\u5ea6\u5bf9\u6bd4\u8868<\/li>\n
                • \u4e86\u89e3N\u7687\u540e\u7684\u56de\u6eaf\u5199\u6cd5<\/li>\n

                  9.4 \u6700\u540e\u7684\u53ee\u5631<\/h4>\n
                • \u4ee3\u7801\u4e00\u5b9a\u8981\u624b\u5199\u7ec3\u4e60，\u4e0d\u8981\u53ea\u770b！\u770b\u61c2\u548c\u5199\u5bf9\u662f\u4e24\u56de\u4e8b<\/li>\n
                • \u6bcf\u4e2a\u7b97\u6cd5\u90fd\u8981\u80fd\u9ed8\u5199，\u8003\u8bd5\u4e0d\u4f1a\u7ed9\u4f60\u770b\u53c2\u8003\u4ee3\u7801<\/li>\n
                • \u5148\u4fdd\u8bc1\u57fa\u7840\u9898\u5168\u5bf9，\u518d\u51b2\u51fb\u62d4\u9ad8\u9898<\/li>\n
                • \u5199\u4ee3\u7801\u65f6\u6ce8\u610f\u7f29\u8fdb\u548c\u547d\u540d\u89c4\u8303，\u8001\u5e08\u6539\u5377\u65f6\u7b2c\u4e00\u5370\u8c61\u5f88\u91cd\u8981<\/li>\n
                • \u4e0d\u4f1a\u7684\u9898\u76ee\u4e5f\u8981\u5199\u4e2a\u6846\u67b6\u548c\u601d\u8def，\u80fd\u62ff\u6b65\u9aa4\u5206<\/li>\n
                • \u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e00\u5b9a\u8981\u6807\u6ce8<\/li>\n
                  \n

                  \u9644\u5f55：\u5feb\u901f\u6d4b\u8bd5main\u65b9\u6cd5\u6c47\u603b<\/h3>\n

                  \u4e3a\u4e86\u65b9\u4fbf\u5927\u5bb6\u5feb\u901f\u6d4b\u8bd5\u6240\u6709\u4ee3\u7801，\u8fd9\u91cc\u63d0\u4f9b\u4e00\u4e2a\u7edf\u4e00\u7684\u6d4b\u8bd5\u5165\u53e3：<\/p>\n

                  public<\/span> class<\/span> AlgorithmExamTest<\/span> {<\/span>
                  \n public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[<\/span>]<\/span> args)<\/span> {<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"====== \u671f\u672b\u8003\u8bd5\u7b97\u6cd5\u6d4b\u8bd5 ======\\\\n"<\/span>)<\/span>;<\/span><\/p>\n

                  \/\/ 1. \u4e8c\u5206\u67e5\u627e<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"— \u4e8c\u5206\u67e5\u627e —"<\/span>)<\/span>;<\/span>
                  \n int<\/span>[<\/span>]<\/span> sortedArr =<\/span> {<\/span>1<\/span>,<\/span> 3<\/span>,<\/span> 5<\/span>,<\/span> 7<\/span>,<\/span> 9<\/span>,<\/span> 11<\/span>}<\/span>;<\/span>
                  \n \/\/ binarySearch(sortedArr, 7) -> 3<\/span><\/p>\n

                  \/\/ 2. \u5f52\u5e76\u6392\u5e8f\u6c42\u9006\u5e8f\u5bf9<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"— \u9006\u5e8f\u5bf9 —"<\/span>)<\/span>;<\/span>
                  \n int<\/span>[<\/span>]<\/span> arr =<\/span> {<\/span>7<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>,<\/span> 4<\/span>}<\/span>;<\/span>
                  \n \/\/ countInversions -> 5<\/span><\/p>\n

                  \/\/ 3. 01\u80cc\u5305<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"— 01\u80cc\u5305 —"<\/span>)<\/span>;<\/span>
                  \n int<\/span>[<\/span>]<\/span> weights =<\/span> {<\/span>2<\/span>,<\/span> 3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>}<\/span>;<\/span>
                  \n int<\/span>[<\/span>]<\/span> values =<\/span> {<\/span>3<\/span>,<\/span> 4<\/span>,<\/span> 5<\/span>,<\/span> 6<\/span>}<\/span>;<\/span>
                  \n \/\/ knapsack01(weights, values, 8) -> 10<\/span><\/p>\n

                  \/\/ 4. LCS<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"— LCS —"<\/span>)<\/span>;<\/span>
                  \n \/\/ lcsLength("ABCBDAB", "BDCAB") -> 4<\/span><\/p>\n

                  \/\/ 5. \u7f16\u8f91\u8ddd\u79bb<\/span>
                  \n System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"— \u7f16\u8f91\u8ddd\u79bb —"<\/span>)<\/span>;<\/span>
                  \n \/\/ minDistance("horse", "ros") -> 3<\/span><\/p>\n

                  System<\/span>.<\/span>out.<\/span>println<\/span>(<\/span>"\\\\n====== \u6d4b\u8bd5\u5b8c\u6210 ======"<\/span>)<\/span>;<\/span>
                  \n }<\/span>
                  \n}<\/span><\/p>\n

                  \n

                  \u672c\u6587\u5230\u6b64\u7ed3\u675f\u3002\u5982\u679c\u4f60\u89c9\u5f97\u5bf9\u4f60\u6709\u5e2e\u52a9，\u8bf7\u70b9\u8d5e\u3001\u6536\u85cf\u3001\u5173\u6ce8\u4e09\u8fde！\u671f\u672b\u52a0\u6cb9，\u795d\u4f60\u7b97\u6cd5\u8003\u8bd5\u987a\u5229\u62ff\u9ad8\u5206！💪<\/p>\n

                  \u7248\u6743\u58f0\u660e：\u672c\u6587\u4e3a\u539f\u521b\u6574\u7406，\u8f6c\u8f7d\u8bf7\u6ce8\u660e\u51fa\u5904\u3002\u4ee3\u7801\u5747\u4e3a\u624b\u5199\u9a8c\u8bc1，\u5982\u6709bug\u6b22\u8fce\u8bc4\u8bba\u533a\u6307\u51fa\u3002<\/p>\n

                  \u6807\u7b7e：#Java #\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1 #\u671f\u672b\u8003\u8bd5 #\u52a8\u6001\u89c4\u5212 #\u56de\u6eaf\u7b97\u6cd5 #\u56fe\u7b97\u6cd5 #\u5206\u6cbb #\u6570\u636e\u7ed3\u6784<\/p>\n","protected":false},"excerpt":{"rendered":"

                  Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898：\u5168\u90e8\u8003\u70b9\u9898\u578b\u603b\u7ed3（\u4e07\u5b57\u8be6\u89e3，\u9644\u5b8c\u6574\u4ee3\u7801） \u9002\u7528\u5bf9\u8c61：\u672c\u79d1\u8ba1\u7b97\u673a\u4e13\u4e1a\u671f\u672b\u8003\u8bd5\u590d\u4e60 \u4fa7\u91cd\u70b9：\u624b\u5199Java\u4ee3\u7801，\u4e0d\u8003\u590d\u6742\u5e95\u5c42\u8bc1\u660e \u6838\u5fc3\u8003\u70b9：\u9012\u5f52\u3001\u5206\u6cbb\u3001\u8d2a\u5fc3\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u3001\u56fe\u7b97\u6cd5\u3001\u67e5\u627e\u6392\u5e8f \u5206\u503c\u5206\u5e03：\u4ee3\u7801\u9898\u4e00\u822c6～10\u5206\u4e00\u9898，\u8981\u6c42\u5199\u65b9\u6cd5\/\u5b8c\u6574\u7c7b\u3001\u8f93\u51fa\u7ed3\u679c\u3001\u5206\u6790\u590d\u6742\u5ea6 \u672c\u6587\u7279\u8272&#xff1a<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[99,190,427],"topic":[],"class_list":["post-113435","post","type-post","status-publish","format-standard","hentry","category-server","tag-java","tag-190","tag-427"],"yoast_head":"\nJava\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.wsisp.com\/helps\/113435.html\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"og:description\" content=\"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898：\u5168\u90e8\u8003\u70b9\u9898\u578b\u603b\u7ed3（\u4e07\u5b57\u8be6\u89e3，\u9644\u5b8c\u6574\u4ee3\u7801） \u9002\u7528\u5bf9\u8c61：\u672c\u79d1\u8ba1\u7b97\u673a\u4e13\u4e1a\u671f\u672b\u8003\u8bd5\u590d\u4e60 \u4fa7\u91cd\u70b9：\u624b\u5199Java\u4ee3\u7801，\u4e0d\u8003\u590d\u6742\u5e95\u5c42\u8bc1\u660e \u6838\u5fc3\u8003\u70b9：\u9012\u5f52\u3001\u5206\u6cbb\u3001\u8d2a\u5fc3\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u3001\u56fe\u7b97\u6cd5\u3001\u67e5\u627e\u6392\u5e8f \u5206\u503c\u5206\u5e03：\u4ee3\u7801\u9898\u4e00\u822c6～10\u5206\u4e00\u9898，\u8981\u6c42\u5199\u65b9\u6cd5\/\u5b8c\u6574\u7c7b\u3001\u8f93\u51fa\u7ed3\u679c\u3001\u5206\u6790\u590d\u6742\u5ea6 \u672c\u6587\u7279\u8272&#xff1a\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.wsisp.com\/helps\/113435.html\" \/>\n<meta property=\"og:site_name\" content=\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"article:published_time\" content=\"2026-10-06T02:49:46+00:00\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u4f5c\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data2\" content=\"35 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/113435.html\",\"url\":\"https:\/\/www.wsisp.com\/helps\/113435.html\",\"name\":\"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"isPartOf\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\"},\"datePublished\":\"2026-10-06T02:49:46+00:00\",\"dateModified\":\"2026-10-06T02:49:46+00:00\",\"author\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/113435.html#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.wsisp.com\/helps\/113435.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/113435.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u9996\u9875\",\"item\":\"https:\/\/www.wsisp.com\/helps\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\",\"url\":\"https:\/\/www.wsisp.com\/helps\/\",\"name\":\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"description\":\"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"contentUrl\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"caption\":\"admin\"},\"sameAs\":[\"http:\/\/wp.wsisp.com\"],\"url\":\"https:\/\/www.wsisp.com\/helps\/author\/admin\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.wsisp.com\/helps\/113435.html","og_locale":"zh_CN","og_type":"article","og_title":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","og_description":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898：\u5168\u90e8\u8003\u70b9\u9898\u578b\u603b\u7ed3（\u4e07\u5b57\u8be6\u89e3，\u9644\u5b8c\u6574\u4ee3\u7801） \u9002\u7528\u5bf9\u8c61：\u672c\u79d1\u8ba1\u7b97\u673a\u4e13\u4e1a\u671f\u672b\u8003\u8bd5\u590d\u4e60 \u4fa7\u91cd\u70b9：\u624b\u5199Java\u4ee3\u7801，\u4e0d\u8003\u590d\u6742\u5e95\u5c42\u8bc1\u660e \u6838\u5fc3\u8003\u70b9：\u9012\u5f52\u3001\u5206\u6cbb\u3001\u8d2a\u5fc3\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u3001\u56fe\u7b97\u6cd5\u3001\u67e5\u627e\u6392\u5e8f \u5206\u503c\u5206\u5e03：\u4ee3\u7801\u9898\u4e00\u822c6～10\u5206\u4e00\u9898，\u8981\u6c42\u5199\u65b9\u6cd5\/\u5b8c\u6574\u7c7b\u3001\u8f93\u51fa\u7ed3\u679c\u3001\u5206\u6790\u590d\u6742\u5ea6 \u672c\u6587\u7279\u8272&#xff1a","og_url":"https:\/\/www.wsisp.com\/helps\/113435.html","og_site_name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","article_published_time":"2026-10-06T02:49:46+00:00","author":"admin","twitter_card":"summary_large_image","twitter_misc":{"\u4f5c\u8005":"admin","\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"35 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.wsisp.com\/helps\/113435.html","url":"https:\/\/www.wsisp.com\/helps\/113435.html","name":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","isPartOf":{"@id":"https:\/\/www.wsisp.com\/helps\/#website"},"datePublished":"2026-10-06T02:49:46+00:00","dateModified":"2026-10-06T02:49:46+00:00","author":{"@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41"},"breadcrumb":{"@id":"https:\/\/www.wsisp.com\/helps\/113435.html#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.wsisp.com\/helps\/113435.html"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.wsisp.com\/helps\/113435.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u9996\u9875","item":"https:\/\/www.wsisp.com\/helps"},{"@type":"ListItem","position":2,"name":"Java\u7248\u300a\u7b97\u6cd5\u5206\u6790\u4e0e\u8bbe\u8ba1\u300b\u671f\u672b\u4ee3\u7801\u9898\uff1a\u5168\u90e8\u8003\u70b9+\u9898\u578b\u603b\u7ed3\uff08\u4e07\u5b57\u8be6\u89e3\uff0c\u9644\u5b8c\u6574\u4ee3\u7801\uff09"}]},{"@type":"WebSite","@id":"https:\/\/www.wsisp.com\/helps\/#website","url":"https:\/\/www.wsisp.com\/helps\/","name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","description":"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"zh-Hans"},{"@type":"Person","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41","name":"admin","image":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/","url":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","contentUrl":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","caption":"admin"},"sameAs":["http:\/\/wp.wsisp.com"],"url":"https:\/\/www.wsisp.com\/helps\/author\/admin"}]}},"_links":{"self":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/113435","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/comments?post=113435"}],"version-history":[{"count":0,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/113435\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media?parent=113435"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/categories?post=113435"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/tags?post=113435"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/topic?post=113435"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}