获胜者最多玩的游戏

有 N 个玩家正在参加比赛。我们需要找到获胜者可以玩的最大游戏数。在本次比赛中，只有当他们玩的游戏之间的差异不超过一场时，才允许两名玩家互相比赛。
例子：

Input  : N = 3
Output : 2
Maximum games winner can play = 2
Assume that player are P1, P2 and P3
First, two players will play let (P1, P2)
Now winner will play against P3, 
making total games played by winner = 2

Input  : N = 4
Output : 2
Maximum games winner can play = 2
Assume that player are P1, P2, P3 and P4
First two pairs will play lets (P1, P2) and 
(P3, P4). Now winner of these two games will 
play against each other, making total games
played by winner = 2

我们可以通过首先计算所需的最小玩家数量来解决这个问题，这样获胜者将玩 x 场比赛。一旦计算出来，实际问题就与此相反。现在假设 dp[i] 表示所需的最少玩家人数，以便获胜者进行 i 场比赛。我们可以写出 dp 值之间的递归关系，
dp[i + 1] = dp[i] + dp[i – 1] 因为如果亚军已经打了 (i – 1) 场比赛，获胜者已经打了 i 场比赛，并且他们打过比赛的所有球员都不相交，总共获胜者的比赛将是这两组球员的加法。
上面的递归关系可以写成 dp[i] = dp[i – 1] + dp[i – 2]
这与斐波那契级数关系相同，因此我们的最终答案将是小于或等于输入中给定玩家人数的最大斐波纳契数的索引。

C++

// C/C++ program to find maximum number of
// games played by winner
#include 
using namespace std;
 
// method returns maximum games a winner needs
// to play in N-player tournament
int maxGameByWinner(int N)
{
    int dp[N];
 
    // for 0 games, 1 player is needed
    // for 1 game, 2 players are required
    dp[0] = 1;   
    dp[1] = 2;
     
    // loop until i-th Fibonacci number is 
    // less than or equal to N
    int i = 2;
    do {
        dp[i] = dp[i - 1] + dp[i - 2];
    } while (dp[i++] <= N);
 
    // result is (i - 2) because i will be
    // incremented one extra in while loop
    // and we want the last value which is
    // smaller than N, so one more decrement
    return (i - 2);
}
 
// Driver code to test above methods
int main()
{
    int N = 10;
    cout << maxGameByWinner(N) << endl;
    return 0;
}

Java

// Java program to find maximum number of
// games played by winner
class Max_game_winner {
 
    // method returns maximum games a winner needs
    // to play in N-player tournament
    static int maxGameByWinner(int N)
    {
        int[] dp = new int[N];
      
        // for 0 games, 1 player is needed
        // for 1 game, 2 players are required
        dp[0] = 1;   
        dp[1] = 2;
          
        // loop until i-th Fibonacci number is 
        // less than or equal to N
        int i = 2;
        do {
            dp[i] = dp[i - 1] + dp[i - 2];
        } while (dp[i++] <= N);
      
        // result is (i - 2) because i will be
        // incremented one extra in while loop
        // and we want the last value which is
        // smaller than N, so one more decrement
        return (i - 2);
    }
      
    // Driver code to test above methods
    public static void main(String args[])
    {
        int N = 10;
        System.out.println(maxGameByWinner(N));
    }
}
//This code is contributed by Sumit Ghosh

Python3

# Python3 program to find maximum
# number of games played by winner
 
# method returns maximum games
# a winner needs to play in
# N-player tournament
 
def maxGameByWinner(N):
    dp = [0 for i in range(N)]
     
    # for 0 games, 1 player is needed
    # for 1 game, 2 players are required
    dp[0] = 1
    dp[1] = 2
     
    # loop until i-th Fibonacci
    # number is less than or
    # equal to N
    i = 1
    while dp[i] <= N:
        i = i + 1
        dp[i] = dp[i - 1] + dp[i - 2]
         
    # result is (i - 1) because i will be
    # incremented one extra in while loop
    # and we want the last value which is
    # smaller than N, so
    return (i - 1)
 
# Driver code
N = 10
print(maxGameByWinner(N))
 
# This code is contributed
# by sahilshelangia

C#

// C# program to find maximum number
// of games played by winner
using System;
 
class GFG {
     
    // method returns maximum games a
    // winner needs to play in N-player
    // tournament
    static int maxGameByWinner(int N)
    {
        int[] dp = new int[N];
     
        // for 0 games, 1 player is needed
        // for 1 game, 2 players are required
        dp[0] = 1;
        dp[1] = 2;
         
        // loop until i-th Fibonacci number
        // is less than or equal to N
        int i = 2;
         
        do {
            dp[i] = dp[i - 1] + dp[i - 2];
        } while (dp[i++] <= N);
     
        // result is (i - 2) because i will be
        // incremented one extra in while loop
        // and we want the last value which is
        // smaller than N, so one more decrement
        return (i - 2);
    }
     
    // Driver code
    public static void Main()
    {
        int N = 10;
        Console.Write(maxGameByWinner(N));
    }
}
 
// This code is contributed by Nitin Mittal.

Javascript

 
// Javascript program to find maximum number of
// games played by winner
 
    // method returns maximum games a winner needs
    // to play in N-player tournament
    function maxGameByWinner(N)
    {
        let dp = new Array(N).fill(0);
        
        // for 0 games, 1 player is needed
        // for 1 game, 2 players are required
        dp[0] = 1;   
        dp[1] = 2;
            
        // loop until i-th Fibonacci number is 
        // less than or equal to N
        let i = 2;
        do {
            dp[i] = dp[i - 1] + dp[i - 2];
        } while (dp[i++] <= N);
        
        // result is (i - 2) because i will be
        // incremented one extra in while loop
        // and we want the last value which is
        // smaller than N, so one more decrement
        return (i - 2);
    }
 
// driver program
     
        let N = 10;
        document.write(maxGameByWinner(N));
 
// This code is contributed by code_hunt.

输出 ：

4

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。