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

点击题号跳转

A4789 B1123 C4266 D3672 E3412

F5360 G4871 H5331 I2291 J5610

A.传染病控制回到顶部

题意

给一棵树1为根被感染，每次切断一条边，然后从已经被感染的传播到相邻节点，若相连则被传染，问如何操作使得感人的人最少，n<=300

题解

考虑一个贪心做法，显然可以按照深度下来，求出每个点对应的深度，每次切对应深度的点儿子最多的树

显然这样并不能AC，考虑一种情况，一个节点一条链儿子最多，另一个节点分叉，那么如果切分叉，再来切链显然比贪心更优

那么就需要搜索所有的情况，显然按照贪心思路下来，获得的值较优，再来剪枝复杂度会大大降低，复杂度O(常数*n^2)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private int[][] G = new int[305][305];
    private int[] sz = new int[305];
    private int[] deep = new int[305];
    private int[] father = new int[305];
    private boolean[] vis = new boolean[305];
    private int n, m, deaded;
    public void solve(Scanner sc) {
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            G[u][v] = G[v][u] = 1;
        }
        dfs(1, 1, 1);
        deaded = n;
        dep_dfs(1, 1);
        System.out.println(deaded);
    }

    private void dfs(int u, int fa, int dep) {
        sz[u] = 1;
        deep[u] = dep;
        father[u] = fa;
        for (int v = 1; v <= n; v++) {
            if (G[u][v] == 1 && v != fa) {
                dfs(v, u, dep + 1);
                sz[u] += sz[v];
            }
        }
    }

    private void dep_dfs(int dep, int dead) {
        if (dead >= deaded) return;
        //处理一层节点
        for (int i = 2; i <= n; i++) {
            if (deep[i] == dep + 1) {
                //System.out.println("i:" + i + " fa:" + father[i]);
                //System.out.println("vis[i]:" + vis[i] + " vis[fa]:" + vis[father[i]]);
                vis[i] = vis[father[i]];
            }
        }
        //sum代表这一层有多少个会死掉的节点
        int sum = 0;
        for (int i = 2; i <= n; i++) {
            if (deep[i] == dep + 1 && !vis[i]) {
                sum++;
            }
        }
        //System.out.println("max:" + max);
        //System.out.println("sum:" + sum);
        //这一层所有的节点都活着，结束
        if (sum == 0) {
            //System.out.println("dead:" + dead);
            deaded = Math.min(deaded, dead);
            return;
        }
        //选择儿子最多的活下来
        for (int i = 2; i <= n; i++) {
            if (deep[i] == dep + 1 && !vis[i]) {
                //System.out.println("cut:" + i);
                vis[i] = true;
                dep_dfs(dep + 1, dead + sum - 1);
                vis[i] = false;
            }
        }
    }

}

B.Billing Tables回到顶部

题意

n个电话，A - B 电话名，[A,B]的电话号表示改电话名，A，B代表的前缀可以合并，12300-12399可以合并为拨打123就可以知道对应电话名

拨一个电话按顺序下来查找对应电话名，其中电话名为invalid表示区间不可用

问这n个电话最少需要多少电话号表示

PS：题意看了n久n久

题解

显然字典树，我们需要把[A,B]区间插进去，很难做到吧

我们可以只插A和B，然后通过A往右，B往左圈定范围，每次把这个范围往下压

倒过来插入，这样可以覆盖掉原先标记的值，还要注意如果电话名相同可以会出现合并，就需要相同电话名标记相同

uL表示A当前的节点，uR表示B

1、如果uL=uR相当于父节点相同，所有子节点为nxt[uL][j]和nxt[uR][j]，子节点只需要更新[L[i]+1,R[i]-1]这一段范围

　　1、为什么不把L[i]和R[i]更新了，因为最后需要遍历整颗树，遍历条件就是当前节点未被标记

　　2、但是根需要标记L[i]和R[i]，这是结束遍历的标志，相当于尾部节点

2、如果uL和uR不相同，相当于uL更新[L[i]+1，9]，uR更新[0，R[i]-1]

接下来要输出方案数，如果节点未被标记，往下遍历，如果已被标记，方案数加上1（如果合法）

由于需要求最少的前缀表示，那么就需要合并，可以知道如果某个节点的子节点0-9都合法，那么合并，合并只需要标记u为nxt[u][j]，这样在搜索的时候下面就不会搜索而直接返回了

最后输出所有前缀表示，如果节点未被标记，往下遍历，如果已被标记则输出该方案

PS：好艰难意识模糊（看代码的debug就知道快炸了）

代码

import java.util.*;

public class Main {

    private Scanner sc;
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private final int MAXN = 100005;
    private final int CHAR_SIZE = 10;

    private ArrayList<String> L = new ArrayList<>();
    private ArrayList<String> R = new ArrayList<>();
    private ArrayList<String> N = new ArrayList<>();
    private HashMap<String, Integer> hashMap = new HashMap<>();
    private int[] pl = new int[105]; // 处理相同名字N
    private boolean[] vis = new boolean[105];// 是否非法
    private int[] mark = new int[MAXN]; // 节点标记【可能是一个区间】，用于计数
    private int[][] nxt = new int[MAXN][CHAR_SIZE];
    private char[] out = new char[13];
    private int tot, ans;

    public void solve(Scanner sc) {
        int n = sc.nextInt();
        sc.nextLine(); // 读回车
        L.add("");R.add("");N.add("");
        for (int i = 1; i <= n; i++) {
            String s = sc.nextLine();
            String[] str = s.split(" ");
            // 对齐
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < str[0].length() - str[2].length(); j++)
                sb.append(str[0].charAt(j));
            sb.append(str[2]);
            L.add(str[0]);
            R.add(sb.toString());
            N.add(str[3]);
            //System.out.println(str[0]);
            //System.out.println(sb.toString());
            //System.out.println(str[3]);
            vis[i] = !("invalid".equals(str[3]));
            //System.out.println(vis[i]);
            if (hashMap.containsKey(str[3])) {
                // 名字相同可合并
                pl[i] = hashMap.get(str[3]);
            }
            else {
                pl[i] = i;
                hashMap.put(str[3], i);
            }
        }

        // root = 0;
        for (int i = n; i >= 1; i--) {
            insert(i);
        }
        // 计数
        dfs1(0);
        System.out.println(ans);

        // 输出路径
        dfs2(0, 0);
    }

    private void insert(int pos) {
        //System.out.println("pos:" + pos + " pl:" + pl[pos]);
        int uL = 0, uR = 0;
        for (int i = 0; i < L.get(pos).length(); i++) {
            // 当前父节点u如果有标记，传递标记
            for (int j = 0; j < CHAR_SIZE; j++) {
                if (nxt[uL][j] == 0) nxt[uL][j] = ++tot;
                if (nxt[uR][j] == 0) nxt[uR][j] = ++tot;
                if (mark[uL] > 0) mark[nxt[uL][j]] = mark[uL];
                if (mark[uR] > 0) mark[nxt[uR][j]] = mark[uR];
            }

            mark[uL] = mark[uR] = 0;
            if (uL == uR) {
                // 如果父节点u相同，子节点可以一起更新
                // 子节点标记markId
                for (int j = L.get(pos).charAt(i) - '0' + 1; j < R.get(pos).charAt(i) - '0'; j++)
                    mark[nxt[uL][j]] = pl[pos];
            } else {
                // 如果父节点u不同，左子节点到L[i]+1 - 9，右子节点到0 - R[i]-1
                for (int j = L.get(pos).charAt(i) - '0' + 1; j < CHAR_SIZE; j++)
                    mark[nxt[uL][j]] = pl[pos];
                for (int j = 0; j < R.get(pos).charAt(i) - '0'; j++)
                    mark[nxt[uR][j]] = pl[pos];
            }
            //System.out.println("uL:" + uL + " uR:" + uR);
            uL = nxt[uL][L.get(pos).charAt(i) - '0'];
            uR = nxt[uR][R.get(pos).charAt(i) - '0'];
        }
        // 若循环结束，标记当前节点为尾部节点
        mark[uL] = pl[pos];
        mark[uR] = pl[pos];
    }

    private void dfs1(int u) {
        // 如果节点被标记
        // 1、区间内的节点
        // 2、搜索尾部节点
        if (mark[u] > 0) {
            int add = vis[mark[u]] ? 1 : 0;
            //System.out.println("u:" + u + " add:" + add);
            ans += add;
            return;
        }
        if (nxt[u][0] == 0) return;

        //儿子个数，如果为10个则合并
        boolean f = true;
        for (int i = 0; i < CHAR_SIZE; i++) {
            dfs1(nxt[u][i]);
            if (mark[nxt[u][i]] != mark[nxt[u][0]]) f = false;
        }
        if (f && vis[mark[nxt[u][0]]] && u != 0) {
            ans -= 9;
            mark[u] = mark[nxt[u][0]];
        }
    }

    private void dfs2(int u, int p) {
        int add = vis[mark[u]] ? 1 : 0;
        if (mark[u] > 0) {
            if (add != 0) {
                for (int i = 0; i < p; i++) {
                    System.out.print(out[i]);
                }
                System.out.print(' ');
                System.out.println(N.get(mark[u]));
            }
            return;
        }
        if (nxt[u][0] == 0) return;
        for (int i = 0; i < CHAR_SIZE; i++) {
            out[p] = (char) (i + '0');
            dfs2(nxt[u][i], p + 1);
        }
    }
}

C.Arithmetic Progression回到顶部

题意

n个数，求最长连续递增子串，n<=100000

题解

对原数组做一次差分即a[i]=a[i]-a[i-1]，求得最长连续相同子串，注意n=1输出1，复杂度O(n)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    public void solve(Scanner sc) {
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[] a = new int[n];
            int last = 0;
            for (int i = 0; i < n; i++) {
                int x = sc.nextInt();
                if (i > 0)
                    a[i] = x - last;
                last = x;
            }
            //System.out.println(Arrays.toString(a));
            if (n <= 2) {
                System.out.println(n);
                continue;
            }
            int maxLen = 0;
            for (int i = 1; i < n; i++) {
                int Len = 0;
                while (i + Len + 1 < n && a[i + Len + 1] == a[i]) {
                    Len++;
                }
                i += Len;
                maxLen = Math.max(maxLen, Len + 2);
            }
            System.out.println(maxLen);
        }
    }

}

D.To be a Palindrome回到顶部

题意

给一个长度<=100的串，接上一个最短的串使得回文

题解

长度很短，直接暴力把所有情况枚举一下，复杂度O(100^2)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    public void solve(Scanner sc) {
        while (sc.hasNext()) {
            String s = sc.next();
            if (check(s)) {
                System.out.println(s);
                continue;
            }
            for (int i = 0; i < s.length(); i++) {
                String s1 = s + reverse(s.substring(0, i + 1));
                if (check(s1)) {
                    System.out.print(s1);
                    break;
                }
            }
            System.out.println();
        }
    }

    private boolean check(String s) {
        for(int L = 0, R = s.length() - 1; L < R; L++, R--) {
            if (s.charAt(L) != s.charAt(R))
                return false;
        }
        return true;
    }

    private String reverse(String s) {
        StringBuilder sb = new StringBuilder();
        for (int i = s.length() - 1; i >= 0; i--) {
            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
}

E.Railroad回到顶部

题意

给两个队列，问能否构造出一个队列满足条件，n<=1000

题解

dp[i][j][k]表示第一个队列到i，第二个队列到j，答案队列到k

显然已知i和j，那么k固定，所以dp[i][j]即可

那么合法的方案数为1000^2个，那么直接深搜即可解决，复杂度O(n^2)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private int[] a;
    private int[] b;
    private int[] c;
    private boolean[][] vis;
    private boolean f;
    private int n1, n2;

    public void solve(Scanner sc) {
        while (sc.hasNext()) {
            n1 = sc.nextInt();
            n2 = sc.nextInt();
            if (n1 == 0 && n2 == 0) break;
            a = new int[n1];
            b = new int[n2];
            c = new int[n1 + n2];
            vis = new boolean[n1 + 5][n2 + 5];
            for (int i = 0; i < n1; i++) a[i] = sc.nextInt();
            for (int i = 0; i < n2; i++) b[i] = sc.nextInt();
            for (int i = 0; i < n1 + n2; i++) c[i] = sc.nextInt();
            f = false;
            dfs(0, 0, 0);
            System.out.println(f ? "possible" : "not possible");
        }
    }

    private void dfs(int na, int nb, int nc) {
        if (nc == n1 + n2 || f) {
            f = true;
        } else if (!vis[na][nb]){
            vis[na][nb] = true;
            if (na < n1 && c[nc] == a[na])
                dfs(na + 1, nb, nc + 1);
            if (nb < n2 && c[nc] == b[nb])
                dfs(na, nb + 1, nc + 1);
        }
    }
}

F.统计数字个数回到顶部

题意

给n个数，求合法数字个数（数字中可能夹杂着错误符号，但不会包含小数点、空格等，也不会出现有前导符0的的情况如0123或-0123等，每个数字长度不超过10）

题解

题意数据的构造，按照题意判断，复杂度O(1)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    public void solve(Scanner sc) {
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int cnt = 0;
            boolean f;
            for (int i = 0; i < n; i++) {
                String s = sc.next();
                f = true;
                if (!(s.charAt(0) == '-' || s.charAt(0) >= '0' && s.charAt(0) <= '9')) f = false;
                for (int j = 1; j < s.length(); j++) if (!(s.charAt(j) >= '0' && s.charAt(j) <= '9')) f = false;
                if (f) cnt++;
            }
            System.out.println(cnt);
        }
    }

}

G.文化之旅回到顶部

题意

n个点m条边，每个点有一个文化，对于(u，v，w)如果文化不同则连通，问S->T的最短路，n,k<=100,m<=n^2

题解

n只有100，直接floyd算出任意两点的最短路，直接搜索，复杂度O(n^3)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private final int MAXN = 105;

    private int N, K, M, S, T, u, v, w, ans;
    private int[][] a = new int[MAXN][MAXN];
    private int[][] d = new int[MAXN][MAXN];
    private int[][] G = new int[MAXN][MAXN];
    private int[] c = new int[MAXN];
    private boolean[] vis = new boolean[MAXN];

    void dfs(int u, int dis) {
        if (dis + d[u][T] >= ans) return;
        if (u == T) {
            ans = Math.min(ans, dis);
            return;
        }
        for (int v = 1; v <= N; v++) {
            if (a[c[v]][c[u]] == 0 && !vis[c[v]]) {
                vis[c[v]] = true;
                dfs(v, dis + G[u][v]);
                vis[c[v]] = false;
            }
        }
    }

    public void solve(Scanner sc) {
        N = sc.nextInt();
        K = sc.nextInt();
        M = sc.nextInt();
        S = sc.nextInt();
        T = sc.nextInt();

        for (int i = 1; i <= N; i++)
            for (int j = 1; j <= N; j++)
                d[i][j] = G[i][j] = 0x3f3f3f3f;

        for (int i = 1; i <= N; i++) {
            c[i] = sc.nextInt();
            G[i][i] = d[i][i] = 0;
        }
        for (int i = 1; i <= K; i++)
            for (int j = 1; j <= K; j++)
                a[i][j] = sc.nextInt();

        for (int i = 1; i <= M; i++) {
            u = sc.nextInt();
            v = sc.nextInt();
            w = sc.nextInt();
            if (a[c[u]][c[v]] == 0 && c[u] != c[v]) G[v][u] = d[v][u] = Math.min(d[v][u], w);
            if (a[c[v]][c[u]] == 0 && c[u] != c[v]) G[u][v] = d[u][v] = Math.min(d[u][v], w);
        }

        //floyd
        for (int k = 1; k <= N; k++)
            for (int i = 1; i <= N; i++)
                for (int j = 1; j <= N; j++)
                    if (a[c[k]][c[i]] == 0 && a[c[j]][c[k]] == 0 && d[i][j] > d[i][k] + d[k][j])
                        d[i][j] = d[i][k] + d[k][j];

        for (int i = 1; i <= N; i++)
            vis[i] = false;
        ans = 0x3f3f3f3f;
        vis[c[S]] = true;
        dfs(S, 0);
        if (ans == 0x3f3f3f3f) System.out.println(-1);
        else System.out.println(ans);
    }

}

H.同花顺2回到顶部

题意

给一副牌，判断是否同花顺

题解

模拟，求出花色对应的点数，判断连续5个是否合法，细节题，复杂度O(n)

PS：一度空指针异常，原来是对象数组得new两次，一次是指针空间，一次是对象空间

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    class Pai {
        int f, ds;
    }

    public void solve(Scanner sc) {
        while (sc.hasNext()) {
            int n = sc.nextInt();
            Pai[] pai = new Pai[100];
            for (int i = 0; i < 100; i++) {
                pai[i] = new Pai();
                pai[i].f = pai[i].ds = 0;
            }
            for (int i = 0; i < n; i++) {
                String hs = sc.next();
                if (hs.charAt(0) == 'S')
                    pai[i].f = 1;
                else if (hs.charAt(0) == 'H')
                    pai[i].f = 2;
                else if (hs.charAt(0) == 'C')
                    pai[i].f = 3;
                else if (hs.charAt(0) == 'D')
                    pai[i].f = 4;
                if (hs.charAt(1) == '1' && hs.charAt(2) == '0')
                    pai[i].ds = 10;
                else if (hs.charAt(1) >= '0' && hs.charAt(1) <= '9')
                    pai[i].ds = hs.charAt(1) - '0';
                else if (hs.charAt(1) == 'J')
                    pai[i].ds = 11;
                else if (hs.charAt(1) == 'Q')
                    pai[i].ds = 12;
                else if (hs.charAt(1) == 'K')
                    pai[i].ds = 13;
                else if (hs.charAt(1) == 'A')
                    pai[i].ds = 14;
            }
            List<Integer> b = new ArrayList<>();
            List<Integer> c = new ArrayList<>();
            List<Integer> d = new ArrayList<>();
            List<Integer> e = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (pai[i].f == 1)
                    b.add(pai[i].ds);
                if (pai[i].f == 2)
                    c.add(pai[i].ds);
                if (pai[i].f == 3)
                    d.add(pai[i].ds);
                if (pai[i].f == 4)
                    e.add(pai[i].ds);
            }

            if (check(b) || check(c) || check(d) || check(e))
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }

    private boolean check(List<Integer> a) {
        int n = a.size();
        if (n <= 4) return false;
        Collections.sort(a);
        for (int i = 0; i <= n - 5; i++) {
            if (a.get(i) != 2) {
                boolean f = true;
                for (int j = i + 1; j <= i + 4; j++) {
                    if (a.get(j) - a.get(j - 1) != 1)
                        f = false;
                }
                if (f) return true;
            }
        }
        return false;
    }
}

I.Parallel computer simulator回到顶部

题意

背景：操作系统CPU切换执行不同程序

n段程序，每段end结束，5种语句分别为a = 1（只有26个变量，赋值<=1000），print a，lock，unlock，end和各自需要执行的时间，再给一个t表示一次单位时间。每次取出就绪队列首部程序id执行一个单位时间；

1、一次单位时间内可以执行多条语句；

2、若单位时间内单位语句未执行完则等到其执行完；

3、若获取lock失败则不会执行其他语句；

4、若unlock则从阻塞队列获得第一个程序id放入就绪队列

5、若程序id还有语句未执行则放入就绪队列尾部

n<=100，单个程序语句数<=200

PS：题意够长够恶心

题解

直接按照题意模拟，双端队列代表就绪队列，队列代表阻塞队列，复杂度O(100*200)

PS：查了一下java中的双端队列和阻塞队列，ConcurrentLinkedDeque(Queue)，JDK1.7 JUC包引入，采用无锁算法，底层使用自旋+CAS的方式实现非阻塞来保证线程并发访问时的数据一致性

但是它的迭代器是弱一致性的，不能保证完全一致性。例如一个线程在遍历，另一个线程在修改不会抛出异常

代码

import java.util.*;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Main {

    private Scanner sc;
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private int[] t = new int[5];
    private List< List<String> > list = new ArrayList<>();
    private int[] list_pos = new int[205];
    private int[] val = new int[26];
    private ConcurrentLinkedDeque<Integer> ready = new ConcurrentLinkedDeque<>();
    private ConcurrentLinkedQueue<Integer> block = new ConcurrentLinkedQueue<>();
    public void solve(Scanner sc) {
        int n = sc.nextInt();
        for (int i = 0; i < 5; i++) t[i] = sc.nextInt();
        int time = sc.nextInt();
        sc.nextLine();// 读回车
        for (int i = 0; i < n; i++) {
            list.add(new ArrayList<>());
            ready.addLast(i);
            while (true) {
                String s = sc.nextLine();
                list.get(i).add(s);
                if ("end".equals(s)) break;
            }
        }
        // 是否阻塞
        boolean blocked = false;
        while (!ready.isEmpty()) {
            int id = ready.getFirst();
            ready.removeFirst();
            int time_cur = time;
            // 是否能够继续运行
            boolean ok = true;
            // 当前程序执行一段时间
            do {
                String exec = list.get(id).get(list_pos[id]);
                char ch = exec.charAt(2);
                if (ch == '=') {
                    // a = 4
                    time_cur -= t[0];
                    String cut = exec.substring(4);
                    val[exec.charAt(0) - 'a'] = Integer.parseInt(cut);
                } else if (ch == 'i') {
                    // print a
                    time_cur -= t[1];
                    System.out.printf("%d: %d
", id + 1, val[exec.charAt(6) - 'a']);
                } else if (ch == 'c') {
                    // lock
                    // 获取lock成功
                    time_cur -= t[2];
                    // 获取lock失败，当前程序停止，进入阻塞队列
                    if (blocked) {
                        block.add(id);
                        time_cur = 0;
                        ok = false;
                    }
                    blocked = true;
                } else if (ch == 'l') {
                    // unlock
                    time_cur -= t[3];
                    // 若阻塞队列有，移除开头放入就绪队列头
                    if (!block.isEmpty()) {
                        ready.addFirst(block.element());
                        block.remove();
                    }
                    blocked = false;
                } else if (ch == 'd') {
                    // end
                    time_cur = 0;
                }
                // 如果当前语句调用成功
                if (ok) list_pos[id]++;
            } while (time_cur > 0);

            // 如果能够继续运行，并且没到end，放回
            if (ok && list_pos[id] != list.get(id).size()) {
                ready.addLast(id);
            }
        }
    }

}

J.简单21点游戏回到顶部

题意

给n张牌，判断和21的关系

题解

按题意来，复杂度O(n)

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    public void solve(Scanner sc) {
        int n = sc.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            int card = sc.nextInt();
            sum += card;
        }
        if (sum == 21) System.out.println("Yes");
        else if (sum < 21 &&Math.abs(sum - 21) <= 5) System.out.printf("Just so so %d", Math.abs(sum - 21));
        else System.out.printf("No %d", Math.abs(sum - 21));
    }

}