Codeforces Round #656

https://codeforces.com/contest/1385

本来是练习Java的，后面三道题还是上了C++，顺便学了一遍2SAT。这次可以说是拓扑排序专场，E题用了BFS，G题用DFS，各有千秋，记录一下最后三题。

Problem E

给出一个有向图的边，两种情况：有的边已经指定了方向(u -> v)，有的边待指定方向(u - v)。现尝试为所有边确定方向，使这个图成为DAG。

tutorial: 简单地进行拓扑排序，若已有环路肯定无法成为DAG，若无则将待指定的方向按拓扑序指向(逆拓扑序可能生成环路)。 

#include <bits/stdc++.h>
using namespace std;

typedef pair<int , int> pii;

const int mxsz = 200000 + 5;
vector<vector<int>> G;
vector<pii> Bi;
int vec2Order[mxsz];
int indeg[mxsz];

bool topo() {
    queue<int> que;
    for(int i = 1; i < G.size(); ++i) {
        if(indeg[i] == 0)
            que.push(i);
    }
    int topoInd = 0;
    while (!que.empty()) {
        int cur = que.front();
        que.pop();
        vec2Order[cur] = topoInd++;

        for(int v : G[cur]) {
            indeg[v] --;
            if(indeg[v] == 0)
                que.push(v);
        }
    }
    cerr << topoInd << "," << G.size() << endl;
    return topoInd + 1 == G.size();
}

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        int n, m;
        scanf("%d%d", &n, &m);
        G.assign(n+1, vector<int>());
        Bi.clear();
        memset(indeg, 0, sizeof(indeg));

        for(int i = 0 ;i < m; ++i) {
            int tmp, u, v;
            scanf("%d%d%d", &tmp, &u, &v);
            if(tmp) {
                G[u].push_back(v);
                indeg[v] ++;
            }
            else
                Bi.push_back(make_pair(u,v));
        }
        if(topo()) {
            puts("Yes");
            for(int i = 0; i < G.size(); ++i) {
                for(int j = 0;j < G[i].size(); ++j)
                    printf("%d %d
", i, G[i][j]);
            }

            for(int i = 0; i < Bi.size(); ++i) {
                int u = Bi[i].first, v = Bi[i].second;
                if(vec2Order[u] > vec2Order[v])
                    swap(u, v);
                printf("%d %d
", u, v);
            }
        } else {
            puts("NO");
        }

    }
    return 0;
}

Problem F

给出一棵树和数字k，要求每一次刚好删除k个叶子节点，问能删除几次。

tutorial: 意思上是简单的implementation，直接模拟删除的过程即可。但是实现上需要注意表示删除叶子结点后的树的结构变化，即新的叶子节点生成以及其父节点，以及特例情况。我的实现略微粗糙，可以优化。

#include <bits/stdc++.h>
using namespace std;


const int mxsz = 200000 + 5;

int cntleaves[mxsz];
vector<vector<int>> G;
set<int> Leaves;

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, k;
        scanf("%d%d", &n,&k);

        fill(cntleaves, cntleaves + n, 0);
        G.assign(n, vector<int>());
        Leaves.clear();
        for(int i = 0;i < n-1; ++i) {
            int u, v;
            scanf("%d%d", &u, &v);
            u--; v--;
            G[u].push_back(v);
            G[v].push_back(u);
        }

        //special when n = 2, k = 1
        if(k == 1) {
            printf("%d
", n - 1);
            continue;
        }

        int ans = 0;
        queue<int> vec;
        for(int i = 0 ;i < G.size(); ++i) {
            if(G[i].size() == 1) {
                cntleaves[G[i][0]] ++;
                Leaves.insert(i);
            }
        }
        for(int i = 0; i < n; ++i) {
            if(cntleaves[i] > 0)
                vec.push(i);
        }
        while (!vec.empty()) {
            int cur = vec.front();
            vec.pop();

            int moves = cntleaves[cur] / k;
            cntleaves[cur] %= k;
            int cntDelLeaves = moves * k;
            int cntDegree = 0;

            if(cntDelLeaves > 0) {
                for(int i = 0 ; i < G[cur].size(); ++i) {
                    if(G[cur][i] != -1) {
                        cntDegree ++;
                        if(Leaves.count(G[cur][i]) && cntDelLeaves) {
                            cntDelLeaves --;
                            G[cur][i] = -1;
                        }
                    }
                }
                if(cntDegree - moves * k == 1) {
                    for(int i = 0 ;i < G[cur].size(); ++i) {
                        if(G[cur][i] != -1) {
                            Leaves.insert(cur);
                            cntleaves[G[cur][i]] ++;
                            vec.push(G[cur][i]);
                            break;
                        }
                    }
                }
            }

            ans += moves;
        }

        printf("%d
", ans);
    }
    return 0;
}

Problem G

给出两行数列，可以交换同一列的上下两个数字，问能否将其转换为两行permutation，并要求回答最小交换次数的解。

这题有意思，由于正在看SMT，Satisfiability，正好通过这题学习2SAT问题的相关算法。

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;
vector<vector<pii>> indWhere;
set<int> NotChange;

vector<vector<int>> g,gt;
vector<int> Order;
vector<bool> Used;
vector<int> Comp;
vector<bool> Assign;
int ans;

inline int TrueVec(int x) {return 2 * x;}
inline int FalseVec(int x) {return 2 * x + 1;}

void dfs1(int u) {
    Used[u] = true;

    for(int v : g[u]){
        if(!Used[v])
            dfs1(v);
    }
    Order.push_back(u);
}

void dfs2(int u, int cc) {
    Comp[u] = cc;
    for(int v : gt[u]) {
        if(Comp[v] == -1)
            dfs2(v ,cc);
    }
}

bool solve(int n) {
    Order.clear();
    Used.assign(2 * n, false);
    Comp.assign(2 * n, -1);
    Assign.assign(n, false);
    ans = 0;

    for(int i = 0 ;i < g.size(); ++i) {
        if(!Used[i]) {
            dfs1(i);
        }
    }
    int cntComp = 0;
    for(int i = 0 ;i < Order.size(); ++i) {
        int u = Order[Order.size() - 1 - i];
        if(Comp[u] == -1)
            dfs2(u, cntComp++);
    }

    for(int i = 0 ;i < Comp.size(); i += 2) {
        if(Comp[i] == Comp[i+1]) return false;
        Assign[i/2] = Comp[i] > Comp[i+1];
        if(Assign[i/2]) ans++;
    }

    return true;
}

int main(){
    int t;
    scanf("%d", &t);
    while (t--) {
        ans = 0;
        int n;
        scanf("%d", &n);
        indWhere.assign(n, vector<pii>());
        for(int i = 0 ;i < 2; ++i) {
            for(int j = 0;j < n ; ++j) {
                int tmp;
                scanf("%d", &tmp);
                tmp --;
                indWhere[tmp].push_back(make_pair(i, j));
                if(indWhere[tmp].size() > 2) {
                    ans = -1;
                }
            }
        }
        // special
        if(ans == -1) {
            puts("-1");
            continue;
        }

        g.assign(2 * n, vector<int>());
        gt.assign(2 * n,vector<int>());
        NotChange.clear();

        for(int i = 0; i < n; ++i) {
            int r0 = indWhere[i][0].first, c0 = indWhere[i][0].second;
            int r1 = indWhere[i][1].first, c1 = indWhere[i][1].second;
            if(c0 == c1) { // co is false
                NotChange.insert(c0); //
                g[TrueVec(c0)].push_back(FalseVec(c0));

                gt[FalseVec(c0)].push_back(TrueVec(c0));
            } else if(r0 == r1) { // c0 xor c1 is true;
                g[TrueVec(c0)].push_back(FalseVec(c1));
                g[TrueVec(c1)].push_back(FalseVec(c0));
                g[FalseVec(c0)].push_back(TrueVec(c1));
                g[FalseVec(c1)].push_back(TrueVec(c0));

                gt[FalseVec(c1)].push_back(TrueVec(c0));
                gt[FalseVec(c0)].push_back(TrueVec(c1));
                gt[TrueVec(c1)].push_back(FalseVec(c0));
                gt[TrueVec(c0)].push_back(FalseVec(c1));
            } else { // c0 xor c1 is false
                g[TrueVec(c0)].push_back(TrueVec(c1));
                g[TrueVec(c1)].push_back(TrueVec(c0));
                g[FalseVec(c0)].push_back(FalseVec(c1));
                g[FalseVec(c1)].push_back(FalseVec(c0));

                gt[TrueVec(c1)].push_back(TrueVec(c0));
                gt[TrueVec(c0)].push_back(TrueVec(c1));
                gt[FalseVec(c1)].push_back(FalseVec(c0));
                gt[FalseVec(c0)].push_back(FalseVec(c1));
            }
        }



        if(solve(n)) {
            if(ans <= n - NotChange.size() - ans) {
                printf("%d
", ans);
                for(int i = 0, cntAns = 0;i < Assign.size(); ++i){
                    if(Assign[i] && NotChange.count(i) == 0) printf("%d%c", i+1, cntAns++==ans-1 ?'
':' ');
                }
            } else {
                ans = n - NotChange.size() - ans;
                printf("%d
", ans);
                for(int i = 0, j = 0; i < Assign.size(); ++i) {
                    if(Assign[i] == false && NotChange.count(i) == 0)
                        printf("%d%c", i+1, j++==ans-1?'
':' ');
                }
                if(ans == 0) puts("");
            }

        } else {
            puts("-1");
        }


    }
    return 0;
}

tutorial: 这题按照解2SAT问题可以得到一组解，但未必是最小交换次数的。其实类似这种想法，还是按照联通分量的思想，点与点之间用不同的边值代表其关系(异或和的真假)，然后对一个点先随便赋一个值 b ，其所在联通分量的所有其他点的值必然也会确定，这时再贪心的比较最初赋值为~b 的结果是否更优(同一个联通分量其他点的值取逆即可)，查完所有联通分量，即可得到解。

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;

vector<vector<pii>> indWhere;
vector<vector<pii>> G;
vector<bool> Used;
vector<vector<int>> comp;
vector<int> Assign;
vector<int> Ans;

void dfs1(int u, int cC) {
    Used[u] = true;
    for(pair<int, int> item : G[u]) {
        int v = item.first;
        if(!Used[v])
            dfs1(v, cC);
    }
    comp[cC].push_back(u);
}

void dfs2(int u, bool flag) {
    Assign[u] = flag;
    for (auto item : G[u]) {
        if(Assign[item.first] == -1) {
            dfs2(item.first, flag ^ item.second);
        }
    }
}

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        int ans = 0;
        int n;
        scanf("%d", &n);
        indWhere.assign(n, vector<pii>());
        for(int i = 0 ;i < 2; ++i) {
            for(int j = 0;j < n ; ++j) {
                int tmp;
                scanf("%d", &tmp);
                tmp --;
                indWhere[tmp].push_back(make_pair(i, j));
                if(indWhere[tmp].size() > 2) {
                    ans = -1;
                }
            }
        }
        if(ans){
            puts("-1");
            continue;
        }
        G.assign(n, vector<pii>());
        for(int i = 0 ;i < n; ++i) {
            int r0 = indWhere[i][0].first, c0 = indWhere[i][0].second;
            int r1 = indWhere[i][1].first, c1 = indWhere[i][1].second;

            if(c0 == c1) continue;

            G[c0].push_back(make_pair(c1, r0 == r1));
            G[c1].push_back(make_pair(c0, r0 == r1));
        }

        Used.assign(n, false);
        comp.clear();
        for (int i = 0; i < n; ++i) {
            int curComp = comp.size();
            comp.push_back(vector<int>());
            if(!Used[i])
                dfs1(i, curComp);
        }

        Assign.assign(n, -1);
        Ans.clear();
        for(int i = 0 ;i < comp.size(); ++i) {
            int tot = comp[i].size();
            if(tot <= 1) continue;

            int cntTrue = 0;
            dfs2(comp[i][0], true);
            for (int j = 0; j < comp[i].size(); ++j) {
                if(Assign[comp[i][j]])
                   cntTrue++;
            }
            bool flag = cntTrue > tot - cntTrue;
            for (int j = 0; j < comp[i].size(); ++j) {
                if(flag^Assign[comp[i][j]])
                    Ans.push_back(comp[i][j]);
            }
        }

        if(Ans.empty()) {
            printf("0

");
        } else {
            printf("%d
", Ans.size());
            for (int i = 0; i < Ans.size(); ++i) {
                printf("%d%c", Ans[i] + 1, i == Ans.size() - 1?'
':' ');
            }
        }
    }
    return 0;
}

只要permutation的每个数字刚好在两行数列中共出现两次，就必然有解。这其实从2SAT构图的过程中也可发现端倪，因为都是异或的关系，改为imperative后所有的 a 与 ~a之间都没有边，没有一对能直接连，这也会使没有一对在同一个联通分量里，整个图就像是一个个联通分量的团，这也解释了为什么会有多解(任何解取逆也是一个解)，也解释了为什么按老方法赋值会不行。

后记

https://cp-algorithms.com/graph/2SAT.html

这是一篇讲2SAT讲的不错的文章，实现用Kosaraju's algorithm感觉比Tarjan写起来要更容易些，个人很喜欢利用  transpose graph 的感觉。