Maximum difference of count of black and white vertices in a path containing vertex V
Last Updated :
27 Mar, 2023
Given a Tree with N vertices and N – 1 edge where the vertices are numbered from 0 to N – 1, and a vertex V present in the tree. It is given that each vertex in the tree has a color assigned to it which is either white or black and the respective colors of the vertices are represented by an array arr[]. The task is to find the maximum difference between the number of white-colored vertices and the number of black colored vertices from any possible subtree from the given tree that contains the given vertex V.
Examples:
Input: V = 0,
arr[] = {'b', 'w', 'w', 'w', 'b',
'b', 'b', 'b', 'w'}
Tree:
0 b
/ \
/ \
1 w 2 w
/ / \
/ / \
5 b w 3 4 b
| | |
| | |
7 b b 6 8 w
Output: 2
Explanation:
We can take the subtree
containing the vertex 0
which contains vertices
0, 1, 2, 3 such that
the difference between
the number of white
and the number of black vertices
is maximum which is equal to 2.
Input:
V = 2,
arr[] = {'b', 'b', 'w', 'b'}
Tree:
0 b
/ | \
/ | \
1 2 3
b w b
Output: 1
Approach: The idea is to use the concept of dynamic programming to solve this problem.
- Firstly, make a vector for color array and for white color, push 1 and for black color, push -1.
- Make an array dp[] to calculate the maximum possible difference between the number of white and black vertices in some subtree containing the vertex V.
- Now, traverse through the tree using depth first search traversal and update the values in dp[] array.
- Finally, the minimum value present in the dp[] array is the required answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class tree {
vector< int > dp;
vector<vector< int > > g;
vector< int > c;
public :
tree( int n)
{
dp = vector< int >(n);
g = vector<vector< int > >(n);
c = vector< int >(n);
}
void addEdge( int u, int v)
{
g[u].push_back(v);
g[v].push_back(u);
}
void dfs( int v, int p = -1)
{
dp[v] = c[v];
for ( auto i : g[v]) {
if (i == p)
continue ;
dfs(i, v);
dp[v] += max(0, dp[i]);
}
}
void maximumDifference( int v,
char color[],
int n)
{
for ( int i = 0; i < n; i++) {
if (color[i] == 'w' )
c[i] = 1;
else
c[i] = -1;
}
dfs(v);
cout << dp[v] << "\n" ;
}
};
int main()
{
tree t(9);
t.addEdge(0, 1);
t.addEdge(0, 2);
t.addEdge(2, 3);
t.addEdge(2, 4);
t.addEdge(1, 5);
t.addEdge(3, 6);
t.addEdge(5, 7);
t.addEdge(4, 8);
int V = 0;
char color[] = { 'b' , 'w' , 'w' ,
'w' , 'b' , 'b' ,
'b' , 'b' , 'w' };
t.maximumDifference(V, color, 9);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int []dp;
static Vector<Integer> []g;
static int [] c;
GFG( int n)
{
dp = new int [n];
g = new Vector[n];
for ( int i = 0 ; i < g.length; i++)
g[i] = new Vector<Integer>();
c = new int [n];
}
void addEdge( int u, int v)
{
g[u].add(v);
g[v].add(u);
}
static void dfs( int v, int p)
{
dp[v] = c[v];
for ( int i : g[v])
{
if (i == p)
continue ;
dfs(i, v);
dp[v] += Math.max( 0 , dp[i]);
}
}
void maximumDifference( int v,
char color[],
int n)
{
for ( int i = 0 ; i < n; i++)
{
if (color[i] == 'w' )
c[i] = 1 ;
else
c[i] = - 1 ;
}
dfs(v, - 1 );
System.out.print(dp[v] + "\n" );
}
public static void main(String[] args)
{
GFG t = new GFG( 9 );
t.addEdge( 0 , 1 );
t.addEdge( 0 , 2 );
t.addEdge( 2 , 3 );
t.addEdge( 2 , 4 );
t.addEdge( 1 , 5 );
t.addEdge( 3 , 6 );
t.addEdge( 5 , 7 );
t.addEdge( 4 , 8 );
int V = 0 ;
char color[] = { 'b' , 'w' , 'w' ,
'w' , 'b' , 'b' ,
'b' , 'b' , 'w' };
t.maximumDifference(V, color, 9 );
}
}
|
Python3
def addEdge(g, u, v):
g[u].append(v)
g[v].append(u)
def dfs(v, p, dp, c, g):
dp[v] = c[v]
for i in g[v]:
if i = = p:
continue
dfs(i, v, dp, c, g)
dp[v] + = max ( 0 , dp[i])
def maximumDifference(v, color, n, dp, c, g):
for i in range (n):
if (color[i] = = 'w' ):
c[i] = 1
else :
c[i] = - 1
dfs(v, - 1 , dp, c, g)
print (dp[v])
n = 9
g = {}
dp = [ 0 ] * n
c = [ 0 ] * n
for i in range ( 0 , n + 1 ):
g[i] = []
addEdge(g, 0 , 1 )
addEdge(g, 0 , 2 )
addEdge(g, 2 , 2 )
addEdge(g, 2 , 4 )
addEdge(g, 1 , 5 )
addEdge(g, 3 , 6 )
addEdge(g, 5 , 7 )
addEdge(g, 4 , 8 )
V = 0
color = [ 'b' , 'w' , 'w' ,
'w' , 'b' , 'b' ,
'b' , 'b' , 'w' ]
maximumDifference(V, color, 9 , dp, c, g)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int []dp;
static List< int > []g;
static int [] c;
GFG( int n)
{
dp = new int [n];
g = new List< int >[n];
for ( int i = 0; i < g.Length; i++)
g[i] = new List< int >();
c = new int [n];
}
void addEdge( int u, int v)
{
g[u].Add(v);
g[v].Add(u);
}
static void dfs( int v, int p)
{
dp[v] = c[v];
foreach ( int i in g[v])
{
if (i == p)
continue ;
dfs(i, v);
dp[v] += Math.Max(0, dp[i]);
}
}
void maximumDifference( int v,
char []color,
int n)
{
for ( int i = 0; i < n; i++)
{
if (color[i] == 'w' )
c[i] = 1;
else
c[i] = -1;
}
dfs(v, -1);
Console.Write(dp[v] + "\n" );
}
public static void Main(String[] args)
{
GFG t = new GFG(9);
t.addEdge(0, 1);
t.addEdge(0, 2);
t.addEdge(2, 3);
t.addEdge(2, 4);
t.addEdge(1, 5);
t.addEdge(3, 6);
t.addEdge(5, 7);
t.addEdge(4, 8);
int V = 0;
char []color = { 'b' , 'w' , 'w' ,
'w' , 'b' , 'b' ,
'b' , 'b' , 'w' };
t.maximumDifference(V, color, 9);
}
}
|
Javascript
<script>
let n = 9;
let dp = new Array(n);
let g = new Array(n);
let c = new Array(n);
for (let i = 0; i < g.length; i++)
g[i] = [];
function addEdge(u, v)
{
g[u].push(v);
g[v].push(u);
}
function dfs(v, p)
{
dp[v] = c[v];
for (let i = 0; i < g[v].length; i++)
{
if (g[v][i] == p)
continue ;
dfs(g[v][i], v);
dp[v] += Math.max(0, dp[g[v][i]]);
}
}
function maximumDifference(v, color, n)
{
for (let i = 0; i < n; i++)
{
if (color[i] == 'w' )
c[i] = 1;
else
c[i] = -1;
}
dfs(v, -1);
document.write(dp[v] + "</br>" );
}
addEdge(0, 1);
addEdge(0, 2);
addEdge(2, 3);
addEdge(2, 4);
addEdge(1, 5);
addEdge(3, 6);
addEdge(5, 7);
addEdge(4, 8);
let V = 0;
let color = [ 'b' , 'w' , 'w' ,
'w' , 'b' , 'b' ,
'b' , 'b' , 'w' ];
maximumDifference(V, color, 9);
</script>
|
Time Complexity: O(N), where N is the number of vertices in the tree.
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...