http://codeforces.com/contest/967/problem/F
题目大意：
有n个点，n*(n-1)/2条边的无向图，其中有m条路目前开启（即能走），剩下的都是关闭状态
定义：从x走到y(即x->y)后，和x所连接的边的所有状态都反转（即开启->关闭，关闭->开启）
问，从起点1走到终点n，最少需要经过几步，并且输出这个路径(如果存在多挑最短路径，输出任意一条)
如果不存在，则输出-1
思路：
其实这道题第一眼看过去就是bfs，不过，由于每个状态都在改变，那要怎么利用这个bfs的特性呢？
后来画了画图，你会发现，存在如下的问题。
对于一个a+1个点，b条边的图(其中终点，即a+1这个点是没有边连向它)来说，如果b=a*（a-1）/2，那么，无论如何都是走不到a+1这个点的。
所以，问题就转换成，如果b<a*(a-1)/2需要走几步。
于是我们可以发现，在b<a*(a-1)/2的情况中，我们又可以找出bb=aa*(aa-1)/2的情况。 其中bb表示b的子集，aa表示a的子集
于是不断剖析下去，最后只会得到两种情况
第一种：
a=3， b=2的情况（注，a=4才是终点，前面定义过了= =）
图形：①->②->③
即该情况步数是4步，即1->2->3->1->4
第二种：
a=4, b=5的情况
(= =)一共4个点，告诉你边，你自己画吧
边为：
1 2
2 3
3 4
4 1
1 3
该情况步数是5
当然，可能存在步数<=4的情况，即从1出发直接按照题目所给边走到终点，这个就不用我说了吧！！！(具体为什么的话，请自己利用上面的两种情况分析一下)
所以根本不存在output中说的le6的情况
对于前面两种情况中，步数=4的情况是容易解决的，关键就是步数=5的情况容易TLE（= =，退役一年没做题，脑子锈逗了，T了一天）
首先我们可以发现步数=5的情况可以转移成——在删除起点1之后，步数=4的情况。
因此，我们只需要找一个从1->u的情况，设u包含u下面所有的子节点（不包含1）个数位C，那么如果该集合的节点个数（包含u）< u的边数，那么就存在解
解为1->u->v->z->u->n
然而= =，楼主先暴力u，再暴力v，再暴力z，T死我了
改成先暴力u，再暴力z，最后通过u、z找v就过了= =
原因是，因为你会发现，v满足的条件比z满足的条件要少，所以v的剪枝比较少，因此先暴力v所要判断的节点数目会更多，因此不优秀
（退役了以后做题是真的伤不起，还写得很麻烦= =，懒得优化了，自己看着办吧）
//看看会不会爆int!数组会不会少了一维！
//取物问题一定要小心先手胜利的条件
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker,"/STACK:102400000,102400000")
#define LL long long
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define mk make_pair
#define fi first
#define se second
#define haha printf("haha\n")
const int maxn = 5e5 + ;
int n, m;
vector<int> G[maxn];
bool vis[maxn];
int pre[maxn]; bool bfs(int u){
queue<pair<int, int> > que;
que.push(mk(, ));
memset(pre, -, sizeof(pre));
vis[] = ;
while (!que.empty()){
pair<int, int> p = que.front(); que.pop();
int u = p.fi, step = p.se;
//if (u == n) break;
for (int i = ; i < G[u].size(); i++){
int v = G[u][i];
if (vis[v]) continue;
vis[v] = true;
pre[v] = u;
if (step + <= ){
que.push(mk(v, step+));
}
}
}
while(!que.empty()) que.pop();
if (pre[n] == -) return false;
int pos = n;
vector<int> ans; ans.pb(pos);
while (pre[pos] != -){
ans.pb(pre[pos]);
pos = pre[pos];
}
reverse(ALL(ans));
if (ans.size() > ) return false;
printf("%d\n", ans.size()-);
for (int i = ; i < ans.size(); i++)
printf("%d ", ans[i]);
cout << endl;
return true;
} void display(int a, int b, int c, int d, int e, int f){
printf("5\n%d %d %d %d %d %d\n", a, b, c, d, e, f);
} void bfs2(int x, vector<int> &cache){
vis[x] = ;
queue<int> que;
que.push(x);
cache.pb(x);
while (!que.empty()){
int u = que.front(); que.pop();
for (int i = ; i < G[u].size(); i++){
if (vis[G[u][i]] || u == )continue;
vis[G[u][i]] = ;
que.push(G[u][i]);
cache.pb(G[u][i]);
}
}
} set<int> mys[maxn];
int main(){
cin >> n >> m;
for (int i = ;i <= m; i++){
int u, v; scanf("%d%d", &u, &v);
G[u].pb(v), G[v].pb(u);
mys[u].insert(v); mys[v].insert(u);
}
if (m == ) return puts("-1"), ;
if (n == ) return printf("1\n1\n"), ;
//direct from 1 to n
if (bfs()) return ;
memset(vis, , sizeof(vis));
//other(just 4 steps) for (int i = ; i < G[].size(); i++){//the next point which connect to 1
vis[G[][i]] = ;
}
for (int i = ; i < G[].size(); i++){
int u = G[][i];
for (int j = ; j < G[u].size(); j++){
int v = G[u][j];
if (v == || vis[v]) continue;
printf("4\n1 %d %d 1 %d\n", u, v, n);
return ;
}
}
//other(just 5 steps)
//1->u->v->z->u->n
memset(vis, , sizeof(vis));
vector<int> cache;
for (int i = ; i < G[].size(); i++){
int u = G[][i];
if (vis[u]) continue;
cache.clear();
bfs2(u, cache);
if (G[u].size() < cache.size()){
for (int j = ; j < cache.size(); j++){
u = cache[j];
if (!mys[u].count()) continue;
if (G[u].size() >= cache.size()) continue;
for (int k = ; k < G[].size(); k++){
int z = G[][k];
if (!vis[z] || mys[z].count(u) || z == u) continue;
if (G[z].size() >= cache.size()) continue;
for (int f = ; f < G[z].size(); f++){
int v = G[z][f];
if (!mys[v].count() || !mys[v].count(u)) continue;
if (v == ) continue;
display(, u, v, z, u, n);
return ;
}
} }
}
}
puts("-1");
return ;
} /*
5 5
1 2
2 3
3 4
4 1
1 3
*/