三角形类的数据摆放转矩阵、蛇形填数

原创已于 2023-04-02 17:59:01 修改 · 146 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2023-03-27 20:30:44 首次发布

java 同时被 3 个专栏收录

81 篇文章

订阅专栏

蓝桥杯

44 篇文章

订阅专栏

好题

20 篇文章

订阅专栏

文章展示了两种使用Java解决数学问题的方法：一种是通过找规律迭代，另一种是暴力打表法。第一段代码通过迭代计算特定序列的第20个数，而第二段代码通过填充矩阵直到找到第20行第20列的值。

直接上图模拟：

答案：761

AC代码1：（找规律）

import java.io.*;
import java.math.BigInteger;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = 100010;

    public static void main(String[] args) throws NumberFormatException, IOException
    {
        int i = 4;

        int cnt = 0; // 记录迭代次数，需要迭代19次
        int sum = 1;
        while(true)
        {
            sum += i;
            i += 4;
            cnt ++; // 迭代次数+1
            if(cnt == 19) // 求第20个数，迭代19次
            {
                pw.println(sum);
                pw.flush();
                return;
            }
        }
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException { return reader.readLine(); }
    static String next() throws IOException
    {
        while(!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException { return Integer.parseInt(next()); }
    static double nextDouble() throws IOException { return Double.parseDouble(next()); }
    static long nextLong() throws IOException { return Long.parseLong(next()); }
    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class math
{
    int gcd(int a,int b)
    {
        if(b == 0)  return a;
        else return gcd(b,a % b);
    }

    int lcm(int a,int b)
    {
        return a * b / gcd(a, b);
    }

    // 求n的所有约数
    List get_factor(int n)
    {
        List<Long> a = new ArrayList<>();
        for(long i = 1; i <= Math.sqrt(n) ; i ++)
        {
            if(n % i == 0)
            {
                a.add(i);
                if(i != n / i)  a.add(n / i);  // // 避免一下的情况：x = 16时，i = 4 ，x / i = 4的情况，这样会加入两种情况  ^-^复杂度能减少多少是多少
            }
        }

        // 相同因子去重，这个方法，完美
        a = a.stream().distinct().collect(Collectors.toList());

        // 对因子排序（升序）
        Collections.sort(a);

        return a;
    }

    // 判断是否是质数
    boolean check_isPrime(int n)
    {
        if(n < 2) return false;
        for(int i = 2 ; i <= n / i; i ++)  if (n % i == 0) return false;
        return true;
    }
}

class PII implements Comparable<PII>
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
    public int compareTo(PII a)
    {
        if(this.x-a.x != 0)
            return this.x-a.x;  //按x升序排序
        else return this.y-a.y;  //如果x相同，按y升序排序
    }
}

class Edge
{
    int a,b,c;
    public Edge(int a ,int b, int c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

AC代码2：（暴力打表）

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;



public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)200;
    static int a[][] = new int[N][N];

    public static void main(String[] args ) throws IOException
    {
        a[1][1] = 1;

        int num = 1;
        int row = 1;
        int col = 1;
        while(a[20][20] == 0) // 更新到a[20][20]退出循环
        {
            // 右移
            a[row][++col] = ++num;

            // 左下方
            while(col > 1)  a[++row][--col] = ++num; // 注意等于

            // 下移
            a[++ row][col] = ++num;
            while(row > 1)  a[--row][++ col] = ++num; // 注意等于
        }

        pw.println(a[20][20]);
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException  { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

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

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

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

    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}