java 快读快写应用及dfs走迷宫的实现

java 快读快写

快读

StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

①StreamTokenizer只能接收数字或字母，如果输入除空格和回车以外的字符
无法识别，会显示null。
②输入字符串的格式：不能含有数字，但可以含汉字，不然会显示null。
输入数字的格式：不能是字符。

• 用空格分隔每个输入数据，直到输入数据(不论格式是否正确）并输入回车才结束输入
• 每次输入前要执行st.nextToken();
• st.nval读取数值型数据（默认是double类型，可转换成其他类型）。
• st.sval读取字符串(因为是以空格分隔每个输入数据，所以当输入字符串含有一个空格，将被认为输入了两个数据，只接收第一个数据，空格后的字符串片段将被下一次读取时接收，因此不能用于输入带有空格的字符串），只能接收数字或字母，如果输入除空格和回车以外的字符无法识别，会显示null

若要输入带空格的字符串，建议使用

BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=in.read();//读取字符，并返回其ascii值。当输入97时，打印n为57，因为'9'的ascii值为57。注意；它不以空格分隔每个输入，若输入空格将会被认为该空格是一个输入数据
        int n2=in.read();
        String str=in.readLine();
        in.close();
        System.out.println(n+"  "+n2);
        System.out.println(str);
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        out.write(57);//默认接收参数为字符类型，所以输入57，将打印'9'。如果超过ascii的范围将无法显示。。
        out.flush();//必须flush,否则结果不会输出到控制台
/*测试用例:abcdefg
前两个字符被read接收，余下的被readLine接收，输出：
97  98
cdefg
9
*/

快写

PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

• pw.println(str);//输出字符串str后换行；pw.print(str);//不换行
• 只有执行了pw.flush()方法才会打印到控制台

代码示例

import java.io.*;
public class QuickyIO {
    public static void main(String[] args) throws IOException {
        StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        st.nextToken(); // 每输入一次数据前都应该执行
        double a = st.nval;//.nval读取数值型数据（默认是double类型，可转换成其他类型），
        st.nextToken();
        int n=(int)st.nval;
        System.out.println(n);
        st.nextToken();
        String b = st.sval;
        printWriter.println(""+n+"sdfh"+b);
        printWriter.flush();
    }
}

dfs走迷宫的实现

注意事项：

• if(findPath(x,y+1,aimx,aimy)||findPath(x+1,y,aimx,aimy)||findPath(x,y-1,aimx,aimy)||findPath(x-1,y,aimx,aimy)){//这里表明通过(x,y)点能到达目的地，所以递归将一路向上返回true，退出。
• if(map[y][x]==AIM)
  map[aimy][aimx]=PATH;
  这一步是需要的，因为到达了目的地，用于标记可以一路退出。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Scanner;
/*
起始点默认1，1
 */
public class MiGong {
    static int[][] map;
    static final int KONG=0;
    static final int AIM=1;
    static final int PATH=2;
    static final int WALL=3;
    static final int BLOCK=4;
    public static void main(String[] args) throws IOException {
        int len,width;
        StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        System.out.print("请输入迷宫规模(长宽大于2)"+"\n"+"请输入长度：");
        st.nextToken();
        len=(int)st.nval;
        System.out.print("请输入宽度：");
        st.nextToken();
        width=(int)st.nval;
        map=new int[len][width];
        for (int i = 0; i < len; i++) {
            map[i][0]=WALL;
            map[i][width-1]=WALL;
        }
        for (int j = 1; j < width-1; j++) {
            map[0][j]=WALL;
            map[len-1][j]=WALL;
        }
        //打印迷宫
        System.out.println("生成地图如下：");
        for(int[] ma:map){
            for(int i:ma){
                System.out.print(i+" ");
            }
            System.out.println();
        }
        System.out.print("请输入目标点坐标(左上角为（1,1)）：");
        st.nextToken();
        int aimx,aimy;
        aimx=(int)st.nval-1;
        st.nextToken();
        aimy=(int)st.nval-1;
        map[aimy][aimx]=AIM;
        System.out.println("随机生成障碍物中");
        for(int i=0;i<len;i++){
            int wx=(int)(Math.random()*(width-2)+1);
            int wy=(int)(Math.random()*(len-2)+1);
            if(map[wy][wx]==KONG&&!(wx==1&&wy==1))//不生成在非空或起始点
                map[wy][wx]=WALL;
            else
                i--;
            System.out.println(wx+":"+wy);
        }
        //打印迷宫
        System.out.println("生成地图如下：");
        for(int[] ma:map){
            for(int i:ma){
                System.out.print(i+" ");
            }
            System.out.println();
        }
        findPath(1,1,aimx,aimy);
        System.out.println("生成路径如下：");
        for(int[] ma:map){
            for(int i:ma){
                System.out.print(i+" ");
            }
            System.out.println();
        }

//            System.out.println("无路可走");
    }
    static boolean findPath(int x,int y,int aimx,int aimy){
        if(map[y][x]==AIM)
            map[aimy][aimx]=PATH;
        if(map[aimy][aimx]==PATH){
            return true;
        }
        if(map[y][x]!=KONG)//未到目的地且走不通
            return false;
        map[y][x]=PATH;//尝试加入路径
        if(findPath(x,y+1,aimx,aimy)||findPath(x+1,y,aimx,aimy)||findPath(x,y-1,aimx,aimy)||findPath(x-1,y,aimx,aimy)){//这里表明通过(x,y)点能到达目的地
            return true;
        }
        else{
            map[y][x]=BLOCK;//不能加入路径
            return false;
        }
    }

}
/*测试用例
请输入迷宫规模(长宽大于2)
请输入长度：6 6
请输入宽度：生成地图如下：
3 3 3 3 3 3 
3 0 0 0 0 3 
3 0 0 0 0 3 
3 0 0 0 0 3 
3 0 0 0 0 3 
3 3 3 3 3 3 
请输入目标点坐标(左上角为（1,1)）：3 4
随机生成障碍物中
3:1
2:3
4:4
3:3
4:4
1:4
1:2
4:1
生成地图如下：
3 3 3 3 3 3 
3 0 0 3 3 3 
3 3 0 0 0 3 
3 0 1 3 0 3 
3 3 0 0 3 3 
3 3 3 3 3 3 
生成路径如下： //用数字2标识，但有缺陷，路径可能形成一个面等，可能无法直观的表示具体路径。
3 3 3 3 3 3 
3 2 2 3 3 3 
3 3 2 0 0 3 
3 0 2 3 0 3 
3 3 0 0 3 3 
3 3 3 3 3 3 
*/

可以考虑把快读封装一下，就不用每次读取前写一遍st.nextToken()

import java.io.*;
class Myio{
    StreamTokenizer st;
    PrintWriter pw;
    public Myio() {
        this.st =new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        this.pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    }
    int readInt()throws IOException{
        st.nextToken();
        return (int)st.nval;
    }
    double readDouble()throws IOException{
        st.nextToken();
        return st.nval;
    }
    String readLine()throws IOException{
        st.nextToken();
        return st.sval;
    }
}

另有
优化版迷宫算法点此处