題目

傳送門

題解

首先判斷無解的情況：有兩個及兩個以上的連通塊中存在需要走奇數次的點。

這個判斷可以在輸入的時候做。

然後考慮怎麼解決這個問題？

對於最優的情況，我們不經過偶數點，只經過奇數點，走一條單鏈

但是這只是我們的夢想，這種資料只存在於樣例...

但是我們不能放棄我們的夢想，考慮多走一些其他的點，將這些奇數點串起來，這樣，在我們走的這條路徑上，奇數點有些走了奇數次，有些走了偶數次（因為可能有回溯），偶數點同理，再反觀我們走出的路徑，實際上可以說成是一顆 \(dfs\) 樹，我們在這顆樹上對於一些走了奇數次的偶數點進行修改，亦可以完成這個任務，但是由於我們的 \(dfs\) 樹十分不可控，許多資訊諸如樹根、結構都不清楚，那麼，我們考慮隨意生成一顆樹來代替這個 \(dfs\)

那麼，隨意弄一顆生成樹，在這個生成樹上首先 \(dfs\) 一遍，在某個點所有兒子都訪問完之後，如果這個點的走到步數與要求不符，那麼我們就再走到父節點，再走到它，這會造成什麼？父節點多走一步，它變成目標狀態，相當於將它的錯誤轉移到父節點上，一直這樣轉移，直到根節點，對於根節點的最後一個節點，如果回溯到根節點，會造成根節點錯誤，那麼我們就不回溯，保證根節點正確。

不難看出，這道題除了之前所說的特判情況，是一定有解的

程式碼

#include<cstdio>
#include<cstring>
#include<vector>
#include<cstdlib>
using namespace std;

#define rep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i<=i##_end_;++i)
#define fep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i>=i##_end_;--i)
#define erep(i,u) for(signed i=tail[u],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define writc(a,b) fwrit(a),putchar(b)
#define mp(a,b) make_pair(a,b)
#define ft first
#define sd second
typedef long long LL;
// typedef pair<int,int> pii;
typedef unsigned long long ull;
typedef unsigned uint;
#define Endl putchar('\n')
// #define int long long
// #define int unsigned
// #define int unsigned long long

#define cg (c=getchar())
template<class T>inline void read(T& x){
    char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    if(f)x=-x;
}
template<class T>inline T read(const T sample){
    T x=0;char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    return f?-x:x;
}
template<class T>void fwrit(const T x){//just short,int and long long
    if(x<0)return (void)(putchar('-'),fwrit(-x));
    if(x>9)fwrit(x/10);
    putchar(x%10^48);
}
template<class T>inline T Max(const T x,const T y){return x>y?x:y;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
inline int gcd(const int a,const int b){return b?gcd(b,a%b):a;}
inline void getInv(int inv[],const int lim,const int MOD){
    inv[0]=inv[1]=1;for(int i=2;i<=lim;++i)inv[i]=1ll*inv[MOD%i]*(MOD-MOD/i)%MOD;
}
inline LL mulMod(const LL a,const LL b,const LL mod){//long long multiplie_mod
    return ((a*b-(LL)((long double)a/mod*b+1e-8)*mod)%mod+mod)%mod;
}

const int MAXN=1e5;
const int MAXM=1e5;

struct edge{int to,nxt;}e[MAXM*2+5];
int tail[MAXN+5],ecnt;
int x[MAXN+5],n,m;
inline void add_edge(const int u,const int v){
    e[++ecnt]=edge{v,tail[u]};tail[u]=ecnt;
    e[++ecnt]=edge{u,tail[v]};tail[v]=ecnt;
}

bool vis[MAXN+5];
int Dfs_check(const int u){
    int ret=x[u];vis[u]=true;
    for(int i=tail[u],v;i;i=e[i].nxt)if(!vis[v=e[i].to])
        ret+=Dfs_check(v);
    return ret>0;
}

bool start[MAXN+5];
inline void Init(){
    n=read(1),m=read(1);
    rep(i,1,m)add_edge(read(1),read(1));
    rep(i,1,n)x[i]=read(1);
    int cnt=0,ret;
    rep(i,1,n)if(!vis[i]){
        ret=Dfs_check(i);
        cnt+=ret;
        if(ret>0)start[i]=true;
    }
    if(cnt>=2){puts("-1");exit(0);}
}

int rt;
vector<int>to[MAXN+5];

void Generate(const int u){
    vis[u]=true;
    for(int i=tail[u],v;i;i=e[i].nxt)if(!vis[v=e[i].to]){
        to[u].push_back(v);
        Generate(v);
    }
}

inline void Maketre(){
    memset(vis,0,sizeof vis);
    rep(i,1,n)if(start[i]){
        Generate(i);
        rt=i;
        break;
    }
    // rep(i,1,n){
    //     for(auto j : to[i])writc(j,' ');Endl;
    // }
}

vector<int>ans;
int cnt[MAXN+5];
void Dfs(const int u,const int fa){
    ans.push_back(u);
    cnt[u]^=1;
    rep(i,0,(int)to[u].size()-1)if(to[u][i]!=fa){
        Dfs(to[u][i],u);
        if(u==rt && i==(int)to[rt].size()-1 && cnt[rt]==x[rt])
            break;
        ans.push_back(u);
        cnt[u]^=1;
    }
    if(cnt[u]!=x[u]){
        ans.push_back(fa);
        ans.push_back(u);
        cnt[fa]^=1,cnt[u]^=1;
    }
}

signed main(){
    Init();
    Maketre();
    if(rt)Dfs(rt,0);
    writc(ans.size(),'\n');
    rep(i,0,(int)ans.size()-1)writc(ans[i],' ');Endl;
    return 0;
}