牛客练习赛101 D - 罪业之都（树形dp、构造）

罪恶都市

• 因为保证是无向连通图，所以 m 最少都是 n - 1 条边形成一颗树。分类探讨：
• 如果是一棵树，用树形dp维护；
• 否则我们肯定能在图中构造出一个环，让所有点走向这个环即可。

难点主要还是树形dp的状态表示

$Code:$

#include<bits/stdc++.h>
#include<unordered_map>
#define debug cout << "debug---  "
#define debug_ cout << "\n---debug---\n"
#define oper(a) operator<(const a& ee)const
#define forr(a,b,c) for(int a=b;a<=c;a++)
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define all(a) a.begin(),a.end()
#define sz(a) (int)a.size()
#define endl "\n"
#define ul (u << 1)
#define ur (u << 1 | 1)
#define PI 3.14159265358979323846
using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll, int> PII;

const int N = 3e5 + 10, M = 2e6 + 10, mod = 998244353;
int INF = 0x3f3f3f3f; ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, B = 10, ki;

int h[N], ne[M], e[M], idx;
void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
int f[N], bian[M], dp[N];
//dp[i]>=0 表示以 i 为根的子树内均满足 f 数组要求，且从 i 出发能往下走 dp[i]步；
//dp[i]<0 表示子树内不满足情况，至少需要往上走 |dp[i]| 步才可以满足要求

void dfs_dp(int x, int fa) {
    dp[x] = -f[x];
    //初始没子节点时，只能往上走

    for (int i = h[x]; ~i; i = ne[i]) {
        int j = e[i]; if (j == fa)continue;
        dfs_dp(j, x);

        if (dp[j] < 0) { 
            bian[i] = 1;
            bian[i ^ 1] = 0;
            //子节点子树只能往上走，所以该边固定为反向

            //如果该点不能经过 x 往下走其他路径，x 只能维护往上走
            if (-dp[j] - 1 > dp[x])dp[x] = min(dp[x], dp[j] + 1);
        }
        else {
            bian[i ^ 1] = 1;
            bian[i] = 0;
            //能往下走，所以反向边固定为反向

            if (dp[j] + 1 >= -dp[x])dp[x] = max(dp[x], dp[j] + 1);
        }
    }
}

bool st[N], ins[N], c[N];
int id = -1;
bool flag;

void dfs_circle(int x, int from) {
    st[x] = ins[x] = true;
    for (int i = h[x]; ~i; i = ne[i]) {
        int j = e[i]; if (i == (from ^ 1))continue;
        if (!st[j])dfs_circle(j, i);
        else if (ins[j]) {
            id = j;
            flag = true;
        }
        if (flag) {
            if (id != -1) {
                bian[i ^ 1] = 1;
                bian[i] = 0;
                c[x] = true;
            }
            if (x == id)id = -1;
            return;
        }
    }
    ins[x] = false;
}

void dfs(int x, int from) {
    for (int i = h[x]; ~i; i = ne[i]) {
        int j = e[i];
        if (i == (from ^ 1) || bian[i] != -1)continue;
        bian[i] = 1;
        bian[i ^ 1] = 0;
        dfs(j, i);
    }
}

void solve() {
    cin >> n >> m;
    forr(i, 1, n)cin >> f[i];

    mem(h, -1);
    mem(bian, -1);

    for (int i = 1; i <= m; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }

    if (m == n - 1) {
        dfs_dp(1, -1);
        if (dp[1] < 0) {
            cout << -1;
            return;
        }
    }
    else {
        dfs_circle(1, -1);
        for (int i = 1; i <= n; i++) {
            if (c[i])dfs(i, -1);
        }
    }

    for (int i = 0; i < idx; i += 2)
        cout << bian[i];
}

signed main() {
    cinios;
    int T = 1;
    
    for (int t = 1; t <= T; t++) {
        solve();
    }
    return 0;
}
/*
*/
//板子