2025届北华大学新生赛题解

有趣的回文字符串

https://ac.nowcoder.com/acm/contest/119449/A

锐评

在此，我谨向各方致以诚挚的感谢：首先，衷心感谢北华ACM程序设计工作室出题组的精心筹备，是你们的专业与用心为活动奠定了优质基础；同时，感谢各位老师的悉心指导与鼎力支持，为我们提供了宝贵的方向与保障；也感谢牛客平台提供的优质展示与实践空间，让想法得以落地、交流得以实现；最后，特别感谢给予我验题的机会，这份信任与认可让我倍感荣幸。

验题报告

这套题个人感觉是比较好的。难度也是适合北华新生体质。

N 是发现了数据的错误

剩下的没有什么问题

题目A：有趣的回文字符串

要会的还是十进制到任意进制的转化

这题是力扣原题

********************************************************* 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        long n = sc.nextLong();
        for(int i = 2; i <= n-2; i++) {
            String s = numberToBase(n, i);
//            System.out.println(s);
            if(s.equals(new StringBuilder(s).reverse().toString())==false) {
                System.out.println("NO");
                return;
            }
        }
        System.out.println("YES");
    }

    /**
     * 将一个长整数转换为指定进制的字符串表示。
     *
     * @param n 要转换的长整数
     * @param b 目标进制，必须大于等于2
     * @return 转换后的字符串表示
     */
    public static String numberToBase(long n, long b) {
        if (n == 0) {
            return "0";
        }
        StringBuilder sb = new StringBuilder();
        while (n > 0) {
            sb.append(n % b);
            n = n / b;
        }
        return sb.reverse().toString();
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目B：扫雷启动

实际上我并没有读懂题目

可以参考 新生这位同学的做法 

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e3+10;
const int M=2e6+10;
int n,m;
int a[N][N],v[N][N];
struct pt
{
    int x,y;
}lin[M];
int tot;

void dfs(int x,int y)
{
    if(x<1||x>n||y<1||y>m) return;
    if(v[x][y]) return;
    if(a[x][y]!=2) return;
    v[x][y]=1;
    if(a[x][y]!=2) return;
    dfs(x+1,y-1);
    dfs(x+1,y);
    dfs(x+1,y+1);
    dfs(x,y+1);
    dfs(x,y-1);
    dfs(x-1,y+1);
    dfs(x-1,y);
    dfs(x-1,y-1);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            char c;
            cin>>c;
            if(c=='*') a[i][j]=-1;
            else if(c=='.')
            {
                a[i][j]=2;
                lin[++tot].x=i;
                lin[tot].y=j;
            }
            else a[i][j]=1;
        }
    }
    int ans=0;
    for(int i=1;i<=tot;i++)
    {
        int x2=lin[i].x,y2=lin[i].y;
        if(v[x2][y2]) continue;
        dfs(x2,y2);
        ans++;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(a[i][j]==1&&!v[i][j]) ans++;
        }
    }
    printf("%d",ans);
//     for(int i=1;i<=n;i++)
//     {
//         for(int j=1;j<=m;j++)
//         {
//             printf("%2d",a[i][j]);
//         }
//         printf("\n");
//     }
// 4 4
// 111.
// 1*1.
// 111.
// ....
    return 0;
}

题目C：X

经典的读入和读出 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        String next1 = sc.next();
        String next2 = sc.next();
        System.out.println(next2);
        System.out.println(next1);
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目D：道阻且长(2)

这题是有一个数学结论

已知任何数除 7 要不是 6 个一循环要不是除尽

试一试就知道了 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
//        System.out.println((double) 1/(double)7);
//        System.out.println((double) 2/(double)7);
//        System.out.println((double) 3/(double)7);
//        System.out.println((double) 4/(double)7);
//        System.out.println((double) 5/(double)7);
//        System.out.println((double) 6/(double)7);
//        System.out.println((double) 7/(double)7);
//        System.out.println((double) 8/(double)7);
//        System.out.println((double) 9/(double)7);
//        System.out.println((double) 10/(double)7);
//        System.out.println((double) 11/(double)7);
//        System.out.println((double) 12/(double)7);
        long n=sc.nextLong();
        if(n%7==0){
            dduoln("0");
        }else {
            dduoln("6");
        }
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目E：王+{"中","大","超大"}+凡

用一个变量 cnt 去模拟每一次上下车的人数

cnt 代表的是当前车上的人数

循环 n 次

每次 cnt - a 下车 cnt + b 上车 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        int n = sc.nextInt();
        long cnt=0;
        for (int i = 0; i < n - 1; i++) {
            long a=sc.nextLong();
            long b=sc.nextLong();
            cnt-=a;
            cnt+=b;
        }
        dduoln(cnt);
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目F：百思不得其解

// 今天早上和Litar打了一把 csgo 被 Litar 狠狠带飞了

简单判断 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        double n = sc.nextDouble();
        double ans = n * 199 * 0.01;
        ans=Math.floor(ans);
//        System.out.println(ans);
        if(ans>=100){
            dduoln("-1");
        }else{
            dduoln((int)(100-ans));
        }
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目G：道阻且长(1)

简单判断 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        if(c<=a||b<=a){
            dduoln("Yes");
        }else {
            dduoln("No");
        }

    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目H：香蕉与猴(easy)

试一下 答案是 n/3

因为最优解是根据三个时间单位把整个长度分成三部分 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        long n = sc.nextLong();
        System.out.println(n/3);

    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目I：道阻且长(3)

简单循环

可能会涉及到双列集合相关。 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        int n=sc.nextInt();
        int m=sc.nextInt();
        int k=sc.nextInt();

        long arr[]=new long[n];
        for(int i=0;i<n;i++){
            arr[i]=sc.nextLong();
        }

        Arrays.sort(arr);
        int pi=0;
        int pj=n-1;
        long cnt=0;
        for (int i = 0; i < k; i++) {
            if(m>0){
                m--;
                cnt+=1000000007-arr[pi];
                pi++;
            }else {
                cnt+=arr[pj];
                pj--;
            }
        }
        dduoln(cnt);
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目J：切西瓜？no！cake！

每次都变成原来两倍

出题人是个人才

木木三是个人才 

import java.math.BigInteger;
import java.util.Scanner;

public class Main {    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger n = sc.nextBigInteger();
        BigInteger i = BigInteger.ZERO;
        BigInteger floor = new BigInteger(1+"");
        
        while (floor.compareTo(n) < 0) {
            floor = calculate(floor);
            i = i.add(BigInteger.ONE);
        }
        
        System.out.println(i);
        sc.close();
    }
    
    private static BigInteger calculate(BigInteger i) {
        return i.multiply(new BigInteger(2+""));
    }
}

题目K：拿石子

思维 

import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = 1;
        // t = scanner.nextInt();
        
        while (t-- > 0) {
            solve(scanner);
        }
        scanner.close();
    }

    static void solve(Scanner scanner) {
        long n = scanner.nextLong();
        if(n%5!=0){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}

题目L：蜂蜜水

思维 

import java.util.Scanner;

public class Main {
    static int[] dx = {-1, 1, 0, 0, -1, -1, 1, 1};
    static int[] dy = {0, 0, -1, 1, -1, 1, -1, 1};
    static final int maxN = 200000 + 10;
    static final int mod = 1000000000 + 7;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = 1;
        // t = scanner.nextInt();
        
        while (t-- > 0) {
            solve(scanner);
        }
        scanner.close();
    }

    static void solve(Scanner scanner) {
        long a = scanner.nextLong();
        long n = scanner.nextLong();
        long l = scanner.nextLong();
        
        if (n == 1) {
            System.out.println("Yes");
        } else {
            if (n > a) {
                System.out.println("NO");
            } else if (((a - l) / (n - 1)) * 2 < l) {
                System.out.println("NO");
            } else {
                System.out.println("Yes");
            }
        }
    }
}

题目M：根

枚举 便利 乘 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        String str = sc.next();
        char[] charArray = str.toCharArray();
        int p_first = 0 ;
        int p_last = str.length()-1 ;
        long cnt=0;
        long t = str.length();
        long add = str.length() - 2;
        while (p_first <= p_last){
            if(p_last != p_first ){
                cnt+= (charArray[p_first]-'0')*t;
                cnt+= (charArray[p_last]-'0')*t;
//                 System.out.println(charArray[p_first]-'0'+" "+t);
//                 System.out.println(charArray[p_last]-'0'+" "+t);
            }else {
                cnt+= (charArray[p_first]-'0')*t;
//                 System.out.println(charArray[p_first]-'0'+" "+t);
            }
//             System.out.println(cnt);
            t+=add;
            add-=2;
            p_first++;
            p_last--;
//             System.out.println("point:"+p_first+" "+p_last);
        }
        dduoln(cnt);
    }

    public static void main(String[] args) throws Exception {
        int t = 1;
        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

题目N：烟花易逝

双列集合 

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;


public class Main {

    static IoScanner sc = new IoScanner();
    static final int mod = (int) (1e9 + 7);
//    static final int mod = (int) (1e9 + 7);

    static int n;
    static int arr[];
    static boolean visited[];
    static ArrayList<ArrayList<Integer>> adj = new ArrayList<>();

    /**
     * @throws IOException
     */
    private static void solve() throws IOException {
        // todo
        HashMap<Character, Character> hm = new HashMap<>();
        int n=sc.nextInt();
        for (int i = 0; i < 3; i++) {
            char ch = sc.next().charAt(0);
            char ch1 = sc.next().charAt(0);
            hm.put(ch, ch1);
        }

        char arr[][]=new char[3][n];
        for (int i = 0; i < 3; i++) {
            String ch = sc.next();
            arr[i]=ch.toCharArray();
        }

        for (int i = 0; i < 3; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                System.out.print(hm.get(arr[i][i1]));
            }
            System.out.println();
        }


    }

    public static void main(String[] args) throws Exception {
        int t = 1;
//        t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    static <T> void dduo(T t) {
        System.out.print(t);
    }

    static <T> void dduoln() {
        System.out.println("");
    }

    static <T> void dduoln(T t) {
        System.out.println(t);
    }
}

/**
 * IoScanner类
 *
 * @author Dduo
 * @version 1.0
 * @description 通过IO流操作缓冲区减少了与底层输入输出设备的交互次数，旨在简化 Java 中的标准输入读取操作。
 */
class IoScanner {
    BufferedReader bf;
    StringTokenizer st;
    BufferedWriter bw;

    public IoScanner() {
        bf = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    public String nextLine() throws IOException {
        return bf.readLine();
    }

    public String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    public char nextChar() throws IOException {
        return next().charAt(0);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    public BigInteger nextBigInteger() throws IOException {
        return new BigInteger(next());
    }

    public BigDecimal nextDecimal() throws IOException {
        return new BigDecimal(next());
    }
}

引流

牛客网

https://www.nowcoder.com/users/619886673

csdn

https://blog.csdn.net/qq_30500575?type=blog

github

https://github.com/Dddddduo

微信公众号

欢迎大家来到北华大学，未来的世界无比精彩，请尽情享用！

全部评论

相关推荐

10-09 23:55
门头沟学院 后端工程师
字节后端一面
字节一面一上来就八股框框问，难绷，聊了四十分钟才开始手撕，我这边todesk看到直接开始写，先思路，再代码再注释，最后复杂度分析，一套流程下来也就十来分钟，没难度，简单说下面试手撕&nbsp;使用两个指针，快指针先移动k步，然后快慢指针同时移动，当快指针到达链表末尾时，慢指针正好指向倒数第k个节点。&nbsp;算法选择：双指针法。快指针先移动k步，如果快指针在移动过程中变为null，说明k大于链表长度，返回null。然后同时移动快慢指针，直到快指针到达链表末尾，此时慢指针指向的节点即为所求。&nbsp;复杂度分析：时间复杂度为O(n)，其中n是链表的长度，因为我们只遍历了一次链表。空间复杂度为O(1)，只使用了两个指针。
查看1道真题和解析
点赞 评论 收藏
分享
今天 11:10
联想_后端开发部_语音算法工程师(准入职员工)
联想内推，联想内推码
供应链管理面经1.&nbsp;你如何理解&nbsp;&quot;供应链管理&quot;&nbsp;的核心目标？举一个简单的供应链例子。&nbsp;◦&nbsp;追问1：供应链的&nbsp;&quot;三流&quot;&nbsp;指什么？&nbsp;◦&nbsp;追问2：如何提升供应链响应速度？&nbsp;2.&nbsp;请描述一次你参与的物流或库存管理项目，有什么收获？&nbsp;3.&nbsp;解释你理解的&nbsp;&quot;供应商管理&quot;，如何选择和评估供应商？&nbsp;◦&nbsp;追问1：供应商评估的指标有哪些？&nbsp;◦&nbsp;追问2：如何建立供应商合作关系？&nbsp;4.&nbsp;你认为供应链管理中最常见的挑战是什么？如何应对？&nbsp;5.&nbsp;作为供应链管理专员，你认为需要具备哪些核心能力？如何培养？&nbsp;◦&nbsp;追问1：如何学习供应链知识？&nbsp;◦&nbsp;追问2：如何提升系统...
点赞 评论 收藏
分享
08-27 12:02
已编辑
南京外国语学校 网络安全
华子进池成功！！
期待开奖捏😁😁
再来一遍：实则劝各位不要all in华子，不要相信华为hr
点赞 评论 收藏
分享
10-09 15:47
已编辑
美团_本地核心商业_前端开发(准入职员工)
点赞 评论 收藏
分享
评论
3
收藏
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 实习在多还是在精 #
18968次浏览 167人参与
# 我的求职进度条 #
20450次浏览 329人参与
# 爱玛科技集团求职进展汇总 #
33856次浏览 228人参与
# 秋招踩过的“雷”，希望你别再踩 #
46945次浏览 641人参与
# 如果不考虑收入，你最想做什么工作？ #
30030次浏览 170人参与
# 找工作中的小确幸 #
20026次浏览 194人参与
# 实习下班不想学习，正常吗？ #
11721次浏览 142人参与
# 柠檬微趣工作体验 #
12647次浏览 72人参与
# 你见过哪些工贼行为 #
9056次浏览 62人参与
# 校招谈薪一定要知道的事 #
8140次浏览 87人参与
# 反问环节如何提问 #
110777次浏览 2237人参与
# 你觉得什么岗位会被AI替代 #
11249次浏览 141人参与
# 高学历就一定能找到好工作吗？ #
54942次浏览 607人参与
# 大厂VS公务员你怎么选 #
9176次浏览 170人参与
# 顺丰求职进展汇总 #
61281次浏览 301人参与
# 华为池子有多大 #
101323次浏览 731人参与
# 远程面试的尴尬瞬间 #
201979次浏览 1286人参与
# 工作中，努力重要还是选择重要？ #
203143次浏览 2060人参与
# 实习生应该准时下班吗 #
293950次浏览 1627人参与
# 面包vs爱情，怎么选？ #
21808次浏览 248人参与
# 面试时最害怕被问到的问题 #
634882次浏览 8709人参与
牛客网
牛客网在线编程
牛客网题解
牛客企业服务