#include "longesttrip.h"
#include <vector>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <chrono>
#include <random>
using namespace std;
bool find_edge(int a, int b) {
return are_connected({ a }, { b });
}
vector <int> longest_trip(int n, int d) {
vector <int> perm(n);
for (int i = 0; i < n; i++) {
perm[i] = i;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
shuffle(perm.begin(), perm.end(), rng);
vector <int> p1, p2;
p1.push_back(perm[0]);
p2.push_back(perm[1]);
bool ch = false;
for (int j = 2; j < n; j++) {
int i = perm[j];
if (ch) {
if (find_edge(p1.back(), i)) {
p1.push_back(i);
}
else p2.push_back(i);
ch = false;
}
else {
if (find_edge(p1.back(), i)) {
p1.push_back(i);
continue;
}
ch = true;
if (find_edge(p2.back(), i)) {
p2.push_back(i);
}
while (!p2.empty()) {
p1.push_back(p2.back());
p2.pop_back();
}
p2.push_back(i);
ch = true;
}
}
if (find_edge(p1[0], p2[0])) {
vector <int> ans;
reverse(p1.begin(), p1.end());
for (auto& it : p1) {
ans.push_back(it);
}
for (auto& it : p2) {
ans.push_back(it);
}
return ans;
}
if (find_edge(p1[0], p2.back())) {
vector <int> ans;
reverse(p1.begin(), p1.end());
reverse(p2.begin(), p2.end());
for (auto& it : p1) {
ans.push_back(it);
}
for (auto& it : p2) {
ans.push_back(it);
}
return ans;
}
if (find_edge(p1.back(), p2[0])) {
vector <int> ans;
for (auto& it : p1) {
ans.push_back(it);
}
for (auto& it : p2) {
ans.push_back(it);
}
return ans;
}
if (find_edge(p1.back(), p2.back())) {
vector <int> ans;
reverse(p2.begin(), p2.end());
for (auto& it : p1) {
ans.push_back(it);
}
for (auto& it : p2) {
ans.push_back(it);
}
return ans;
}
if (!are_connected(p1, p2)) {
if ((int)p1.size() > (int)p2.size()) {
return p1;
}
return p2;
}
int l = 0, r = (int)p1.size() - 1, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
vector <int> w;
for (int i = mid; i < (int)p1.size(); i++) {
w.push_back(p1[i]);
}
if (are_connected(w, p2)) {
ans = mid;
l = mid + 1;
}
else r = mid - 1;
}
int vert1 = ans;
l = 0; r = (int)p2.size() - 1; ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
vector <int> w;
for (int i = mid; i < (int)p2.size(); i++) {
w.push_back(p2[i]);
}
if (are_connected({ p1[vert1] }, w)) {
ans = mid;
l = mid + 1;
}
else r = mid - 1;
}
int vert2 = ans;
vector <int> final_ans;
for (int i = vert1 + 1; i < (int)p1.size(); i++) {
final_ans.push_back(p1[i]);
}
for (int i = 0; i <= vert1; i++) {
final_ans.push_back(p1[i]);
}
for (int i = vert2; i < (int)p2.size(); i++) {
final_ans.push_back(p2[i]);
}
for (int i = 0; i < vert2; i++) {
final_ans.push_back(p2[i]);
}
return final_ans;
}
# |
결과 |
실행 시간 |
메모리 |
Grader output |
1 |
Incorrect |
1 ms |
344 KB |
Incorrect |
2 |
Halted |
0 ms |
0 KB |
- |
# |
결과 |
실행 시간 |
메모리 |
Grader output |
1 |
Correct |
7 ms |
344 KB |
Output is correct |
2 |
Correct |
5 ms |
344 KB |
Output is correct |
3 |
Correct |
5 ms |
344 KB |
Output is correct |
4 |
Correct |
7 ms |
440 KB |
Output is correct |
5 |
Correct |
5 ms |
600 KB |
Output is correct |
# |
결과 |
실행 시간 |
메모리 |
Grader output |
1 |
Correct |
9 ms |
344 KB |
Output is correct |
2 |
Correct |
6 ms |
344 KB |
Output is correct |
3 |
Correct |
5 ms |
344 KB |
Output is correct |
4 |
Correct |
4 ms |
440 KB |
Output is correct |
5 |
Correct |
4 ms |
344 KB |
Output is correct |
6 |
Incorrect |
0 ms |
344 KB |
Incorrect |
7 |
Halted |
0 ms |
0 KB |
- |
# |
결과 |
실행 시간 |
메모리 |
Grader output |
1 |
Correct |
7 ms |
344 KB |
Output is correct |
2 |
Correct |
6 ms |
372 KB |
Output is correct |
3 |
Correct |
5 ms |
344 KB |
Output is correct |
4 |
Correct |
5 ms |
344 KB |
Output is correct |
5 |
Correct |
7 ms |
600 KB |
Output is correct |
6 |
Incorrect |
0 ms |
344 KB |
Incorrect |
7 |
Halted |
0 ms |
0 KB |
- |
# |
결과 |
실행 시간 |
메모리 |
Grader output |
1 |
Correct |
8 ms |
344 KB |
Output is correct |
2 |
Correct |
7 ms |
344 KB |
Output is correct |
3 |
Correct |
5 ms |
344 KB |
Output is correct |
4 |
Correct |
5 ms |
344 KB |
Output is correct |
5 |
Correct |
5 ms |
344 KB |
Output is correct |
6 |
Incorrect |
1 ms |
344 KB |
Incorrect |
7 |
Halted |
0 ms |
0 KB |
- |