Problem p03112 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <fstream>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <vector>
// #include <unordered_map>
// #include <unordered_set>
// #include <boost/container/static_vector.hpp>
// #include <boost/unordered_set.hpp>
// #include <boost/unordered_map.hpp>
// #include <unistd.h>

// #include <cv.h>
// #include <highgui.h>
#include <stdlib.h>
#include <string>

#include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <fstream>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <vector>
// #include <unordered_map>
// #include <unordered_set>
// #include <boost/container/static_vector.hpp>
// #include <boost/unordered_set.hpp>
// #include <boost/unordered_map.hpp>
// #include <unistd.h>

// #include <cv.h>
// #include <highgui.h>
#include <stdlib.h>
#include <time.h>

#include <string>

const int MAX_A = 100000;
const int MAX_B = 100000;
const int MAX_Q = 100000;

// int p_in[MAX_N+1];
long long s[MAX_A + 2], t[MAX_B + 2];
long long X[MAX_Q];
int A, B, Q;

const long long lim = (long long)100000000000;

// bool tmp[MAX_N+1];

long long distance(const long long x, int ls, int lt) {
  assert(s[ls] <= x);
  assert(t[lt] <= x);
  long long ret = lim;
  long long tmp = 0;
  // 最初左
  if (t[lt] <= s[ls]) {
    tmp += x - s[ls];
    tmp += std::min(s[ls] - t[lt], t[lt + 1] - s[ls]);
  } else {
    tmp += x - t[lt];
    tmp += std::min(t[lt] - s[ls], s[ls + 1] - t[lt]);
  }
  ret = std::min(tmp, ret);

  // 最初右
  tmp = 0;
  if (s[ls + 1] <= t[lt + 1]) {
    tmp += s[ls + 1] - x;
    tmp += std::min(t[lt + 1] - s[ls + 1], s[ls + 1] - t[lt]);
  } else {
    tmp += t[lt + 1] - x;
    tmp += std::min(s[ls + 1] - t[lt + 1], t[lt + 1] - s[ls]);
  }
  ret = std::min(tmp, ret);

  return ret;
}

int get_lidx(long long x, long long *loc, int num) {
  int lb = 0;
  int ub = num;
  while (lb + 1 < ub) {
    assert(loc[lb] <= x && x < loc[ub]);
    int mid = (lb + ub) / 2;
    if (loc[mid] <= x) {
      lb = mid;
    } else {
      ub = mid;
    }
  }
  return lb;
}

int main(int argc, char **argv) {
  std::cin >> A >> B >> Q;
  for (int i = 1; i <= A; i++) {
    std::cin >> s[i];
  }
  for (int i = 1; i <= B; i++) {
    std::cin >> t[i];
  }
  s[0] = -lim;
  t[0] = -lim;
  s[A + 1] = lim;
  t[B + 1] = lim;
  for (int i = 1; i <= Q; i++) {
    std::cin >> X[i];
  }

  for (int i = 1; i <= Q; i++) {
    int ls = get_lidx(X[i], s, A + 1);
    int lt = get_lidx(X[i], t, B + 1);
    // std::cout << ls << " " << lt << std::endl;
    std::cout << distance(X[i], ls, lt) << std::endl;
  }

  return 0;
}


Fixed submission:
#include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <fstream>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <vector>
// #include <unordered_map>
// #include <unordered_set>
// #include <boost/container/static_vector.hpp>
// #include <boost/unordered_set.hpp>
// #include <boost/unordered_map.hpp>
// #include <unistd.h>

// #include <cv.h>
// #include <highgui.h>
#include <stdlib.h>
#include <string>

#include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <fstream>
#include <iostream>
#include <queue>
#include <set>
#include <stdio.h>
#include <vector>
// #include <unordered_map>
// #include <unordered_set>
// #include <boost/container/static_vector.hpp>
// #include <boost/unordered_set.hpp>
// #include <boost/unordered_map.hpp>
// #include <unistd.h>

// #include <cv.h>
// #include <highgui.h>
#include <stdlib.h>
#include <time.h>

#include <string>

const int MAX_A = 100000;
const int MAX_B = 100000;
const int MAX_Q = 100000;

// int p_in[MAX_N+1];
long long s[MAX_A + 2], t[MAX_B + 2];
long long X[MAX_Q + 1];
int A, B, Q;

const long long lim = (long long)100000000000;

// bool tmp[MAX_N+1];

long long distance(const long long x, int ls, int lt) {
  assert(s[ls] <= x);
  assert(t[lt] <= x);
  long long ret = lim;
  long long tmp = 0;
  // 最初左
  if (t[lt] <= s[ls]) {
    tmp += x - s[ls];
    tmp += std::min(s[ls] - t[lt], t[lt + 1] - s[ls]);
  } else {
    tmp += x - t[lt];
    tmp += std::min(t[lt] - s[ls], s[ls + 1] - t[lt]);
  }
  ret = std::min(tmp, ret);

  // 最初右
  tmp = 0;
  if (s[ls + 1] <= t[lt + 1]) {
    tmp += s[ls + 1] - x;
    tmp += std::min(t[lt + 1] - s[ls + 1], s[ls + 1] - t[lt]);
  } else {
    tmp += t[lt + 1] - x;
    tmp += std::min(s[ls + 1] - t[lt + 1], t[lt + 1] - s[ls]);
  }
  ret = std::min(tmp, ret);

  return ret;
}

int get_lidx(long long x, long long *loc, int num) {
  int lb = 0;
  int ub = num;
  while (lb + 1 < ub) {
    assert(loc[lb] <= x && x < loc[ub]);
    int mid = (lb + ub) / 2;
    if (loc[mid] <= x) {
      lb = mid;
    } else {
      ub = mid;
    }
  }
  return lb;
}

int main(int argc, char **argv) {
  std::cin >> A >> B >> Q;
  for (int i = 1; i <= A; i++) {
    std::cin >> s[i];
  }
  for (int i = 1; i <= B; i++) {
    std::cin >> t[i];
  }
  s[0] = -lim;
  t[0] = -lim;
  s[A + 1] = lim;
  t[B + 1] = lim;
  for (int i = 1; i <= Q; i++) {
    std::cin >> X[i];
  }

  for (int i = 1; i <= Q; i++) {
    int ls = get_lidx(X[i], s, A + 1);
    int lt = get_lidx(X[i], t, B + 1);
    // std::cout << ls << " " << lt << std::endl;
    std::cout << distance(X[i], ls, lt) << std::endl;
  }

  return 0;
}