【LeetCode】拓扑排序

【207】 Course Schedule

排课问题，n门课排课，有的课程必须在另外一些课程之前上，问能不能排出来顺序。

题解：裸的拓扑排序。参考代码见算法竞赛入门指南这本书。

 class Solution {
 public:
     bool dfs(const vector<vector<int>>& g, vector<int>& c, int u) {
         c[u] = -;
         for (int v = ; v < n; ++v) {
             if (g[u][v]) {
                 if (c[v] < ) { return false; }
                 else if (!c[v] && !dfs(g, c, v)) {
                     return false;
                 }
             }
         }
         c[u] = ;
         topo[--t] = u;
         return true;
     }
     bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
         vector<vector<int>> graph(numCourses, vector<int>(numCourses, ));
         n = numCourses;
         topo.resize(n);
         t = n;
         for (auto ele : prerequisites) {
             int u = ele.first, v = ele.second;
             graph[v][u] = ;
         }
         vector<int> c(n, );
         for (int i = ; i < n; ++i) {
             if (!c[i]) {
                 if (!dfs(graph, c, i)) {
                     return false;
                 }
             }
         }
         /*
         for (int i = 0; i < n; ++i) {
             cout << topo[i] << " " ;
         }
         cout << endl;
         */
         return true;
     }
     vector<int> topo;
     int n, t;
 };

【210】 Course Schedule II

同上一个排课问题，这次的问题是能不能给出一个可行的顺序。

题解：还是裸的拓扑排序。

 class Solution {
 public:
     bool dfs(vector<int>& c, vector<int>& topo, int u) {
         c[u] = -;
         for (int v = ; v < n; ++v) {
             if (g[u][v]) {
                 if (c[v] < ) {return false;}
                 else if (!c[v] && !dfs(c, topo, v)) {return false; }
             }
         }
         c[u] = ;
         topo[--t] = u;
         return true;
     }
     vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
         n = numCourses, t = n;
         vector<int> topo(n, );
         vector<int> c(n, );
         vector<vector<int>> graph(n, vector<int>(n, ));
         for (auto ele : prerequisites) {
             int u = ele.first, v = ele.second;
             graph[v][u] = ;
         }
         g = graph;

         for (int u = ; u < n; ++u) {
             if (!c[u]) {
                 if (!dfs(c, topo, u)) {
                     vector<int> temp;
                     return temp;
                 }
             }
         }
         return topo;
     }
     int n, t;
     vector<vector<int>> g;
 };

【269】 Alien Dictionary

给了一门新的语言，给了一个单词字典，所有的单词按照字典序排序。要求返回现有字母的顺序，没有顺序的话，返回空数组。

题解：逐个比较两个相邻的单词，如果他们第i个位置不同，说明前一个单词的第i个字母u，要小于后一个单词的第i个字母v，然后建图，建完图直接裸的拓扑排序。

 class Solution {
 public:
     bool dfs(int u) {
         c[u] = -;
         for (int v = ; v < tot; ++v) {
             if (g[u][v]) {
                 if (c[v] < ) {return false;}
                 else if (!c[v] && !dfs(v)) {return false;}
             }
         }
         c[u] = ;
         topo[--cur] = u;
         return true;
     }

     string alienOrder(vector<string>& words) {
         vector<pair<int, int>> order;
         const int n = words.size();
         int t = ;
         for (int i = ; i < n; ++i) {
             string word = words[i];
             for (auto ele : word) {
                 if (mpCh2Num.find(ele) == mpCh2Num.end()) {
                     mpCh2Num[ele] = t;
                     mpNum2Ch[t] = ele;
                     ++t;
                 }
             }
         }
         c.resize(t), topo.resize(t);
         tot = t; cur = t;

         for (int i = ; i < n - ; ++i) {
             string word1 = words[i], word2 = words[i+];
             for (int idx = ; idx < min(word1.size(), word2.size()); ++idx) {
                 if (word1[idx] != word2[idx]) {
                     pair<int, int> p = make_pair(mpCh2Num[word1[idx]], mpCh2Num[word2[idx]]);
                     order.push_back(p);
                     break;
                 }
             }
         }

         vector<vector<int>> graph(t, vector<int>(t, ));
         for (auto ele : order) {
             int u = ele.first, v = ele.second;
             graph[u][v] = ;
         }
         g = graph;

         for (int u = ; u < t; ++u) {
             if (!c[u]) {
                 if (!dfs(u)) {
                     string temp;
                     return temp;
                 }
             }
         }
         string ans;
         for (auto ele : topo) {
             ans += mpNum2Ch[ele];
         }
         return ans;
     }
     vector<vector<int>> g;
     vector<int> c, topo;
     map<int, char> mpNum2Ch;
     map<char, int> mpCh2Num;
     int tot;
     int cur;
 };

【329】 Longest Increasing Path in a Matrix

给了一个矩阵matrix， 一个点他可以朝着上下左右四个方向走，问这个矩阵能走出来的最长递增的路径的长度是多少。

题解：裸的dfs会超时，所以加上了一个记忆化数组过了。题目的解法三有拓扑排序的相关解法，下次要搞懂那个解法。

 class Solution {
 public:
     void print(vector<vector<int>>& mat) {
         const int n = mat.size(), m = mat[].size();
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 cout << mat[i][j] << " ";
             }
             cout << endl;
         }
     }
     int dirx[] = {-, , , };
     int diry[] = {, -, , };
     int dfs(const vector<vector<int>>& mat, int x, int y, vector<vector<int>>& vis) {
         vis[x][y] = ;
         for (int i = ; i < ; ++i) {
             int newx = x + dirx[i], newy = y + diry[i];
             if (newx >=  && newx < n && newy >=  && newy < m && !vis[newx][newy]&& mat[newx][newy] > mat[x][y]) {
                 if (memo[newx][newy] != ) {
                     memo[x][y] = max(memo[x][y], memo[newx][newy] + );
                 } else {
                     memo[x][y] = max(memo[x][y], dfs(mat, newx, newy, vis) + );
                 }
             }
         }
         vis[x][y] = ;
         return memo[x][y];
     }
     int longestIncreasingPath(vector<vector<int>>& matrix) {
         n = matrix.size();
         if (n == ) { return ; }
         m = matrix[].size();
         if (m == ) { return ; }

         int ans = ;
         memo = matrix;
         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 memo[i][j] = ;
             }
         }

         for (int i = ; i < n; ++i) {
             for (int j = ; j < m; ++j) {
                 vector<vector<int>> vis(n, vector<int>(m, ));
                 memo[i][j] = dfs(matrix, i, j, vis);
                 ans = max(ans, memo[i][j]);
             }
         }
         return ans  +;
     }
     int n, m;
     vector<vector<int>> memo;
 };

【444】 Sequence Reconstruction