Problem p02726 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
using namespace std;
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) reverse((a).begin(), (a).end())
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(a) ((a).begin(), (a).end())
typedef long long ll;
// const long long INF = 1LL << 60;
const int INF = 1010101010;
using Graph = vector<vector<int>>;
const int MOD = 1000000007;

#define MAX_N 1000000

struct edge {
  int to;
  int cost;
};

// <最短距離, 頂点の番号>
using P = pair<int, int>;

int n;
vector<edge> G[MAX_N];
int d[MAX_N];

void dijkstra(int s) {
  priority_queue<P, vector<P>, greater<P>> que;
  fill(d, d + n, INF);
  d[s] = 0;
  que.push(P(0, s));

  while (!que.empty()) {
    P p = que.top();
    que.pop();
    int v = p.second;
    if (d[v] < p.first)
      continue;

    for (int i = 0; i < G[v].size(); ++i) {
      edge e = G[v][i];
      if (d[e.to] > d[v] + e.cost) {
        d[e.to] = d[v] + e.cost;
        que.push(P(d[e.to], e.to));
      }
    }
  }
}

int main() {
  int x, y;
  cin >> n >> x >> y;

  for (int i = 0; i < n - 1; i++) {
    edge e1 = {i, 1};
    edge e2 = {i + 1, 1};
    G[i + 1].push_back(e1);
    G[i].push_back(e2);
  }
  x--;
  y--;
  edge e1 = {y, 1};
  edge e2 = {x, 1};
  G[x].push_back(e1);
  G[y].push_back(e2);
  vector<int> ans(n);

  rep(k, n) {
    dijkstra(k);
    for (int i = 0; i < n; i++) {
      if (d[i] != INF)
        ans[d[i]]++;
    }
  }

  for (int i = 1; i < n; i++)
    cout << ans[i] / 2 << endl;
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) reverse((a).begin(), (a).end())
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(a) ((a).begin(), (a).end())
typedef long long ll;
// const long long INF = 1LL << 60;
// const int INF = 1010101010;
using Graph = vector<vector<int>>;
const int MOD = 1000000007;

// 隣接リストで使う辺を表す型
struct Edge {
  int to, cost; // 辺の接続先頂点, 辺の重み
  Edge(int to, int cost) : to(to), cost(cost) {} // コンストラクタ
};

typedef vector<vector<Edge>> AdjList; // 隣接リストの型
AdjList graph;                        // グラフの辺を格納した構造体
               // graph[v][i]は頂点vから出るi番目の辺Edge

const int INF = 100000000;

vector<int> dist; // 最短距離

// 戻り値がtrueなら負の閉路を含む
bool bellman_ford(int n, int s) { // nは頂点数、sは開始頂点
  dist = vector<int>(n, INF);
  dist[s] = 0; // 開始点の距離は0
  for (int i = 0; i < n; i++) {
    for (int v = 0; v < n; v++) {
      for (int k = 0; k < graph[v].size(); k++) {
        Edge e = graph[v][k];
        if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
          dist[e.to] = dist[v] + e.cost;
          if (i == n - 1)
            return true; // n回目にも更新があるなら負の閉路が存在
        }
      }
    }
  }
  return false;
}

int main() {
  int n, x, y;
  cin >> n >> x >> y;
  vector<vector<int>> d(n, vector<int>(n, INF));

  graph = AdjList(n);

  for (int i = 0; i < n - 1; i++) {
    graph[i].push_back(Edge(i + 1, 1));
    graph[i + 1].push_back(Edge(i, 1));
  }
  x--;
  y--;
  graph[x].push_back(Edge(y, 1));
  graph[y].push_back(Edge(x, 1));
  vector<int> ans(n);

  rep(k, n) {
    bellman_ford(n, k);
    for (int i = 0; i < n; i++) {
      if (dist[i] != INF)
        ans[dist[i]]++;
    }
  }

  for (int i = 1; i < n; i++)
    cout << ans[i] / 2 << endl;
}