[codeforces1187E]Tree Painting

本文探讨了一种基于树形结构的游戏策略优化问题,通过两次深度优先搜索(DFS)算法,实现了对有根树中节点染色过程的最大得分计算。文章详细介绍了问题背景、解决思路及具体实现代码,旨在最大化玩家在特定游戏规则下的得分。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

time limit per test : 2 seconds
memory limit per test : 256 megabytes

You are given a tree (an undirected connected acyclic graph) consisting of nnn vertices. You are playing a game on this tree.

Initially all vertices are white. On the first turn of the game you choose one vertex and paint it black. Then on each turn you choose a white vertex adjacent (connected by an edge) to any black vertex and paint it black.

Each time when you choose a vertex (even during the first turn), you gain the number of points equal to the size of the connected component consisting only of white vertices that contains the chosen vertex. The game ends when all vertices are painted black.

Let’s see the following example:
在这里插入图片描述
Vertices 111 and 444 are painted black already. If you choose the vertex 222, you will gain 444 points for the connected component consisting of vertices 222,333,555 and 666. If you choose the vertex 999, you will gain 333 points for the connected component consisting of vertices 777,888 and 999.
Your task is to maximize the number of points you gain.

Input

The first line contains an integer nnn — the number of vertices in the tree (2≤n≤2⋅105)(2≤n≤2⋅10^5)(2n2105).

Each of the next n−1n−1n1 lines describes an edge of the tree. Edge iii is denoted by two integers uiu_iui and viv_ivi, the indices of vertices it connects (1≤ui,vi≤n,ui≠vi)(1≤u_i,v_i≤n, ui≠vi)(1ui,vin,ui̸=vi).It is guaranteed that the given edges form a tree.

Output

Print one integer — the maximum number of points you gain if you will play optimally.

Examples
Input

9
1 2
2 3
2 5
2 6
1 4
4 9
9 7
9 8

Output

36

Input

5
1 2
1 3
2 4
2 5

Output

14

Note

The first example tree is shown in the problem statement.

题目:
刚开始给定一个树,节点都是白色的,你需要做n次操作让他所有节点都变成黑色的。操作的定义如下:
第一次操作选取一个白色节点染成黑色
除了第一次操作外,每次操作选取一个白色的、与至少一个黑色节点相邻的节点,将其染成黑色,每次次操作的得分是当前操作被染色的节点所在的白色节点联通块的大小。

求出n次操作之后的最大可能总得分

题解:
我们发现,这个其实是一个给有根树定根的操作,根就是第一次染色的点,然后答案就是以这个点为根的树上所有子树的大小之和。
两次dfs计算即可。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll ans;
int n;
int sz[200004],du[200004];
struct edge{
    int to,nt;
}e[400004];
int ne,h[200004];
void add(int u,int v){
    e[++ne].to=v;e[ne].nt=h[u];h[u]=ne;
}
void dfs(int x,int fa){
    sz[x]=1;
    for(int i=h[x];i;i=e[i].nt){
        if(e[i].to==fa)continue;
        dfs(e[i].to,x);
        sz[x]+=sz[e[i].to];
    }
    ans+=sz[x];
}
void calc(int x,int fa,ll now){
    ans=max(ans,now);
    for(int i=h[x];i;i=e[i].nt){
        if(e[i].to==fa)continue;
        calc(e[i].to,x,now+n-2LL*sz[e[i].to]);
    }
}
int main(){
    memset(du,0,sizeof(du));
    memset(h,0,sizeof(h));
    ne=0;
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int u,v;scanf("%d%d",&u,&v);
        ++du[u];++du[v];
        add(u,v);add(v,u);
    }
    dfs(1,0);
    calc(1,0,ans);
    printf("%lld\n",ans);
    return 0;
}
### Codeforces 887E Problem Solution and Discussion The problem **887E - The Great Game** on Codeforces involves a strategic game between two players who take turns to perform operations under specific rules. To tackle this challenge effectively, understanding both dynamic programming (DP) techniques and bitwise manipulation is crucial. #### Dynamic Programming Approach One effective method to approach this problem utilizes DP with memoization. By defining `dp[i][j]` as the optimal result when starting from state `(i,j)` where `i` represents current position and `j` indicates some status flag related to previous moves: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = ...; // Define based on constraints int dp[MAXN][2]; // Function to calculate minimum steps using top-down DP int minSteps(int pos, bool prevMoveType) { if (pos >= N) return 0; if (dp[pos][prevMoveType] != -1) return dp[pos][prevMoveType]; int res = INT_MAX; // Try all possible next positions and update 'res' for (...) { /* Logic here */ } dp[pos][prevMoveType] = res; return res; } ``` This code snippet outlines how one might structure a solution involving recursive calls combined with caching results through an array named `dp`. #### Bitwise Operations Insight Another critical aspect lies within efficiently handling large integers via bitwise operators instead of arithmetic ones whenever applicable. This optimization can significantly reduce computation time especially given tight limits often found in competitive coding challenges like those hosted by platforms such as Codeforces[^1]. For detailed discussions about similar problems or more insights into solving strategies specifically tailored towards contest preparation, visiting forums dedicated to algorithmic contests would be beneficial. Websites associated directly with Codeforces offer rich resources including editorials written after each round which provide comprehensive explanations alongside alternative approaches taken by successful contestants during live events. --related questions-- 1. What are common pitfalls encountered while implementing dynamic programming solutions? 2. How does bit manipulation improve performance in algorithms dealing with integer values? 3. Can you recommend any online communities focused on discussing competitive programming tactics? 4. Are there particular patterns that frequently appear across different levels of difficulty within Codeforces contests?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值