#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int>> g;
vector<int> bestPath;
pair<int,int> bfs_far(int start, vector<int>& comp) {
vector<int> dist(n+1, -1);
queue<int> q;
dist[start] = 0;
q.push(start);
int far = start;
while(!q.empty()) {
int u = q.front(); q.pop();
for(int v : g[u]) {
if(dist[v] == -1) {
dist[v] = dist[u] + 1;
q.push(v);
if(dist[v] > dist[far]) far = v;
}
}
}
return {far, dist[far]};
}
vector<int> bfs_path(int s, int t) {
vector<int> dist(n+1, -1), par(n+1, -1);
queue<int> q;
dist[s] = 0;
q.push(s);
while(!q.empty()) {
int u = q.front(); q.pop();
for(int v : g[u]) if(dist[v] == -1) {
dist[v] = dist[u] + 1;
par[v] = u;
q.push(v);
}
}
vector<int> path;
if(dist[t] == -1) return path;
for(int cur=t; cur!=-1; cur=par[cur]) path.push_back(cur);
reverse(path.begin(), path.end());
return path;
}
void dfs_heuristic(int u, vector<int>& path, vector<bool>& used) {
if(path.size() > bestPath.size()) bestPath = path;
for(int v : g[u]) {
if(!used[v]) {
used[v] = true;
path.push_back(v);
dfs_heuristic(v, path, used);
path.pop_back();
used[v] = false;
}
}
}
void solve_component(vector<int>& comp) {
if(comp.empty()) return;
int start = comp[0];
auto [a, _] = bfs_far(start, comp);
auto [b, __] = bfs_far(a, comp);
vector<int> path = bfs_path(a,b);
if(path.size() > bestPath.size()) bestPath = path;
// thử DFS từ 2 đầu
for(int root : {a, b}) {
vector<int> cur = {root};
vector<bool> used(n+1,false);
used[root] = true;
dfs_heuristic(root, cur, used);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
g.assign(n+1, {});
for(int i=0;i<m;i++) {
int u,v; cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<bool> vis(n+1,false);
for(int i=1;i<=n;i++) if(!vis[i]) {
vector<int> comp;
queue<int> q;
q.push(i);
vis[i] = true;
while(!q.empty()) {
int u = q.front(); q.pop();
comp.push_back(u);
for(int v : g[u]) if(!vis[v]) {
vis[v] = true;
q.push(v);
}
}
solve_component(comp);
}
cout << (int)bestPath.size()-1 << "\n";
for(int x : bestPath) cout << x << " ";
cout << "\n";
}
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