update 308.md

Author: coderhare

Diff for: leetcode/weekly/308.md

@@ -0,0 +1,117 @@
+### T1
+贪心
+```c++
+class Solution {
+public:
+    vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
+        sort(begin(nums), end(nums));
+        vector <int> ans;
+        for (int q: queries) {
+            int j = 0, tot = 0;
+            while(j < nums.size()) {
+                tot += nums[j++];
+                if(tot == q) break;
+                if(tot > q) {
+                    j--;
+                    break;
+                }
+            }
+            ans.push_back(j);
+        }
+        return ans;
+    }
+};
+```
+
+### T2
+模拟栈
+```c++
+class Solution {
+public:
+    string removeStars(string s) {
+        string ans;
+        for (char c: s) {
+            if(c == '*' && ans.size()) ans.pop_back();
+            else ans += c;
+        }
+        return ans;
+    }
+};
+```
+
+### T3
+简单模拟，总之就是中规中矩
+```c++
+class Solution {
+public:
+    int garbageCollection(vector<string>& a, vector<int>& b) {
+        int n = a.size();
+        vector <vector<int>> cnt(3, vector <int> (n));
+        for (int i = 0; i < n; i++) {
+            for (char c: a[i]) {
+                if(c == 'G') cnt[0][i]++;
+                if(c == 'M') cnt[1][i]++;
+                if(c == 'P') cnt[2][i]++;
+            }
+        }
+        int ans = 0;
+        for (int i = 0; i < 3; i++) {
+            ans += cnt[i][0];
+            int last = 0;
+            for (int j = 1; j < n; j++){
+                if(cnt[i][j]) ans += cnt[i][j], last = j;
+            }
+            for (int j = 0; j < last; j++) ans += b[j];
+        }
+        return ans;
+    }
+};
+```
+
+### T4
+记录状态依赖关系，可以通过拓扑排序跑一次确定下来
+```c++
+class Solution {
+public:
+    vector<vector<int>> buildMatrix(int k, vector<vector<int>>& a, vector<vector<int>>& b) {
+        int n = a.size(), m = b.size();
+        vector <vector<int>> g1(k + 1), g2(k + 1);
+        vector <int> dg1(k + 1), dg2(k + 1);
+        for (auto & a: a) {
+            g1[a[0]].push_back(a[1]);
+            dg1[a[1]]++;
+        }
+        for (auto & b: b) {
+            g2[b[0]].push_back(b[1]);
+            dg2[b[1]]++;
+        }
+        auto get = [&](vector <vector<int>> & g, vector <int> & dg)->vector<int> {
+             queue <int> q;
+             for (int i = 1; i <= k; i++) {
+                 if(dg[i] == 0) q.push(i);
+             }
+             int level = 0, cnt = 0;
+             vector <int> ans(k + 1);
+             while(q.size()) {
+                 auto u = q.front(); q.pop();
+                 ans[u] = level++;
+                 cnt++;
+                 for (int v: g[u]) {
+                     if(--dg[v] == 0) {
+                         q.push(v);
+                     }
+                 }
+             }
+             if(cnt != k) return {};
+             return ans;
+        };
+        vector <vector<int>> ans(k, vector <int> (k));
+        auto a1 = get(g1, dg1), a2 = get(g2, dg2);
+        if(a1.empty() || a2.empty()) return {};
+        for (int i = 1; i <= k; i++) {
+            ans[a1[i]][a2[i]] = i;
+        }
+        return ans;
+    }
+};
+```