hnucm_oj 算法分析与设计 练习14

湖中大OJ

问题 A: 菱形图案

题目描述
KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“*”组成的菱形图案。

输入
多组输入，一个整数（2~20）。

输出
针对每行输入，输出用“”组成的菱形，每个“”后面有一个空格。每输出一个菱形的后面需要空一行。

样例输入
2
3
4

样例输出

  * 
 * * 
* * * 
 * * 
  * 

   * 
  * * 
 * * * 
* * * * 
 * * * 
  * * 
   * 

    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 

代码：

import java.util.Scanner;
   
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            printf(0,n);
            System.out.println();
        }
    }
     
    public static void printf(int k,int m) {
    	//最后一行只需要输出一遍
        if(k==m) {
            for(int i=0;i<m-k;i++) {
                System.out.print(" ");
            }
            for(int i=0;i<k+1;i++) {
                System.out.print("* ");
            }
            System.out.println();
            return;
        }
        for(int i=0;i<m-k;i++) {
            System.out.print(" ");
        }
        for(int i=0;i<k+1;i++) {
            System.out.print("* ");
        }
        System.out.println();
        printf(k+1,m);
        for(int i=0;i<m-k;i++) {
            System.out.print(" ");
        }
        for(int i=0;i<k+1;i++) {
            System.out.print("* ");
        }
        System.out.println();
    }
}

解题思路：每一次递归除了最中间的一行都要输出两遍，所以结束条件就是最后一行并且只输出一行。

问题 B: 牛妹的蛋糕

题目描述
众所周知，牛妹非常喜欢吃蛋糕。
第一天牛妹吃掉蛋糕总数三分之一多一个，第二天又将剩下的蛋糕吃掉三分之一多一个，以后每天吃掉前一天剩下的三分之一多一个，到第n天准备吃的时候只剩下一个蛋糕。
牛妹想知道第一天开始吃的时候蛋糕一共有多少呢？

输入
输入n，0<n< 30。

输出
输出第一天蛋糕的数量。

样例输入
2
4

样例输出
3
10

代码：

import java.util.Scanner;
   
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            int rel = printf(1,n);
            System.out.println(rel);
        }
    }
     
    public static int printf(int k,int n) {
        if(k==n) {
            return 1;
        }
        return (printf(k+1,n)+1)*3/2;
    }
}

解题思路：规规矩矩的递归求解。

问题 C: 尼科彻斯定理

题目描述
验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
例如：
1^3=1
2^3=3+5
3^3=7+9+11
4^3=13+15+17+19

输入
多组输入，输入一个整数。

输出
输出分解后的字符串。

样例输入
6
样例输出
31+33+35+37+39+41

代码：

import java.util.Scanner;
   
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            int sum = 0;
            int m = n*n*n;
            //sum代表1到m-1的和乘2
            for(int i=1;i<=n-1;i++) {
                sum+=i*2;
            }
            m = (m-sum)/n;
            System.out.print(m);
            for(int i=1;i<n;i++) {
                m = m+2;
                System.out.print("+"+m);
            }
            System.out.println();
        }
    }
}

解题思路：先找规律求出第一个数，然后递归输出解。

问题 D: ABC + DEF = GHI

题目描述
用1, 2, 3…9 这九个数字组成一个数学公式，满足：ABC + DEF = GHI，每个数字只能出现一次，编写程序输出所有的组合。

输入
无

输出
输出所有的 ABC + DEF = GHI，
每行一条数据，格式为ABC+DEF=GHI
输出结果按照ABC升序排列，如果ABC相同，则按照DEF升序排列。

代码：

public class Main {
    public static void main(String[] args) {
        int[] a = new int[10];
        int[] b = new int[10];
        miumiumama(1,a,b);
    }
     
    public static void miumiumama(int k,int[] a,int[] b) {
        if(k==9) {
            for(int i=1;i<10;i++) {
                if(a[i]==0) {
                    b[k]=i;
                }
            }
            if(b[1]*100+b[2]*10+b[3]+b[4]*100+b[5]*10+b[6]==b[7]*100+b[8]*10+b[9]) {
                System.out.println(""+b[1]+b[2]+b[3]+"+"+b[4]+b[5]+b[6]+"="+b[7]+b[8]+b[9]);
            }
        }
        else {
            for(int i=1;i<10;i++) {
                if(a[i]==0) {
                    b[k]=i;
                    a[i]=1;
                    miumiumama(k+1,a,b);
                    b[k]=0;
                    a[i]=0;
                }
            }
             
        }
    }
}

解题思路：a数组记录是否用过，1为用过，下标就是数，b数组存结果。

问题 E: 油田问题

题目描述
输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻（横、竖或者对角线方向），即属于同一个八连块。

输入
多组输入
输入行数m，以及列数n。
然后输入*和@
1<=n,m<=100

输出
联通块个数

样例输入

5 5
****@
*@@*@
*@**@
@@@*@
@@**@

样例输出
2

代码：

import java.util.Scanner;
 
public class Main {
    static int[] dx = {-1,-1,-1,0,0,1,1,1};
    static int[] dy = {-1,0,1,-1,1,-1,0,1};
     
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            sc.nextLine();
            String[] a = new String[m];
            int[][] b = new int[m][n];
            int count=0;
            for(int i=0;i<m;i++) {
                a[i] = sc.nextLine();
            }
            for(int i=0;i<m;i++) {
                for(int j=0;j<n;j++) {
                    if(a[i].charAt(j)=='@'&&b[i][j]==0) {
                        b[i][j]=1;
                        miumiumama(i,j,m,n,a,b);
                        count++;
                    }
                }
            }
            System.out.println(count);
        }
    }
     
    public static void miumiumama(int x,int y,int m,int n,String[] a,int[][] b) {
        for(int i=0;i<8;i++) {
            if(x+dx[i]<m&&y+dy[i]<n&&x+dx[i]>=0&&y+dy[i]>=0) {
                if(a[x+dx[i]].charAt(y+dy[i])=='@'&&b[x+dx[i]][y+dy[i]]==0) {
                    b[x+dx[i]][y+dy[i]]=1;
                    miumiumama(x+dx[i],y+dy[i],m,n,a,b);
                }
            }
        }
    }
}

解题思路：dx，dy是方向数组，找到一个就调用递归函数把所有的都求出来，同时count++；

问题 F: 马的遍历问题

题目描述
在5*4的棋盘中，马只能走斜“日”字。马从位置(x, y)处出发，把棋盘的每一格都走一次，且只走一次，请找出所有路径。

输入
x,y，表示马的初始位置。
输出
将每一格都走一次的路径总数，如果不存在该路径则输出“No solution!”。

样例输入
1 1
2 2

样例输出
32
No solution!

代码：

import java.util.Scanner;
 
public class Main {
    static int[] dx = {-2,-2,-1,-1,1,1,2,2};
    static int[] dy = {-1,1,-2,2,-2,2,-1,1};
    static int[][] a = new int[5][4];
    static int count = 0;
     
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int x = sc.nextInt()-1;
            int y = sc.nextInt()-1;
            int b = 1;
            count=0;
            a[x][y]=1;
            miumiumama(x,y,b+1);
            if(count!=0) {
                System.out.println(count);
            }
            else {
                System.out.println("No solution!");
            }
            a[x][y]=0;
        }
    }
     
    public static void miumiumama(int x,int y,int b) {
        for(int i=0;i<8;i++) {
            if(x+dx[i]<5&&y+dy[i]<4&&x+dx[i]>=0&&y+dy[i]>=0) {
                if(a[x+dx[i]][y+dy[i]]==0) {
                    a[x+dx[i]][y+dy[i]]=b;
                    if(b==20) {
                        count++;
                    }
                    else {
                        miumiumama(x+dx[i],y+dy[i],b+1);
                    }
                    a[x+dx[i]][y+dy[i]]=0;
                }
            }
        }
    }
}

解题思路：从头走到步数等于20就得到了一组结果，然后每一递归完把上一次用的那个点变成未访问。