牛客周赛 Round 92 题解 Java

最新推荐文章于 2025-05-12 23:16:27 发布
最新推荐文章于 2025-05-12 23:16:27 发布
阅读量472 收藏 9
点赞数 3
分类专栏： # 算法题记录 算法与数据结构 web开发基础 文章标签： 算法 数据库 java 开发语言 sql mysql 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30500575/article/details/147879186
版权

目录

A 小红的签到题

B 小红的模拟题

C 小红的方神题

D 小红的数学题

E 小红的 ds 题

F 小红的小苯题

A 小红的签到题

直接构造类似于 a_aaaa，a_aaaaaaaa 这种 即可

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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();
        dduo("a_");
        for(int i=0;i<n-2;i++) {
        	dduo("a");
        }
    }

    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 小红的模拟题

第一眼以为是 dfs

但是看到了

只有一个陷阱格子

所以只要规定一条到终点的路线 先一直往右走 再一直往下走

如果陷阱格子在这条线路上

就一直往下走 再一直往右走 以到达终点

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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();
        
        char arr[][]=new char[n][m];
        for(int i=0;i<n;i++) {
        	String str=sc.next();
        	arr[i]=str.toCharArray();
        }
        
        int x=0;
        int y=0;
        for(int i=0;i<n;i++) {
        	for(int j=0;j<m;j++) {
        		if(arr[i][j]=='#') {
        			x=i;
        			y=j;
        		}
        	}
        }
        
        if(x==0||y==m-1) {
          	for(int i=0;i<n-1;i++) {
        		dduo("S");
        	}
        	for(int i=0;i<m-1;i++) {
        		dduo("D");
        	}
        }else if(y==0||x==n-1){
        	for(int i=0;i<m-1;i++) {
        		dduo("D");
        	}
        	for(int i=0;i<n-1;i++) {
        		dduo("S");
        	}
        }else {
        	for(int i=0;i<n-1;i++) {
        		dduo("S");
        	}
        	for(int i=0;i<m-1;i++) {
        		dduo("D");
        	}
        }
        
    }

    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());
    }
}

C 小红的方神题

其实我想了一会

然后根据样例试了试

输入 4

1 4 3 2

输入 5

1 5 4 3 2

都是符合的

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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();
        
        if(n==1||n==2) {
        	dduoln("-1");
        	return;
        }
        
        dduo(1+" ");
        
        for(int i=n;i>=2;i--) {
        	dduo(i+" ");
        }
    }

    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 小红的数学题

我的首先想到的是韦达定理

要求是 x1 x2 互不相同 而且 x1+x2+x1*x2==k

之后 x1+x2 为 p ，x1*x2 为 q

其次进行了打表

获取了大量数据

发现奇数的话 是一定可以的 只要构造其中一个数为 1 即可

接着是偶数

我找出的规律是这样的

然后根据规律推

放大循环的次数 就过了

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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
    	
//    	TreeSet<Integer>hs=new TreeSet<>();
//    	for(int i=1;i<=100;i++) {
//    		for(int j=i+1;j<=100;j++) {
//    			// k
//    			if( (i+j+i*j) %2==0) {
//    				dduoln((i+j)+" "+(i*j)+" "+(i+j+i*j));	
//    			}
//    			hs.add((i+j+i*j));
//    		}
//    	}
//    	
//    	for(Integer i:hs) {
//    		if(i%2==0) {
//    			dduoln(i);
//    		}
//    	}
    	
    	long k=sc.nextLong();
    	if(k%2!=0) {
    		// 奇数
    		if(k==1||k==3) {
    			dduoln("-1");
    			return;
    		}
    		long ans1=k-1;
    		ans1/=2;
    		long ans2=(1+ans1);
    		dduoln((ans1)+" "+(ans2));	
    	}else {
    		// 偶数
    		long zuobian=14;
    		long youbian=6;
    		
    		long zuopbianjia=12;
    		long youbianjia=4;
    		
    		// todo
    		for(int i=0;i<1000000;i++) {
    			if(k-zuobian<0) {
    				dduoln("-1");
    				return;
    			}
    			long youbianshengxialai=k-zuobian;
    			if(youbianshengxialai%youbian==0) {
    				long nn=youbianshengxialai/youbian;
//    				dduoln(nn);
//    				dduoln((zuobian-youbian)+" "+nn*(youbian-2));
    				dduoln((youbian+2*nn)+" "+((zuobian-youbian)+(nn*(youbian-2))));
    				return;
    			}
    			zuopbianjia+=8;
    			zuobian+=zuopbianjia;
    			youbian+=youbianjia;
    		}
    	}
        
        
    }

    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 小红的 ds 题

我感觉这题的难度小于 D

给出二叉树每一层的节点

然后构造出二叉树

每个节点有 0 个 1 个 2 个节点

我们直接顺着往下构造就行

直接一层一层推

什么情况下构造不出来呢

当这下层的节点数大于这一层的两倍时无法构造 因为这一层的每个节点最多连下一层的两个节点

接着就是一个个构造

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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 arr[]=new long[n+1];
    	for(int i=1;i<=n;i++) {
    		arr[i]=sc.nextLong();
    	}
    	
    	for(int i=2;i<=n;i++) {
    		if( (arr[i]) > (arr[i-1]*2) ) {
    			dduoln("-1");
    			return;
    		}
    	}
    	
    	dduoln("1");
    	
    	long cnt=2;
    	
    	for(int i=1;i<=n;i++) {
    		long ans=arr[i]; // 当前层有多少节点
    		if(i==n) {
        		// 最后一层
    			for(int j=0;j<ans;j++) {
    				dduoln("-1 -1");
    			}
    		}else {
    			// 下一层有多少个节点
    			long next=arr[i+1];
//    			cnt+=ans;
    			for(int j=0;j<ans;j++) {
    				if(next>=2) {
        				dduo(cnt);
        				dduo(" ");
        				cnt++;
        				dduoln(cnt);
        				cnt++;
        				next-=2;
        			}else if(next==1){
        				dduo(cnt);
        				dduo(" ");
        				cnt++;
        				dduoln("-1");
        				next-=1;
        			}else {
        				dduoln("-1 -1");
        			}
    			}    			
    		}
//			cnt+=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());
    }
}

F 小红的小苯题

构造一个矩阵 每行每列的异或和构成排列

这样构造 然后正好要满足这个情况

就是 行加列%4==3

很奇妙！

// @github https://github.com/Dddddduo
// @github https://github.com/Dddddduo/acm-java-algorithm
// @github https://github.com/Dddddduo/Dduo-mini-data_structure
import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
import java.time.*;

/**
 * 题目地址
 *
 */

// xixi♡西
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
     */
    
    // 2 5
    // 0 0 0 0 7
    // 1 2 3 4 2
    private static void solve() throws IOException {
        // todo
    	  int n = sc.nextInt();
          int m = sc.nextInt();
          int k = n + m;
          
          if (k % 4 != 3) {
              dduoln("-1");
              return;
          }

          // 行
          int[] rows = new int[n];
          for (int i = 0; i < n; i++) {
              rows[i] = k - i;
          }
          
          // 列
          int[] cols = new int[m];
          for (int i = 0; i < m; i++) {
              cols[i] = i + 1;
          }

          int[][] arr = new int[n][m];
          for (int i = 0; i < n - 1; i++) {
              for (int j = 0; j < m - 1; j++) {
            	  arr[i][j] = 0;
              }
              arr[i][m - 1] = rows[i];
          }

          if (m == 0) {
        	  dduoln("-1");
              return;
          }

          // 列处理
          for (int j = 0; j < m - 1; j++) {
        	  arr[n - 1][j] = cols[j];
          }

          int ans = 0;
          for (int i = 0; i < n - 1; i++) {
        	  ans ^= rows[i];
          }
          
          int x = cols[m - 1] ^ ans;
          arr[n - 1][m - 1] = x;

          for (int i = 0; i < n; i++) {
              int xor = 0;
              for (int num : arr[i]) {
                  xor ^= num;
              }
              assert xor == rows[i] : "Row " + i + " xor error";
          }

          for (int j = 0; j < m; j++) {
              int xor = 0;
              for (int i = 0; i < n; i++) {
                  xor ^= arr[i][j];
              }
              assert xor == cols[j] : "Col " + j + " xor error";
          }

          for (int[] row : arr) {
              StringBuilder sb = new StringBuilder();
              for (int num : row) {
                  sb.append(num).append(" ");
              }
              dduoln(sb.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());
    }
}
牛客周赛 Round 82 题解
Crasen_ka的博客
02-26 1120
这次周赛难度偏低，F题类似于cf的构造。
牛客周赛 Round 46 题解 C++
2202_75334392的博客
06-10 747
【代码】牛客周赛 Round 46 题解 C++
牛客周赛 Round 54 题解（A~E）
TCaaaaa的博客
08-05 617
思路解析:显然只需要数字符串的的个数即可。ON。
牛客周赛 Round 92-题解
hongjianMa的博客
05-11 564
长度为。
牛客周赛 Round 38 题解
2303_76151267的博客
03-25 978
牛客周赛 Round 38 全题解
题解 | 牛客周赛 Round 49 DEF Java题解
2301_78234743的博客
07-01 796
完全找不到工作，走的是运维方向，写代码能力挺差的。我投的太晚了到现在都没几次面试，大多都是已读不回，最近有同学吐槽了自己当年选择offer的问题，大厂的边缘业务和小的公司的核心业务，最终选择了大厂的边。宇通专业面强度校核具体是怎么校核的，关注应力还是关注位移产品的寿命通常是怎么计算的，需要知道哪些参数。----------时间线------------2024.5.30 | 线上投递简历2024.5.24届已经入职快三个月了，技术太菜了，领导给了一个模块功能搞了快三个星期还没咋完全实现，我在想我是不。
题解 | 牛客周赛 Round 47 CDEF Java题解
han_xue_feng的博客
06-18 1782
如题，本人四川非川大985毕业，gap一年申到港理硕士，本硕专业都是大数据人工智能相关，求职方向是数。40多分钟，凭记忆写一下static关键字作用-1的原码，反码，补码数组和链表的区别vector e。24应届 0 offer，想找个后端开发或者java，求佬痛批简历，顺便找找工作，大公司已经不敢奢求。想找个B端销售的工作来实习一下，从而丰富一下履历，我这简历真的没有什么写的 #实习，投递多份简历没人。不太清楚两个公司的发展情况，感觉都还不错。二选一，都是央企，本2硕9，女生，城市都在一线，软件专业。
题解 | 牛客周赛 Round 41 BCDEF Java
华鑫的专栏
05-06 1172
上学的时候就很想去立白工作了，偶然机会投了立白集团，很幸运被“翻牌”面试啦，面试感觉上还是很不错的，电网省职能部门，固定市区位置，但感觉属于电网边缘部门，未来发展空间小，只能在部门内部发展。拼多多和雷火，暑期实习拼多多服务端，主管面是一个Java岗，数据管理相关的。中建三局，宁德时代，金证科技，途游游戏，得物，蓝禾，顺丰，康冠科技24春招内推①得物【岗位】技术，设。专升本民办，后端开发实在走不动流程，现在有个广州小厂安卓开发9.6k，年终奖2个，再犹豫要不要去。周末回家，2号又回北京看房子，三号搬家。
牛客周赛 Round 50
2301_80105412的博客
07-08 665
牛客周赛 Round 50 ABCDE
牛客周赛 Round 62_小红的中位数查询（easy）
2302_80127404的博客
09-30 650
当窗口大小等于区间长度时，由于窗口中的数有序，且区间长度为奇数，所以最中间的数为该段区间的中位数，同时该数也为以当前查插入数的位置为右端点区间的中位数。由此可以枚举出所有数组中所有长度等于k的区间的中位数，然后在根据右端点查询，代码时间复杂度大约为O(n*log n)，在可接受范围内。先不断向窗口中按顺序插入数，利用二分函数lower_bound()找到该数的位置插入，可以保证该窗口的所有元素都是有序的。由于每一组测试样例的区间长度都相同，本题可以用一个长度为k的滑动窗口来维护查询每个区间的中位数。
牛客周赛 Round 55（解题）
m0_60738889的博客
08-13 1071
本质上就是bfs，但只不过我们这道题建图有点麻烦，我们得考虑每行的最近点对和每列的，我们要搞虫洞，我们可以用二维数组来装一下在。这道题就是dp问题，类似数位dp，我们可以设：f[i][j]表示已经到了第i个位置，当前位的是j的方案数集合。这道题就是计算几何的基础应用，其实就是算直线跟圆的交点，然后所有交点算完之后存储起来最后做区间合并就可以了。的位置，然后每行每列找到之后，我们就将它们建图，最后我们只需要跑个最短路（我这边用的是bfs）即可解决。就是直接看个位数就可以了，别的不管。我们就直接排个序即可。
牛客周赛 Round 60(思维、逆元、组合数、概率DP)
mldl_的博客
09-18 500
牛客周赛 Round 60题解。
牛客周赛 [Round 63] E、F
m0_73494480的博客
10-16 715
小红每次操作可以选择一盏灯，改变和它同一行以及同一列所有的灯（包括它自己）的开关状态。现在，考虑翻转的情况，很显然这道题肯定也是用这种计算贡献的方法（不然不会给给定字符串。首先，考虑改变一个灯的状态，那么其会改变和它有关的灯的状态，相当于对其。子序列（子序列可以不连续）。是通过那些数字异或得到的，由于灯按两次等于没按，因此要使用异或。首先，加入没有区间翻转，那么这是一个经典的计算贡献问题，记。翻转之后，会产生什么影响，首先不在翻转区间内的。的位置产生的贡献肯定不会变，在区间。注意，这个算的是翻转区间内的。
牛客周赛 Round 14 题解报告 | 珂学家 | 环形模拟 + 滑窗&amp；前缀和&amp；二分 + 数学
2301_78234743的博客
10-08 392
终于终于有面试了，虽然只面了20几分钟，面试官好像是蚂蚁的，人巨好，不会还一直引导我....主要就是讲了讲实习和项目，再从项目引申了几点：1，实习项目，遇到啥困。怎么说呢，22往届，趁着今年三四月份春招找了个渠道开发的工作干了一个多月跑了，最近又蹭秋招拿了第二份技术管培的岗位，工业制造企业要参与公司的信息化项目，待遇也还。第一题：染色有一个树，根节点是1，你可以给它染红，蓝，绿三种颜色，但是每一个结点的染色不能和他的父亲结点和爷爷结点颜色相同。二面20min 光问项目细节，后来没啥问了，就开始手撕。
力扣 旋转图像
最新发布
fancy166166的博客
05-12 260
创建一个新的数组，存储旋转后的数组，将数组的第一行存到新创的数组空间的最后一列。
2025.05.07-淘天研发岗-第一题
春秋招笔试突围
05-09 133
她发现，当且仅当一组结晶石的能量乘积是完全平方数时，这组结晶石能够产生共振。完全平方数是指可以表示为某个整数的平方的数，如1、4、9等。要使乘积是完全平方数，我们需要所有质因子的指数和都是偶数。总体来说，这道题的难点在于将"乘积是完全平方数"转化为"所有质因子的指数和都是偶数"，并利用位运算高效地判断和统计符合条件的组合。我们知道，一个数是完全平方数当且仅当它的所有质因子的指数都是偶数。比如说，4 = 2² 是完全平方数，而6 = 2¹ × 3¹ 不是完全平方数，因为2和3的指数都是1（奇数）。
趣谈Ai各种模型算法及应用
m0_68856746的博客
05-12 1111
大家好！今天，我们来聊一个让很多初学者甚至有经验的开发者都头疼的问题：面对琳琅满目的机器学习和深度学习模型，到底该如何选择？就像走进一家拥有无数工具的五金店，如果你不知道每件工具的用途，很容易就挑花了眼。
【Python】异步优势演员-评论家（A3C）算法在Python中的实现与应用
一个被知识诅咒的人
05-11 1246
在深度强化学习（DRL）领域，异步优势演员-评论家（A3C）算法作为一种高效的强化学习方法，广泛应用于各种决策问题和智能控制领域。A3C算法通过使用多个线程并行地探索环境，提高了训练效率并减少了计算资源的消耗。本文详细介绍了A3C算法的核心原理，并通过Python实现了一个简单的深度强化学习模型。文章中包含了A3C算法的数学基础、模型架构、代码实现以及训练过程的详细步骤。通过结合大量的代码和中文注释，本文旨在帮助读者深入理解A3C算法的实现和应用，进而为更复杂的强化学习问题提供指导和参考。
YOLO目标检测算法评估标准
jdjhcn的博客
05-10 1063
不同类型的模型，评估指标各有侧重。分类模型中，准确率反映预测正确的整体比例；精确率关注预测正例中实际正例的占比；召回率衡量实际正例被正确预测的程度；F1 值综合精确率与召回率，适合样本不均衡场景。回归模型里，均方误差计算预测值与真实值误差平方的均值，能体现平均差异；平均绝对误差以误差绝对值平均，对异常值敏感度低；聚类模型中，轮廓系数综合凝聚度和分离度，值近 1 代表聚类佳。那么我们今天学习的YOLO目标检测模型使用什么指标评估模型的效果。
牛客周赛round83
03-30
关于牛客网 Round 83 的具体题目和解答，目前并未提供直接的引用支持。然而，可以基于以往的经验以及类似的周赛模式来推测可能涉及的内容结构。 通常情况下，牛客周赛会包含多个不同难度级别的题目，从简单的签到题（A 类型）到较难的挑战性问题（E 或 F 类型）。以下是根据已有经验构建的一般框架： ### 牛客周赛 Round 83 可能的主题 #### A - 签到题 这类题目通常是简单算法的应用或者基础逻辑判断。例如： ```python def solve_a(): n = int(input()) result = sum(range(1, n + 1)) # 计算前N项自然数之和 print(result) solve_a() ``` 此部分无需深入解析，主要考察参赛者的基础编程能力[^1]。 #### B - 中等难度题 此类题目可能会涉及到数组操作、字符串处理或基本数据结构应用。比如给定一段文字统计特定字符频率的问题。 ```python from collections import Counter def solve_b(): s = input().strip() counter = Counter(s) most_common_char, count = counter.most_common(1)[0] print(most_common_char, count) solve_b() ``` 上述代码片段展示了如何利用Python内置库快速解决常见计数类问题[^2]。 #### C/D/E/F 更高阶挑战 这些更复杂的任务往往需要运用高级技巧如动态规划(DP)，图论(Graph Theory)或者其他专门领域知识才能有效完成。由于缺乏具体的Round 83资料，这里仅给出一个假设性的例子有关最短路径寻找: ```python import heapq INF = float('inf') def dijkstra(graph, start_node): distances = {node: INF for node in graph} distances[start_node] = 0 priority_queue = [(0, start_node)] while priority_queue: current_distance, current_vertex = heapq.heappop(priority_queue) if current_distance > distances[current_vertex]: continue for neighbor, weight in graph[current_vertex].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances graph_example = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } print(dijkstra(graph_example, 'A')) ``` 这段程序实现了经典的迪杰斯特拉算法用于求解加权无向图中的单源最短路径问题[^3]. 尽管无法确切知道每道实际考题是什么样子，但通过以上介绍应该能够帮助理解一般竞赛形式下的潜在考点及其解决方案设计方法.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是一只多多

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值