NOI模拟（5.7） HNOID1T3 毒瘤 （bzoj5287）

最新推荐文章于 2020-08-17 21:32:31 发布
最新推荐文章于 2020-08-17 21:32:31 发布
阅读量270 收藏 1
点赞数
分类专栏： NOIP总结 杂 --------DP-------- 虚树 --------图论---------- 文章标签： NOI 虚树 DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scar_lyw/article/details/80257978
版权

毒瘤

题目背景：

5.7 模拟 HNOI2018D1T3  

分析：虚树 + DP

 

毒瘤到了直接拿毒瘤当题目，不想说什么，不过部分分比较高还是灰常资瓷的，首先，对于80分的部分分就是先2d（d = m - n + 1）枚举每一条非树边的其中一个端点的状态，然后直接DP。

 

Source:

/*
    created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>
#include <ctime>
#include <bitset>
 
inline char read() {
    static const int IN_LEN = 1024 * 1024;
    static char buf[IN_LEN], *s, *t;
    if (s == t) {
        t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
        if (s == t) return -1;
    }
    return *s++;
}
 
// /*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = read(), iosig = false; !isdigit(c); c = read()) {
        if (c == -1) return ;
        if (c == '-') iosig = true; 
    }
    for (x = 0; isdigit(c); c = read()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN];
char *oh = obuf;
inline void write_char(char c) {
	if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
	*oh++ = c;
}


template<class T>
inline void W(T x) {
	static int buf[30], cnt;
	if (x == 0) write_char('0');
	else {
		if (x < 0) write_char('-'), x = -x;
		for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
		while (cnt) write_char(buf[cnt--]);
	}
}

inline void flush() {
    for (int i = 0; i <= 10; ++i) std::cout << obuf[i];
    std::cout << '\n';
	fwrite(obuf, 1, oh - obuf, stdout), oh = obuf;
}
 
/*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = getchar(), iosig = false; !isdigit(c); c = getchar())
        if (c == '-') iosig = true; 
    for (x = 0; isdigit(c); c = getchar()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int MAXN = 100000 + 9;
const int mod = 998244353;
std::vector<int> edge[MAXN];
std::vector<int> down[MAXN];
int cnt, n, m, x, y;
int dp[MAXN][2], mark[MAXN], dep[MAXN], id[20];
bool vis[MAXN];

inline void add_edge(int x, int y) {
    edge[x].push_back(y), edge[y].push_back(x);
}

inline void dfs1(int cur, int fa) {
    vis[cur] = true, dep[cur] = dep[fa] + 1;
    int s = 0;
    for (int p = 0; p < edge[cur].size(); ++p) {
        int v = edge[cur][p];
        if (v == fa) continue ;
        if (vis[v] && dep[v] < dep[cur]) {
            down[cur].push_back(v);
            if (down[cur].size() == 1) id[cnt++] = cur;
        }
        else if (!vis[v]) dfs1(v, cur); 
    }
}

inline void dfs(int cur) {
    vis[cur] = true;
    dp[cur][0] = 1, dp[cur][1] = 1;
    for (int p = 0; p < edge[cur].size(); ++p) {
        int v = edge[cur][p];
        if (!vis[v]) {
            dfs(v), dp[cur][1] = (long long)dp[cur][1] * dp[v][0] % mod;
            dp[cur][0] = (long long)dp[cur][0] * (dp[v][1] + dp[v][0]) % mod;
        }
    }
    if (mark[cur] != -1) dp[cur][mark[cur] ^ 1] = 0;
}

inline void solve() {
    R(n), R(m);
    long long ans = 0;
    for (int i = 1; i <= m; ++i) R(x), R(y), add_edge(x, y);
    dfs1(1, 0);
    for (int i = 1; i <= n; ++i) mark[i] = -1;
    for (int i = 0, end = (1 << cnt); i < end; ++i) {
        bool flag = true;
        for (int j = 0; j < cnt; ++j) {
            int pos = id[j];
            for (int k = 0; k < down[pos].size(); ++k) {
                int v = down[pos][k];
                mark[v] = -1;
            }
            mark[pos] = -1;
        }
        for (int j = 0; j < cnt; ++j)
            if (i & (1 << j)) {
                int pos = id[j];
                if (mark[pos] == 0) {
                    flag = false;
                    break ;
                } else mark[pos] = 1;
                for (int k = 0; k < down[pos].size(); ++k) { 
                    int v = down[pos][k];
                    if (mark[v] == 1) {
                        flag = false;
                        break ;
                    } else mark[v] = 0;
                }
            } else mark[id[j]] = 0;
        if (flag == false) continue ;
        for (int j = 1; j <= n; ++j) vis[j] = false;
        dfs(1), ans += dp[1][1] + dp[1][0];
    }
    std::cout << ans % mod;
}

int main() {
	clock_t start = clock();
    freopen("duliu.in", "r", stdin);
    freopen("duliu.out", "w", stdout);
    solve();
    std::cerr << clock() - start << '\n';
    return 0;
}

考虑优化，其实，这2d次DP的很多地方的转移是重复的，有所改变的只是非树边的端点位置的DP方式，那么我们可以将这些点建出虚树，然后直接统计虚树上每一条边的转移贡献，我们需要现在原树上DP出需要用的系数，定义g[x][0/1]表示f[x][0/1]的常数，即没有关键点的儿子的贡献，然后定义k[x][0/1][0/1]表示，x下面（包括儿子）的第一个关键点对于x的转移系数，用dp方程表示就是：

f[x][0] = k[x][0][0] * f[v][0] + k[x][0][1] * f[v][1]

f[x][1] = k[x][1][0] * f[v][0] + k[x][1][1] * f[v][1]

边界显然就是，对于一个关键点，

k[x][0][0] = k[x][1][1] = 1

k[x][1][0] = k[x][0][1] = 0

dp出k和g的值，直接在虚树转移即可。

 

Source:

/*
    created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>
#include <ctime>
#include <bitset>
 
inline char read() {
    static const int IN_LEN = 1024 * 1024;
    static char buf[IN_LEN], *s, *t;
    if (s == t) {
        t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
        if (s == t) return -1;
    }
    return *s++;
}
 
///*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = read(), iosig = false; !isdigit(c); c = read()) {
        if (c == -1) return ;
        if (c == '-') iosig = true; 
    }
    for (x = 0; isdigit(c); c = read()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN];
char *oh = obuf;
inline void write_char(char c) {
	if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
	*oh++ = c;
}


template<class T>
inline void W(T x) {
	static int buf[30], cnt;
	if (x == 0) write_char('0');
	else {
		if (x < 0) write_char('-'), x = -x;
		for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
		while (cnt) write_char(buf[cnt--]);
	}
}

inline void flush() {
	fwrite(obuf, 1, oh - obuf, stdout), oh = obuf;
}
 
/*
template<class T>
inline void R(T &x) {
    static char c;
    static bool iosig;
    for (c = getchar(), iosig = false; !isdigit(c); c = getchar())
        if (c == '-') iosig = true; 
    for (x = 0; isdigit(c); c = getchar()) 
        x = ((x << 2) + x << 1) + (c ^ '0');
    if (iosig) x = -x;
}
//*/

const int MAXN = 200000 + 10;
const int mod = 998244353;

int n, m, x, y, cnt;
std::vector<int> edge[MAXN];
int up[20], down[20], size[MAXN], dep[MAXN];
bool is_key[MAXN], ban[MAXN][2], vis[MAXN];
long long g[MAXN][2], f[MAXN][2];

struct node {
    long long x, y;
    node() {}
    node(long long x, long long y) : x(x), y(y) {}
    inline node operator + (const node &a) const {
        return node((x + a.x) % mod, (y + a.y) % mod);
    }

    inline node operator * (const long long &a) const {
        return node(x * a % mod, y * a % mod);
    }
} k[MAXN][2];

struct data {
    int to;
    node f0, f1;
    data() {}
    data(int to, node f0, node f1) : to(to), f0(f0), f1(f1) {}
} ;

std::vector<data> key[MAXN];

inline void add_edge(int x, int y) {
    edge[x].push_back(y), edge[y].push_back(x);
}

inline void dfs(int cur, int fa) {
    dep[cur] = dep[fa] + 1, vis[cur] = true;
    for (int p = 0; p < edge[cur].size(); ++p) {
        int v = edge[cur][p];
        if (v == fa) continue ;
        if (vis[v] && dep[v] < dep[cur]) {
            is_key[cur] = true, is_key[v] = true;
            down[cnt] = cur, up[cnt++] = v;
        } else if (!vis[v]) dfs(v, cur), size[cur] += size[v];
    }
    is_key[cur] |= (size[cur] >= 2);
    size[cur] = (size[cur] || is_key[cur]);
}

inline int pre_work(int cur) {
    int last = 0;
    vis[cur] = true, g[cur][0] = g[cur][1] = 1;
    for (int p = 0; p < edge[cur].size(); ++p) {
        int v = edge[cur][p];
        if (!vis[v]) {
            int temp = pre_work(v);
            if (last == 0) last = temp;
            if (temp == 0) {
                g[cur][0] = g[cur][0] * (g[v][1] + g[v][0]) % mod;
                g[cur][1] = g[cur][1] * g[v][0] % mod;
            } else if (is_key[cur]) 
                key[cur].push_back(data(temp, k[v][0] + k[v][1], k[v][0]));
            else k[cur][0] = k[v][0] + k[v][1], k[cur][1] = k[v][0];
        }
    }
    if (is_key[cur]) k[cur][0] = node(1, 0), k[cur][1] = node(0, 1), last = cur;
    else k[cur][0] = k[cur][0] * g[cur][0], k[cur][1] = k[cur][1] * g[cur][1];
    return last;
}

inline void dp(int cur) {
    f[cur][0] = (ban[cur][0] ^ 1) * g[cur][0];
    f[cur][1] = (ban[cur][1] ^ 1) * g[cur][1];
    for (int p = 0; p < key[cur].size(); ++p) {
        data *e = &key[cur][p];
        dp(e->to);
        f[cur][0] = f[cur][0] * (e->f0.x * f[e->to][0] % mod
                 + e->f0.y * f[e->to][1] % mod) % mod; 
        f[cur][1] = f[cur][1] * (e->f1.x * f[e->to][0] % mod
                 + e->f1.y * f[e->to][1] % mod) % mod;
    }
}

inline void read_in() {
    R(n), R(m);
    for (int i = 1; i <= m; ++i) R(x), R(y), add_edge(x, y);
}

inline void solve() {
    long long ans = 0;
    dfs(1, 0), is_key[1] = true, memset(vis, false, sizeof(vis)), pre_work(1);
    for (int i = 0, end = (1 << cnt); i < end; ++i) {
        for (int j = 0; j < cnt; ++j) {
            if (i & (1 << j)) ban[down[j]][0] = true, ban[up[j]][1] = true;
            else ban[down[j]][1] = true;
        }
        dp(1), ans += (f[1][0] + f[1][1]);
        for (int j = 0; j < cnt; ++j) {
            if (i & (1 << j)) ban[down[j]][0] = false, ban[up[j]][1] = false;
            else ban[down[j]][1] = false;
        }
    }
    std::cout << ans % mod;
}

int main() {
    // freopen("in.in", "r", stdin);
    // freopen("out.out", "w", stdout);
    read_in();
    solve();
    return 0;
}
scarlyw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
noi模拟题3
07-22
【压缩包子文件的文件名称列表】"BZOJ NoiRound 3"可能表示这是来自BZOJ（Blue Zoo Online Judge，一个在线编程评测系统）的NOI Round 3模拟题目集。BZOJ平台常用于信息学竞赛的训练，它提供了自动判题服务，用户...
NOI模拟（5.8） HNOID2T3 道路 （bzoj5290）
scarlyw的博客
05-09 308
记忆化搜索
[BZOJ5287][HNOI2018]毒瘤-虚树-动态规划
「嫌われ者のフィロソフィ」
04-17 1258
毒瘤 Description 从前有一名毒瘤。 毒瘤最近发现了量产毒瘤题的奥秘。考虑如下类型的数据结构题：给出一个数组，要求支持若干种奇奇怪怪的修改操作（比如区间加一个数，或者区间开平方），并支持询问区间和。毒瘤考虑了nnn 个这样的修改操作，并编号为111 ~nnn 。当毒瘤要出数据结构题的时候，他就将这些修改操作中选若干个出来，然后出成一道题。 当然了，这样出的题有可能不可做。通过...
[HNOI2018]毒瘤
BeNoble_的博客
04-22 1088
题意 求一幅图的最大独立集方案数 n≤105,n≤105,n\le10^5,满足非树边≤11≤11\le11条 AFOAFOAFO之后这篇题解搁了好久=.==.==.= 题解 1.1.1.考虑一棵树怎么做 和普通求独立集一样枚举这个点选不选然后用乘法原理计算即可 f[u][1]=f[u][1]*f[v][0]; f[u][0]=f[u][0]*(f[v][0]+f...
BZOJ5287 HNOI2018毒瘤
Rayment的博客
06-13 363
Problem BZOJ Solution 顾名思义，如果不是暴力分比较多，的确是一道很毒瘤的题。。 题面中所谓的联通操作就是保证互斥的连边后，是一个连通图。我们从树的状态考虑起。不妨设f[x][1/0]表示子树x中x选/不选时合法的方案数。 容易得到转移方程f[x][1]=∏f[son][0],f[x][0]=∏(f[son][0]+f[son][1])f[x][1]=∏f[son...
【HNOI 2018】毒瘤
洛水·锦依卫's Blog
03-21 289
【HNOI 2018】毒瘤 Problem Description 从前有一名毒瘤。 毒瘤最近发现了量产毒瘤题的奥秘。考虑如下类型的数据结构题：给出一个数组，要求支持若干种奇奇怪怪的修改操作（例如给一个区间内的数同时加上 \(c\)，或者将一个区间内的数同时开平方根），并且支持询问区间的和。毒瘤考虑了 \(n\) 个这样的修改操作,并将它们编号为 ...
noi模拟题1
07-22
【标题】"noi模拟题1"所指的是一场针对全国信息学奥林匹克（NOI）的模拟竞赛题目。NOI是中国青少年计算机程序设计竞赛的一项重要活动，旨在培养青少年的计算机编程技能和算法理解能力。这类模拟题通常由资深教练或...
noi模拟题4
07-23
【压缩包子文件的文件名称列表】"BZOJ NoiRound 4"可能表示这是一个在BZOJ（Blue Zoo Online Judge）平台上的NOI模拟赛第四轮的题目集。BZOJ是一个在线编程练习和竞赛平台，它提供编译器和测试系统，让用户可以提交...
noi模拟题5
07-23
【全国信息学奥林匹克模拟题5】是一场针对信息学竞赛选手的重要练习，通常在NOI（全国青少年信息学奥林匹克）之前进行，旨在帮助参赛者熟悉比赛环境和提高解题能力。"AFO后发福利"可能指的是某个知名的信息学竞赛...
noi模拟题2
07-22
压缩包内的"BZOJ NoiRound 2"可能是一个特定的子集或者一轮模拟比赛的名字，BZOJ（Blue Zoo Online Judge）是一个常见的在线编程评测系统，用于提交和测试代码。在这个子目录下，可能会有多个题目文件，每个文件都...
bzoj5287/洛谷P4426/loj2496 毒瘤 虚树+树形dp
litble的成(tui)长(fei)史
05-24 766
题目分析 首先orz一下 这是一道虽然不是数据结构，但也足够毒瘤了的毒瘤题。 原图应该是一棵树+若干非树边，题意转化为求独立集数量。 先考虑暴力做法，对于与非树边相连的点，我们暴力枚举它是选，还是不选。然后再跑一遍树形dp统计答案，方程显而易见： f[x][0]=f[x][0]*(f[son][0]+f[son[1]); f[x][1]=f[x][1]*f[son][0]; 当然这个...
bzoj5287 [Hnoi2018]毒瘤（树形dp+枚举+虚树）
Icefox的博客
06-07 408
求一张连通无向图的独立集个数。特点是边数-点数&lt;=11. 首先如何求一棵树的独立集个数呢？我们可以树形dp: f[x][0/1]表示x子树内不选/选根x的独立集个数。我们有转移: f[x][0]=∏(f[y][0]+f[y][1])f[x][0]=∏(f[y][0]+f[y][1])f[x][0]=\prod(f[y][0]+f[y][1]) f[x][1]=∏f[y][0]f[x]...
【JZOJ 5459】密室【最短路】
stoorz
09-15 331
题目大意： 题目链接：https://jzoj.net/senior/#main/show/5459 题目图片： http://wx1.sinaimg.cn/mw690/0060lm7Tly1fva78gse8vj30jc0fu3z6.jpg http://wx2.sinaimg.cn/mw690/0060lm7Tly1fva78grjjuj30jb072t8m.jpg http://w...
【HNOI2018】毒瘤
weixin_33860722的博客
03-14 118
【HNOI2018】毒瘤 设\(f_{v,0}\)表示\(v\)的子树中\(v\)不选的方案数，\(f_{v,1}\)表示\(v\)选的方案数。 显然 \[ f_{v,0}=\prod (f_{sn,0}+f_{sn,1})\\ f_{v,1}=\prod f_{sn,0} \] 我们可以写成矩阵乘法的形式 \[ \begin{bmatrix}f_{sn,0}& f_{sn,1}\...
NOI2020 瞎逛游记
smarthehe的博客
08-17 5157
NOI2020 游记 我是 BJ D 类，没实力的氪金选手。 Day -1 APIO 炸沉，此处略去不计。 下午 Mr_Wu 讲二分图讲得天花乱坠，体验极其欠佳，但是仍然学到很多。 Day 0 报道日。 一大早起来等火车，EI，xtq 等人陆续到来，压力爆满。 候车室分成北大附，人大附和十一的《三国》。八十中虽然只有两人，但拥有 cy 坐镇。 家长撮合了一波面基，但最终弱国无外交（ 座位与其他学校隔得有点远，火车上也失去了外交机会。 捣鼓了一大通总算到了学校，期间还有其他选手上同一辆车坐我旁边然后把我认错了
优秀而强行的十进制快速幂
scarlyw的博客
04-14 3077
十进制快速幂 & 快速幂
NOIP赛前总结
scarlyw的博客
11-16 1136
NOIP赛前总结 基础算法： ·（o）排序 ·（?）贪心（注意每一次写拍，验证思想） ·（o）二分答案（注意边界，对拍验证，自己出极值） ·（o）逆序对（树状数组） ·（o）离散化（排序） ·（?）倍增（注意使用的范围和方法） ·（?）三分答案   数学问题： ·（o）公约数&公倍数 ·（X）素数问题+莫比乌斯+欧拉函数（线筛板子） ·（o）gcd & ext_gcd（
中国剩余定理学习总结
scarlyw的博客
04-14 916
中国剩余定理
欧拉回路学习总结
scarlyw的博客
01-29 745
欧拉回路学习总结   理解： 设G = (V, E)是一个图。 欧拉回路 图G中经过每条边一次并且仅一次的回路称作欧拉回路。 欧拉路径 图G中经过每条边一次并且仅一次的路径称作欧拉路径。 欧拉图 存在欧拉回路的图称为欧拉图。 半欧拉图 存在欧拉路径但不存在欧拉回路的图称为半欧拉图。   思想：  首先明确一点，如果原图存在孤立点，那么我们去除孤立点不会对答案有所影响，然后我们
NOI比赛专用平台：NOI Linux详解
"NOI系列比赛平台NOI Linux是一款专为NOI（全国青少年信息学奥林匹克竞赛）设计的定制化操作系统，旨在提供一个统一、标准化的竞赛环境，消除因平台差异导致的评分不公。该系统由NOI科学委员会授权，由评测小组基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值