liuchuo – 第51页 – 我不管，反正我最萌～

[Java] 蓝桥杯ADV-203 算法提高 8皇后·改

问题描述
规则同8皇后问题，但是棋盘上每格都有一个数字，要求八皇后所在格子数字之和最大。
输入格式
一个8*8的棋盘。
输出格式
所能得到的最大数字和
样例输入
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48
48 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64
样例输出
260
数据规模和约定
棋盘上的数字范围0~99

package adv203;

import java.util.Scanner;

public class Main {
    private static int[][] cheese = new int[8][8];

    private static int[] pos = new int[8];

    private static int maxValue = 0;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                cheese[i][j] = in.nextInt();
            }
        }
        in.close();
        dfs(0, 0);

        System.out.println(maxValue);
    }

    private static boolean isOk(int row) {
        for (int i = 0; i < row; i++) { if (pos[row] == pos[i] || row - i == Math.abs(pos[row] - pos[i])) { return false; } } return true; } private static void dfs(int row, int maxTempValue) { if (row >= 8) {
            maxValue = Integer.max(maxValue, maxTempValue);
            return;
        }

        for (pos[row] = 0; pos[row] < 8; pos[row]++) {
            if (isOk(row)) {
                dfs(row + 1, maxTempValue + cheese[row][pos[row]]);
            }
        }
    }
}

package adv203;

import java.util.Scanner;

public class Main {

private static int[][] cheese = new int[8][8];

private static int[] pos = new int[8];

private static int maxValue = 0;

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

for (int i = 0; i < 8; i++) {

for (int j = 0; j < 8; j++) {

cheese[i][j] = in.nextInt();

}

in.close();

dfs(0, 0);

System.out.println(maxValue);

}

private static boolean isOk(int row) {

for (int i = 0; i < row; i++) { if (pos[row] == pos[i] || row - i == Math.abs(pos[row] - pos[i])) { return false; } } return true; } private static void dfs(int row, int maxTempValue) { if (row >= 8) {

maxValue = Integer.max(maxValue, maxTempValue);

return;

}

for (pos[row] = 0; pos[row] < 8; pos[row]++) {

if (isOk(row)) {

dfs(row + 1, maxTempValue + cheese[row][pos[row]]);

}

[Java] 蓝桥杯ADV-209 算法提高 c++_ch02_04

问题描述
输出1~100间的质数并显示出来。注意1不是质数。
输出格式
每行输出一个质数。
2
3
…
97

package adv209;

public class Main {

    public static void main(String[] args) {
        boolean[] prime = new boolean[101];
        setPrime(prime);
        for (int i = 2; i < prime.length; i++) {
            if (prime[i]) {
                System.out.println(i);
            }
        }
    }
    
    private static void setPrime (boolean[] prime) {
        for (int i = 1; i < prime.length; i++) {
            prime[i] = true;
        }
        
        for (int i = 2; i < 100; i++) {
            for (int j = 2; i * j <= 100; j++) {
                prime[i * j] = false;
            }
        }
    }

}

package adv209;

public class Main {

public static void main(String[] args) {

boolean[] prime = new boolean[101];

setPrime(prime);

for (int i = 2; i < prime.length; i++) {

if (prime[i]) {

System.out.println(i);

}

private static void setPrime (boolean[] prime) {

for (int i = 1; i < prime.length; i++) {

prime[i] = true;

}

for (int i = 2; i < 100; i++) {

for (int j = 2; i * j <= 100; j++) {

prime[i * j] = false;

}

[Java] 蓝桥杯ADV-210 算法提高 2-1屏幕打印

样例输出
**********************
* My first C program *
**********************

package adv210;

public class Main {

    public static void main(String[] args) {
        System.out.println("**********************");
        System.out.println("* My first C program *");
        System.out.println("**********************");
    }

}

package adv210;

public class Main {

public static void main(String[] args) {

System.out.println("**********************");

System.out.println("* My first C program *");

System.out.println("**********************");

}

[Java] 蓝桥杯ADV-213 算法提高 3-2求存款

问题描述
见计算机程序设计基础（乔林）P50第5题。
接受两个数，一个是用户一年期定期存款金额，一个是按照百分比格式表示的利率，计算一年期满后的本金与利息总额。说明：(1) 存款金额以人民币元为单位，精确到分；(2) 输入利率时不输入百分号，例如利率为3.87%，用户直接输入3.87；(3) 按照国家法律，存储利息所得需缴纳5%的所得税，计算结果时应当扣除所得税。(4) 显示的结果精确到人民币分。
注意：数据须用float表示；计算结果须保存到一个float变量中，再用printf输出。
输入格式
一行，以一个空格隔开的两个浮点数。
输出格式
一个浮点数。
样例输入
5000.00 5.00
样例输出
5237.50
数据规模和约定
输入数据中每一个数的范围。本金<100000000，利息<100

package adv213;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        float balance = in.nextFloat();
        float ratio = in.nextFloat();
        in.close();
        System.out.printf("%.2f", (float)(balance + balance * 0.95 * ratio / 100.0));
    }

}

package adv213;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

float balance = in.nextFloat();

float ratio = in.nextFloat();

in.close();

System.out.printf("%.2f", (float)(balance + balance * 0.95 * ratio / 100.0));

}

[Java] 蓝桥杯ADV-214 算法提高 3-3求圆面积表面积体积

问题描述
接受用户输⼊的数值，输出以该值为半径的(1)圆面积，(2)球体表面积，(3)球体体积。pi 取值3.1415926536 ，结果保留10位小数，每一列占20个字符，左对齐。
样例输入
一个满足题目要求的输入范例。
例：
1
样例输出
与上面的样例输入对应的输出。
例：(第一行1是输入，第二行是输出)

数据规模和约定
所有结果在double类型的表示范围内。

package adv214;

import java.util.Scanner;

public class Main {

    private final static double p = 3.1415926536;
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double r = in.nextDouble();
        in.close();
        
        System.out.printf("%.10f ", p * r * r);
        System.out.printf("%.10f ", 4 * p * r * r);
        System.out.printf("%.10f ", 4.0 / 3 * p * r * r * r);
    }

}

package adv214;

import java.util.Scanner;

public class Main {

private final static double p = 3.1415926536;

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

double r = in.nextDouble();

in.close();

System.out.printf("%.10f ", p * r * r);

System.out.printf("%.10f ", 4 * p * r * r);

System.out.printf("%.10f ", 4.0 / 3 * p * r * r * r);

}

[Java] 蓝桥杯ADV-147 算法提高学霸的迷宫

问题描述
学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。
输入格式
第一行两个整数n， m，为迷宫的长宽。
接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。
输出格式
第一行一个数为需要的最少步数K。
第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。
样例输入
Input Sample 1:
3 3
001
100
110
Input Sample 2:
3 3
000
000
000
样例输出
Output Sample 1:
4
RDRD
Output Sample 2:
4
DDRR
数据规模和约定
有20%的数据满足：1<=n,m<=10
有50%的数据满足：1<=n,m<=50
有100%的数据满足：1<=n,m<=500。

package adv147;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

    public static int isVisited[][];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        char[][] maze = new char[n][m];
        isVisited = new int[n][m];
        for (int i = 0; i < n; i++) {
            maze[i] = in.next().toCharArray();
        }
        in.close();

        Queue queue = new LinkedList<>();
        queue.add(new Index(0, 0));
        Index e = new Index(n-1, m-1);
        isVisited[0][0] = 1;
        bfs(maze, queue, e);
        printPath(n-1, m-1, n, m);
    }

    public static void bfs(char[][] maze, Queue q, Index e) {
        Queue queue = new LinkedList<>();

        while (!q.isEmpty()) {
            Index s = q.poll();

            if (s.equals(e)) {
                System.out.println(isVisited[s.r][s.l] - 1);
                return;
            }

            // Down
            if (s.r + 1 <= e.r && isVisited[s.r + 1][s.l] == 0 && maze[s.r+1][s.l] == '0') { queue.add(new Index(s.r + 1, s.l)); isVisited[s.r+1][s.l] = isVisited[s.r][s.l] + 1; } // Left if (s.l >= 1 && isVisited[s.r][s.l - 1] == 0 && maze[s.r][s.l - 1] == '0') {
                queue.add(new Index(s.r, s.l - 1));
                isVisited[s.r][s.l - 1] = isVisited[s.r][s.l] + 1;
            }

            // Right
            if (s.l + 1 <= e.l && isVisited[s.r][s.l + 1] == 0 && maze[s.r][s.l + 1] == '0') { queue.add(new Index(s.r, s.l+1)); isVisited[s.r][s.l + 1] = isVisited[s.r][s.l] + 1; } // Up if (s.r >= 1 && isVisited[s.r - 1][s.l] == 0 && maze[s.r - 1][s.l] == '0') {
                queue.add(new Index(s.r - 1, s.l));
                isVisited[s.r - 1][s.l] = isVisited[s.r][s.l] + 1;
            }
        }

        bfs(maze, queue, e);
    }

    public static void printPath(int r, int l, int n, int m) {
        if (r == 0 && l == 0) {
            return;
        }

        if (r+1 < n && isVisited[r][l] - 1 == isVisited[r+1][l]) { // Down printPath(r+1, l, n, m); System.out.print("U"); } else if (l>=1 && isVisited[r][l] - 1 == isVisited[r][l-1]) {
            // Left
            printPath(r,l-1, n, m);
            System.out.print("R");
        } else if (l +1 < m && isVisited[r][l] - 1 == isVisited[r][l+1]) { // Right printPath(r, l+1, n, m); System.out.print("L"); } else if (r >= 1 && isVisited[r][l] - 1 == isVisited[r-1][l]) {
            // Up
            printPath(r-1, l, n, m);
            System.out.print("D");
        }
    }


}

class Index {
    int r;
    int l;

    public Index (int r, int l) {
        this.r = r;
        this.l = l;
    }

    public boolean equals(Index e) {
        return r == e.r && l == e.l;
    }

}

package adv147;

import java.util.LinkedList;

import java.util.Queue;

import java.util.Scanner;

public class Main {

public static int isVisited[][];

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int m = in.nextInt();

char[][] maze = new char[n][m];

isVisited = new int[n][m];

for (int i = 0; i < n; i++) {

maze[i] = in.next().toCharArray();

}

in.close();

Queue queue = new LinkedList<>();

queue.add(new Index(0, 0));

Index e = new Index(n-1, m-1);

isVisited[0][0] = 1;

bfs(maze, queue, e);

printPath(n-1, m-1, n, m);

}

public static void bfs(char[][] maze, Queue q, Index e) {

Queue queue = new LinkedList<>();

while (!q.isEmpty()) {

Index s = q.poll();

if (s.equals(e)) {

System.out.println(isVisited[s.r][s.l] - 1);

return;

}

// Down

if (s.r + 1 <= e.r && isVisited[s.r + 1][s.l] == 0 && maze[s.r+1][s.l] == '0') { queue.add(new Index(s.r + 1, s.l)); isVisited[s.r+1][s.l] = isVisited[s.r][s.l] + 1; } // Left if (s.l >= 1 && isVisited[s.r][s.l - 1] == 0 && maze[s.r][s.l - 1] == '0') {

queue.add(new Index(s.r, s.l - 1));

isVisited[s.r][s.l - 1] = isVisited[s.r][s.l] + 1;

}

// Right

if (s.l + 1 <= e.l && isVisited[s.r][s.l + 1] == 0 && maze[s.r][s.l + 1] == '0') { queue.add(new Index(s.r, s.l+1)); isVisited[s.r][s.l + 1] = isVisited[s.r][s.l] + 1; } // Up if (s.r >= 1 && isVisited[s.r - 1][s.l] == 0 && maze[s.r - 1][s.l] == '0') {

queue.add(new Index(s.r - 1, s.l));

isVisited[s.r - 1][s.l] = isVisited[s.r][s.l] + 1;

}

bfs(maze, queue, e);

}

public static void printPath(int r, int l, int n, int m) {

if (r == 0 && l == 0) {

return;

}

if (r+1 < n && isVisited[r][l] - 1 == isVisited[r+1][l]) { // Down printPath(r+1, l, n, m); System.out.print("U"); } else if (l>=1 && isVisited[r][l] - 1 == isVisited[r][l-1]) {

// Left

printPath(r,l-1, n, m);

System.out.print("R");

} else if (l +1 < m && isVisited[r][l] - 1 == isVisited[r][l+1]) { // Right printPath(r, l+1, n, m); System.out.print("L"); } else if (r >= 1 && isVisited[r][l] - 1 == isVisited[r-1][l]) {

// Up

printPath(r-1, l, n, m);

System.out.print("D");

}

class Index {

int r;

int l;

public Index (int r, int l) {

this.r = r;

this.l = l;

}

public boolean equals(Index e) {

return r == e.r && l == e.l;

}