NOIP模拟题 2016.11.10 [模拟] [状压DP] [线段树] [DFS序]

最新推荐文章于 2024-11-06 06:35:51 发布
最新推荐文章于 2024-11-06 06:35:51 发布
阅读量747 收藏
点赞数
分类专栏： NOIP模拟题 动态规划 状压dp 线段树 dfs序 文章标签： NOIP模拟题 状压DP 动态规划 线段树 DFS序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ourfutr2330/article/details/53114354
版权

A
Statement
给出一个长度不超过100只包含’B’和’R’的字符串，将其无限重复下去。
比如，BBRB则会形成
BBRBBBRBBBRB
现在给出一个区间[l,r]询问该区间内有多少个字符’B’(区间下标从1开始)
Input
第一行为一个只包含’B’和’R’的字符串
第二行为两个整数，表示l和r
Output
输出[l,r]区间内字符’B’的数量
Sample Input
BBRB
4 8
Sample Output
4
Limit
1<=|S|<=100(字符串长度大于等于1，小于等于100)
1<=i<=r<=1e18

模拟，前缀和相减。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 105;
char s[maxn];
int sum[maxn];
LL L,R;
int n;
LL calc(LL x)
{
    LL ret = sum[n] * (x/n);
    ret += sum[x%n];
    return ret;
}
int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    scanf("%s"AUTO AUTO,s+1,&L,&R);
    n = strlen(s+1);
    for(int i=1;i<=n;i++) sum[i] = sum[i-1] + (s[i]=='B');
    LL ans = calc(R) - calc(L-1);
    printf(AUTO,ans);
    return 0;
}

B
【题目描述】
我们要从n种食物选m个出来，安排一个顺序吃掉它（们），每种食物有个美味值ai，然后我们有k个规则，每个规则有 xi, yi 和 ci三个数，如果吃完第xi种食物接下来马上吃第yi种食物，第j种食物的美味值会增加ci。每种食物至多吃一个，求美味值最大的和是多少？
【输入格式】
第一行有三个数n,m,k,k代表有k个规则(0<=k<=n*(n-1))。
第二行有n个数字代表每个食物的美味值。
接下去有k行，每行三个数xi,yi,ci。保证没有任意两个规则的xi和yi同时相同。
【输出格式】
一行一个数代表答案
【sample input1】
2 2 1
1 1
2 1 1
【sample output1】
3
【sample input 2】
4 3 2
1 2 3 4
2 1 5
3 4 2
【sample output 2】
12
【数据范围】
30% m<=n<=5 ,0<=ci,ai<=1e5
100% m<=n<=18，0<=ci,ai<=1e9

数据范围剧透题解类型。。
状压DP
dp(S,i)表示已经选了的集合为S，最后一个选的是i的最大价值。
方程 ：dp[S+{i}][i] = dp[S][j] + a[i] + g[j][i] ， 其中 j 属于 S ，i 不属于S
每次如果S中1的个数为m，就更新答案。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int maxS = (1<<18) + 5;
const int maxn = 20;
int a[maxn];
int g[maxn][maxn];
LL dp[maxS][maxn];
int n,m,k;
inline void init()
{
    read(n); read(m); read(k);
    for(int i=0;i<n;i++) read(a[i]);
    for(int i=1;i<=k;i++)
    {
        int x,y,c;
        read(x); read(y); read(c);
        x--; y--;
        g[x][y] += c;
    }
}
LL dynamic()
{
    LL ans = 0;
    for(int i=0;i<n;i++) dp[(1<<i)][i] = a[i];
    for(int S=1;S<(1<<n);S++)
        if(__builtin_popcount(S) == m)
            for(int i=0;i<n;i++)
                if(S&(1<<i)) smax(ans,dp[S][i]);
                else continue;
        else
            for(int i=0;i<n;i++) if(!(S&(1<<i))) // haven't been eaten
                for(int j=0;j<n;j++) if(S&(1<<j)) // the last one
                    smax(dp[S|(1<<i)][i],dp[S][j]+a[i]+g[j][i]);
    return ans;
}
int main()
{
    freopen("b.in","r",stdin);
    freopen("b.out","w",stdout);
    init();
    LL ans = dynamic();
    printf(AUTO,ans);
    return 0;
}

C
【题目描述】
历史上有一个著名的王国。它的所有城市互相连通并且构成一棵树。城市1
为首都也就是这棵树的根。
因为外来的入侵，国王决定在某些城市加派士兵。所有城市初始士兵数量
为0。当城市i 被加派了k 名士兵时。城市i 的所有子城市需要被加派k+1 名士
兵。这些子城市的所有子城市需要被加派k+2 名士兵。以此类推。
当然，加派士兵的同时，国王也需要不断了解当前的情况。于是他随时可
能询问以城市i 为根的子树中的所有城市共被加派了多少士兵。
你现在是国王的军事大臣，你能回答出国王的每个询问么？
【输入】
第一行，包含两个整数N,P 代表城市数量以及国王的命令的数量。
接下来的P 行，每行代表国王的一个命令，命令分两种
A X K 在城市X 加入K 个士兵
Q X 询问以城市X 为根的子树中所有士兵数量的和
【输出】
对于每个Q，输出答案。
【输入样例】
7 10
1 1 2 2 5 5
Q 1
A 2 1
Q 1
Q 2
Q 5
A 5 0
Q 5
A 3 1
Q 1
Q 2
【输出样例】
0
11
11
8
10
14
13
【数据范围】
对于50%的数据， 1<=N<=1000 1<=P<=300
对于100%的数据， 1<=N<=50000 1<=P<=100000 1<=X<=N 0<=K<=1000

50%：直接在节点做标记，每次查询时下传即可。考虑到树的形状不是平衡的，直接这样做肯定要T

100%：
每次操作都是对一个子树的操作，很容易想到在dfs序中区间修改和标记下传，这样就可以保证nlogn的时间复杂度了。
但是每个子树的修改时不一样的，新操作一次的贡献是k+depth[v]-depth[u]，由于depth[v]是节点本身的性质，而k-depth[u]是这次操作的性质，那么可以考虑分成两部分来求解。
假设某个节点被操作了tot次（包括它的父亲的操作），那么这部分的贡献是tot*depth[v]，对于一个子树来说，这部分总的贡献就是tot*Sigma(depth[v])。
再来处理操作的贡献。每一个节点都是k-depth[u]，那么子树的贡献就是size*Sigma(k-depth[u])
这两部分分别用线段树来维护即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
//end template

const int INF=0x3f3f3f3f;
const int maxn = 50005;

// original tree related
struct Edge
{
    int to,next;
}edge[maxn<<1];
int head[maxn];
int maxedge;
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
    edge[++maxedge] = (Edge) { u,head[v] };
    head[v] = maxedge;
}
int maxnode;
int id[maxn]; // from dfn to original node id
int pre[maxn],post[maxn]; // two dfs_clocks
int depth[maxn];
void dfs(int u,int father,int deep)
{
    depth[u] = deep;
    pre[u] = ++maxnode;
    id[maxnode] = u;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == father) continue;
        dfs(v,u,deep+1);
    }
    post[u] = maxnode;
}
// end original tree

// segment tree related
struct Node
{
    LL dep,tot,sum_tot; // sum of depth[v] , total add (lazy) , sum part 1
    LL delta,size,sum_delta; // sum of delta , total nodes (lazy) , sum part 2
}node[maxn<<2];
#define dep(x) node[x].dep
#define tot(x) node[x].tot
#define sum_tot(x) node[x].sum_tot
#define delta(x) node[x].delta
#define size(x) node[x].size
#define sum_delta(x) node[x].sum_delta
inline void add_tot(int root,LL val)
{
    tot(root) += val;
    sum_tot(root) += val * dep(root);
}
inline void add_delta(int root,LL val)
{
    delta(root) += val;
    sum_delta(root) += val * size(root);
}
inline void pushdown_tot(int root)
{
    if(!tot(root)) return;
    add_tot(root<<1,tot(root));
    add_tot(root<<1|1,tot(root));
    tot(root) = 0;
}
inline void pushdown_delta(int root)
{
    if(!delta(root)) return;
    add_delta(root<<1,delta(root));
    add_delta(root<<1|1,delta(root));
    delta(root) = 0;
}
inline void update_tot(int root) { sum_tot(root) = sum_tot(root<<1) + sum_tot(root<<1|1); }
inline void update_delta(int root) { sum_delta(root) = sum_delta(root<<1) + sum_delta(root<<1|1); }
void modify_tot(int root,int l,int r,int x,int y,LL val)
{
    if(x<=l && r<=y)
    {
        add_tot(root,val);
        return;
    }
    pushdown_tot(root);
    int mid = (l+r)>>1;
    if(x<=mid && l<=y) modify_tot(root<<1,l,mid,x,y,val);
    if(y>=mid+1 && r>=x) modify_tot(root<<1|1,mid+1,r,x,y,val);
    update_tot(root);
}
void modify_delta(int root,int l,int r,int x,int y,LL val)
{
    if(x<=l && r<=y)
    {
        add_delta(root,val);
        return;
    }
    pushdown_delta(root);
    int mid = (l+r)>>1;
    if(x<=mid && l<=y) modify_delta(root<<1,l,mid,x,y,val);
    if(y>=mid+1 && r>=x) modify_delta(root<<1|1,mid+1,r,x,y,val);
    update_delta(root);
}
LL query(int root,int l,int r,int x,int y)
{
    if(x<=l && r<=y) return sum_tot(root)+sum_delta(root);
    pushdown_tot(root); pushdown_delta(root);
    int mid = (l+r)>>1;
    LL ret = 0;
    if(x<=mid && l<=y) ret += query(root<<1,l,mid,x,y);
    if(y>=mid+1 && r>=x) ret += query(root<<1|1,mid+1,r,x,y);
    return ret;
}
inline void update(int root)
{
    dep(root) = dep(root<<1) + dep(root<<1|1);
    size(root) = size(root<<1) + size(root<<1|1);
}
void build(int root,int l,int r)
{
    if(l == r)
    {
        dep(root) = depth[id[l]];
        size(root) = 1;
        return;
    }
    int mid = (l+r)>>1;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
    update(root);
}
// end segment tree

// main
int n,q,Root;
inline void init()
{
    memset(head,-1,sizeof(head)); maxedge=-1;
    read(n); read(q); Root=1;
    for(int i=2;i<=n;i++)
    {
        int to;
        read(to);
        addedge(i,to);
    }
    dfs(Root,-1,1);
    build(1,1,n);
}
void work()
{
    for(int i=1;i<=q;i++)
    {
        char ch = (char) getchar();
        while(!isalpha(ch)) ch = (char) getchar();
        int x,k;
        read(x);
        if(ch == 'Q')
        {
            LL ans = query(1,1,n,pre[x],post[x]);
            printf(AUTO,ans);
            putchar('\n');
        }
        else
        {
            read(k);
            modify_tot(1,1,n,pre[x],post[x],1);
            modify_delta(1,1,n,pre[x],post[x],k-depth[x]);
        }
    }
}
int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);
    init();
    work();
    return 0;
}
NOIP模拟题 2016.11.9 [动态规划] [数论] [二分答案] [启发式合并] [线段树] [树链剖分]
C'est la vie.
11-09 1115
子序列 描述 给定3 个字符串，求它们的最长公共子序列。 输入 第一行一个整数n，表示三个字符串的长度 接下来三行，每行是一个长度为n 只包含小写字母的字符串。 输出 输出最长公共子序列的长度。 输入样例 4 abac abbc cbca 输出样例 2 提示 30% n<=10 100% n<=120T1： 三个串的LCS。。直接DP。。#include<iost
jzoj2020.06.06【NOIP提高组】模拟
jay_zai的博客
06-06 629
好久没打博客了~~~~~ 趁着改完题就搞一搞（话说最近的题都好淼 ） T1 The Bovine Shuffle Description FJ 坚信快乐的牛可以产出更多的牛奶，因此 FJ 在牛棚里安装了一个巨大的迪斯科球并且打算让奶牛们学会跳舞。 FJ在许多出名的奶牛舞中选择了一种叫做 Bovine Shuffle 的舞蹈。这种舞蹈由 FJ 的 N 头奶牛组成。N头奶牛以一种顺序排成一行，接着表演数次 shuffle。每次的 shuffle 会将奶牛重新排列。FJ 为了让奶牛们更加快乐，让奶牛们更容易找到重
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
NOIP模拟 偷书（状压DP）
weixin_30920513的博客
10-01 83
【题目描述】 在L的书架上，有 N本精彩绝伦的书籍，每本书价值不菲。 M 是一个书籍爱好者，他对 L 的书籍早就垂涎三尺。最后他忍受不了诱惑，觉得去偷 L 的书，为了迅速完成这件事，同时他不希望 L 很快发现书籍少了，他决定偷书时，对于任意连续的 k 本书，他最多选 B 本，最少选 A 本。现在他想知道怎么选出来的书本最后使得偷的书籍的价值和，与剩下的书籍价值...
选点(巧妙的dfs序dp)
jziwjxjd的博客
11-07 389
传送门 注意一下这两句话 如果选了根节点的话，在这棵子树内选的其他的点都要比根节点的值大； 如果在左子树选了一个点，在右子树中选的其他点要比它小。 根节点比子节点都要小 右子树比左子树都要大 所以可以跑dfsdfsdfs序维护最长上升子序列来写 #include <bits/stdc++.h> using namespace std; const int maxn = 2e5+10; int n,l[maxn],r[maxn],a[maxn],id,top,w[maxn],ans[maxn];
BZOJ - 2654 ZJOI 三色二叉树 DFS序 树形DP
Lazer2001
07-05 4386
大家都很强， 可与之共勉 。1864: [Zjoi2006]三色二叉树Time Limit: 1 Sec Memory Limit: 64 MB DescriptionInput仅有一行，不超过500000个字符，表示一个二叉树序列。Output输出文件也只有一行，包含两个数，依次表示最多和最少有多少个点能够被染成绿色。Sample Input1122002010Sample Output5 2
dfs序+线性dp 树
不知所云的博客
05-09 367
题目描述 shy有一颗树，树有n个结点。有k种不同颜色的染料给树染色。一个染色方案是合法的，当且仅当对于所有相同颜色的点对(x,y)，x到y的路径上的所有点的颜色都要与x和y相同。请统计方案数。 输入描述: 第一行两个整数n，k代表点数和颜色数； 接下来n-1行，每行两个整数x,y表示x与y之间存在一条边； 输出描述: 输出一个整数表示方案数（mod 1e9+7）。 看上去是树形dp； 这题要是没想到把树上问题转化为dfs序是很难做的出来的； 转化为dfs序，就是一道线性dp，dp[i][j]表示前 i
11.5 NOIP模拟赛题解
xiebohang的博客
11-06 728
若他们处于不同的集合中，且其中一个集合中包含1，那么就把另一个集合所有点的掉落时间改为t，再把它们合并；根据“手松开”这一特点，我们可以使用“时光倒流法”，按照时间顺序从后往前处理，将松开手转化为抓住，将分开两个集合转化为合并两个集合。这道题还是挺好的，题面改编的也好，今天晚上整体的题目还是挺有水平的，这道题就是贪心+排序+枚举。设我们有四块饼干，温度分别为958，42195，114514，5201314，那么两种方案分别为。区间的长度是固定的，是个滑窗问题，做到了。贪心WA了，wc，这是道假的贪心，
论蒟蒻是怎样作死的（noip模拟赛心得&易错总结）
lanshuizhiyun
11-01 467
作为一名蒟蒻oier…… 蒟蒻，俗称魔芋，全株有毒，以块茎为最，不可生吃，需加工后方可食用。 （手动滑稽） sort() 从不写 #include<algorithm> memset() 从不写#include<cstring> 从不关心是否 爆 int，从不开 long long 双向边 和 线段树 从来只开一倍大小 求 Lcm 总是先乘后除爆 long long 导致 RE DP
NOIP NOI 信息学竞赛 ACM-ICPC POJ（北京大学在线评测系统）刷题推荐 OI复习计划 算法大纲
10-04
11. **线段树**（Segment Tree） 线段树用于区间查询和更新，如2352、2528等。 12. **计算几何**（Computational Geometry） 包括点、线、面的几何运算，如1113、1292、2148等，1113是凸包算法的基础题。 13. **...
树形DP+DFS序+树状数组 HDOJ 5293 Tree chain problem（树链问题）
weixin_34419326的博客
07-18 135
题目链接 题意： 　　有n个点的一棵树。其中树上有m条已知的链，每条链有一个权值。从中选出任意个不相交的链使得链的权值和最大。 思路： 　　树形DP。设dp[i]表示i的子树下的最优权值和，sum[i]表示不考虑i点时子树的最优权值和，即（j是i的儿子），显然dp[i]>=sum[i]。那么问题是考虑i点时dp[i]的值是多少，假设有一条链通过i，且端点a和b都在i的子树里，即...
【DFS序】【数学+前缀和】【DP+容斥原理】Day 8.26
weixin_30652879的博客
08-26 98
第一次用LaTeX T1 判断树上两节点间的父子关系 这道题恰好是我以前给自己出的题，没想到这次居然真的碰上了 大部分人都用LCA来做，但是我有更好的方法$O(n)$ DFS的时候标记每个节点的DFS序$dfn[i]$，再标记该节点的子树中所有点的DFS序最大值$sub[i]$ 如果$dfn[y]<dfn[x]\leq sub[y]$，那么说明x在y的子树中 1 #inc...
回滚树形dp（按dfs序dp）——hdu6035
weixin_30878501的博客
07-17 212
本题前面的操作别的博客里都有。难点在于颜色ci的贡献，如何一次dfs求出答案 先来考虑如何在一次dfs中单独对颜色i进行计算 　　用遍历dfs序的方式，在深搜过程中，碰到带有颜色 i 的点u，u每个颜色不为i的子节点v都会贡献一个联通块， 　　v的贡献的联通块大小是size[v]-sum{v中层次最高的以颜色i的结点为根的子树大小} 　　那我们要先求出v中层次最高的以颜色i的结点为根的子...
【分数规划+DFS序上DP】BZOJ4753 [Jsoi2016]最佳团体
linkfqy
12-24 675
题面在这里这个题一看就要二分吧……然后可以用DP验证其实就是树上取最大和但是如果定义不好的话会被卡常……可以DFS序上DP，常数较小fi,jf_{i,j}表示DFS序上前i-1个点，取了j个的最大值然后fi,j→fi+1,j+1 (取i) f_{i,j} \rightarrow f_{i+1,j+1} \text{ } \tag {取i} fi,j→fout(i),j (不取i) f_
牛客练习赛1 树 dp + dfs序
黑丝太白的博客
04-09 295
题目链接 题解： 一开始考虑树形DP自底向上更新发现儿子多的时候情况太多，无法考虑。 可以按照dfs序对树上的点一个个进行染色。这样对一个节点x进行染色的时候，它的父亲节点已经被染色了。 定义状态dp[i][j]dp[i][j]dp[i][j]为dfs序中前iii个节点用jjj种颜色染色有多少种方案。 对于第iii个结点进行染色时有两种选择： 选择前i−1i - 1i−1个结点已经用过的颜色。那...
hdu_5293_Tree chain problem(DFS序+树形DP+LCA)
bin_gege的博客
06-28 427
题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=5293 被这题打蹦了，看着题解写的，很是爆炸，确实想不到，我用的DFS序+LCA+树形DP，当然也可以写树剖，不过这里DFS序更简单，因为都是对点到根的操作 #include #include #include #pragma comment(linker, "/STACK:102400000,10
[二分+DFS序上DP]BZOJ 4753—— [Jsoi2016]最佳团体
CHN_JZ的博客
12-05 849
题目梗概题目给定一棵树，选K个节点。任意节点满足如果它被选其父亲也必须被选。使得价值与花费之比最大。解题思路这类题目显然是要二分的。最初的想法，在树上进行左儿子右父亲DP合并，这样每次check的效率是O(n^2)。但是怎么卡就是不过（我下面给出的就是树上合并的代码）。我将其归结为常数过大，记住其效率是稳定的。因此引进DFS序上DP，可以想象常数极小。fi,jf_{i,j}表示DFS序的前i个选择j
dfs序 & 欧拉序
yo_bc的博客
05-29 1161
dfs序：s[u]: dfs时进入u节点子树时的时间戳;s[v]: dfs时离开u节点子树时的时间戳.欧拉序：E[i]: 第i时间访问到的节点R[u]: 节点u被访问到的第一时间Question：给定树形图，然后q次询问，问点u是否是点v的父节点。Answer：通过dfs序判断v节点的时间区间是否在u节点的时间区间内。通过欧拉序判断u和v的最近公共祖先是否是u。Code1：#include &lt...
【dfn序+DP】树
weixin_62528401的博客
05-22 1013
我们会发现，如果我们按dfn序涂色，在涂每一个点之前，他的父亲祖父等祖先节点肯定都已经先涂过了（这些点的dfn序都比当前点小），他的兄弟节点（也包括各种或近或远的“堂兄弟”节点）和兄弟节点的子树也许也涂过一些。涂这个点无非是两种选择：涂一种新的颜色，或者涂一种已经用过的颜色。而涂一种已经用过的颜色的话，这个点的颜色必须和他父亲的颜色一样，因为这个点到之前的所有点的路径都是要经过它父亲的，如果他和父亲不同色，他和他同色那个点的路径上就不可能所有点颜色都一样，至少他父亲就是不同的。由于有限制：只能用K种颜色。
NOIP2024T3的题解
最新发布
02-27
NOIP是全国青少年信息学奥林匹克联赛，2024年的题目目前还没有发布，所以用户可能指的是某个模拟题或者往年的题目，或者是笔误。我需要先确认这一点。 首先，我应该检查是否存在NOIP2024的题目。由于现在是2023年，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值