动态规划笔试题

方格走法

有一个X*Y的网格，小团要在此网格上从左上角到右下角，只能走格点且只能向右或向下走。请设计一个算法，计算小团有多少种走法。给定两个正整数int x,int y，请返回小团的走法数目。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        int[][] array = new int[x+1][y+1];
        array[0][0]=0;
        //生成边界条件
        for (int i = 1; i < x+1; i++) {
            array[i][0]=1;
        }
        for (int i = 1; i < y+1; i++) {
            array[0][i]=1;
        }
        for (int i = 1; i < x+1; i++) {
            for (int j = 1; j < y+1; j++) {
                array[i][j]=array[i-1][j]+array[i][j-1];
            }
        }
        System.out.println(array[x][y]);
    }
}

字符串最小变换次数

给定两个字符串，已知可以使用三种方式进行变换

1. 插入一个字符
2. 删除一个字符
3. 更改一个字符
   请设计一个算法，找到两个字符串之间的经历几次最小变换，可以字符串1转换成字符串2

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s1 = sc.nextLine();
        String s2 = sc.nextLine();
        String[] split1 = s1.split("");
        String[] split2 = s2.split("");
        int m = split1.length;
        int n = split2.length;
        int[][] array = new int[m][n];
        array[0][0]=split1[0].equals(split2[0])?0:1;
        for (int i = 1; i < m; i++) {
           if (split1[i].equals(split2[0])){
               array[i][0]=array[i-1][0];
           }else {
               array[i][0]=array[i-1][0]+1;
           }
        }
        for (int j = 1; j < n; j++) {
            if (split2[j].equals(split1[0])){
                array[0][j]=array[j-1][0];
            }else {
                array[0][j]=array[j-1][0]+1;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (split1[i].equals(split2[j])){
                    array[i][j]=Math.min(Math.min(array[i-1][j],array[i][j-1]),array[i-1][j-1]);
                }else {
                    array[i][j]=Math.min(Math.min(array[i-1][j],array[i][j-1]),array[i-1][j-1])+1;
                }
            }
        }
        System.out.println(array[m-1][n-1]);
    }
}

青蛙跳格子

假设你正在玩跳格子（所有格子排成一个纵列）游戏。需要 跳完n 个格子你才能抵达终点。
每次你可以跳 1 或 2 个格子。你有多少种不同的方法可以到达终点呢？

import java.util.Scanner;

public class Main {


     public static int f(int n){
         if (n==1){
            return 1;
         }else if (n==2){
             return 2;
         }
         return f(n-1)+f(n-2);
     }

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

    }
}

爬楼梯

在你面前有一个n阶的楼梯(n>=100且n<500)，你一步只能上1阶或3阶。
请问计算出你可以采用多少种不同的方式爬完这个楼梯（到最后一层为爬完）。

import java.math.BigInteger;
import java.util.Scanner;



public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        BigInteger[] b = new BigInteger[n];
        b[0]=new BigInteger("1");
        b[1]=new BigInteger("1");
        b[2]=new BigInteger("2");
        for (int i = 3; i < b.length; i++) {
            b[i]=b[i-1].add(b[i-3]);
        }
        System.out.println(b[n-1]);
    }
}

求连续子数组的最大和

一个非空整数数组，选择其中的两个位置，使得两个位置之间的数和最大。

思路：创建一个新的dp数组，初始化为给定数组array的第一个元素，然后判断dp中前一个元素是否大于0，如果大于0就加上array[i]dp[i]=dp[i-1]+array[i]，否则就从array[i]开始计算dp[i]=array[i]

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[] split = s.split(",");
        int[] array = new int[split.length];
        for (int i = 0; i < array.length; i++) {
            array[i] = Integer.parseInt(split[i]);
        }
        int[] dp = new int[array.length];
        dp[0]=array[0];
        int max=array[0];
        for (int i = 1; i < array.length; i++) {
            if (dp[i-1]>0){
                dp[i]=array[i]+dp[i-1];
            }else {
                dp[i]=array[i];
            }
            if (dp[i]>max){
                max=dp[i];
            }
        }
        if (max<=0){
            System.out.println(0);
        }else {
            System.out.println(max);

        }
    }
}