update dp

Author: jiangyinzuo

README.md

@@ -4,6 +4,8 @@ Codes and documentations for algorithms.
 
 POJ, lintcode, 洛谷, 牛客, 计蒜客, leetcode, hduoj
 
+https://oi-wiki.org/
+
 ## Development Environment
 
 ### 牛客网

doc/asset/LIS.png

@@ -113,10 +113,126 @@ public:
 
 ```
 
+## 最长公共子串 [interview]
 
+dp[i][j]表示在str1中以第i个字符结尾，在str2中以第j个字符结尾时的公共子串长度。
+
+$$
+dp(i, j) = \begin{cases}
+dp(i-1, j-1) + 1 & str1[i] = str2[j] \\
+0 & str1[i] \neq str2[j]
+\end{cases}
+$$
+
+牛客 NC127 最长公共子串
+```cpp
+class Solution {
+public:
+    string LCS(string str1, string str2) {
+        //dp[i][j]表示到str1第i个个到str2第j个为止的公共子串长度
+        vector<vector<int> > dp(str1.length() + 1, vector<int>(str2.length() + 1, 0)); 
+        int max = 0;
+        int pos = 0;
+        for(int i = 1; i <= str1.length(); i++){
+            for(int j = 1; j <= str2.length(); j++){
+                //如果该两位相同
+                if(str1[i - 1] == str2[j - 1]){ 
+                    //则增加长度
+                    dp[i][j] = dp[i - 1][j - 1] + 1; 
+                }
+                else{ 
+                    //该位置为0
+                    dp[i][j] = 0; 
+                }
+                //更新最大长度
+                if(dp[i][j] > max){ 
+                    max = dp[i][j];
+                    pos = i - 1;
+                }
+            }
+        }
+        return str1.substr(pos - max + 1, max);
+    }
+};
+```
+
+## 最长公共子序列 [interview]
+
+f(i, j)表示只考虑序列A前i个元素，序列B前j个元素的最长公共子序列时的长度。
+
+$$
+f(i, j) = \begin{cases}
+f(i-1, j-1) + 1 & A[i] = B[j] \\
+max(f(i-1, j), f(i, j-1)) & A[i] \neq B[j]
+\end{cases}
+$$
+
+如果要输出最长公共子序列，可以根据dp数组逆推。
+
+牛客BM65 最长公共子序列(二)
+```cpp
+class Solution {
+public:
+    string LCS(string s1, string s2) {
+        //只要有一个空字符串便不会有子序列
+        if(s1.length() == 0 || s2.length() == 0) 
+            return "-1";
+        int len1 = s1.length();
+        int len2 = s2.length();
+        //dp[i][j]表示第一个字符串到第i位，第二个字符串到第j位为止的最长公共子序列长度
+        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1, 0)); 
+        //遍历两个字符串每个位置求的最长长度
+        for(int i = 1; i <= len1; i++){
+            for(int j = 1; j <= len2; j++){
+                //遇到两个字符相等
+                if(s1[i - 1] == s2[j -1])
+                    //来自于左上方
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                //遇到的两个字符不同
+                else
+                    //来自左边或者上方的最大值
+                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+        //从动态规划数组末尾开始
+        int i = len1, j = len2;
+        stack<char> s;
+        while(dp[i][j]){
+            //来自于左方向
+            if(dp[i][j] == dp[i - 1][j])
+                i--;
+            //来自于上方向
+            else if(dp[i][j] == dp[i][j - 1])
+                j--;
+            //来自于左上方向
+            else if(dp[i][j] > dp[i - 1][j - 1]){
+                i--;
+                j--;
+                //只有左上方向才是字符相等的情况，入栈，逆序使用
+                s.push(s1[i]); 
+           }
+        }
+        string res = "";
+        //拼接子序列
+        while(!s.empty()){
+            res += s.top();
+            s.pop();
+        }
+        //如果两个完全不同，返回字符串为空，则要改成-1
+        return res != "" ? res : "-1";  
+    }
+};
+```
 
 ## 最长递增子序列
 
+![LIS](./asset/LIS.png)
+
+[图片来源](https://github.com/labuladong/fucking-algorithm/blob/master/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%B3%BB%E5%88%97/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E8%AE%BE%E8%AE%A1%EF%BC%9A%E6%9C%80%E9%95%BF%E9%80%92%E5%A2%9E%E5%AD%90%E5%BA%8F%E5%88%97.md)
+### 仅输出长度
+
+二分查找 $$O(nlogn)$$
+
 ```c++
 // 严格递增
 #include <cstdio>
@@ -128,7 +244,7 @@ int arr[MAX_N] = {0};
 int main() {
     int n;
     scanf("%d", &n);
-    
+
     int element, idx = 0;
     int *index;
     for (int i = 0; i < n; ++i) {
@@ -160,7 +276,9 @@ std::vector<int> get_lcs(const std::vector<int> &vec) {
 }
 ```
 
-##### 求逆序对的个数
+### 打印序列
+
+### 求逆序对的个数
 
 相当于原序列长度-最长递增子序列长度
 

doc/动态规划.md

@@ -2,7 +2,11 @@
 
 [TOC]
 
+## 拓扑排序
 
+节点带权重，在满足拓扑序的情况下，按权重高低优先输出。
+
+思路：利用优先队列作为中间结构，每次将入度为0的点加入优先队列，然后取出最高优先级的点，并更新该点所有邻接点的入度，如果入度为0，则加入优先队列。
 
 ## 二分图
 
@@ -974,6 +978,113 @@ int main() {
 O(ElgV)
 
 
+## 树
+
+### LCA
+
+倍增求LCA
+
+```C++
+/**
+ * luogu3379
+ */
+
+#include <cstdio>
+#include <algorithm>
+
+using namespace std;
+
+struct Edge {
+    int v;
+    int next;
+} edges[500002 << 1];
+int heads[500002];
+int total = 0;
+
+int depth[500002] = {0};
+int ancestors[500002][22] = {0};
+
+int LOG_2[500002];
+
+void add_edge(int u, int v) {
+    edges[++total] = {v, heads[u]};
+    heads[u] = total;
+}
+
+void dfs(int cur_v, int parent) {
+    ancestors[cur_v][0] = parent;
+    depth[cur_v] = depth[parent] + 1;
+
+    for (int i = 1; i <= LOG_2[depth[cur_v]]; ++i) {
+        ancestors[cur_v][i] = ancestors[ancestors[cur_v][i-1]][i-1];
+    }
+
+    for (int i = heads[cur_v]; i; i = edges[i].next) {
+        if (edges[i].v != parent) {
+            dfs(edges[i].v, cur_v);
+        }
+    }
+}
+
+int lca(int a, int b) {
+    if (depth[a] < depth[b]) {
+        swap(a, b);
+    }
+    while (depth[a] > depth[b]) {
+        a = ancestors[a][LOG_2[depth[a]-depth[b]]];
+    }
+    if (a == b) {
+        return a;
+    }
+    for (int i = LOG_2[depth[a]]; i >= 0; --i) {
+        if (ancestors[a][i] != ancestors[b][i]) {
+            a = ancestors[a][i];
+            b = ancestors[b][i];
+        }
+    }
+    return ancestors[a][0];
+}
+
+void get_log_2() {
+    LOG_2[1] = 0;
+    for (int i = 2; i <= 500001; ++i) {
+        LOG_2[i] = LOG_2[i>>1] + 1;
+    }
+}
+
+int main() {
+    get_log_2();
+
+    int n, m, s;
+    scanf("%d %d %d", &n, &m, &s);
+
+    int x, y;
+    for (int i = 0; i < n - 1; ++i) {
+        scanf("%d %d", &x, &y);
+        add_edge(x, y);
+        add_edge(y, x);
+    }
+
+    dfs(s, 0);
+
+    int a, b;
+    for (int i = 0; i < m; ++i) {
+        scanf("%d %d", &a, &b);
+        printf("%d\n", lca(a, b));
+    }
+
+    return 0;
+}
+```
+
+### 树的直径
+
+### 两次dfs
+
+先从任意一点P出发，找离它最远的点Q，再从点Q出发，找离它最远的点W，W到Q的距离就是是的直径
+
+### 树形DP
+
 
 ## 参考文献
 

doc/图论.md

@@ -61,6 +61,8 @@ int main() {
 }
 ```
 
+利用KMP算法中的get_next()可以求字符串最大回文前缀（cf1326D）
+
 ## 字符串哈希
 
 ```c++

doc/字符串.md

@@ -506,3 +506,60 @@ int main() {
 }
 ```
 
+## LRU Cache
+
+迭代器变量声明: `std::unordered_map<int, std::list<Entry>::iterator> map;`
+
+[牛客BM100 设计LRU缓存结构](https://www.nowcoder.com/practice/5dfded165916435d9defb053c63f1e84?tpId=295&tqId=2427094&ru=/exam/oj&qru=/ta/format-top101/question-ranking&sourceUrl=%2Fexam%2Foj)
+
+```cpp
+#include <cassert>
+#include <list>
+#include <unordered_map>
+
+class Solution {
+    using Entry = std::pair<int, int>;
+
+  public:
+    Solution(int capacity) : capacity(capacity) {
+    }
+
+    int get(int key) {
+        auto it = map.find(key);
+        if (it == map.end()) {
+            return -1;
+        }
+        assert(it->first == key);
+        auto t = it->second;
+        assert(t->first == key);
+        int result = t->second;
+        entries.erase(t);
+        doSet(key, result);
+        return result;
+    }
+
+    void set(int key, int value) {
+        auto it = map.find(key);
+        if (it != map.end()) {
+            map.erase(it);
+        }
+
+        doSet(key, value);
+    }
+  private:
+
+    void doSet(int key, int value) {
+        auto it = entries.emplace_front(key, value);
+        map[key] = entries.begin();
+        if (entries.size() > capacity) {
+            map.erase(entries.back().first);
+            entries.pop_back();
+            assert(entries.size() == capacity);
+        }
+    }
+    int capacity;
+
+    std::list<Entry> entries;
+    std::unordered_map<int, std::list<Entry>::iterator> map;
+};
+```