# Check which player visits more number of Nodes

Given a tree with **N** nodes. Two players **A** and **B** start from node **1** and node **N** respectively. **A** can visit all the adjacent nodes to the nodes already visited by **A** but can not visit any nodes which is already visited by **B** and similarly for **B** also.

The player who visits more cities win. Find the player who wins if they both play optimally.

**Examples:**

Input:Output:A wins

**Approach: **The optimal solution is that both the Player starts visiting the nodes which lie in the path connecting node **1** and node **N**. This is because one player cannot visit the nodes already visited by another player so each player will try to limit the number of nodes that can be visited by another player. Then it will be easy to count the number of nodes that can be visited by each player and find out the winner.

The DFS will be use to find out the path between two nodes and mark them one by one like 1 or 2, 1 for A and 2 for B and then mark all the adjacent unvisited nodes with the respective value and then calculate the count of nodes of A and B.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Vector to store Tree ` `vector<vector<` `int` `> > graph; ` ` ` `// To check if there ` `// is path or not ` `int` `found = 0, n; ` ` ` `// Path and temporary vector ` `vector<` `int` `> path, temp; ` ` ` `// Count of A and B ` `int` `c_A = 0, c_B = 0; ` ` ` `// Function to find the path connecting 1 to n ` `void` `find(` `int` `i, ` `int` `prev) ` `{ ` ` ` `// Push the ith node ` ` ` `temp.push_back(i); ` ` ` ` ` `// If we reached our destination ` ` ` `if` `(i == n) { ` ` ` `path = (temp); ` ` ` `return` `; ` ` ` `} ` ` ` `for` `(` `int` `j = 0; j < graph[i].size(); j++) ` ` ` `if` `(graph[i][j] != prev) { ` ` ` ` ` `// Dfs for its children ` ` ` `find(graph[i][j], i); ` ` ` `} ` ` ` ` ` `// Remove the node ` ` ` `temp.pop_back(); ` `} ` ` ` `// Function to mark all the adjacent ` `// unvisited nodes ` `void` `mark(` `int` `i, ` `int` `visited[], ` `int` `c) ` `{ ` ` ` `if` `(!visited[i]) { ` ` ` ` ` `// Increase the count ` ` ` `if` `(c == 1) ` ` ` `c_A++; ` ` ` `else` ` ` `c_B++; ` ` ` `} ` ` ` ` ` `visited[i] = c; ` ` ` ` ` `// Increase the count ` ` ` `if` `(c == 1) ` ` ` `c_A++; ` ` ` `else` ` ` `c_B++; ` ` ` ` ` `// Dfs for all its unvisted adjacent nodes ` ` ` `for` `(` `int` `j = 0; j < graph[i].size(); j++) ` ` ` `if` `(!visited[graph[i][j]]) ` ` ` `mark(graph[i][j], visited, c); ` `} ` ` ` `// Function to find the winner among the players ` `void` `findWinner() ` `{ ` ` ` `// Finds the path ` ` ` `find(1, -1); ` ` ` ` ` `int` `visited[n + 1] = { 0 }; ` ` ` ` ` `for` `(` `int` `i = 0; i < path.size(); i++) { ` ` ` ` ` `// Mark nodes visited by ` ` ` `// A as 1 and B as 2 ` ` ` `if` `(i < ` `ceil` `(path.size() / 2.0)) ` ` ` `visited[path[i]] = 1, c_A++; ` ` ` `else` ` ` `visited[path[i]] = 2, c_B++; ` ` ` `} ` ` ` ` ` `// Mark all the adjacent unvisted nodes ` ` ` `for` `(` `int` `i = 0; i < path.size(); i++) ` ` ` `mark(path[i], ` ` ` `visited, ` ` ` `visited[path[i]]); ` ` ` ` ` `if` `(c_A > c_B) ` ` ` `cout << ` `"A wins"` `; ` ` ` `else` `if` `(c_A < c_B) ` ` ` `cout << ` `"B wins"` `; ` ` ` `else` ` ` `cout << ` `"Draw"` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `n = 7; ` ` ` `graph.clear(); ` ` ` `graph.resize(n + 1); ` ` ` ` ` `// Graph ` ` ` `graph[6].push_back(4); ` ` ` `graph[4].push_back(6); ` ` ` `graph[6].push_back(5); ` ` ` `graph[5].push_back(6); ` ` ` `graph[5].push_back(7); ` ` ` `graph[7].push_back(5); ` ` ` `graph[5].push_back(2); ` ` ` `graph[2].push_back(5); ` ` ` `graph[3].push_back(4); ` ` ` `graph[4].push_back(3); ` ` ` `graph[1].push_back(4); ` ` ` `graph[4].push_back(1); ` ` ` ` ` `findWinner(); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the above approach ` `from` `math ` `import` `ceil, floor ` ` ` `# Vector to store Tree ` `graph ` `=` `[[] ` `for` `i ` `in` `range` `(` `1000` `)] ` ` ` `# To check if there ` `# is path or not ` `found ` `=` `0` `n ` `=` `0` ` ` `# Path and temporary vector ` `path ` `=` `[] ` `temp ` `=` `[] ` ` ` `# Count of A and B ` `c_A ` `=` `0` `c_B ` `=` `0` ` ` `# Function to find the path connecting 1 to n ` `def` `find(i, prev): ` ` ` `global` `c_A, c_B, path ` ` ` ` ` `# Push the ith node ` ` ` `temp.append(i) ` ` ` ` ` `# If we reached our destination ` ` ` `if` `(i ` `=` `=` `n): ` ` ` `path ` `=` `temp ` ` ` `return` ` ` ` ` `for` `j ` `in` `graph[i]: ` ` ` `if` `j !` `=` `prev: ` ` ` ` ` `# Dfs for its children ` ` ` `find(j, i) ` ` ` ` ` `# Remove the node ` ` ` `del` `temp[` `-` `1` `] ` ` ` `# Function to mark all the adjacent ` `# unvisited nodes ` `def` `mark(i, visited, c): ` ` ` `global` `c_B, c_A ` ` ` ` ` `if` `visited[i] ` `=` `=` `0` `: ` ` ` ` ` `# Increase the count ` ` ` `if` `(c ` `=` `=` `1` `): ` ` ` `c_A ` `+` `=` `1` ` ` `else` `: ` ` ` `c_B ` `+` `=` `1` ` ` ` ` `visited[i] ` `=` `c ` ` ` ` ` `# Increase the count ` ` ` `if` `(c ` `=` `=` `1` `): ` ` ` `c_A ` `+` `=` `1` ` ` `else` `: ` ` ` `c_B ` `+` `=` `1` ` ` ` ` `# Dfs for all its unvisted adjacent nodes ` ` ` `for` `j ` `in` `graph[i]: ` ` ` `if` `(visited[j] ` `=` `=` `0` `): ` ` ` `mark(j, visited, c) ` ` ` `# Function to find the winner among the players ` `def` `findWinner(): ` ` ` `global` `c_B, c_A, path ` ` ` ` ` `# Finds the path ` ` ` `find(` `1` `, ` `-` `1` `) ` ` ` ` ` `visited ` `=` `[` `0` `for` `i ` `in` `range` `(n ` `+` `1` `)] ` ` ` ` ` `for` `i ` `in` `range` `(` `len` `(path)): ` ` ` ` ` `# Mark nodes visited by ` ` ` `# A as 1 and B as 2 ` ` ` `if` `(i < ceil(` `len` `(path) ` `/` `2.0` `)): ` ` ` `visited[path[i]] ` `=` `1` ` ` `c_A ` `+` `=` `1` ` ` `else` `: ` ` ` `visited[path[i]] ` `=` `2` ` ` `c_B ` `+` `=` `1` ` ` ` ` `# Mark all the adjacent unvisted nodes ` ` ` `for` `i ` `in` `path: ` ` ` `mark(i, visited, visited[i]) ` ` ` ` ` `if` `(c_A > c_B): ` ` ` `print` `(` `"A wins"` `) ` ` ` `elif` `(c_A < c_B): ` ` ` `print` `(` `"B wins"` `) ` ` ` `else` `: ` ` ` `print` `(` `"Draw"` `) ` ` ` `# Driver code ` `n ` `=` `7` ` ` `# Graph ` `graph[` `6` `].append(` `4` `) ` `graph[` `4` `].append(` `6` `) ` `graph[` `6` `].append(` `5` `) ` `graph[` `5` `].append(` `6` `) ` `graph[` `5` `].append(` `7` `) ` `graph[` `7` `].append(` `5` `) ` `graph[` `5` `].append(` `2` `) ` `graph[` `2` `].append(` `5` `) ` `graph[` `3` `].append(` `4` `) ` `graph[` `4` `].append(` `3` `) ` `graph[` `1` `].append(` `4` `) ` `graph[` `4` `].append(` `1` `) ` ` ` `findWinner() ` ` ` `# This code is contributed by Mohit Kumar ` |

*chevron_right*

*filter_none*

**Output:**

A wins

## Recommended Posts:

- Print levels with odd number of nodes and even number of nodes
- Check if two nodes are on same path in a tree
- Check whether the given node is in the path between the nodes U and V
- Check if two nodes are in same subtree of the root node
- Check if two nodes are cousins in a Binary Tree | Set-2
- Check if two nodes are cousins in a Binary Tree
- Check if two nodes in a Binary Tree are siblings
- Check sum of Covered and Uncovered nodes of Binary Tree
- Queries to check if the path between two nodes in a tree is a palindrome
- Given a n-ary tree, count number of nodes which have more number of children than parents
- Check if given path between two nodes of a graph represents a shortest paths
- Print all the levels with odd and even number of nodes in it | Set-2
- Calculate number of nodes in all subtrees | Using DFS
- Level with maximum number of nodes
- Number of nodes greater than a given value in n-ary tree

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.