TZOJ 挑战题库随机训练10（JAVA）

点击题号跳转

A5985 B1792 C5644 D4038 E3229

F3322 G3614 H2824 I4286 J6225

A.矩形嵌套回到顶部

题意

n个矩形嵌套，跟E题类似，求最多嵌套，n<=1000

题解

这个题因为比较的是点对，所以可以先排序，使得第一维有序，然后只需要求出第二维的最长上升子序列，复杂度O(nlogn)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    private final int N = 1005;

    private int[] dp = new int[N << 1];
    private List<Node> list = new ArrayList<>();

    class Node {
        int l, r;
        Node(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }

    public void solve() {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (sc.hasNext()) {
            int n = sc.nextInt();
            list.clear();
            for (int i = 0; i < n; i++) {
                int l = sc.nextInt();
                int r = sc.nextInt();
                list.add(new Node(l, r));
                list.add(new Node(r, l));
                dp[i] = dp[n + i] = 0;
            }

            Collections.sort(list, (o1, o2) -> {
                if (o1.l > o2.l) return 1;
                else if (o1.l == o2.l) {
                    if (o1.r > o2.r) return 1;
                    else if (o1.r == o2.r) return 0;
                }
                return -1;
            });

            //list.stream().forEach((node) -> System.out.println(node.l + " " + node.r));

            int maxx = 0;
            for (int i = 0; i < n << 1; i++) {
                dp[i] = 1;
                for (int j = 0; j < i; j++) {
                    if (list.get(i).l > list.get(j).l && list.get(i).r > list.get(j).r) {
                        dp[i] = Math.max(dp[i], dp[j] + 1);
                    }
                }
                maxx = Math.max(maxx, dp[i]);
            }

            System.out.println(maxx);
        }
    }
}

B.Introspective Caching回到顶部

题意

背景：类似于操作系统的请求分页（分段）过程

快速缓冲区大小c，n个不同的程序，q次请求访问快速缓冲区的程序，问最少需要多少次把程序调入快速缓冲区，q<=10^5

题解

这样想，需要删除的元素肯定是要最远（值r）才有用的，如果删的不是最远的（值v），那么就会在r之前把v再调入快速缓冲区，如果删了最远的，这次操作就可以省略

每个程序维护一个nxt[i]，nxt[i]代表值为i的下一个位置，用TreeSet维护，复杂度O(nlogn)

PS：TreeSet自定义类需要实现Comparable，然后重载compareTo方法，TreeSet底层红黑树，会自动排序，排序会调用compareTo方法

PS：TreeSet.contains会调用compareTo方法用0来判断相同

PS：compareTo值为正表示A>B，值为0表示A=B，值为负表示A<B

PS：一开始contains方法没起作用调了好久，后来发现判断相同需要返回0，因为自动排序正交换0和负不交换，就忽略了0的处理

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    class Node implements Comparable<Node> {

        int i, val;

        Node(int i, int val) {
            this.i = i;
            this.val = val;
        }

        //@Override
        public int compareTo(Node o) {
            if (i < o.i) return 1;
            else if (i > o.i) return -1;
            else return 0;
        }
    }

    public void solve() {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        int n = sc.nextInt();
        int q = sc.nextInt();
        int[] a = new int[q + 5];
        int[] nxt = new int[q + 5];
        int[] ha = new int[n + 5];
        for (int i = 1; i <= q; i++) a[i] = sc.nextInt();
        for (int i = q; i >= 1; i--) {
            if (ha[a[i]] == 0) nxt[i] = q + 1;
            else nxt[i] = ha[a[i]];
            ha[a[i]] = i;
        }
        TreeSet<Node> treeSet = new TreeSet<>();
//        Node node1 = new Node(1, 2);
//        treeSet.add(node1);
//        treeSet.add(new Node(2, 3));
//        treeSet.add(new Node(1, 3));
//        treeSet.add(new Node(5, 7));
//        treeSet.stream().forEach((node) -> System.out.println(node.i + " " + node.val));
//        System.out.println(treeSet.contains(node1));

        int ans = 0;
        for (int i = 1; i <= q; i++) {
            Node node = new Node(i, a[i]);
            if (treeSet.contains(node)) {
                treeSet.remove(node);
                treeSet.add(new Node(nxt[i], a[i]));
            } else {
                if (treeSet.size() == c) treeSet.pollFirst();
                treeSet.add(new Node(nxt[i], a[i]));
                ans++;
            }
        }
        System.out.println(ans);
    }

}

C.C实验：复读机回到顶部

题意

输入一行文本s，输出s，在输出s wsl，要求用给定函数实现

题解

char* p = (char*)malloc(105*sizeof(char));复杂度O(105)

PS：可能有空格，需要gets读入

代码

char *GetText(){
   char *p=(char*)malloc(105*sizeof(char));
   gets(p);
   return p;
}

D.Robot Navigation回到顶部

题意

机器人从NWES出发到X，指令1往当前方向走x步，指令2右转，指令3左转，问到X的最少指令和方案数，n，m<=100

题解

最短路计数，dis[i][j][k]代表走到(i,j)方向是k的最短距离，cal表示方案数

指令1相当于判断当前方向，然后走，如果为*就break

指令2相当于+1%4，指令3相当于(-1+4)%4，复杂度O(4nm)

PS：一直以为距离相同也要放进队列重新更新，然后就mle了，后来发现不需要，感谢黄bob

——相当于自带了一个bfs，保证了最短，无权的直接考虑层，有权的相当于用权值维护了一个层

——dij可以理解为堆优化的bfs，spfa是队列优化的，如果层数过多spfa炸了，但是dij活着

——但是如果出现负权，dij考权值搜索肯定炸了，但是spfa活着

PS：为了不出现重复代码，可以把相同方法抽取出一个函数

PS：测试了一下LinkedLists比ConcurrentLinkedQueue慢，所以最好还是用后面一个

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    private final int N = 105;
    private final int INF = 1000000000;
    private final long P = 1000000;

    private Queue<Integer> qx = new LinkedList<Integer>();
    private Queue<Integer> qy = new LinkedList<Integer>();
    private Queue<Integer> qdir = new LinkedList<Integer>();
    private char[][] g = new char[N][N];
    private int[][][] dis = new int[N][N][4];
    private long[][][] cal = new long[N][N][4];

    public void solve() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            if (n == 0 && m == 0) break;
            int sx = 0, sy = 0, sdir = 0, ex = 0, ey = 0;

            for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) for (int k = 0; k < 4; k++) {
                dis[i][j][k] = INF;
                cal[i][j][k] = 0;
            }

            for (int i = 0; i < n; i++) {
                g[i] = sc.next().toCharArray();
                for (int j = 0; j < m; j++) {
                    if (g[i][j] == 'N' || g[i][j] == 'E' || g[i][j] == 'S' || g[i][j] == 'W') {
                        sx = i; sy = j;
                        if (g[i][j] == 'N') sdir = 0;
                        else if (g[i][j] == 'E') sdir = 1;
                        else if (g[i][j] == 'S') sdir = 2;
                        else if (g[i][j] == 'W') sdir = 3;
                    } else if (g[i][j] == 'X') {
                        ex = i; ey = j;
                    }
                }
            }

            bfs(n, m, sx, sy, sdir, ex, ey);
        }
    }

    private void bfs(int n, int m, int sx, int sy, int sdir, int ex, int ey) {
        qx.clear(); qy.clear(); qdir.clear();
        qx.add(sx); qy.add(sy); qdir.add(sdir);
        dis[sx][sy][sdir] = 0; cal[sx][sy][sdir] = 1;
        while (!qx.isEmpty()) {
            int ux = qx.poll(), uy = qy.poll(), udir = qdir.poll();
            //System.out.println("ux:" + ux + " uy:" + uy + " udir:" + udir + " dis:" + dis[ux][uy][udir]);
            // 上，右，下，左
            if (udir == 0) for (int i = ux - 1; i >= 0; i--) if (g[i][uy] == '*') break; else update(ux, uy, udir, i, uy, udir);
            else if (udir == 1) for (int i = uy + 1; i < m; i++) if (g[ux][i] == '*') break; else update(ux, uy, udir, ux, i, udir);
            else if (udir == 2) for (int i = ux + 1; i < n; i++) if (g[i][uy] == '*') break; else update(ux, uy, udir, i, uy, udir);
            else if (udir == 3) for (int i = uy - 1; i >= 0; i--) if (g[ux][i] == '*') break; else update(ux, uy, udir, ux, i, udir);
            // 右转
            update(ux, uy, udir, ux, uy, (udir + 1) % 4);
            // 左转
            update(ux, uy, udir, ux, uy, (udir + 3) % 4);
        }
        long minnDis = INF, ans = 0;
        for (int i = 0; i < 4; i++) if (minnDis > dis[ex][ey][i]) minnDis = dis[ex][ey][i];
        for (int i = 0; i < 4; i++) if (minnDis == dis[ex][ey][i]) ans = (ans + cal[ex][ey][i]) % P;
        System.out.println((minnDis == INF ? 0 : minnDis) + " " + ans);
    }

    // 更新答案
    private void update(int ux, int uy, int udir, int vx, int vy, int vdir) {
        if (dis[ux][uy][udir] + 1 < dis[vx][vy][vdir]) {
            dis[vx][vy][vdir] = dis[ux][uy][udir] + 1;
            cal[vx][vy][vdir] = cal[ux][uy][udir];
            qx.add(vx); qy.add(vy); qdir.add(vdir);
        } else if (dis[ux][uy][udir] + 1 == dis[vx][vy][vdir]) {
            cal[vx][vy][vdir] = (cal[vx][vy][vdir] + cal[ux][uy][udir]) % P;
        }
    }
}

E.Rectangles回到顶部

题意

n个矩形嵌套，跟A题类似，求最多嵌套，n<=2000

题解

求最长路，分析一下可以知道是单向边和无环图，那么最长路就是放负权值的最短路，复杂度O(n^2)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    private final int N = 1005;

    private List<List<Integer>> list = new ArrayList<>();
    private int[] d = new int[N];
    private Point[] p1 = new Point[N];
    private Point[] p2 = new Point[N];
    private Queue<Integer> q = new LinkedList<>();
    private int n;

    class Point {
        int x, y;
        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public void solve() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            n = sc.nextInt();
            if (n == 0) break;
            list.clear();
            list.add(new ArrayList<>());
            for (int i = 1;i <= n; i++) {
                p1[i] = new Point(sc.nextInt(), sc.nextInt());
                p2[i] = new Point(sc.nextInt(), sc.nextInt());
                list.add(new ArrayList<>());
            }

            for (int i = 1;i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    if (check(i, j))
                        list.get(i).add(j);
                }
            }
            for (int i = 1; i <= n; i++) list.get(0).add(i);

            System.out.println(dij());
        }
    }

    private boolean check(int i, int j) {
        return p2[i].x < p1[j].x && p2[i].y < p1[j].y;
    }

    private int dij() {
        d[0] = 0;
        for (int i = 1; i <= n; i++) d[i] = 1000000000;
        q.clear(); q.add(0);
        while (!q.isEmpty()) {
            int u = q.poll();
            for (int i = 0; i < list.get(u).size(); i++) {
                int v = list.get(u).get(i);
                if (d[v] > d[u] - 1) {
                    q.add(v);
                    d[v] = d[u] - 1;
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= n; i++) ans = Math.max(ans, -d[i]);
        return ans;
    }
}

F.悼念512汶川大地震遇难同胞――选拔志愿者回到顶部

题意

AB轮流捐钱，单次不超过m，总共捐到n结束，A开始

题解

简单博弈，如果n%(m+1)==0，由于A最多拿m，比如A拿了a，那么B只需要拿m+1-a，就可以让B赢，复杂度O(1)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    public void solve() {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        for (int i = 0; i < c; i++) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            if (n % (m + 1) == 0) System.out.println("Rabbit");
            else System.out.println("Grass");
        }
    }
    
}

G.小强的Linux回到顶部

题意

给一个图，每个点需要时间，有依赖关系，问安装完n个点需要最少时间，n<=1000

题解

拓扑排序，首先取出时间最少的，把度数为0的所有点减掉最少时间，如果安装完就把这个点从图上去掉，并更新度数，复杂度O(n^2)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    private final int N = 1005;

    private int[] d = new int[N];
    private int[] t = new int[N];
    private int[] vec = new int[N];
    private boolean[][] G = new boolean[N][N];
    private boolean[] vis = new boolean[N];

    public void solve() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) t[i] = sc.nextInt();
        int m = sc.nextInt();
        for (int i = 1; i <= m; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            if (!G[v][u]) {
                G[v][u] = true;
                d[u]++;
            }
        }

        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int minn = 1000000000;
            int tot = 0;
            for (int j = 1; j <= n; j++) {
                if (!vis[j] && d[j] == 0) {
                    vec[tot++] = j;
                    minn = Math.min(minn, t[j]);
                }
            }
            if (minn == 1000000000) break;
            for (int j = 0; j < tot; j++) {
                t[vec[j]] -= minn;
                if (t[vec[j]] == 0) {
                    vis[vec[j]] = true;
                    for (int k = 1; k <= n; k++) {
                        if (!vis[k] && G[vec[j]][k]) {
                            G[vec[j]][k] = false;
                            d[k]--;
                        }
                    }
                }
            }
            sum += minn;
        }

        System.out.println(sum);
    }
}

H.Unique Snowflakes回到顶部

题意

n个点，问最长连续的一段不存在重复的数字，n<=10^6

题解

这样想，如果a[l]=a[r]，那么只需要去掉a[l]，l+1往后还是满足的，复杂度O(n)

PS：题意get错误2次，晕了

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    private HashMap<Integer, Integer> hashMap = new HashMap<>();

    public void solve() {

        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int i = 0; i < t; i++) {
            hashMap.clear();
            int n = sc.nextInt();
            int maxl = 0, maxx = 0;
            for (int j = 0; j < n; j++) {
                int x = sc.nextInt();
                if (hashMap.containsKey(x))
                    maxl = Math.max(maxl, hashMap.get(x) + 1);
                hashMap.put(x, j);
                maxx = Math.max(maxx, j - maxl + 1);
            }
            System.out.println(maxx);
        }
    }
}

I.Draw Something Cheat回到顶部

题意

n个长度12的大写串，问每个串都有的字母（会重复），n<=20

题解

每个串处理一个a[26]，答案就是min(a[26])，复杂度O(n^2)

PS：第一次没有get到重复这个坑

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {

    public void solve() {

        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for (int i = 0; i < t; i++) {
            int n = sc.nextInt();
            int[] sum1 = new int[26];
            for (int j = 0; j < n; j++) {
                String s = sc.next();
                int[] sum2 = new int[26];
                for (int k = 0; k < s.length(); k++) {
                    if (j == 0) sum1[s.charAt(k) - 'A']++;
                    else sum2[s.charAt(k) - 'A']++;
                }
                if (j != 0) {
                    for (int k = 0; k < 26; k++)
                        sum1[k] = Math.min(sum1[k], sum2[k]);
                }
            }
            for (int j = 0; j < 26; j++)
                for (int k = 0; k < sum1[j]; k++)
                    System.out.print((char) (j + 'A'));
            System.out.println();
        }
    }
}

J.教堂回到顶部

题意

n*m个点，8个方向，距离1或sqrt(2)，问走过每个点再回到起点的最短路

题解

如果n=1或m=1，那么就是走过去再走回来

如果n为奇m为奇，那么需要走一个斜

其余情况直接一次性走完

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Solution solver = new Solution();
        solver.solve();
    }

}

class Solution {
    
    public void solve() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            double m = sc.nextDouble();
            double n = sc.nextDouble();
            if (m == 1) System.out.println(String.format("%.2f", (n - 1) * 2));
            else if (n == 1) System.out.println(String.format("%.2f", (m - 1) * 2));
            else if (n % 2 == 1 && m % 2 == 1) System.out.println(String.format("%.2f", n * m - 1 + Math.sqrt(2)));
            else System.out.println(String.format("%.2f", n * m));
        }
    }
}