CF 1608C - Game Master（思维，图，dfs）

题目大意：
n 个玩家玩一个游戏，游戏中有两个地图，每个玩家在两个地图中的能力值已知，同一个地图中能力值大的玩家可以打赢能力值小的玩家（同一地图中不会出现能力值相同的玩家），现组织一场比赛，进行 n - 1 场对战，每场对战顺序和地图可以选择，判断哪些玩家可以获胜，输出 1，否则输出 0。
思路：
我的思路是正确的：对当前的玩家a，如果他的某一项能力能打败玩家b，则将b划到自己的阵营，同时玩家b阵营的所有玩家也划到玩家a阵营。这样，如果所有的玩家都能被划到玩家a阵营，则说明玩家a可以打败所有玩家，获胜。如此这般用dfs遍历n个玩家，时间复杂度为O(n2)，无法接受。
关键是我没想到要建图。如果a能打败b，则增加a到b的边。这样，以每个点为起点走一遍图，能全覆盖则能赢。
怎样精简时间复杂度呢？试想，如果从一个点出发能达到能力最大点（两种能力最大点能到其一即可），那么这个点一定可以覆盖所有点，则一定可以赢。因此我们把边取反，从两个能力最大点出发分别走一遍图，则到达点都是获胜点。
边的数量也可以减少至2n-2。将a、b数组降序排序，只在a[i]->a[i+1]、a[i+1]->a[i+2]…之间连边（b同理）。这是因为我们只从a[i]、b[i]对应的点出发，这样连不会漏掉它俩可以到达的点。
这样时间复杂度为O(n)。

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class Main2 {

    static InputReader2 sc=new InputReader2(System.in);
/*    static int MAXN=200005,n,m,a[]=new int[MAXN],dp[]=new int[MAXN],edge[][]=new int[MAXN][2];
    static long k;
    static boolean vis[]=new boolean[MAXN],ok=false;
    static Vector<Integer> G[]=new Vector[MAXN],g[]=new Vector[MAXN];*/
    static int MAXN=100005,ans[]=new int[MAXN];
    static Vector<Integer> G[]=new Vector[MAXN];

    public static void main(String args[]){
        solve();
    }

    private static void solve() {
        for(int i=1;i<=100000;i++){
            G[i]=new Vector<>();
        }
        int t=sc.nextInt();
        while(t-->0){
            int n=sc.nextInt();
            for(int i=1;i<=n;i++){
                G[i].clear();
                ans[i]=0;
            }
            int a[][]=new int[n+1][2];
            int b[][]=new int[n+1][2];
            int maxa[]={0,0},maxb[]={0,0};
            for(int i=1;i<=n;i++){
                a[i][0]=sc.nextInt();
                a[i][1]=i;
                if(a[i][0]>maxa[0]){
                    maxa[1]=i;
                    maxa[0]=a[i][0];
                }
            }
            for(int i=1;i<=n;i++){
                b[i][0]=sc.nextInt();
                b[i][1]=i;
                if(b[i][0]>maxb[0]){
                    maxb[1]=i;
                    maxb[0]=b[i][0];
                }
            }
            Arrays.sort(a, (o1, o2) -> o1[0]-o2[0]);
            Arrays.sort(b, (o1, o2) -> o1[0]-o2[0]);
            for(int i=n;i>=2;i--){
                G[a[i-1][1]].add(a[i][1]);
                G[b[i-1][1]].add(b[i][1]);
            }
            //System.out.println(maxa[1]+" "+maxb[1]);
            ans[maxa[1]]=ans[maxb[1]]=1;
            dfs(maxa[1]);
            dfs(maxb[1]);
            for(int i=1;i<=n;i++){
                System.out.print(ans[i]);
            }
            System.out.println();
        }
    }

    private static void dfs(int x) {
        for(int v:G[x]){
            if(ans[v]==1)continue;
            //System.out.println(x+" "+v);
            ans[v]=1;
            dfs(v);
        }
    }


}

class InputReader2 {

    private final InputStream stream;
    private final byte[] buf = new byte[8192];
    private int curChar, snumChars;

    public InputReader2(InputStream st) {
        this.stream = st;
    }

    public int read() {
        if (snumChars == -1)
            throw new InputMismatchException();
        if (curChar >= snumChars) {
            curChar = 0;
            try {
                snumChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (snumChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public int[] nextIntArray(int n) {
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndOfLine(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

}