杂题瞎做（1）

图论

CF19E Fairy

瞎做的第一题。。。古早 *2900，是我没有想出来的捏，体感 *2400。

先说一下我的心路历程，先看联通的问题，对于联通块，发现有超过两个联通块不是二分图无解，然后全是二分图的话，也显然随便删，感性理解。接着看到二分图，于是考虑转化为没有奇环，所以显然的建 dfs 树，然后用树上差分打标记即可。之后手模样例发现这是错的，遂放弃。先说一下错误的点，你考虑一种显然的反例，就是一个偶环包着一个奇环，此时删除奇环上的树边没有意义。

后来就想到，既然枚举奇环贡献边很复杂，不如对于每条边都试着做做。一种显然的方法，分讨树边和非树边，然后删除非树边显然，当且仅当只有这一个非树边会造成奇环，否则啥用没有，树边的探讨，一个显然的想法是必然是各个奇环的交，但是只有这一个限制太弱了，接着就不会了。。。

经过提示，貌似会了。我们来换个角度看问题，奇环是不好想的，于是考虑用二分图判定的另一种形式——染色。我们先把 dfs 树先都染上色，对于奇环来讲就可以转化成非树边连了同色点。然后来用染色刻画一下断边这个操作，显然只断边不会解决连接同色的情况，也就是说我们断边的本质是把分出去的那个子树的全部颜色做了一次翻转。然后此时来思考，我的更强限制也就出现在，翻转这棵子树后，又有非树边构成同色，因此也就是对于一条可以删的树边，它不能出现在本来的连了异色的的边和树边锁构成的环里，否则就会把这条边变成连接同色的环。

于是这题做完了。

纯净版压行版：

#include<bits/stdc++.h>
using namespace std;
const int N=10005;
struct edge{
    int to,nxt,id;
}e[N<<1];
int hd[N],tot=1,col[N],d[N],f[N],sz[N],w[N],top[N],vis[N];
int c1[N],c2[N],sum,pos,ans[N],cnt;
void add(int u,int v,int id){
    e[++tot].to=v;
    e[tot].nxt=hd[u];
    e[tot].id=id;
    hd[u]=tot;
}
void dfs1(int u,int fa){
    vis[u]=1;
    sz[u]=1,d[u]=d[fa]+1,f[u]=fa;
    int mx=0,k=0;
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to;
        if (!vis[v]){
            col[v]=col[u]^1;
            dfs1(v,u);
            sz[u]+=sz[v];
            if (sz[v]>mx)mx=sz[v],k=v;
        }
    }
    w[u]=k;
}
void dfs2(int u){
    if (!w[u])return;
    top[w[u]]=top[u];
    dfs2(w[u]);
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to;
        if (f[v]!=u||v==w[u])continue;
        top[v]=v;
        dfs2(v);
    }
}
int lca(int u,int v){
    while (top[u]!=top[v]){
        if (d[top[u]]>d[top[v]])u=f[top[u]];
        else v=f[top[v]];
    }
    return (d[u]>d[v]?v:u);
}
void dfs3(int u,int pid){
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to,id=e[i].id;
        if (id==pid)continue;
        if (d[v]==d[u]+1){
            dfs3(v,id);
            c1[u]+=c1[v];
            c2[u]+=c2[v];
        }
    }
    if (pid&&c1[u]==sum&&c2[u]==0)ans[++cnt]=pid;
}
int main(){
    ios::sync_with_stdio(0);cin.tie(0);
    int n,m;cin>>n>>m;
    for (int i=1;i<=m;++i){
        int u,v;cin>>u>>v;
        add(u,v,i),add(v,u,i);
    }
    for (int i=1;i<=n;++i)if (!vis[i]){
        col[i]=0;
        dfs1(i,0);
        top[i]=i;
        dfs2(i);
    }
    for (int u=1;u<=n;++u){
        for (int i=hd[u];i;i=e[i].nxt){
            int v=e[i].to,id=e[i].id;
            if (d[v]<d[u]&&f[u]!=v){
                if (col[u]==col[v]){
                    sum++;
                    pos=id;
                    c1[u]++,c1[v]++,c1[lca(u,v)]-=2;
                }
                else c2[u]++,c2[v]++,c2[lca(u,v)]-=2;
            }
        }
    }
    for (int i=1;i<=n;++i)if (d[i]==1)dfs3(i,0);
    if (!sum){
        cout<<m<<'\n';
        for (int i=1;i<=m;++i)cout<<i<<" ";
        return 0;
    }
    if (sum==1)ans[++cnt]=pos;
    sort(ans+1,ans+1+cnt);
    cout<<cnt<<'\n';
    for (int i=1;i<=cnt;++i)cout<<ans[i]<<" ";
}

额注释版

#include<bits/stdc++.h>
using namespace std;
const int N=10005;

// 前向星存图
struct edge{
    int to,nxt,id;   // id 是边的原始编号
}e[N<<1];
int hd[N],tot=1;     // tot=1 方便双向边配对（i^1 取反向边，虽然本题没用到）

// 树剖相关
int col[N];          // 染色 0/1
int d[N],f[N];       // 深度，父亲
int sz[N],w[N];      // 子树大小，重儿子
int top[N];          // 链顶
int vis[N];          // dfs1 的访问标记

// 差分标记
int c1[N],c2[N];     // c1: 奇环覆盖次数，c2: 偶环覆盖次数
int sum;             // 奇环总数
int pos;             // 唯一奇环对应的那条非树边编号
int ans[N],cnt;      // 答案数组

void add(int u,int v,int id){
    e[++tot].to=v;
    e[tot].nxt=hd[u];
    e[tot].id=id;
    hd[u]=tot;
}

// ---------- 树剖第一遍 ----------
// 求 f, d, sz, w，顺带染色
void dfs1(int u,int fa){
    vis[u]=1;
    sz[u]=1, d[u]=d[fa]+1, f[u]=fa;
    int mx=0,k=0;
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to;
        if (!vis[v]){                    // 树边：儿子
            col[v]=col[u]^1;             // 染色：与父亲相反
            dfs1(v,u);
            sz[u]+=sz[v];
            if (sz[v]>mx)mx=sz[v],k=v;   // 找重儿子
        }
    }
    w[u]=k;                              // 重儿子
}

// ---------- 树剖第二遍 ----------
// 求 top
void dfs2(int u){
    if (!w[u])return;                    // 叶子
    top[w[u]]=top[u];                    // 重儿子继承链顶
    dfs2(w[u]);
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to;
        if (f[v]!=u||v==w[u])continue;   // 只看轻儿子（父亲是 u 且不是重儿子）
        top[v]=v;                        // 轻儿子新开一条链
        dfs2(v);
    }
}

// ---------- 树剖 LCA ----------
int lca(int u,int v){
    while (top[u]!=top[v]){
        if (d[top[u]]>d[top[v]])u=f[top[u]];
        else v=f[top[v]];
    }
    return (d[u]>d[v]?v:u);
}

// ---------- 差分回溯 ----------
// 只沿树边向下（d[v]==d[u]+1），从叶子往上累加 c1, c2
void dfs3(int u,int pid){
    for (int i=hd[u];i;i=e[i].nxt){
        int v=e[i].to,id=e[i].id;
        if (id==pid)continue;
        if (d[v]==d[u]+1){               // 树边
            dfs3(v,id);
            c1[u]+=c1[v];
            c2[u]+=c2[v];
        }
    }
    // 判断这条树边 (u, f[u]) 是否可删
    if (pid&&c1[u]==sum&&c2[u]==0)ans[++cnt]=pid;
}

// ---------- 主函数 ----------
int main(){
    ios::sync_with_stdio(0);cin.tie(0);
    int n,m;cin>>n>>m;
    for (int i=1;i<=m;++i){
        int u,v;cin>>u>>v;
        add(u,v,i),add(v,u,i);
    }

    // 1. 建 dfs 树 + 树剖（处理多联通块）
    for (int i=1;i<=n;++i)if (!vis[i]){
        col[i]=0;
        dfs1(i,0);
        top[i]=i;
        dfs2(i);
    }

    // 2. 处理所有非树边，打差分标记
    //    d[v]<d[u] && f[u]!=v 保证每条非树边只由浅到深处理一次
    for (int u=1;u<=n;++u){
        for (int i=hd[u];i;i=e[i].nxt){
            int v=e[i].to,id=e[i].id;
            if (d[v]<d[u]&&f[u]!=v){
                if (col[u]==col[v]){          // 同色 → 奇环
                    sum++;
                    pos=id;                   // 记录这条非树边
                    c1[u]++,c1[v]++;          // 端点 +1
                    c1[lca(u,v)]-=2;          // LCA -2（差分）
                }
                else {                        // 异色 → 偶环
                    c2[u]++,c2[v]++;
                    c2[lca(u,v)]-=2;
                }
            }
        }
    }

    // 3. 回溯累加差分
    for (int i=1;i<=n;++i)if (d[i]==1)dfs3(i,0);

    // 4. 输出答案
    if (!sum){                                // 原图就是二分图
        cout<<m<<'\n';
        for (int i=1;i<=m;++i)cout<<i<<" ";
        return 0;
    }
    if (sum==1)ans[++cnt]=pos;                // 唯一奇环的非树边也可删
    sort(ans+1,ans+1+cnt);
    cout<<cnt<<'\n';
    for (int i=1;i<=cnt;++i)cout<<ans[i]<<" ";
}

sycblogs

杂题瞎做（1）

图论

CF19E Fairy

P8346 「Wdoi-6」最澄澈的空与海

P5663 [CSP-J 2019] 加工零件

P9377 [THUPC 2023 决赛] 百合

旧址

丁香之路

P4334 [COI 2007] Policija

P4652 [CEOI 2017] One-Way Streets

DP

镜寺

染色

冰火两重天

线性生物

中国象棋

快递服务

P6772 [NOI2020] 美食家

P11335 [NOISG 2020 Finals] Arcade

AT_abc400_g [ABC400G] Patisserie ABC 3

P3473 [POI 2008] UCI-The Great Escape

CF1987F2

数学

NOIP R6 T4

[HAOI2010] 计数

CF1228E

P6570 [NOI Online #3 提高组] 优秀子序列

基础算法

P6902 [ICPC 2014 WF] Surveillance

P16902 [CCO 2026] Melborp

公告