[CF453C]Little Pony and Summer Sun Celebration

题目

传送门

题解

首先判断无解的情况：有两个及两个以上的连通块中存在需要走奇数次的点。

这个判断可以在输入的时候做。

然后考虑怎么解决这个问题？

对于最优的情况，我们不经过偶数点，只经过奇数点，走一条单链

但是这只是我们的梦想，这种数据只存在于样例...

但是我们不能放弃我们的梦想，考虑多走一些其他的点，将这些奇数点串起来，这样，在我们走的这条路径上，奇数点有些走了奇数次，有些走了偶数次（因为可能有回溯），偶数点同理，再反观我们走出的路径，实际上可以说成是一颗 \(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;
}