给定一棵树，子树的代价定义为| S | * AND(S)其中| S |是子树的大小，AND(S)是子树中所有节点索引的按位与，任务是找到可能的子树的最大成本。
先决条件：不交集集合
例子：
Input : Number of nodes = 4
Edges = (1, 2), (3, 4), (1, 3)
Output : Maximum cost = 4
Explanation :
Subtree with singe node {4} gives the maximum cost.
Input : Number of nodes = 6
Edges = (1, 2), (2, 3), (3, 4), (3, 5), (5, 6)
Output : Maximum cost = 8
Explanation :
Subtree with nodes {5, 6} gives the maximum cost.方法：策略是修复AND，并找到子树的最大大小，以使所有索引的AND等于给定的AND。假设我们将AND固定为“ A”。在A的二进制表示中，如果第i个位为“ 1”，则所需子树的所有索引(节点)在二进制表示中的第i个位置应为“ 1”。如果第i个位为“ 0”，则索引在第i个位置具有“ 0”或“ 1”。这意味着子树的所有元素都是A的超级掩码。A的所有超级掩码都可以在O(2 ^ k)时间内生成，其中“ k”是A中“ 0”的位数。
现在，可以使用树上的DSU找到具有给定AND“ A”的子树的最大大小。假设“ u”是A的超级掩码，“ p [u]”是u的父代。如果p [u]也是A的超级掩码，那么我们必须通过合并u和p [u]的分量来更新DSU。同时，我们还必须跟踪子树的最大大小。 DSU可以帮助我们做到这一点。如果我们看下面的代码，将会更加清楚。
CPP
// CPP code to find maximum possible cost
#include
using namespace std;
#define N 100010
// Edge structure
struct Edge {
int u, v;
};
/* v : Adjacency list representation of Graph
p : stores parents of nodes */
vector v[N];
int p[N];
// Weighted union-find with path compression
struct wunionfind {
int id[N], sz[N];
void initial(int n)
{
for (int i = 1; i <= n; i++)
id[i] = i, sz[i] = 1;
}
int Root(int idx)
{
int i = idx;
while (i != id[i])
id[i] = id[id[i]], i = id[i];
return i;
}
void Union(int a, int b)
{
int i = Root(a), j = Root(b);
if (i != j) {
if (sz[i] >= sz[j]) {
id[j] = i, sz[i] += sz[j];
sz[j] = 0;
}
else {
id[i] = j, sz[j] += sz[i];
sz[i] = 0;
}
}
}
};
wunionfind W;
// DFS is called to generate parent of
// a node from adjacency list representation
void dfs(int u, int parent)
{
for (int i = 0; i < v[u].size(); i++) {
int j = v[u][i];
if (j != parent) {
p[j] = u;
dfs(j, u);
}
}
}
// Utility function for Union
int UnionUtil(int n)
{
int ans = 0;
// Fixed 'i' as AND
for (int i = 1; i <= n; i++) {
int maxi = 1;
// Generating supermasks of 'i'
for (int x = i; x <= n; x = (i | (x + 1))) {
int y = p[x];
// Checking whether p[x] is
// also a supermask of i.
if ((y & i) == i) {
W.Union(x, y);
// Keep track of maximum
// size of subtree
maxi = max(maxi, W.sz[W.Root(x)]);
}
}
// Storing maximum cost of
// subtree with a given AND
ans = max(ans, maxi * i);
// Separating components which are merged
// during Union operation for next AND value.
for (int x = i; x <= n; x = (i | (x + 1))) {
W.sz[x] = 1;
W.id[x] = x;
}
}
return ans;
}
// Driver code
int main()
{
int n, i;
// Number of nodes
n = 6;
W.initial(n);
Edge e[] = { { 1, 2 }, { 2, 3 }, { 3, 4 },
{ 3, 5 }, { 5, 6 } };
int q = sizeof(e) / sizeof(e[0]);
// Taking edges as input and put
// them in adjacency list representation
for (i = 0; i < q; i++) {
int x, y;
x = e[i].u, y = e[i].v;
v[x].push_back(y);
v[y].push_back(x);
}
// Initializing parent vertex of '1' as '1'
p[1] = 1;
// Call DFS to generate 'p' array
dfs(1, -1);
int ans = UnionUtil(n);
printf("Maximum Cost = %d\n", ans);
return 0;
} Python3
# Python3 code to find maximum possible cost
N = 100010
# Edge structure
class Edge:
def __init__(self, u, v):
self.u = u
self.v = v
''' v : Adjacency list representation of Graph
p : stores parents of nodes '''
v=[[] for i in range(N)];
p=[0 for i in range(N)];
# Weighted union-find with path compression
class wunionfind:
def __init__(self):
self.id = [0 for i in range(1, N + 1)]
self.sz = [0 for i in range(1, N + 1)]
def initial(self, n):
for i in range(1, n + 1):
self.id[i] = i
self.sz[i] = 1
def Root(self, idx):
i = idx;
while (i != self.id[i]):
self.id[i] = self.id[self.id[i]]
i = self.id[i];
return i;
def Union(self, a, b):
i = self.Root(a)
j = self.Root(b);
if (i != j):
if (self.sz[i] >= self.sz[j]):
self.id[j] = i
self.sz[i] += self.sz[j];
self.sz[j] = 0;
else:
self.id[i] = j
self.sz[j] += self.sz[i];
self.sz[i] = 0
W = wunionfind()
# DFS is called to generate parent of
# a node from adjacency list representation
def dfs(u, parent):
for i in range(0, len(v[u])):
j = v[u][i];
if(j != parent):
p[j] = u;
dfs(j, u);
# Utility function for Union
def UnionUtil(n):
ans = 0;
# Fixed 'i' as AND
for i in range(1, n + 1):
maxi = 1;
# Generating supermasks of 'i'
x = i
while x<=n:
y = p[x];
# Checking whether p[x] is
# also a supermask of i.
if ((y & i) == i):
W.Union(x, y);
# Keep track of maximum
# size of subtree
maxi = max(maxi, W.sz[W.Root(x)]);
x = (i | (x + 1))
# Storing maximum cost of
# subtree with a given AND
ans = max(ans, maxi * i);
# Separating components which are merged
# during Union operation for next AND value.
x = i
while x <= n:
W.sz[x] = 1;
W.id[x] = x;
x = (i | (x + 1))
return ans;
# Driver code
if __name__=='__main__':
# Number of nodes
n = 6;
W.initial(n);
e = [ Edge( 1, 2 ), Edge( 2, 3 ), Edge( 3, 4 ),
Edge( 3, 5 ), Edge( 5, 6 ) ];
q = len(e)
# Taking edges as input and put
# them in adjacency list representation
for i in range(q):
x = e[i].u
y = e[i].v;
v[x].append(y);
v[y].append(x);
# Initializing parent vertex of '1' as '1'
p[1] = 1;
# Call DFS to generate 'p' array
dfs(1, -1);
ans = UnionUtil(n);
print("Maximum Cost =", ans)
# This code is contributed by rutvik_56输出：
Maximum Cost = 8时间复杂度： DSU中的联合需要O(1)时间。生成所有超级掩码需要O(3 ^ k)时间，其中k是最大位数“ 0”。 DFS取O(n)。总时间复杂度为O(3 ^ k + n)。