[题解]CF666B World Tour

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;  
}