update

src/8/23/P7991.cpp

@@ -0,0 +1,104 @@
+#include <vector>
+#include <iostream>
+#include <queue>
+#include <algorithm>
+
+using namespace std;
+using ll = long long;
+
+static const ll INF = (ll)4e18;
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int T;
+    cin >> T;
+    while(T--){
+        int N, M;
+        cin >> N >> M;
+        vector<vector<int>> adj(N+1);
+        for(int i = 0; i < M; i++){
+            int u, v;
+            cin >> u >> v;
+            adj[u].push_back(v);
+            adj[v].push_back(u);
+        }
+
+        vector<char> vis1(N+1, 0), visN(N+1, 0);
+        queue<int> q;
+
+        vis1[1] = 1;
+        q.push(1);
+        while(!q.empty()){
+            int u = q.front(); q.pop();
+            for(int v: adj[u]){
+                if(!vis1[v]){
+                    vis1[v] = 1;
+                    q.push(v);
+                }
+            }
+        }
+
+        visN[N] = 1;
+        q.push(N);
+        while(!q.empty()){
+            int u = q.front(); q.pop();
+            for(int v: adj[u]){
+                if(!visN[v]){
+                    visN[v] = 1;
+                    q.push(v);
+                }
+            }
+        }
+
+        if(vis1[N]){
+            cout << 0 << "\n";
+            continue;
+        }
+
+        vector<int> S, Tset;
+        S.reserve(N);
+        Tset.reserve(N);
+        for(int i = 1; i <= N; i++){
+            if(vis1[i]) S.push_back(i);
+            if(visN[i]) Tset.push_back(i);
+        }
+        sort(S.begin(), S.end());
+        sort(Tset.begin(), Tset.end());
+
+        vector<ll> dist1(N+1, INF), distN(N+1, INF);
+        {
+            int j = 0;
+            for(int w = 1; w <= N; w++){
+                while(j+1 < (int)S.size() &&
+                      llabs((ll)S[j+1] - w) <= llabs((ll)S[j] - w))
+                {
+                    j++;
+                }
+                ll d = ll(S[j] - w);
+                dist1[w] = d*d;
+            }
+        }
+
+        {
+            int j = 0;
+            for(int w = 1; w <= N; w++){
+                while(j+1 < (int)Tset.size() &&
+                      llabs((ll)Tset[j+1] - w) <= llabs((ll)Tset[j] - w))
+                {
+                    j++;
+                }
+                ll d = ll(Tset[j] - w);
+                distN[w] = d*d;
+            }
+        }
+
+        ll ans = INF;
+        for(int w = 1; w <= N; w++){
+            ans = min(ans, dist1[w] + distN[w]);
+        }
+
+        cout << ans << "\n";
+    }
+}

src/8/24/find-the-minimum-area-to-cover-all-ones-ii.cpp

@@ -0,0 +1,102 @@
+#include <algorithm>
+#include <iostream>
+#include <string_view>
+#include <tuple>
+#include <utility>
+#include <vector>
+using namespace std;
+
+
+class Solution {
+public:
+    static inline int getminarea(const vector<vector<int>>&v,int x1,int y1,int x2,int y2){
+        bool all0=true;
+        int a1=x2,b1=y2,a2=x1,b2=y1;
+        for(int i=x1;i<x2;i++){
+            for(int j=y1;j<y2;j++){
+                if(v[i][j]==1){
+                    all0=false;
+                    a1=min(a1,i);
+                    b1=min(b1,j);
+                    a2=max(a2,i);
+                    b2=max(b2,j);
+                }
+            }
+        }
+        if(all0)return 0;
+        return (b2-b1+1)*(a2-a1+1);
+    }
+    int minimumSum(const vector<vector<int>>& g) {
+        int ans=1145141;
+        //横三条
+        for(int i=1;i<g.size();i++){
+            for(int j=i+1;j<g.size();j++){
+                int nans=0;
+                nans+=getminarea(g, 0, 0, i, g[0].size());
+                nans+=getminarea(g, i, 0, j, g[0].size());
+                nans+=getminarea(g, j, 0, g.size(), g[0].size());
+                ans=min(ans,nans);
+            }
+        }
+        //竖三条
+        for(int i=1;i<g[0].size();i++){
+            for(int j=i+1;j<g[0].size();j++){
+                int nans=
+                getminarea(g, 0, 0, g.size(), i)
+                +getminarea(g, 0, i, g.size(), j)
+                +getminarea(g, 0, j, g.size(), g[0].size());
+                ans=min(ans,nans);
+            }
+        }
+        //上长条
+        for(int i=1;i<g.size();i++){
+            for(int j=1;j<g[0].size();j++){
+                int nans=
+                getminarea(g, 0, 0, i, g[0].size())
+                +getminarea(g, i, 0, g.size(), j)
+                +getminarea(g, i, j, g.size(), g[0].size())
+                ;
+                ans=min(ans,nans);
+            }
+        }
+        //下长条
+        for(int i=1;i<g.size();i++){
+            for(int j=1;j<g[0].size();j++){
+                int nans=
+                getminarea(g, 0, 0, i, j)
+                +getminarea(g, i, 0, g.size(), g[0].size())
+                +getminarea(g, 0, j, i, g[0].size())
+                ;
+                ans=min(ans,nans);
+            }
+        }
+        //左长条
+        for(int i=1;i<g.size();i++){
+            for(int j=1;j<g[0].size();j++){
+                int nans=
+                getminarea(g, 0, 0, g.size(), j)
+                +getminarea(g, 0, j, i, g[0].size())
+                +getminarea(g, i, j, g.size(), g[0].size())
+                ;
+                ans=min(ans,nans);
+            }
+        }
+        //右长条
+        for(int i=1;i<g.size();i++){
+            for(int j=1;j<g[0].size();j++){
+                int nans=
+                getminarea(g, 0, 0, i, j)
+                +getminarea(g, i, 0, g.size(), j)
+                +getminarea(g, 0, j, g.size(), g[0].size())
+                ;
+                ans=min(ans,nans);
+            }
+        }
+
+        return ans;
+    }
+};
+
+int main(){
+
+}