题目链接

http://codeforces.com/problemset/problem/666/B

思路

给你一张有向图，叫你给出四个点的序列，使得这四个点依次间的最短路之和最大。

n有3000，直接枚举四个点肯定超时，所以枚举b、c两个点，然后BFS预处理出能到b的最远的3个点，和c能到的最远的3个点。
之所以是3个点是因为，有可能备选点会和已定点重合，例如abc都定好了，然后d的备选是a、b，那就漏情况了，所以要备选3个点。

AC代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;


const int INF = 0x3f3f3f3f;
struct edge_t
{
    int v;
    int next;
}
edge[5000 + 100];

int head[3000 + 100], tot = 0;
void add_edge(int u, int v)
{
    edge[tot].v = v; edge[tot].next = head[u]; head[u] = tot++;
}

struct node
{
    node() {}
    node(int _index, int _len)
    {
        index = _index;
        len = _len;
    }
    int index;
    int len;
    bool friend operator < (node a, node b)
    {
        if (a.len == b.len)
            return a.index < b.index;
        return a.len < b.len;
    }
};
node longestTo[3000 + 100][3], longestFrom[3000 + 100][3];

void updateTo(node u, node t)//能到u的最远的点 
{
    t.len = u.len;
    longestTo[u.index][0] = t;
    sort(longestTo[u.index], longestTo[u.index] + 3);
}
void updateFrom(node u, node t)//从u能到的最远的点 
{
    longestFrom[u.index][0] = t;
    sort(longestFrom[u.index], longestFrom[u.index] + 3);
}
int dis[3000 + 100][3000 + 100];
bool vis[3000 + 100];
void bfs(int st)
{
    queue<node>q;
    node start(st, 0);
    q.push(start);
    vis[st] = 1;
    while (!q.empty())
    {
        node u = q.front(); q.pop();
        for (int i = head[u.index]; ~i; i = edge[i].next)
        {
            node v(edge[i].v, u.len + 1);
            if (vis[v.index])continue;
            vis[v.index] = 1;
            updateFrom(start, v);//从start能到的最远的点 
            updateTo(v, start);//能到v的最远的点
            dis[start.index][v.index] = v.len;
            q.push(v);
        }
    }
}

int main()
{
    memset(dis, INF, sizeof dis);
    memset(head, -1, sizeof head);
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; ++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        add_edge(u, v);
    }
    for (int i = 1; i <= n; ++i)
    {
        memset(vis, 0, sizeof vis);
        bfs(i);
    }
    int sumLen = 0;
    int ans[4] = { 0 };
    for (int b = 1; b <= n; ++b)
    {
        for (int c = 1; c <= n; ++c)
        {
            for (int i = 2; i >= 0; --i)
            {
                for (int j = 2; j >= 0; --j)
                {
                    int a = longestTo[b][i].index;
                    int d = longestFrom[c][j].index;
                    if (dis[a][b] == INF || dis[b][c] == INF || dis[c][d] == INF)
                        continue;
                    if (a == b || a == c || a == d || b == c || b == d || c == d)
                        continue;
                    int t = dis[a][b] + dis[b][c] + dis[c][d];
                    if (t > sumLen)
                    {
                        sumLen = t;
                        ans[0] = a;
                        ans[1] = b;
                        ans[2] = c;
                        ans[3] = d;
                    }
                }
            }
        }
    }
    for (int i = 0; i < 4; ++i)
    {
        if (i == 0)printf("%d", ans[i]);
        else printf(" %d", ans[i]);
    }
    printf("\n");
    return 0;
}