1 second
256 megabytes
standard input
standard output
Twilight Sparkle learnt that the evil Nightmare Moon would return during the upcoming Summer Sun Celebration after one thousand years of im*ment on the moon. She tried to warn her mentor Princess Celestia, but the princess ignored her and sent her to Ponyville
to check on the preparations for the celebration.
Twilight Sparkle wanted to track the path of Nightmare Moon. Unfortunately, she didn't know the exact path. What she knew is the parity of the number of times that each place Nightmare Moon visited. Can you help Twilight Sparkle to restore any path that is
consistent with this information?
Ponyville can be represented as an undirected graph (vertices are places, edges are roads between places) without self-loops and multi-edges. The path can start and end at any place (also it can be empty). Each place can be visited multiple times. The path
must not visit more than 4n places.
The first line contains two integers n and m (2 ≤ n ≤ 105; 0 ≤ m ≤ 105)
— the number of places and the number of roads in Ponyville. Each of the following m lines contains two integers ui, vi (1 ≤ ui, vi ≤ n; ui ≠ vi),
these integers describe a road between places ui and vi.
The next line contains n integers: x1, x2, ..., xn (0 ≤ xi ≤ 1) —
the parity of the number of times that each place must be visited. If xi = 0,
then the i-th place must be visited even number of times, else it must be visited odd number of times.
Output the number of visited places k in the first line (0 ≤ k ≤ 4n).
Then output k integers — the numbers of places in the order of path. Ifxi = 0,
then the i-th place must appear in the path even number of times, else i-th
place must appear in the path odd number of times. Note, that given road system has no self-loops, therefore any two neighbouring places in the path must be distinct.
If there is no required path, output -1. If there multiple possible paths, you can output any of them.
3 2
1 2
2 3
1 1 1
3
1 2 3
5 7
1 2
1 3
1 4
1 5
3 4
3 5
4 5
0 1 0 1 0
10
2 1 3 4 5 4 5 4 3 1
2 0
0 0
0
题目大意：
给出一张图，有N个点，M条边，并给出每一个点要求訪问次数的奇偶性。，要求输出訪问路径。
解法：
首先我们能够明白一点，这就是一个图的遍历，找一个点，设为起点，建立一个搜索遍历树，对于树每个点，我们全然能够控制奇偶性，如果：
眼下訪问的点为v。父节点为fa，如若点v不符合当前的奇偶性。则就让父节点到v绕一次，这样 odd[v] ^= 1, fa[v] ^= 1，这样我们能够全然保证全然控制子节点，将不符合要求的奇偶性调整成符合要求的奇偶性。同一时候父节点的奇偶性也在改变。
通过上述的操作，我们能够每次保证子节点的奇偶性符合要求，然而父节点的奇偶性如若不符合要求，则能够通过调整父节点 与 父节点的父节点来调整奇偶性。这样我们就能够奇偶性传递，终于传递到根节点。
根节点如若不符合该怎样调整呢？因为我们是走遍历树。到达叶节点还要回来的，意味着我们要走至少两次根节点。一次是出发。一次是最后一次回归。我们能够将根节点 r1 调整到根节点的当中一个子节点r2，使得奇偶性再次得到调整
代码：
#include <cstdio>
#include <vector>
#define N_max 123456 using namespace std; int n, m, fa[N_max], want[N_max];
int Odd_n, Odd_x, haveOdd[N_max];
vector <int> G[N_max], ans; int getf(int x) {
return (fa[x] == x) ? x : fa[x] = getf(fa[x]);
}
void addedge(int x, int y) {
G[x].push_back(y);
} void init() {
scanf("%d%d", &n, &m); for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int x, y; scanf("%d%d", &x, &y); int tmpx=getf(x);
int tmpy=getf(y);
if (tmpx != tmpy) {
fa[tmpx] = tmpy;
addedge(x, y);
addedge(y, x);
}
} for (int i = 1; i <= n; i++) {
scanf("%d", &want[i]); if (want[i]) haveOdd[getf(i)] = 1;
} for (int i = 1; i <= n; i++)
if (haveOdd[i]) {
Odd_n++;
Odd_x = i;
}
} void dfs(int now, int pre) {
ans.push_back(now);
want[now] ^= 1; for (int i = 0; i < G[now].size(); i++) {
int nex = G[now][i];
if (nex == pre) continue; dfs(nex, now);
ans.push_back(now);
want[now] ^= 1; if (want[nex]) {
ans.push_back(nex);
want[nex] ^= 1;
ans.push_back(now);
want[now] ^= 1;
}
}
} void solve() {
if (Odd_n == 0) {
printf("0\n");
return;
} if (Odd_n > 1) {
printf("-1\n");
return;
} dfs(Odd_x, -1);
int x = 0;
if (want[Odd_x]) x=1; printf("%d\n", ans.size() - x);
for (int i = x; i < ans.size(); i++)
printf("%d ", ans[i]);
} int main() {
init();
solve();
}
版权声明：本文博客原创文章，博客，未经同意，不得转载。