數(shù)據(jù)結構筆記

1.迭代與遞歸

遞歸過程中的遞歸因子本身可以被忽略（被計入它自己的過程中了）

遞歸跟蹤、遞推方程。遞歸基

減而治之：Decrease and Conquer 線性遞歸的模式 T(n) = T(n-1)+ O(1)

分而治之：Divide and Conquer? 一般出現(xiàn)log(n)都是要用分治法。

這兩個都是分治法。

動態(tài)規(guī)劃算法與分治法最大的差別是：適合于用動態(tài)規(guī)劃法求解的問題，經分解后得到的子問題往往不是互相獨立的（即下一個子階段的求解是建立在上一個子階段的解的基礎上，進行進一步的求解）（https://www.cnblogs.com/xsyfl/p/6926269.html）

計算復雜度：遞推方程?

解決遞歸爆炸（斐波那契數(shù)列）：遞歸—>迭代（自底而上）

解決方法A (記憶: memoization )：將已計算過實例的結果制表備查

解決方法B (動態(tài)規(guī)劃: dynamic programming ) 顛倒計算方向:由自頂而下遞歸,為自底而上迭代

實例1：斐波那契數(shù)列

實例2：最長子序列LCS

https://blog.csdn.net/huanghanqian/article/details/78892808

（完成lcs

2.回溯法

回溯算法實際上一個類似枚舉的搜索嘗試過程，主要是在搜索嘗試過程中尋找問題的解，當發(fā)現(xiàn)已不滿足求解條件時，就“回溯”返回，嘗試別的路徑。回溯法是一種選優(yōu)搜索法，按選優(yōu)條件向前搜索，以達到目標。但當探索到某一步時，發(fā)現(xiàn)原先選擇并不優(yōu)或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術為回溯法，而滿足回溯條件的某個狀態(tài)的點稱為“回溯點”。

回溯法中函數(shù)的參數(shù)一般很有特點，終止條件通常與某個參數(shù)有關，一般還有一個參數(shù)代表一個子問題的解的形成過程，如22題的str，17題的s，39題的single。。
實例1：leetcode-22-生成括號

注意終止條件為右括號數(shù)==n

public List<String> generateParenthesis(int n) {List<String> res = new ArrayList<String>();back("",res,0,0,n);return res;}public void back(String str,List<String> list,int l,int r,int n){if(r==n)因為right是右括號，數(shù)量=n 表明此時已經找到一個結果list.add(str);if(l<n)back(str + "(" ,list,l+1,r,n);if(r<l)//右括號數(shù)一定小于等于左括號數(shù)，一旦超過則不匹配back(str + ")" ,list,l,r+1,n);}

實例2：leetcode-17-電話號碼的字母組合

class Solution {String[] ss = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};List<String> res = new ArrayList<>();public List<String> letterCombinations(String digits) {if(digits.length()==0)return res;back("",digits,0);return res;}public void back(String s,String digits,int index){if(index==digits.length()){res.add(s);return;}String temp = ss[(digits.charAt(index)-'0')];for(int i = 0;i<temp.length();i++){back(s+temp.charAt(i),digits,index+1);}} }

實例3：leetcode-39-組合總和

class Solution {//類似于走樓梯public List<List<Integer>> combinationSum(int[] candidates, int target) {List<List<Integer>> res = new ArrayList<List<Integer>>();List<Integer> temp = new ArrayList<>();Arrays.sort(candidates);cal(res,temp,candidates,target,0);return res;}public void cal(List<List<Integer>> all,List<Integer> single,int[] candidates,int target,int num){if(target == 0){all.add(single);return;}if(candidates[num]>target)return;for(int i = num;i<candidates.length&&candidates[i]<=target;i++){//深拷貝List<Integer> list=new ArrayList<>(single);list.add(candidates[i]);//遞歸運算，將i傳遞至下一次運算是為了避免結果重復cal(all,list,candidates,target-candidates[i],i);}} }

113. 路徑總和 II

class Solution {List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> pathSum(TreeNode root, int sum) {recall(root,new ArrayList<Integer>(),sum);return res;}public void recall(TreeNode root,List<Integer> list,int sum){if(root==null)return;sum -=root.val;list.add(root.val);if(sum==0&&root.left==null&&root.right==null)res.add(list);List<Integer> tmp = new ArrayList<>(list);recall(root.left,list,sum);recall(root.right,tmp,sum);}}

3. 動態(tài)規(guī)劃：

https://blog.csdn.net/hearthougan/article/details/53749841

例1:

class Solution {/*設n個結點的樹能組成bst個數(shù)為dp(n)，以點i為根結點構成的bst數(shù)目為f(i)；根據(jù)以上假設，我們可以先得出dp(0) = 0，dp(1) = 1，這是邊界條件；因為bst的個數(shù)應該為以每個結點作為根結點能構成的bst數(shù)目的總和，則有dp(n) = f(1) + f(2) + f(3) + ... + f(n)：$ \sum_{i=0}^{n}f(i) $再來看下如何計算f(i)的值，每個結點構成的bst樹數(shù)目實際上應該等于所有左子孫結點構成bst數(shù)目與所有右子孫結點構成bst數(shù)目的乘積，即f(i) = dp(i-1) * dp(n-i)；所以最后公式就變成了dp(n) = dp(0) * dp(n-1) + dp(1) * dp(n-2) + ... + dp(n-1) * dp(0)；即：$ dp(n)=\sum_{i=0}^{n}dp(i-1)*dp(n-i-1)$*///注意純迭代怎么實現(xiàn)public int numTrees(int n) {if(n<3)return n;int []dp = new int[n+1];dp[0]=1;dp[1]=1;dp[2]=2;for(int i=3;i<=n;i++){//與上面博客里自底向上的方法一樣，i代表對規(guī)模為i的問題求解for(int j=0;j<i;j++){dp[i] +=dp[j] * dp[i - j - 1];}}return dp[n];} }

先、中、后序遍歷，深廣度優(yōu)先搜索：

https://www.cnblogs.com/xiaolovewei/p/7763867.html

圖：

棧與隊列? 圖 樹（搜索書、b-tree，紅黑樹） 詞典? ?堆、優(yōu)先隊列? ?串

?

?

?

AVL樹插入刪除算法

https://blog.csdn.net/FreeeLinux/article/details/52204851

1：花朵數(shù)_藍橋杯題目

一個N位的十進制正整數(shù)，如果它的每個位上的數(shù)字的N次方的和等于這個數(shù)本身，則稱其為花朵數(shù)。
例如：
當N=3時，153就滿足條件，因為 1^3 + 5^3 + 3^3 = 153，這樣的數(shù)字也被稱為水仙花數(shù)（其中，“^”表示乘方，5^3表示5的3次方，也就是立方）。
當N=4時，1634滿足條件，因為 1^4 + 6^4 + 3^4 + 4^4 = 1634。
當N=5時，92727滿足條件。
實際上，對N的每個取值，可能有多個數(shù)字滿足條件。

程序的任務是：求N=21時，所有滿足條件的花朵數(shù)。

題目分析

看到這個題一般第一想法是暴力枚舉，經過簡單的計算比較，一般電腦cpu的計算速度在10^10次方/s 這個級別，而10^21次方這個級別的運算量顯然超過了合理的時間限制，所以簡單的暴力枚舉不可取，需要對原計算方法進行化簡。

經過簡單的枚舉，發(fā)現(xiàn)花朵數(shù)的和與花朵數(shù)本身數(shù)值無關，只取決于它的21位上0～9 這10個數(shù)字出現(xiàn)的次數(shù)，如153和351、135、531等等的和都是153，而在暴力枚舉的時候會把這幾個數(shù)都計算一遍。從這可以發(fā)現(xiàn)算法改進的地方，即用各個數(shù)字出現(xiàn)的次數(shù)代替暴力枚舉，建立一個數(shù)組，存儲0-9的出現(xiàn)次數(shù)，可知數(shù)組的元素之和為21（總次數(shù)即位數(shù)），因此當 前9個數(shù)的次數(shù)定下來后，最后一個數(shù)字的次數(shù)也就定下來了。最后判斷是否為花朵數(shù)，1）計算他們的和是否是21位，不是的直接pass??2）拿上一步的和，統(tǒng)計各個數(shù)出現(xiàn)的次數(shù)，與之前建立的數(shù)組做比較，若每個數(shù)字出現(xiàn)的次數(shù)都相等，則打印出結果。

代碼需要用到大數(shù)運算，遞歸。

public static void flower(){BigInteger[] num={Fn(0),Fn(1),Fn(2),Fn(3),Fn(4),Fn(5),Fn(6),Fn(7),Fn(8),Fn(9)};//定義一個數(shù)組存貯每個數(shù)字的21次方int [] cishu=new int [10];//定義一個數(shù)組存貯每個數(shù)字在21位數(shù)中出現(xiàn)的次數(shù)fun(num,cishu,0,0);}/** 求n的21次方*/public static BigInteger Fn(int n){BigInteger sum=BigInteger.ONE;for(int i=0;i<21;i++){sum=sum.multiply(BigInteger.valueOf(n));}return sum;}//m表示當前處理的是數(shù)組cishu的第幾位//n表示21位的名額已經甩掉了多少public static void fun(BigInteger[] num, int[] cishu, int m, int n){if(m==9){cishu[9]=21-n;jisuan(num,cishu);return ;}//對當前位置所有可能進行枚舉for(int i=0;i<21-n;i++){cishu[m]=i;fun(num,cishu,m+1,n+i);}}public static void jisuan(BigInteger[] num, int[] cishu){BigInteger ss=BigInteger.ZERO;for(int i=0;i<10;i++){ss=ss.add(num[i].multiply(BigInteger.valueOf(cishu[i])));}String str=""+ss;if(str.length()!=21){return ;}int [] result=new int [10];//result內存放和的21位形式for(int i=0;i<21;i++){result[str.charAt(i)-'0']++;}//測試數(shù)組cishu和數(shù)組result是否完全匹配for(int i=0;i<10;i++){if(cishu[i]!=result[i]){return ;}}//完全匹配，打印結果System.out.println(str);}

2:摩爾投票法

提問： 給定一個int型數(shù)組，找出該數(shù)組中出現(xiàn)次數(shù)大于數(shù)組長度一半的int值。

解決方案： 遍歷該數(shù)組，統(tǒng)計每個int值出現(xiàn)次數(shù)，再遍歷該集合，找出出現(xiàn)次數(shù)大于數(shù)組長度一半的int值。

同樣的，該解決辦法也要求使用Map，否則無法達到線性的時間復雜度。

那么對于這個問題，有沒有什么不使用Map的線性算法呢？

答案就是摩爾投票法。利用該算法來解決這個問題，我們可以達到線性的時間復雜度以及常量級的空間復雜度。

摩爾投票法的基本思想很簡單，在每一輪投票過程中，從數(shù)組中找出一對不同的元素，將其從數(shù)組中刪除。這樣不斷的刪除直到無法再進行投票，如果數(shù)組為空，則沒有任何元素出現(xiàn)的次數(shù)超過該數(shù)組長度的一半。如果只存在一種元素，那么這個元素則可能為目標元素。

那么有沒有可能出現(xiàn)最后有兩種或兩種以上元素呢？根據(jù)定義，這是不可能的，因為如果出現(xiàn)這種情況，則代表我們可以繼續(xù)一輪投票。因此，最終只能是剩下零個或一個元素。

在算法執(zhí)行過程中，我們使用常量空間實時記錄一個候選元素c以及其出現(xiàn)次數(shù)f(c)，c即為當前階段出現(xiàn)次數(shù)超過半數(shù)的元素。根據(jù)這樣的定義，我們也可以將摩爾投票法看作是一種動態(tài)規(guī)劃算法。

程序開始之前，元素c為空，f(c)=0。遍歷數(shù)組A：

* 如果f(c)為0，表示截至到當前子數(shù)組，并沒有候選元素。也就是說之前的遍歷過程中并沒有找到超過半數(shù)的元素。那么，如果超過半數(shù)的元素c存在，那么c在剩下的子數(shù)組中，出現(xiàn)次數(shù)也一定超過半數(shù)。因此我們可以將原始問題轉化為它的子問題。此時c賦值為當前元素, 同時f(c)=1。

* 如果當前元素A[i] == c, 那么f(c) += 1。(沒有找到不同元素，只需要把相同元素累計起來)

* 如果當前元素A[i] != c，那么f(c) -= 1 (相當于刪除1個c)，不對A[i]做任何處理(相當于刪除A[i])

如果遍歷結束之后，f(c)不為0，則找到可能元素。

再次遍歷一遍數(shù)組，記錄c真正出現(xiàn)的次數(shù)，從而驗證c是否真的出現(xiàn)了超過半數(shù)。上述算法的時間復雜度為O(n)，而由于并不需要真的刪除數(shù)組元素，我們也并不需要額外的空間來保存原始數(shù)組，空間復雜度為O(1)。

//leetcode-169 class Solution {public int majorityElement(int[] nums){int major = nums[0];int count = 1;for (int i = 1; i < nums.length; i++) {if (major == nums[i]) {count++;} else if (--count == 0) {major = nums[i + 1];}}return major;} }//未針對題優(yōu)化的版本 public int majorityElement(int[] nums) { int majority = -1; int count = 0; for (int num : nums) { if (count == 0) { majority = num; count++; } else { if (majority == num) { count++; } else { count--; } } } int counter = 0; if (count <= 0) { return -1; } else { for (int num : nums) { if (num == majority) counter ++; } } if (counter > nums.length / 2) { return majority; } return -1; } //leetcode-229 class Solution {public List<Integer> majorityElement(int[] nums) {/**首先可以明確的一點是，這樣的元素可能有0個、1個、或者2個，再沒有別的情況了. 然后，求眾數(shù)I 里的 Boyer-Moore 算法思路在這里依然可用，但需要些改動：1) 滿足條件的元素最多有兩個，那么需要兩組變量. count, major變成了count1, major1; count2, major2;2) 選出的兩個元素，需要驗證它們的出現(xiàn)次數(shù)是否真的滿足條件.**/List<Integer> ret = new ArrayList<>();if(nums.length < 1) return ret;int count1 = 0, count2 = 0;int major1 = nums[0], major2 = nums[0];for(int num : nums) {if(num == major1)count1++;else if(num == major2)count2++;else if(count1 == 0) {count1 = 1;major1 = num;}else if(count2 == 0) {count2 = 1;major2 = num;}else {count1--;count2--;}}count1 = 0;count2 = 0;for(int num : nums) {if(num == major1)count1++;else if(num == major2)count2++;}if(count1 > nums.length/3)ret.add(major1);if(major1 != major2 && count2 > nums.length/3)ret.add(major2);return ret;} }

其實這樣的算法也可以衍生到其它頻率的問題上，比如說，找出所有出現(xiàn)次數(shù)大于n/3的元素。同樣可以以線性時間復雜度以及常量空間復雜度來實現(xiàn)。

3. 求子集

給定一組不含重復元素的整數(shù)數(shù)組?nums，返回該數(shù)組所有可能的子集（冪集）。

說明：解集不能包含重復的子集。

示例:

輸入: nums = [1,2,3] 輸出: [[3],[1],[2],[1,2,3],[1,3],[2,3],[1,2],[] ] class Solution {//位運算法public List<List<Integer>> subsets(int[] nums) {List<List<Integer>> ret = new ArrayList<>();int len = nums.length;for(int i = 0;i<Math.pow(2,len);i++){List<Integer> tmp = new ArrayList<>();for(int j = 0;j<len;j++){// 如示例 001 代表選擇1，101 選1和3if((i&1<<j)!=0)tmp.add(nums[j]);}ret.add(tmp);}return ret;} }

4.滑窗法

滑動窗方法算是解決數(shù)組或者字符串中，處理連續(xù)的字符串段應該想到的一種方法，這里面有變長滑動窗，和定長滑動窗。滑動窗問題總共要處理兩個方面，一個是新加入點和處理和移除滑動窗點點的處理。?

通用偽代碼：

https://blog.csdn.net/haolexiao/article/details/54781671

void slidingwindows(vector<int> nums,int k){先預處理然后進行滑動窗的循環(huán)，一般是個while循環(huán)，同時實現(xiàn)定義好滑動窗的起點和終點，同時還有一個是記錄當前狀態(tài)的數(shù)或者數(shù)組，比如countint begin = 0, end = 0;int count = 0;while(end<nums.size()){//或for循環(huán)1.在循環(huán)里先是當前end到達的時候，更新count2.判斷更新完后是否滿足條件，比如count<k3.如果滿足的話，可以進行一些處理，如果是求最小長度之類的，會在滿足時進行操作4.如果不滿足的話，也需要進行一些處理，比如求最大長度之類的，會在此時進行操作以上3,4條常見的操作就是一個while循環(huán)，進行左邊界begin的收縮處理，一直到收縮到滿足/不滿足條件為止} public int numSubarrayProductLessThanK(int[] nums, int k) {if(k==0)return 0;int res = 0, l = 0,r = 0;int len = nums.length,mul = 1;while(r<len){mul *= nums[r++];while(l<r && mul>=k){mul /= nums[l++];}res += r - l;前面是n位，增加一位后，子數(shù)組個數(shù)增加n+1個}return res;}

滑窗法模版

https://blog.csdn.net/binling/article/details/45747193

5.最大子序和(字符串的一系列問題：如最長回文xx等等

leetcode-53

Kadane算法掃描一次整個數(shù)列的所有數(shù)值，在每一個掃描點計算以該點數(shù)值為結束點的子數(shù)列的最大和（正數(shù)和）。該子數(shù)列由兩部分組成：以前一個位置為結束點的最大子數(shù)列、該位置的數(shù)值。因為該算法用到了“最佳子結構”（以每個位置為終點的最大子數(shù)列都是基于其前一位置的最大子數(shù)列計算得出），該算法可看成動態(tài)規(guī)劃的一個例子。

class Solution {//f[n] = max(0, f[n-1]) + num[n]/*以第n個數(shù)為結束點的子數(shù)列的最大和，存在一個遞推關系f(n) = max(f(n-1) + A[n], A[n]);上面的max(0, f[n-1]) + num[n]等效于max(f(n-1) + A[n], A[n])*/public int maxSubArray(int[] nums) {if(nums.length == 0) return 0;int max = Integer.MIN_VALUE;int fn = -1;int len = nums.length;for(int i = 0;i<len;i++){fn = Math.max(nums[i],fn+nums[i]);max = Math.max(fn,max);}return max;} }

6.對稱二叉樹

遞歸：

class Solution {public boolean isSymmetric(TreeNode root) {if(root == null) return true;//把問題變成判斷兩棵樹是否是對稱的return isSym(root.left, root.right);}//判斷的是根節(jié)點為r1和r2的兩棵樹是否是對稱的public boolean isSym(TreeNode r1, TreeNode r2){if(r1 == null && r2 == null) return true;if(r1 == null || r2 == null) return false;//這兩棵樹是對稱需要滿足的條件：//1.倆根節(jié)點相等。 2.樹1的左子樹和樹2的右子樹，樹2的左子樹和樹1的右子樹都得是對稱的return r1.val == r2.val && isSym(r1.left, r2.right) && isSym(r1.right, r2.left);} }

迭代

public boolean isSymmetric(TreeNode root) {Queue<TreeNode> q = new LinkedList<>();q.add(root);q.add(root);while (!q.isEmpty()) {TreeNode t1 = q.poll();TreeNode t2 = q.poll();if (t1 == null && t2 == null) continue;if (t1 == null || t2 == null) return false;if (t1.val != t2.val) return false;q.add(t1.left);q.add(t2.right);q.add(t1.right);q.add(t2.left);}return true; }

7.最大子序列、最長遞增子序列、最長公共子串、最長公共子序列、字符串編輯距離

https://blog.csdn.net/w_s_h_y/article/details/77447901

https://www.cnblogs.com/AndyJee/p/4465696.html

最長上升子序列o(nlogn)復雜度的解法：

https://blog.csdn.net/wqtltm/article/details/81253935#comments

8.KMP算法與BM算法

1）kmp

https://www.cnblogs.com/tangzhengyue/p/4315393.html：

這里我們借鑒數(shù)學歸納法的三個步驟（或者說是動態(tài)規(guī)劃）：
1、初始狀態(tài)
2、假設第j位以及第j位之前的我們都填完了
3、推論第j+1位該怎么填

初始狀態(tài)我們稍后再說，我們這里直接假設第j位以及第j位之前的我們都填完了。也就是說，從上圖來看，我們有如下已知條件：
next[j] == k;
next[k] == 綠色色塊所在的索引;
next[綠色色塊所在的索引] == 黃色色塊所在的索引;
這里要做一個說明：圖上的色塊大小是一樣的（好吧，請忽略色塊大小，色塊只是代表數(shù)組中的一位）。

我們來看下面一個圖，可以得到更多的信息：

1.由"next[j] == k;"這個條件，我們可以得到A1子串 == A2子串（根據(jù)next數(shù)組的定義，前后綴那個）。

2.由"next[k] == 綠色色塊所在的索引;"這個條件，我們可以得到B1子串 == B2子串。

3.由"next[綠色色塊所在的索引] == 黃色色塊所在的索引;"這個條件，我們可以得到C1子串 == C2子串。

4.由1和2(A1 == A2，B1 == B2)可以得到B1 == B2 == B3。

5.由2和3(B1 == B2， C1 == C2)可以得到C1 == C2 == C3。

6.B2 == B3可以得到C3 == C4 == C1 == C2

接下來，我們開始用上面得到的條件來推導如果第j+1位失配時，我們應該填寫next[j+1]為多少？

next[j+1]即是找strKey從0到j這個子串的最大前后綴：

#：(#:在這里是個標記，后面會用)我們已知A1 == A2，那么A1和A2分別往后增加一個字符后是否還相等呢？我們得分情況討論：

(1)如果str[k] == str[j]，很明顯，我們的next[j+1]就直接等于k+1。

　　用代碼來寫就是next[++j] = ++k;

(2)如果str[k] != str[j]，那么我們只能從已知的，除了A1，A2之外，最長的B1，B3這個前后綴來做文章了。

那么B1和B3分別往后增加一個字符后是否還相等呢？

由于next[k] == 綠色色塊所在的索引，我們先讓k = next[k]，把k挪到綠色色塊的位置，這樣我們就可以遞歸調用"#："標記處的邏輯了。

由于j+1位之前的next數(shù)組我們都是假設已經求出來了的，因此，上面這個遞歸總會結束，從而得到next[j+1]的值。

?

我們唯一欠缺的就是初始條件了：

next[0] = -1, ?k = -1, j = 0

另外有個特殊情況是k為-1時，不能繼續(xù)遞歸了，此時next[j+1]應該等于0，即把j回退到首位。

即 next[j+1] = 0; 也可以寫成next[++j] = ++k;

?

public static int[] getNext(String ps) {char[] strKey = ps.toCharArray();int[] next = new int[strKey.length];// 初始條件int j = 0;int k = -1;next[0] = -1;// 根據(jù)已知的前j位推測第j+1位while (j < strKey.length - 1){if (k == -1 || strKey[j] == strKey[k]){next[++j] = ++k;}else{k = next[k];}}return next; }

現(xiàn)在再看這段代碼應該沒有任何問題了吧。

優(yōu)化：

細心的朋友應該發(fā)現(xiàn)了，上面有這樣一句話：

(1)如果str[k] == str[j]，很明顯，我們的next[j+1]就直接等于k+1。用代碼來寫就是next[++j] = ++k;

可是我們知道，第j+1位是失配了的，如果我們回退j后，發(fā)現(xiàn)新的j(也就是此時的++k那位)跟回退之前的j也相等的話，必然也是失配。所以還得繼續(xù)往前回退。

public static int[] getNext(String ps) {char[] strKey = ps.toCharArray();int[] next = new int[strKey.length];// 初始條件int j = 0;int k = -1;next[0] = -1;// 根據(jù)已知的前j位推測第j+1位while (j < strKey.length - 1){if (k == -1 || strKey[j] == strKey[k]){// 如果str[j + 1] == str[k + 1]，回退后仍然失配，所以要繼續(xù)回退if (str[j + 1] == str[k + 1]){next[++j] = next[++k];}else{next[++j] = ++k;}}else{k = next[k];}}return next; }

kmp算法主程序：?

public static int KMP(String ts, String ps) {char[] t = ts.toCharArray();char[] p = ps.toCharArray();int i = 0; // 主串的位置int j = 0; // 模式串的位置int[] next = getNext(ps);while (i < t.length && j < p.length) {if (j == -1 || t[i] == p[j]) { // 當j為-1時，要移動的是i，當然j也要歸0i++;j++;} else {// i不需要回溯了// i = i - j + 1;j = next[j]; // j回到指定位置}}if (j == p.length) {return i - j;} else {return -1;}}

9.原地算法

使用原地算法，一般就會牽涉到編解碼問題。

//https://segmentfault.com/a/1190000003819277public void gameOfLife(int[][] board) {int m = board.length, n = board[0].length;for(int i = 0; i < m; i++){for(int j = 0; j < n; j++){int lives = 0;// 判斷上邊if(i > 0){lives += board[i - 1][j] == 1 || board[i - 1][j] == 2 ? 1 : 0;}// 判斷左邊if(j > 0){lives += board[i][j - 1] == 1 || board[i][j - 1] == 2 ? 1 : 0;}// 判斷下邊if(i < m - 1){lives += board[i + 1][j] == 1 || board[i + 1][j] == 2 ? 1 : 0;}// 判斷右邊if(j < n - 1){lives += board[i][j + 1] == 1 || board[i][j + 1] == 2 ? 1 : 0;}// 判斷左上角if(i > 0 && j > 0){lives += board[i - 1][j - 1] == 1 || board[i - 1][j - 1] == 2 ? 1 : 0;}//判斷右下角if(i < m - 1 && j < n - 1){lives += board[i + 1][j + 1] == 1 || board[i + 1][j + 1] == 2 ? 1 : 0;}// 判斷右上角if(i > 0 && j < n - 1){lives += board[i - 1][j + 1] == 1 || board[i - 1][j + 1] == 2 ? 1 : 0;}// 判斷左下角if(i < m - 1 && j > 0){lives += board[i + 1][j - 1] == 1 || board[i + 1][j - 1] == 2 ? 1 : 0;}// 根據(jù)周邊存活數(shù)量更新當前點，結果是0和1的情況不用更新if(board[i][j] == 0 && lives == 3){board[i][j] = 3;} else if(board[i][j] == 1){if(lives < 2 || lives > 3) board[i][j] = 2;}}}// 解碼for(int i = 0; i < m; i++){for(int j = 0; j < n; j++){board[i][j] = board[i][j] % 2;}}}

10.染色問題

?圖的m著色問題

//不能用圖有無環(huán)去判斷，有環(huán)也是可以分的，如1->2->3->4->1//本題類似于經典的染色算法https://blog.csdn.net/qq_38959715/article/details/82191026private Map<Integer,List<Integer>> graph886 = new HashMap<>();// 圖存放的數(shù)據(jù)結構private int[] color886; // 每個節(jié)點的顏色public boolean possibleBipartition(int N, int[][] dislikes) {if(N<3)return true;color886 = new int[N+1];Arrays.fill(color886,-1);//-1表示未訪問,0和1是兩種顏色for(int i = 1;i<=N;i++){graph886.put(i,new ArrayList<>());}for(int [] edge : dislikes){graph886.get(edge[0]).add(edge[1]);graph886.get(edge[1]).add(edge[0]);}for(int i = 1;i<=N;i++){if(color886[i]<0){color886[i] = 0;if(!possbi_dfs(i))return false;}}return true;}public boolean possbi_dfs(int now){for(int next : graph886.get(now)){if(color886[next]<0){//第一圈為1 第二圈為0 第三圈為1 依次類推(主要是為了判斷相鄰的兩個層會不會染色沖突)color886[next] = 1 - color886[now];if(!possbi_dfs(next))return false;}else if(color886[next]==color886[now])return false;}return true;}

11.并查集

https://www.cnblogs.com/xzxl/p/7226557.html

http://www.cnblogs.com/xzxl/p/7341536.html

//并查集public int[] findRedundantConnection(int[][] edges) {int n = edges.length;int[] pre = new int[n+1];//每個pre節(jié)點初始化為自己for(int i = 0;i<= n;i++){pre[i] = i;}for(int [] edge : edges){int root1 = findRoot(edge[0],pre);int root2 = findRoot(edge[1],pre);//有共同的根節(jié)點，說明在一個連通子圖中，此時這條邊不能加入，否則會形成環(huán)，因此這條邊需要刪去if(root1==root2)return edge;//并集，將root1下所有子節(jié)點的根節(jié)點設為root2，方便下次尋找根節(jié)點adjust(edge[0],root2,pre);}return new int[0];}//尋找該節(jié)點的根節(jié)點private int findRoot(int num,int[]pre){while(pre[num]!=num)num = pre[num];return num;}//并集 + 路徑壓縮private void adjust(int x,int root,int[] pre){while(pre[x]!=root){int temp = pre[x];pre[x] = root;x = temp;}}

12.堆排序

　　堆排序是利用堆這種數(shù)據(jù)結構而設計的一種排序算法，堆排序是一種選擇排序，它的最壞，最好，平均時間復雜度均為O(nlogn)，它也是不穩(wěn)定排序。

　　堆是具有以下性質的完全二叉樹：每個結點的值都大于或等于其左右孩子結點的值，稱為大頂堆；或者每個結點的值都小于或等于其左右孩子結點的值，稱為小頂堆。

大頂堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] ?

小頂堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] ?

代碼如下：

public class HeapSort {public static void main(String []args){int []arr = {9,8,7,6,5,4,3,2,1};sort(arr);System.out.println(Arrays.toString(arr));}public static void sort(int []arr){//1.構建大頂堆for(int i=arr.length/2-1;i>=0;i--){//從第一個非葉子結點從下至上，從右至左調整結構adjustHeap(arr,i,arr.length);}//2.調整堆結構+交換堆頂元素與末尾元素for(int j=arr.length-1;j>0;j--){swap(arr,0,j);//將堆頂元素與末尾元素進行交換adjustHeap(arr,0,j);//重新對堆進行調整}}//調整大頂堆public static void adjustHeap(int []arr,int i,int length){int temp = arr[i];//先取出當前元素ifor(int k=i*2+1;k<length;k=k*2+1){//從i結點的左子結點開始，也就是2i+1處開始if(k+1<length && arr[k]<arr[k+1]){//如果左子結點小于右子結點，k指向右子結點k++;}if(arr[k] >temp){//如果子節(jié)點大于父節(jié)點，將子節(jié)點值賦給父節(jié)點（不用進行交換）arr[i] = arr[k];i = k;}else{break;}}arr[i] = temp;//將temp值放到最終的位置}public static void swap(int []arr,int a ,int b){int temp=arr[a];arr[a] = arr[b];arr[b] = temp;} }

簡單總結下堆排序的基本思路：

　　a.將無需序列構建成一個堆，根據(jù)升序降序需求選擇大頂堆或小頂堆;

　　b.將堆頂元素與末尾元素交換，將最大元素"沉"到數(shù)組末端;

　　c.重新調整結構，使其滿足堆定義，然后繼續(xù)交換堆頂元素與當前末尾元素，反復執(zhí)行調整+交換步驟，直到整個序列有序。

13. 桶排序

14. 線段樹

//線段樹 也可用前綴和求解 b[i]=b[i-1]+co[i]; //線段樹 https://www.cnblogs.com/TheRoadToTheGold/p/6254255.html //樹狀數(shù)組 https://blog.csdn.net/Small_Orange_glory/article/details/81290634 class NumArray {private segmentNode root;private int[] nums;public NumArray(int[] nums) {if (nums.length == 0) return ;this.nums = nums;root = buildTree(0,nums.length-1);}public void update(int i, int val) {updateNode(root,i,val);}public int sumRange(int i, int j) {return rangeQuery(root,i,j);}private int rangeQuery(segmentNode x,int i,int j) {if (x.start == i && x.end == j) {return x.sum;}int mid = x.start + (x.end - x.start) / 2;if (j <= mid) return rangeQuery(x.left,i,j);//注意這里的 = 放到i上不行，應該是與mid向下取值有原因if (i > mid) return rangeQuery(x.right,i,j);return rangeQuery(x.left,i,mid) + rangeQuery(x.right,mid+1,j);}private void updateNode(segmentNode x,int i,int val) {if (x.start == x.end && x.start == i) {x.sum = val;return ;}int mid = x.start + (x.end - x.start) / 2;if (i <= mid) {updateNode(x.left,i,val);} else {updateNode(x.right,i,val);}x.sum = x.left.sum + x.right.sum;return ;}private segmentNode buildTree(int start,int end) {if (start == end) {return new segmentNode(start,end,nums[start]);}int mid = start + (end - start) / 2;segmentNode node = new segmentNode(start,end,0);node.left = buildTree(start,mid);node.right = buildTree(mid+1,end);node.sum = node.left.sum + node.right.sum;//向上修改，區(qū)間修改不適用return node;}class segmentNode {private int start,end;private segmentNode left,right;private int sum;public segmentNode(int start,int end,int sum) {this.start = start;this.end = end;this.sum = sum;}} }

15.最小生成樹

在一個無向連通圖中，如果存在一個連通子圖包含原圖中所有的結點和部分邊，且這個子圖不存在回路，那么我們稱這個子圖為原圖的一棵生成樹。在帶權圖中，所有的生成樹中邊權的和最小的那棵(或幾棵)被稱為最小生成樹。

定理: 在要求解的連通圖中，任意選擇一些點屬于集合 A，剩余的點屬于集合 B，必定存在一棵最小生成樹包含兩個頂點分別屬于集合 A 和集合 B 的邊(即連通 兩個集合的邊)中權值最小的邊。

這個結論就是我們將要介紹的求最小生成樹 Kruskal 算法的算法原理，它按照按如下步驟求解最小生成樹:

1.初始時所有結點屬于孤立的集合。

2.按照邊權遞增順序遍歷所有的邊，若遍歷到的邊兩個頂點仍分屬不同的集 合(該邊即為連通這兩個集合的邊中權值最小的那條)則確定該邊為最小生成樹 上的一條邊，并將這兩個頂點分屬的集合合并。

3.遍歷完所有邊后，原圖上所有結點屬于同一個集合則被選取的邊和原圖中 所有結點構成最小生成樹;否則原圖不連通，最小生成樹不存在。

如步驟所示，在用 Kruskal 算法求解最小生成樹的過程中涉及到大量的集合 操作，我們恰好可以使用上一節(jié)中討論的并查集來實現(xiàn)這些操作。

1. 鄰接矩陣源碼

1

2. 鄰接表源碼

// 邊的結構體 class ENode {char start; // 邊的起點char end; // 邊的終點int weight; // 邊的權重public ENode(char start, char end, int weight) {this.start = start;this.end = end;this.weight = weight;} };// 鄰接表中表的頂點 class VNode {char data; // 頂點信息ENode firstEdge; // 指向第一條依附該頂點的弧 };class Graph {private static final int INF = Integer.MAX_VALUE; // 最大值char[] vertexs; // 頂點集合int[][] matrix; // 鄰接矩陣// 得到當前有向圖中的所有邊信息public List<ENode> getEdges() {List<ENode> edges = new ArrayList<ENode>();for (int i = 0; i < vertexs.length; i++) {for (int j = 0; j < vertexs.length; j++) {if (matrix[i][j] != INF) {ENode edge = new ENode(vertexs[i], vertexs[j], matrix[i][j]);edges.add(edge);}}}return edges;} }private static final int INF = Integer.MAX_VALUE; // 最大值static void qSort(List<ENode> edges, int low, int high) {if (low < high) {int i = low, j = high;ENode edge = edges.get(low);while (i < j) {while (edge.weight < edges.get(j).weight && i < j)j--;edges.set(i, edges.get(j));while (edge.weight > edges.get(i).weight && i < j)i++;edges.set(j, edges.get(j));}edges.set(i, edge);qSort(edges, low, i - 1);qSort(edges, i + 1, high);}}public static void kruskal(Graph G) {// 1.拿到有向圖中所有邊List<ENode> edges = G.getEdges();int edgeNum = edges.size();// 2.對所有有向邊進行排序qSort(edges, 0, edgeNum - 1);ENode[] minTree = new ENode[G.vertexs.length - 1]; // 結果數(shù)組，保存kruskal最小生成樹的邊int index = 0; // minTree數(shù)組的索引// 用于保存"已有最小生成樹"中每個頂點（以數(shù)組下標表示） 與 其經過“最短邊”的鄰接頂點 （以對應下標的值表示）的并查集int[] start2end = new int[G.vertexs.length]; // 3.依次將最短且不與T構成回路的邊加入T集合for (int i = 0; i < edgeNum; i++) {//得到當前最短邊 在有向圖G中的起始頂點與終結頂點的 下標int p1 = getIndex(G, edges.get(i).start); // 獲取第i條邊的"起點"的序號int p2 = getIndex(G, edges.get(i).end); // 獲取第i條邊的"終點"的序號//分別得到在T集合中沿當前最短邊的“起點”與“終點”遍歷到的最后節(jié)點，//若加入當前最短邊后T集合存在回路，則“起點”與“終點”遍歷到的最后節(jié)點一定是同一節(jié)點int m = getEnd(start2end, p1); // 獲取p1在"已有的最小生成樹"中的終點int n = getEnd(start2end, p2); // 獲取p2在"已有的最小生成樹"中的終點//當前最短邊加入T集合后沒有有回路 則將當前最短邊加入T集合，并且記錄當前最短邊的“起點”與“終點”if (m != n) {start2end[m] = n; // “起點”即vends的數(shù)組下標與“終點”即vends的對應下標的值minTree[index++] = edges.get(i); // 保存結果}}}static int getIndex(Graph G, char ch) {int i = 0;for (; i < G.vertexs.length; i++)if (G.vertexs[i] == ch)return i;return -1;}static int getEnd(int start2end[], int i) {while (start2end[i] != 0)i = start2end[i];return i;}

16.最小高度樹

leetcode310:此問題等同于在無向圖中找到一條最長的路徑，因為最小高度樹的根一定在圖的一條最長路徑的中點位置，尋找這條最長路徑的方法是從任意一點出發(fā)，找到最遠的點a，然后再從這個最遠的點a出發(fā)，找到離它最遠的點b，a—b即為最長路徑。可以用廣度優(yōu)先或者深度優(yōu)先搜索。

之所以能用這種方法找最長路徑，是因為先找到的點a一定是樹的葉子節(jié)點且處于樹中最長或次長的枝上，由此出發(fā)找到的b一定是樹次長或最長的枝的葉子。

代碼如下：

private int maxNode310, maxDepth310;public List<Integer> findMinHeightTrees(int n, int[][] edges) {List<Integer> roots = new ArrayList<>();List<Integer>[] graph = new ArrayList[n];for(int i=0; i<n; i++) graph[i] = new ArrayList<>();for(int i=0; i<edges.length; i++) {graph[edges[i][0]].add(edges[i][1]);graph[edges[i][1]].add(edges[i][0]);}boolean[] visited = new boolean[n];int[] prev = new int[n];//記錄先序節(jié)點maxNode310 = 0;maxDepth310 = 0;visited[0] = true;dfs310(0,0,graph,visited,prev);int node1 = maxNode310;Arrays.fill(prev,0);Arrays.fill(visited, false);maxDepth310 = 0;visited[node1] = true;dfs310(node1, 0, graph, visited, prev);int node2 = maxNode310;int node = node2;for(int i=0; i<maxDepth310/2; i++) node = prev[node];if ((maxDepth310 & 1) == 0) {roots.add(node);} else {roots.add(node);roots.add(prev[node]);}return roots;}private void dfs310(int from, int depth, List<Integer>[] graph, boolean[] visited, int[] prev){if (depth > maxDepth310) {maxDepth310 = depth;maxNode310 = from;}for(int next:graph[from]){if(visited[next]==true)continue;visited[next] = true;prev[next] = from;dfs310(next,depth+1,graph,visited,prev);}}

17.矩陣鏈乘?

18.

1）最短路徑問題

Floyd 算法

在圖的鄰接矩陣表示法中，edge[i][j]表示由結點 i 到結點 j 中間 不經過任何結點時的最短距離，那么我們依次為中間允許經過的結點添加結點 1、結點 2、......直到結點 N，當添加完這些結點后，從結點 i 到結點 j 允許經過 所有結點的最短路徑長度就可以確定了，該長度即為原圖上由結點 i 到結點 j 的 最短路徑長度。

我們設 ans[k][i][j]為從結點 i 到結點 j 允許經過編號小于等于 k 的結點時其最短路徑長度。如上文，ans[0][i][j]即等于圖的鄰接矩陣表示中 edge[i][j]的值。我 們通過如下循環(huán)，完成所有 k 對應的 ans[k][i][j]值的求解:

for (int k = 1;k <= n;k ++) { //從1至n循環(huán)k for (int i = 1;i <= n;i ++) {for (int j = 1;j <= n;j ++) { //遍歷所有的ijif (ans[k - 1][i][k] == 無窮||ans[k - 1][k][j] == 無窮) { //若當允許經過前k-1個結點時,i或j不能與k連通,則ij之間到目前為止不存在經過k的路徑 ans[k][i][j] = ans[k - 1][i][j]; //保持原值,即從i到j允許經過前k個點和允許經過前k-1個結點時最短路徑長度相同 continue; //繼續(xù)循環(huán)}if (ans[k - 1][i][j] == 無窮||ans[k - 1][i][k] + ans[k - 1][k][j] < ans[k - 1][i][j]) //若經過前k-1個結點,i和j不連通 或者 通過經過結點k可以得到比原來更短的路徑 //更新該最短值}ans[k][i][j] = ans[k - 1][i][k] + ans[k - 1][k][j]; else ans[k][i][j] = ans[k - 1][i][j]; //否則保持原狀} }

經過這樣的 n 次循環(huán)后，我們即可得到所有結點間允許經過所有結點條件下 的最短路徑長度，該路徑長度即為我們要求的最短路徑長度。即若要求得 ab 之 間的最短路徑長度，其答案為 ans[n][a][b]的值。

同時我們注意到，我們在通過 ans[k - 1][i][j]的各值來遞推求得 ans[k][i][j]的 值時，所有的 ans[k][i][j]值將由 ans[k - 1][i][j]和 ans[k - 1][i][k] + ans[k - 1][k][j] 的大小關系確定，但同時 ans[k][i][k]和 ans[k][k][j]必定與 ans[k - 1][i][k]和 ans[k - 1][k][j]的值相同，即這些值不會因為本次更新而發(fā)生改變。所以我們將如上代碼片段簡化成如下形式:

for (int k = 1;k <= n;k ++) {for (int i = 1;i <= n;i ++) {for (int j = 1;j <= n;j ++) {if (ans[i][k] == 無窮 || ans[k][j] == 無窮) continue; if(ans[i][j]== 無窮 ||ans[i][k]+ans[k][j]<ans[i][j])ans[i][j] = ans[i][k] + ans[k][j]; } } }

2）單源最短路路徑問題

其實在我看來，dijkstra算法和Floyd算法思想一樣，不過是在Floyd算法上在針對單個點的最短路徑時做了簡化。

Dijkstra 算法流程如下:
1.初始化，集合 K 中加入結點 1，結點 1 到結點 1 最短距離為 0，到其它結點為無窮(或不確定)。
2.遍歷與集合 K 中結點直接相鄰的邊(U，V，C)，其中 U 屬于集合 K，V

不屬于集合 K，計算由結點 1 出發(fā)按照已經得到的最短路到達 U，再由 U 經過 該邊到達 V 時的路徑長度。比較所有與集合 K 中結點直接相鄰的非集合 K 結點

該路徑長度，其中路徑長度最小的結點被確定為下一個最短路徑確定的結點，其 最短路徑長度即為這個路徑長度，最后將該結點加入集合 K。

3.若集合 K 中已經包含了所有的點，算法結束;否則重復步驟 2。

//743. 網絡延遲時間//單源最短路徑問題private final int inf1 = 0x3f3f3f3f;boolean [] visit;int[] dist;//最短距離int[][] graph ;public int networkDelayTime(int[][] times, int N, int K) {visit = new boolean[N+1];dist = new int[N+1];graph = new int[N+1][N+1];Arrays.fill(dist,inf1);for(int i=0;i<=N;i++)for(int j=0;j<=N;j++)graph[i][j]=i==j?0:inf1;for(int[] e : times)graph[e[0]][e[1]] = e[2];dijkstra(K,N);int max = 0;for(int i = 1;i<dist.length;i++) {if (!visit[i])return -1;if(dist[i]>max)max = dist[i];}return max;}public void dijkstra(int source ,int N){dist[source] = 0;visit[source]=true;for(int i = 1;i<N+1;i++){dist[i] = graph[source][i];}for(int j = 0;j<N;j++){//j meiyongint index = -1,min = inf1;for(int i = 1;i<=N;i++) {if (!visit[i] && dist[i] < min) {min = dist[i];index = i;}}if(index==-1)return;visit[index] = true;for(int v = 1;v<=N;++v){if(!visit[v]&&graph[index][v]!=inf1&&dist[v]>dist[index]+graph[index][v])dist[v]=dist[index]+graph[index][v];}}}

3）dp求解最短路路徑問題

用動態(tài)規(guī)劃也可以求出最短路徑，時間復雜度為O（n^2），跟沒有優(yōu)化的Dijistra算法一樣（優(yōu)化后的Dijistra算法時間復雜度為O（（m+n）lgn)）。?

首先這里有15個結點，表現(xiàn)出來的矩陣為：?

左側1-15表示前一個節(jié)點，最上面一行1-15表示后一個節(jié)點，記這個圖的矩陣為P，那么P[0][1]==5表示節(jié)點0與節(jié)點1相連，路徑長度為5。那么我們如何利用動態(tài)規(guī)劃來求解最短路徑？

首先我們需要把整個問題轉換成小的子問題，利用小的子問題的最優(yōu)解求出整個問題的最優(yōu)解。

我們的目的是求0-15之間的最短路徑，由圖可知與節(jié)點15相連的是結點14和節(jié)點13，假設我們已經求出0-13的最短路徑的值D13和0-14的最短路徑的值D14，那么我們只需要比較D13+d(13-15)和D14+d(14-15)的大小就可以知道從哪個節(jié)點出發(fā)到節(jié)點15的路徑最短。按照這個思想一直往前推，推到節(jié)點0時結束，自然就求出了節(jié)點0-節(jié)點15的最短路徑，這個思路是遞歸的，如果用遞歸的方法，時間復雜度很高，當然你也可以用備忘錄，記錄已經計算過的值，我這里將遞歸轉換成迭代。

我們先定義一個類class Node,里面存儲節(jié)點的序號、從0到這個節(jié)點的最短路徑的值、前一個節(jié)點的序號
?

class node{public int number;//value是指從0到這個節(jié)點總共要走多遠，執(zhí)行算法前將value的值初始化為無窮大public int value;public int parent; }

?

//從矩陣a的第一行開始，一行行找相連的節(jié)點 for(int i = 0;i<16;i++){for(int j = 0;j<16;j++){//找到了相連節(jié)點if(a[i][j]!=0){//上一個節(jié)點的最短路徑的值+與下一個節(jié)點相連路徑上的值d = n[i].value+a[i][j];//判斷是否比原先的值要小，如果小就將0-j節(jié)點的長度替換if(d<n[j].value){n[j].value = d;//記錄前一個節(jié)點的序號n[j].parent = i;}}}}

最后將n[15].value打印出來就是最短路徑的值，再根據(jù)parent的值往前找就得到最短路徑的解，當然這個例子有不同的路徑的解。

leetcode例題：

//787. K 站中轉內最便宜的航班 dp 板子題public int findCheapestPrice(int n, int[][] flights, int src, int dst, int K) {int maxv = Integer.MAX_VALUE;if(n==1)return 0;int[][] dp = new int[n][K+1];for(int i = 0;i<n;i++)Arrays.fill(dp[i],maxv);Arrays.fill(dp[src],0);for(int[] f:flights){if(f[0]==src)dp[f[1]][0] = f[2];}for(int i = 1;i<=K;i++){for(int[] f:flights){int snow = f[0];int dnow = f[1];int cost = f[2];if(dp[snow][i-1]!=maxv)dp[dnow][i] = Math.min(dp[dnow][i],dp[snow][i-1]+cost);}}return dp[dst][K]==maxv ? -1 : dp[dst][K];}

19.字典樹

20.LCA 最近公共祖先

Tarjan算法（離線算法）

離線算法，是指首先讀入所有的詢問（求一次LCA叫做一次詢問），然后重新組織查詢處理順序以便得到更高效的處理方法。Tarjan算法是一個常見的用于解決LCA問題的離線算法，它結合了深度優(yōu)先遍歷和并查集，整個算法為線性處理時間。

Tarjan算法是基于并查集的，利用并查集優(yōu)越的時空復雜度，可以實現(xiàn)LCA問題的O(n+Q)算法，這里Q表示詢問 的次數(shù)。

同上一個算法一樣，Tarjan算法也要用到深度優(yōu)先搜索，算法大體流程如下：對于新搜索到的一個結點，首先創(chuàng)建由這個結點構成的集合，再對當前結點的每一個子樹進行搜索，每搜索完一棵子樹，則可確定子樹內的LCA詢問都已解決。其他的LCA詢問的結果必然在這個子樹之外，這時把子樹所形成的集合與當前結點的集合合并，并將當前結點設為這個集合的祖先。之后繼續(xù)搜索下一棵子樹，直到當前結點的所有子樹搜索完。這時把當前結點也設為已被檢查過的，同時可以處理有關當前結點的LCA詢問，如果有一個從當前結點到結點v的詢問，且v已被檢查過，則由于進行的是深度優(yōu)先搜索，當前結點與v的最近公共祖先一定還沒有被檢查，而這個最近公共祖先的包涵v的子樹一定已經搜索過了，那么這個最近公共祖先一定是v所在集合的祖先。

https://www.cnblogs.com/JVxie/p/4854719.html

Tarjan(u)//marge和find為并查集合并函數(shù)和查找函數(shù) {for each(u,v) //訪問所有u子節(jié)點v{Tarjan(v); //繼續(xù)往下遍歷marge(u,v); //合并v到u上標記v被訪問過;}for each(u,e) //訪問所有和u有詢問關系的e{如果e被訪問過;u,e的最近公共祖先為find(e);} } #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<vector> #include<queue> #define eps 1e-8 #define memset(a,v) memset(a,v,sizeof(a)) using namespace std; typedef long long int LL; const int MAXL(1e4); const int INF(0x7f7f7f7f); const int mod(1e9+7); int dir[4][2]= {{-1,0},{1,0},{0,1},{0,-1}}; int father[MAXL+50]; bool is_root[MAXL+50]; bool vis[MAXL+50]; vector<int>v[MAXL+50]; int root; int cx,cy; int ans; int Find(int x) {if(x!=father[x])father[x]=Find(father[x]);return father[x]; }void Join(int x,int y) {int fx=Find(x),fy=Find(y);if(fx!=fy)father[fy]=fx; }void LCA(int u) {for(int i=0; i<v[u].size(); i++){int child=v[u][i];if(!vis[child]){LCA(child);Join(u,child);vis[child]=true;}}if(u==cx&&vis[cy]==true)ans=Find(cy);if(u==cy&&vis[cx]==true)ans=Find(cx);}void init() {memset(is_root,true);memset(vis,false);int n;scanf("%d",&n);for(int i=0; i<=n; i++)v[i].clear();for(int i=1; i<=n; i++)father[i]=i;for(int i=1; i<n; i++){int x,y;scanf("%d%d",&x,&y);v[x].push_back(y);is_root[y]=false;}scanf("%d%d",&cx,&cy);for(int i=1; i<=n; i++){if(is_root[i]==true){root=i;break;}}} int main() {int T;scanf("%d",&T);while(T--){init();LCA(root);cout<<ans<<endl;} }

按類別刷算法題

一：字符操作類

二：樹類

三：動態(tài)規(guī)劃

四：背包問題

總結

以上是生活随笔為你收集整理的常见算法复习整理1的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。