Open In App

Count maximum possible number of draws in a match between two people

Last Updated : 31 Jan, 2022
Improve
Improve
Like Article
Like
Save
Share
Report

Given an array of pairs v[][] of size N which shows the score of the match at N instances where (v[i][0], v[i][1]) shows a score equivalent to (p, q) of 2 players at that moment. After a goal is made score would change to (p+1: q) or (p: q+1). The task is to find the maximum number of times a draw can occur during the whole match.

Note: The last score denotes the final result of the match.  The score is provided in increasing order as time increases.

Examples:

Input: N = 3, v[][] = {{2, 0},  {3, 1}, {3, 4}}
Output: 2
Explanation: Possible scores in the match would be
0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4
Now,  0:0 and 3:3 are two scores leading to draw. 
Thus, answer = 2.

Input: N = 1, v[][] = {{5, 4}} 
Output: 5
Explanation: Possible scores in the match would be 
0:0, 0:1, 1:1, 1:2, 2:2, 2:3, 3:3, 3:4, 4:4, 5:4  
Now, 0:0, 1:1, 2:2, 3:3 and 4:4 are five scores leading to draw. 
Thus, answer = 5.

 

Approach: Assuming a score (p, q) and (r, s). Put in between pairs (x, x) as much as possible. This x needs to be in such a way that :
 p ≤ x ≤ r and q ≤ x ≤ s, thus max(p, q) ≤ x ≤ min(r, s). So, just count number of such x. Follow the steps below to solve the problem:

  • Initialize pairs p1[] and p2[].
  • Initialize the variables draws as 1 and diff as 0.
  • Iterate over the range [0, N) using the variable i and perform the following tasks:
    • Set p2 as v[i].
    • If p1.first is the same as p1.second then decrease the value of draws by 1.
    • Set diff as min(p2.first, p2.second) – max(p1.first, p1.second) + 1.
    • If diff is greater than 0 then increase the value of draws by diff.
    • Set the value of p1 as p2.
  • After performing the above steps, print the value of draws as the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Utility Function
void solve(int& N,
           vector<pair<int, int> > v)
{
 
    // Initializing pair for input and
    // one for starting position {0, 0}
    pair<int, int> p1, p2;
 
    int draws = 1, diff = 0;
    p1 = make_pair(0, 0);
 
    for (int i = 0; i < N; i++) {
        p2 = v[i];
 
        // Reduce if found a draw situation
        if (p1.first == p1.second) {
            draws--;
        }
 
        // Calculation for possible
        // values for x would be
        // min(r, s) - max(p, q) + 1
        diff = min(p2.first, p2.second)
               - max(p1.first, p1.second)
               + 1;
 
        // If possible value found,
        // add to our answer
        if (diff > 0) {
            draws += diff;
        }
 
        // In end, update previous pair
        // to new pair
        p1 = p2;
    }
    cout << draws;
}
 
// Driver Code
int main()
{
    int N = 1;
    vector<pair<int, int> > v = { { 5, 4 } };
 
    solve(N, v);
    return 0;
}


Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
// User defined Pair class
class Pair {
  int x;
  int y;
 
  // Constructor
  public Pair(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
 
class GFG {
 
  // Utility Function
  static void solve(int N, Pair v[])
  {
 
    // Initializing pair for input and
    // one for starting position {0, 0}
    Pair p1 = new Pair(0,0);
 
    int draws = 1, diff = 0;
    p1.x = 0;
    p1.y = 0;
 
    for (int i = 0; i < N; i++) {
      Pair p2 = new Pair(v[i].x, v[i].y);
 
      // Reduce if found a draw situation
      if (p1.x == p1.y) {
        draws--;
      }
 
      // Calculation for possible
      // values for x would be
      // min(r, s) - max(p, q) + 1
      diff = Math.min(p2.x, p2.y)
        - Math.max(p1.x, p1.y)
        + 1;
 
      // If possible value found,
      // add to our answer
      if (diff > 0) {
        draws += diff;
      }
 
      // In end, update previous pair
      // to new pair
      p1 = p2;
    }
    System.out.print(draws);
  }
 
  // Driver Code
  public static void main (String[] args) {
    int n = 1;
    Pair arr[] = new Pair[n];
    arr[0] = new Pair(5, 4);
 
    solve(n, arr);
  }
}
 
// This code is contributed by hrithikgarg03188.


Python3




# Python code for the above approach
 
# Utility Function
def solve(N, v):
 
    # Initializing pair for input and
    # one for starting position {0, 0}
    draws = 1
    diff = 0;
    p1 = { "first": 0, "second": 0 };
 
    for i in range(N):
        p2 = v[i];
 
        # Reduce if found a draw situation
        if (p1["first"] == p1["second"]):
            draws -= 1
 
        # Calculation for possible
        # values for x would be
        # min(r, s) - max(p, q) + 1
        diff = min(p2["first"], p2["second"]) - max(p1["first"], p1["second"]) + 1;
 
        # If possible value found,
        # add to our answer
        if (diff > 0):
            draws += diff;
     
 
        # In end, update previous pair
        # to new pair
        p1 = p2;
     
    print(draws);
     
# Driver Code
N = 1;
v = [{ "first": 5, "second": 4 }];
 
solve(N, v);
 
# This code is contributed by Saurabh Jaiswal


C#




// C# program for the above approach
using System;
 
// User defined Pair class
class Pair {
  public int x;
  public int y;
 
  // Constructor
  public Pair(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
 
public class GFG {
 
  // Utility Function
  static void solve(int N, Pair []v)
  {
 
    // Initializing pair for input and
    // one for starting position {0, 0}
    Pair p1 = new Pair(0,0);
 
    int draws = 1, diff = 0;
    p1.x = 0;
    p1.y = 0;
 
    for (int i = 0; i < N; i++) {
      Pair p2 = new Pair(v[i].x, v[i].y);
 
      // Reduce if found a draw situation
      if (p1.x == p1.y) {
        draws--;
      }
 
      // Calculation for possible
      // values for x would be
      // min(r, s) - max(p, q) + 1
      diff = Math.Min(p2.x, p2.y)
        - Math.Max(p1.x, p1.y)
        + 1;
 
      // If possible value found,
      // add to our answer
      if (diff > 0) {
        draws += diff;
      }
 
      // In end, update previous pair
      // to new pair
      p1 = p2;
    }
    Console.Write(draws);
  }
 
  // Driver Code
  public static void Main(String[] args) {
    int n = 1;
    Pair []arr = new Pair[n];
    arr[0] = new Pair(5, 4);
 
    solve(n, arr);
  }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
       // JavaScript code for the above approach
 
       // Utility Function
       function solve(N,
           v) {
 
           // Initializing pair for input and
           // one for starting position {0, 0}
           let p1, p2;
 
           let draws = 1, diff = 0;
           p1 = { first: 0, second: 0 };
 
           for (let i = 0; i < N; i++) {
               p2 = v[i];
 
               // Reduce if found a draw situation
               if (p1.first == p1.second) {
                   draws--;
               }
 
               // Calculation for possible
               // values for x would be
               // min(r, s) - max(p, q) + 1
               diff = Math.min(p2.first, p2.second)
                   - Math.max(p1.first, p1.second)
                   + 1;
 
               // If possible value found,
               // add to our answer
               if (diff > 0) {
                   draws += diff;
               }
 
               // In end, update previous pair
               // to new pair
               p1 = p2;
           }
           document.write(draws);
       }
 
       // Driver Code
       let N = 1;
       let v = [{ first: 5, second: 4 }];
 
       solve(N, v);
 
      // This code is contributed by Potta Lokesh
   </script>


 
 

Output

5

 

Time Complexity: O(N)
Auxiliary Space: O(1)

 



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads