期末考试算法复习

题目如下：

1、求阶乘

2、字符逆序输出

3、FJ的字符串

4、数塔问题

5、最长公共子序列问题

6、N皇后问题

7、铺瓷砖问题

8、01背包问题

1、求阶乘

编写程序计算N! 要求使用递归算法和普通循环算法分别实现

public class 阶乘 {
    
    public static int NoRecur(int n){
        int res = 1;
        for(int i=1; i<=n; i++){
            res *= i;
        }
        
        return res;
    }
    
    public static int Recur(int n){
        if(n==1){
            return 1;
        }
        return n * Recur(n - 1);
    }
    
    public static void main(String[] args) {
        System.out.println(NoRecur(1));
        System.out.println(Recur(1));
        System.out.println(NoRecur(3));
        System.out.println(Recur(3));
        System.out.println(NoRecur(5));
        System.out.println(Recur(5));
    }
    
}

2、字符逆序输出

import java.util.Scanner;

public class 字符逆序输出 {
    
    // 递归实现逆序输出
    public static void reverseStr(char[] chs, int i) {
        
        if(i == chs.length) {
            return;
        }
        reverseStr(chs, i+1);
        System.out.print(chs[i]);
        
    }
    
    // 非递归实现逆序输出
    public static void reverseStr2(char[] chs) {
        
        for(int i=chs.length-1; i>=0; i--) {
            System.out.print(chs[i]);
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        System.out.println("Input: ");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        reverseStr(str.toCharArray(), 0);
        System.out.println();
        reverseStr2(str.toCharArray());
        
    }
    
}

3、FJ的字符串

FJ在沙盘上写了这样一些字符串：

A1 = “A”  A2 = “ABA”  A3 = “ABACABA”  A4 = “ABACABADABACABA”    … …  　　你能找出其中的规律并写所有的数列AN吗？

输入格式  　仅有一个数：N ≤ 26。

输出格式  请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。

样例输入  3 

样例输出  ABACABA

import java.util.Scanner;

public class FJ的字符串 {

    public static void f(int n) {
        if (n == 0) {
            return;
        } else {
            f(n - 1);
            char c = (char) ('A' + n - 1);
            System.out.print(c);
            f(n - 1);
        }

    }

    public static void main(String[] args) {
        
        System.out.println("Input: ");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        f(n);
        System.out.println();
    }

}

4、数塔问题

有如图所示的一个数塔，从顶部出发，在每一结点可以选择向左走或是向右走，一直走到底层，要求找出一条路径，使路径上的数值和最大

public class 数塔问题 {

    public static void main(String[] args) {
        int[][] dp = new int[5][5];
        dp[0][0] = 9;
        dp[1][0] = 12; dp[1][1] = 15;
        dp[2][0] = 10; dp[2][1] = 6; dp[2][2] = 8;
        dp[3][0] = 2; dp[3][1] = 18; dp[3][2] = 9; dp[3][3] = 5;
        dp[4][0] = 19; dp[4][1] = 7; dp[4][2] = 10; dp[4][3] = 4; dp[4][4] = 16;
        for (int i = 3; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] += Math.max(dp[i + 1][j], dp[i + 1][j + 1]);
            }
        }
        System.out.println(dp[0][0]);
    }

}

 

5、最长公共子序列问题

设有两个序列X=(x₁,x₂,…,x₇)=(a,b,c,b,d,a,b)和Y=(y₁,y₂,…,y₆)=(b,d,c,a,b,a)。

求它们的最长公共子序列。

public class 最长公共子序列问题 {

    public static void main(String[] args) {

        String str1 = "abcbdab";
        String str2 = "bdcaba";
        int str1Len = str1.length();
        int str2Len = str2.length();
        int[][] dp = new int[str1.length() + 1][str2.length() + 1];
        for (int i = 1; i <= str1Len; i++) {// 构造一个LCS长度数组
            for (int j = 1; j <= str2Len; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {// 对应公式第二条相等
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {// 对应公式第三条不相等
                    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
                }
            }
        }
        
        // 反推结果
        int i = str1Len;
        int j = str2Len;
        StringBuffer sb = new StringBuffer();
        while (i > 0 && j > 0) {
            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                sb.append(str1.charAt(i - 1));
                i--;
                j--;
            } else {
                if (dp[i][j - 1] > dp[i - 1][j]) {
                    j--;

                } else if (dp[i][j - 1] < dp[i - 1][j]) {
                    i--;
                } else if (dp[i][j - 1] == dp[i - 1][j]) {
                    i--;
                }
            }
        }
        
        System.out.println(sb.reverse().toString());

    }

}

6、N皇后问题

在一个n*n的国际象棋棋盘上放置n个皇后，使得它们中任意2个之间都不互相“攻击”，即任意2个皇后不可在同行、同列、同斜线上。

输入N，求N皇后问题的所有放法

import java.util.Scanner;

public class N皇后问题 {

    public static int total;
    public static int n;

    public static boolean check(int row, int col, int[][] array) {
        // 判断是否放置正确
        for (int i = 0; i < n; i++) {
            if (i != col && array[row][i] == 1) {
                return false;
            }
            if (i != row && array[i][col] == 1) {
                return false;
            }
            for (int j = 0; j < n; j++) {
                if (i != row && j != col && array[i][j] == 1 && Math.abs((row - i) / (col - j)) == 1) {
                    return false;
                }
            }
        }

        return true;
    }

    public static void queen(int row, int[][] array) {

        if (row == n) {
            total++;
            // 输出最后结果
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (array[i][j] == 1) {
                        System.out.print("Q");
                    } else {
                        System.out.print("X");
                    }
                }
                System.out.println();
            }
            System.out.println("**********");
        } else {
            for (int col = 0; col < n; col++) {
                if (check(row, col, array)) {
                    array[row][col] = 1;
                    queen(row + 1, array);
                    array[row][col] = 0;
                }
            }
        }

    }

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        System.out.println("Input: ");
        n = input.nextInt();
        int[][] array = new int[n][n];
        queen(0, array);
        System.out.println(total);
    }

}

7、铺瓷砖问题

有一长度为N(1<=Ｎ<=10)的地板，给定两种不同瓷砖：一种长度为1，另一种长度为2，数目不限。要将这个长度为N的地板铺满，一共有多少种不同的铺法？

例如，长度为4的地面一共有如下5种铺法：

4=1+1+1+1、4=2+1+1、4=1+2+1、4=1+1+2、4=2+2  

输入格式  只有一个数N，代表地板的长度 

输出格式  输出一个数，代表所有不同的瓷砖铺放方法的总数  

样例输入   4   

样例输出   5

import java.util.Scanner;

public class 铺瓷砖问题 {

    public static int n;
    public static int res;

    public static void f(int t) {

        if (t == n) {
            res++;
            return;
        }

        if (t + 1 <= n) {
            f(t + 1);
        }
        if (t + 2 <= n) {
            f(t + 2);
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Input: ");
        n = input.nextInt();
        f(0);
        System.out.println(res);

    }

}

 

8、01背包问题

问题描述：有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？

换个说法如下：

题目描述

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处

都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。

如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入格式：

第一行有 2个整数T(1≤T≤1000) 和 M(1≤M≤100) ，用一个空格隔开， T 代表总共能够用来采药的时间， M 代表山洞里的草药的数目。
接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100 ）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出格式：

1个整数，表示在规定的时间内可以采到的草药的最大总价值。

输入
70 3
71 100
69 1
1 2
输出
3

import java.util.*;

public class _01背包问题 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println();
        int T = in.nextInt();    // 采药的时间
        int M = in.nextInt();    // 采药的数目
        int[][] arr = new int[M + 1][2];
        for (int i = 1; i <= M; i++) {
            arr[i][0] = in.nextInt();    // 时间
            arr[i][1] = in.nextInt();    // 价值
        }
        int[][] dp = new int[M + 1][T + 1];
        for (int i = 1; i <= M; i++) {
            for (int j = 0; j <= T; j++) {
                if (j < arr[i][0])
                    dp[i][j] = dp[i - 1][j];
                else
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - arr[i][0]] + arr[i][1]);
            }
        }
        System.out.println(dp[M][T]);
    }

}