bool
Trace::optimise_if_old()
{
assert(cached_size == delta_list.size());
assert(cached_size == chronological_list.Count());
if (size() >= m_max_points) {
// first remove points outside max time range
bool updated = erase_earlier_than(get_min_time());
if (size() >= m_opt_points)
// if still too big, remove points based on line simplification
updated |= erase_delta(m_opt_points, no_thin_time);
if (!updated)
return false;
} else if (size() * 2 == m_max_points) {
// half size, appropriate time to remove old points
if (!erase_earlier_than(get_min_time()))
return false;
} else
return false;
m_average_delta_distance = calc_average_delta_distance(no_thin_time);
m_average_delta_time = calc_average_delta_time(no_thin_time);
return true;
}
int get_min_time(int cur)
{
int i, ans, tmp;
if (min_time[cur] != -1) return min_time[cur];
if (is_multiple[cur]) ans = -1;
else ans = INF;
for (i = 0; i < vertex; i++) {
if (map[i][cur]) {
tmp = get_min_time(i);
if (tmp == -1) continue;
tmp++;
if ((is_multiple[cur] && ans < tmp) || (!is_multiple[cur] && ans > tmp)) {
ans = tmp;
}
}
}
if (ans != INF && ans != -1) min_time[cur] = ans;
return min_time[cur];
}
void
Trace::Thin2()
{
const unsigned target_size = m_opt_points;
assert(size() > target_size);
// first remove points outside max time range
erase_earlier_than(get_min_time());
if (size() <= target_size)
return;
// if still too big, remove points based on line simplification
erase_delta(target_size, no_thin_time);
if (size() <= target_size)
return;
// if still too big, thin again, ignoring recency
erase_delta(target_size, no_thin_time);
assert(size() <= target_size);
}
int main()
{
int n_case, i, a, b, ans, tmp;
scanf("%d", &n_case);
while (n_case--) {
memset(map, 0, sizeof(map));
memset(is_multiple, 0, sizeof(is_multiple));
memset(is_end_step, 0, sizeof(is_end_step));
scanf("%d %d", &vertex, &edges);
scanf("%d %d", &init_step, &end_step_cnt);
for (i = 0; i < end_step_cnt; i++) {
scanf("%d", &a);
is_end_step[a] = true;
}
for (i = 0; i < edges; i++) {
scanf("%d %d", &a, &b);
map[a][b] = 1;
}
for (i = 0; i < vertex; i++) {
scanf("%d", &a);
is_multiple[i] = a==1;
}
memset(min_time, -1, sizeof(min_time));
min_time[init_step] = 1;
ans = -1;
for (i = 0; i < vertex; i++) {
if (is_end_step[i]) {
tmp = get_min_time(i);
if (tmp != -1 && tmp != INF) {
if (ans == -1 || ans > tmp) ans = tmp;
}
}
}
printf("%d\n", ans);
}
return 0;
}
