我尝试了所有可能的组合来通过测试用例，但没有成功。我只通过了一个测试用例，即示例一

Question

泰森已经为贝布莱德世界锦标赛做好了准备。锦标赛以团队为基础，每个团队可以有N名成员。一个玩家只能与一个玩家战斗。G-Revolution团队非常兴奋，因为他们已经进行了大量练习。G-Revolution团队的负责人肯尼创建了一个数据库，在那里他有关于其他团队成员和自己团队成员力量的数据。比赛将在一段时间后开始，肯尼在比赛前搬到自助餐厅吃点心。

G革命团队将在一段时间内战斗，当有人从自助餐厅绑架肯尼时，他们变得紧张起来。他们向警方投诉，警方正在寻找肯尼。幸运的是，他们找到了他的设备和所有数据。问题是，数据是随机出现的，而不是按照他们与对手战斗的顺序出现的。G革命团队想要不惜任何代价获胜，为此，他们需要最佳战斗顺序来赢得最大数量的战斗。

一个玩家只有当他/她的魔剑力量严格大于对手的魔剑力量时才能获胜。

示例：假设团队规模为3，N=3。两个团队的3名球员都显示了他们的beyblade力量。G-Revolution团队按顺序呈现：Tyson、Max、Ray团队All Starz按顺序呈现：Michael、Eddy、Steve按照给定的安排，G-Revolution团队只能赢得1场比赛。G-Revolution团队应按以下最佳方式重组：

当G-Revolution团队按最优顺序排列或战斗时，他们可以赢得的最大战斗次数为2次。

G-Revolution团队需要该设备的帮助。泰森听说了你的技能，并打电话给你，帮助他们按顺序洗牌，以便他们能够赢得最多的战斗次数。你能帮助泰森和G-Revolution团队吗？

输入格式输入的第一行由测试用例的数量T组成

每个测试用例的第一行由每个团队可以拥有的成员数量N组成。

每个测试用例的第二行由N个空格分隔的整数组成，这些整数表示G-Revolution团队成员的beybleads的幂。

每个测试用例的第三行由N个空格分隔的整数组成，代表对手团队成员的力量。

Constraints
1<= T <=100000
1<= N <=100000
0<= Power of Beyblade <= LLONG_MAX 

输出格式对于每个测试用例，打印G-Revolution团队以最佳方式战斗时可以赢得的最大战斗次数。

示例测试用例1

Input
1
10
3 6 7 5 3 5 6 2 9 1 
2 7 0 9 3 6 0 6 2 6 
Output
7

代码：

import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.Arrays;

public class CandidateCode {
    private static int testCase = 0;
    private static int numOfMembers = 0;
    private static int gRevolutionTeamSize = 0;
    private static int opponentTeamSize = 0;
    private static int numOfGRevolutionWins = 0;
    private static final Integer initial_Index = 0;
    private static final Integer second_Index = 1;
    private static final Integer third_Index = 2;
    private static final Integer fourth_Index = 3;
    private static final Integer noOfIndex = 4;
    private static final Integer testNumber = 100000;
    private static String[] powerOpponentTeamArr = null;
    private static String[] powerGRevolutionTeamArr = null;

    public static void main(String args[] ) throws Exception {
        List<Integer> gRevolutionWinsList = new ArrayList<Integer>();
        Scanner scan = new Scanner(System.in);
        String[] input = new String[noOfIndex];
        try{
            for(int i = 0; i < input.length; i++){
                input[i] = scan.nextLine();
            }
            if (!validateInput(input[initial_Index],input[second_Index])) {
                System.exit(initial_Index);
            }
        }
        catch(Exception ex){
        }
        finally{
            scan.close();
        }

        testCase = Integer.parseInt(input[initial_Index]);

        numOfMembers = Integer.parseInt(input[second_Index]);

        String gRevolutionMembers = input[third_Index];
        powerGRevolutionTeamArr = gRevolutionMembers.split(" ");

        String opponentMembers = input[fourth_Index];
        powerOpponentTeamArr = opponentMembers.split(" ");

        gRevolutionTeamSize = powerGRevolutionTeamArr.length;
        long[] totalGRevolutionTeamArr = new long[gRevolutionTeamSize];
        for (int i = 0; i < gRevolutionTeamSize; i++){
            totalGRevolutionTeamArr[i] = Long.parseLong(powerGRevolutionTeamArr[i]);
            validateInputPower(totalGRevolutionTeamArr[i]);
        }

        opponentTeamSize = powerOpponentTeamArr.length;
        long[] totalOpponentTeamArr = new long[opponentTeamSize];
        for (int i = 0; i < opponentTeamSize; i++){
            totalOpponentTeamArr[i] = Long.parseLong(powerOpponentTeamArr[i]);
            validateInputPower(totalOpponentTeamArr[i]);
        }

        Arrays.sort(totalGRevolutionTeamArr);
        Arrays.sort(totalOpponentTeamArr);

        for(int i = 0; i < numOfMembers; i++){
            if((totalGRevolutionTeamArr[i] - totalOpponentTeamArr[i]) > 0){
                numOfGRevolutionWins = numOfGRevolutionWins + 1;
            }
        }

        int numCount = numOfGRevolutionWins;
        int moveMembers = numOfMembers - numCount - 1;
        if(moveMembers >= 0){
            for(int i = 0; i < moveMembers; i++){
                long teamMember = totalOpponentTeamArr[numCount];
                int j;
                int numOfGRevolutionWins_1 = 0;
                for (j = 0; j < moveMembers; j++){
                    totalOpponentTeamArr[numCount + j] = totalOpponentTeamArr[numCount + j + 1];
                }
                totalOpponentTeamArr[numCount + j] = teamMember;


                for(int k = numCount; k < numOfMembers; k++){
                    if((totalGRevolutionTeamArr[k] - totalOpponentTeamArr[k]) > 0){
                        numOfGRevolutionWins_1 = numOfGRevolutionWins_1 + 1;
                    }
                }
                gRevolutionWinsList.add(numOfGRevolutionWins_1);
            }
        numOfGRevolutionWins = numOfGRevolutionWins + Collections.max(gRevolutionWinsList);
        }

        System.out.println(numOfGRevolutionWins);
   }

    private static boolean validateInput(String testCases, String noOfPlayers) {
        int test1 = Integer.parseInt(testCases);
        int numOfPlayers = Integer.parseInt(noOfPlayers);
        if (second_Index <= test1 && test1 <= testNumber && second_Index <= numOfPlayers && numOfPlayers <= testNumber) {
            return true;
        }
        return false;
    }

    private static void validateInputPower(long memberPower) {
        if (!(initial_Index <= memberPower && memberPower <= Long.MAX_VALUE)) {
            System.exit(initial_Index);
        }
    }
}

结果：

Input from line 1 = 1
Input from line 2 = 10
Input from line 3 = 3 6 7 5 3 5 6 2 9 1
Input from line 4 = 2 7 0 9 3 6 0 6 2 6
Scanner input job succeeded if we see some value here = 1
Finally block is called to free Scanner job
Value from first line and parsed string to int = 1
Value from second line and parsed string to int = 10
Value from third line = 3 6 7 5 3 5 6 2 9 1
Value from fourth line = 2 7 0 9 3 6 0 6 2 6
Parsed string number 1 to long : 3
Parsed string number 2 to long : 6
Parsed string number 3 to long : 7
Parsed string number 4 to long : 5
Parsed string number 5 to long : 3
Parsed string number 6 to long : 5
Parsed string number 7 to long : 6
Parsed string number 8 to long : 2
Parsed string number 9 to long : 9
Parsed string number 10 to long : 1
Parsed string number 1 to long : 2
Parsed string number 2 to long : 7
Parsed string number 3 to long : 0
Parsed string number 4 to long : 9
Parsed string number 5 to long : 3
Parsed string number 6 to long : 6
Parsed string number 7 to long : 0
Parsed string number 8 to long : 6
Parsed string number 9 to long : 2
Parsed string number 10 to long : 6
After sorting number 1 is : 1
After sorting number 2 is : 2
After sorting number 3 is : 3
After sorting number 4 is : 3
After sorting number 5 is : 5
After sorting number 6 is : 5
After sorting number 7 is : 6
After sorting number 8 is : 6
After sorting number 9 is : 7
After sorting number 10 is : 9
After sorting number 1 is : 0
After sorting number 2 is : 0
After sorting number 3 is : 2
After sorting number 4 is : 2
After sorting number 5 is : 3
After sorting number 6 is : 6
After sorting number 7 is : 6
After sorting number 8 is : 6
After sorting number 9 is : 7
After sorting number 10 is : 9
Number of G-Revolution wins are : 5
Number will be used is : 4
Number shifted is : 6
Number of wins afterwards : 1
Number shifted is : 6
Number of wins afterwards : 2
Number shifted is : 6
Number of wins afterwards : 2
Number shifted is : 7
Number of wins afterwards : 2
Number of wins afterwards in list : [1, 2, 2, 2]
Answer is = 7

Answer 1

我也参加了同一个比赛，我得了满分。我的代码可能对您有帮助。要解决这个问题，您可以对两个列表进行排序以颠倒顺序并相互比较。参考下面Python中的工作示例：

    def main():
    testCase=int(input())
    while testCase>0:
    count=0
    numberOfPlayer=int(input())
    firstPlayer=list(map(int,input().split()))
    secondPlayer=list(map(int,input().split()))
    firstPlayer.sort(reverse=True)
    secondPlayer.sort(reverse=True)
    p=0
    for i in range(numberOfPlayer):
        for j in range(p,numberOfPlayer):
            if firstPlayer[i]>secondPlayer[j]:
                p=j+1
                count+=1
                break
    print(count)
    testCase-=1
main() 
# Made by Ankur Patel

有关基于java的解决方案，请参阅

Answer 2

t=int(input())
while t>0:
    n=int(input())
    gr=[int(x) for x in input().split()]
    op=[int(x) for x in input().split()]
    gr.sort()
    op.sort()
    l=r=count=0
    while l<n and r<n:
        if gr[l]>op[r]:
            l+=1
            r+=1
            count+=1
        elif gr[l]<=op[r]:
            l+=1
    print(count)
    t-=1

Answer 3

您陷入了基于示例而不是考虑一般情况构建算法的经典陷阱。这不是一种批评，而是我们所有人都必须意识到的东西，以便与之斗争。

请在此处查看您的循环：

           for (j = 0; j < moveMembers; j++){
                totalOpponentTeamArr[numCount + j] = totalOpponentTeamArr[numCount + j + 1];
            }
            totalOpponentTeamArr[numCount + j] = teamMember;

因此，在给定的示例中，直接排序会导致我们赢得第一个numCount=5场比赛，因此您的算法会留下这5个结果并从位置6重新排列我们的团队。

问题是，这仅适用于提供的示例。

考虑一下，如果对方球队没有0或1的优势，而是用3取代了这些优势，也就是说，他们的球队是：3 3 6 7 9。

在这种情况下，在最初的直接排序的比赛中，我们将失去前4场比赛，只赢得1场比赛（5-3）。

考虑一下你的算法在这种情况下会如何表现，在numCount=1之后重新排列团队？

所以更好的算法是：

1）按照目前的方式对每个团队进行排序

2） 从他们最弱的成员开始，找到我们最薄弱的成员，击败他们

3） 继续他们的下一个最弱的成员，找到我们最弱的成员，谁将击败那一个

等

在每一步中，如果我们必须跳过一个成员，记下他们（在列表或其他地方）。当我们遇到与他们中的一个比赛的成员不足的情况时，只需在剩下的比赛中填写我们跳过的成员列表-毕竟，他们无论如何都不会赢得比赛！