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 similary 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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


Output:

A wins


My Personal Notes arrow_drop_up

Second year Department of Information Technology Jadavpur University

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.



Improved By : mohit kumar 29



Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.