牛客网编程OJ的总结

简单版：Scanner

1.输入已知大小的二维数组

 public static void main(String[] args) {
      Scanner scan = new Scanner(System.in);
      int n=scan.nextInt();//定义需要的阶层数n
      int[][]array=new int[n][n];//定义一个n*n的数组array
      System.out.println("输入数组的各个元素：");
      for(int i=0;i<n;i++) {
          for (int j = 0; j < n; j++) 
              array[i][j] = scan.nextInt();
      }
 }

2.判断子串是否与主串的某段相等

public class StringExist {
    public static void main(String [] args){
        //输入主串和子串
        Scanner input = new Scanner(System.in);
        String mainString = input.nextLine();
        String subString = input.nextLine();
        //判断方法调用
        boolean result = jugdeExist(mainString,subString);
        System.out.println(result);

    }
    //判断子串是否与主串的某段相等
    public static boolean jugdeExist(String mainString,String subString){
        if (null== mainString)return false;
            String[] forArray = mainString.split(",");
            for (String Id : forArray) {
                if(Id.equals(subString))
                    return true;
            }
        return false;
    }
}

升级版：Buffer和Stream

1.输入：第一行的第一个数字表示第二行数组的长度
7 6
1 2 3 4 5 6 7

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String line = input.readLine();// 读取第一行数据
String[] str = line.trim().split(" ");
int n = Integer.parseInt(str[0]);
int v = Integer.parseInt(str[1]);
line = input.readLine(); // 读取第二行数据
s = line.trim().split(" ");
// 创建一个int型的数组用来储存第二行的个数字
int[] nums = new int[n];
for (int i = 0; i < n; i ++) {
   nums[i] = Integer.parseInt(s[i]);
}   
// 测试输入是否正确
for (int num: nums) { System.out.print(num + " ");  }

2.二叉树的前中后序遍历

第一行输入两个整数 n 和 root，n表示二叉树的总节点数，root表示树的根节点。
接下来 n 行每行三个整数 fa，lch，rch，fa的左儿子为lch，右儿子为rch。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class Main {         
//第一步：定义树结点
    private static class TreeNode{
        TreeNode left;    TreeNode right;  int val;
        public TreeNode(int val) {
           this.val = val;   left = null;   right = null;
        }
    }
    //第二步：创建一个树的结点
    private static TreeNode createTreeCore(BufferedReader in) throws Exception{
        int[] nodes = getIntArray(in.readLine()); //把一行转为整数
        TreeNode node = new TreeNode(nodes[0]);//数组中第一个数是根节点
        //通过递归确定了层数
        if (nodes[1] != 0) node.left = createTreeCore(in);//左孩子
        if (nodes[2] != 0) node.right = createTreeCore(in); //右孩子
        return node;
    }
     //把接收到的字符串转换成整数
    private static int[] getIntArray(String str) {
        String[] temp = str.split(" ");
        int[] result = new int[temp.length];
        for (int i = 0; i < temp.length; i++) {
            result[i] = Integer.parseInt(temp[i]);}
        return result;
    }
    public static void main(String[] args) throws Exception{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        //将第一次换行符前的所有输入以空格分开并保存成字符串的形式
        String[] strings = bf.readLine().split(" ");
        StringBuilder sb = new StringBuilder();//作为结果的输出流
        TreeNode treeNode = createTreeCore(bf); //创建树
        preOrder(treeNode,sb); //前序遍历
        //因为在前序遍历时会多添加一个空格，因此这里最后一个空格不能读取
        System.out.println(sb.substring(0,sb.length()-1));
        sb.delete(0,sb.length());//清空
        innerOrder(treeNode,sb);//中序遍历
        System.out.println(sb.substring(0,sb.length()-1));
        sb.delete(0,sb.length());
        reviewOrder(treeNode,sb);
        System.out.println(sb.substring(0,sb.length()-1));
    }
    //前序遍历
    private static StringBuilder  preOrder(TreeNode treeNode,StringBuilder sb){
        if (treeNode==null) return null;
        sb.append(treeNode.val+" ");
        preOrder(treeNode.left,sb);
        preOrder(treeNode.right,sb);
        return sb;
    }
    //中序遍历
    private static StringBuilder innerOrder(TreeNode treeNode,StringBuilder sb){
        if (treeNode==null) return null;
        innerOrder(treeNode.left,sb);
        sb.append(treeNode.val).append(" ");//注意空格
        innerOrder(treeNode.right,sb);
        return sb;
    }
    private static StringBuilder reviewOrder(TreeNode treeNode,StringBuilder sb){
        if (treeNode==null) return null;
        reviewOrder(treeNode.left,sb);
        reviewOrder(treeNode.right,sb);
        sb.append(treeNode.val);
        sb.append(" ");
        return sb;
    }
}

3.安置路灯题
输入：输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含’.‘和’X’。
输出：对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。

public static void main(String[] args) throws IOException{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String sa = bf.readLine();
        int ca = Integer.valueOf(sa);// 转化包装类
        for(int i=0; i<ca; i++){
            int len = Integer.valueOf(bf.readLine());
            String s = bf.readLine();
            System.out.println(String.valueOf(lampSum(len,s)));
        }
    }

最后附比较有特点的一道2019网易游戏.会话列表题
输入的第一行为一个正整数T（T<=10），表示测试数据组数。
接下来有T组数据。每组数据的第一行为一个正整数N（1<=N<=200），表示接收到信息的次数。第二行为N个正整数，按时间从先到后的顺序表示接收到信息的会话id。会话id不大于1000000000。
输出描述：对于每一组数据，输出一行，按会话列表从上到下的顺序，输出会话id。
相邻的会话id以一个空格分隔，行末没有空格。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
    public static void main(String[] args) throws IOException {
      BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
      int n = Integer.parseInt(bf.readLine());//String对象转换为Integer对象
      for (int i = 0; i < n; i++) {
          int m = Integer.parseInt(bf.readLine());
          System.out.println(getDialogue(bf.readLine(),m));
      }
  }
    //用一个HashSet保存ID，做一个判断作用，从后往前遍历，如果set不包含该id，就添加进去。
  private static String getDialogue(String s, int m) {
      StringBuilder sb = new StringBuilder();
      HashSet<String> set = new HashSet<>();
      String[] ids = s.split(" ");
      for (int i = m - 1; i >= 0; i--) {
          if (!set.contains(ids[i])) {
              set.add(ids[i]);
              sb.append(ids[i]).append(" ");
          }   
      }
      return sb.substring(0,sb.length()-1).toString();
    }
}