CSP-2022 S2 T1 弱化版。

思路

首先因为边权均为 \(1\)，所以我们可以在 \(\Theta(n^2)\) 的复杂度用 BFS 求解出任意两点 \(i,j\) 的最短距离 \(d_{i,j}\)（如果 \(i\) 不能到达 \(j\)，则令 \(d_{i,j} = -1\)）。

有一个贪心的结论，就是使每一条 \(A \to B,B \to C,C \to D\) 的路径长度都更大，我们就想让每一条边都是以每一个点为起点的最长路。

但是，显然这样做事有可能会冲突的，因为有可能有以两个不同的点为起点的最长路的终点可能相同。

所以考虑多处理出次长路和次次长路，这样就一定不会冲突。因为当 \(A \to B\) 和 \(B \to C\) 冲突时，\(B \to C\) 可以用次长路；又当 \(B \to C\) 和 \(C \to D\) 冲突时，\(C \to D\) 可以用次次长路。所以处理出前 \(3\) 大的足矣。

然后求方案，考虑用一个 vector<pii> dm[i][0/1] 分别存储以 \(i\) 为起点的路径，以及以其他点为起点到达 \(i\) 的路径。（注意：当起点为 \(i\)，终点为 \(j\) 时，如果满足 \(d_{i,j} \neq -1\) 时，才能将 \(i \to j\) 的路径存入）

然后枚举 \(B,C\)，再用这个 vector 枚举出 \(A,D\) 即可。

因为上文提到，用前 \(3\) 大路径一定能凑出最终答案，所以在枚举 \(A,D\) 时枚举前 \(3\) 大即可。保证了时间复杂度为 \(\Theta(n^2)\)。

Code

#include <bits/stdc++.h>  
#define fst first  
#define snd second  
#define re register  
  
using namespace std;  
  
typedef pair<int,int> pii;  
const int N = 3010,M = 5010;  
int n,m,Max,A,B,C,D;  
int idx,h[N],e[M],ne[M];  
int dist[N][N];  
vector<pii> dm[N][2];  
  
inline int read(){  
    int r = 0,w = 1;  
    char c = getchar();  
    while (c < '0' || c > '9'){  
        if (c == '-') w = -1;  
        c = getchar();  
    }  
    while (c >= '0' && c <= '9'){  
        r = (r << 3) + (r << 1) + (c ^ 48);  
        c = getchar();  
    }  
    return r * w;  
}  
  
inline void add(int a,int b){  
    ne[idx] = h[a];  
    e[idx] = b;  
    h[a] = idx++;  
}  
  
inline void bfs(int s){  
    queue<int> q;  
    dist[s][s] = 0;  
    q.push(s);  
    while (!q.empty()){  
        int t = q.front();  
        q.pop();  
        for (re int i = h[t];~i;i = ne[i]){  
            int j = e[i];  
            if (!~dist[s][j]){  
                dist[s][j] = dist[s][t] + 1;  
                q.push(j);  
            }  
        }  
    }  
}  
  
int main(){  
    memset(h,-1,sizeof(h));  
    memset(dist,-1,sizeof(dist));  
    n = read();  
    m = read();  
    for (re int i = 1;i <= m;i++){  
        int a,b;  
        a = read();  
        b = read();  
        add(a,b);  
    }  
    for (re int i = 1;i <= n;i++) bfs(i);  
    for (re int i = 1;i <= n;i++){  
        for (re int j = 1;j <= n;j++){  
            if (i == j) continue;  
            if (~dist[i][j]) dm[i][0].push_back({dist[i][j],j});  
            if (~dist[j][i]) dm[i][1].push_back({dist[j][i],j});  
        }  
        sort(dm[i][0].begin(),dm[i][0].end(),[](const pii &a,const pii &b){  
            return a.fst > b.fst;  
        });  
        sort(dm[i][1].begin(),dm[i][1].end(),[](const pii &a,const pii &b){  
            return a.fst > b.fst;  
        });  
    }  
    for (re int b = 1;b <= n;b++){  
        for (re int c = 1;c <= n;c++){  
            if (c == b || !~dist[b][c]) continue;//不能有重复元素，且 b 一定能到达 c   
            int lb = dm[b][1].size();  
            for (re int p = 0;p < 3 && p < lb;p++){  
                int a = dm[b][1][p].snd;  
                if (a == b || a == c) continue;//同理   
                int lc = dm[c][0].size();  
                for (re int q = 0;q < 3 && q < lc;q++){  
                    int d = dm[c][0][q].snd;  
                    if (d == a || d == b || d == c) continue;//同理   
                    if (Max < dist[a][b] + dist[b][c] + dist[c][d]){  
                        Max = dist[a][b] + dist[b][c] + dist[c][d];  
                        A = a;  
                        B = b;  
                        C = c;  
                        D = d;  
                    }  
                }  
            }  
        }  
    }  
    printf("%d %d %d %d",A,B,C,D);  
    return 0;  
}