蓝桥杯算法训练记录1

蓝桥杯算法训练记录（dp题）

第一题 印章

资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
　　共有n种图案的印章，每种图案的出现概率相同。小A买了m张印章，求小A集齐n种印章的概率。
输入格式
　　一行两个正整数n和m
输出格式
　　一个实数P表示答案，保留4位小数。
样例输入
2 3
样例输出
0.7500
数据规模和约定
　　1≤n，m≤20

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        double dp[][] = new double[n][m];
        double p = 1.0/n;//注意除法，数据类型。
        /*
        dp[i][j]是买j个集到i种印章的概率,它相当于买了j-1个已经集齐i种，剩下一个必须是已经集到的i种中的一个。否则会超过目标集齐个数。即现有概率乘以这i种中的一个，即dp[i][j-1]*（i/n）。
        加上买了j-1个集到i-1种，剩下一个必须是不同于已经集到的i-1种印章种的一个，即dp[i-1][j-1]*（n-（i-1））/n。所以有dp[i][j] =dp[i][j-1]*（i/n）+dp[i-1][j-1]*(n-(i-1)）/n      ------注意一下for循环的边界
        数据规模是1<=n,m<=20,所以初始值是n>m时,dp[i][j]=0,dp[0][0] == 1（买1个，集到一种）当i= 0,dp[0][j]为p**j
        1 1 1
        0 0.5

         */

        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++) {
                if(j<i){
                    dp[i][j] = 0;
                }
                else if (i == 0) {
                    dp[i][j] = Math.pow(p, j);
                } else {
                    dp[i][j] = dp[i][j - 1] * ((i+1 )* 1.0 / n) + dp[i - 1][j - 1] * (n - i) / n;
                }
            }
        }
        System.out.printf("%.4f", dp[n-1][m-1]);
  

    }
}

第二题 拿金币

资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
　　有一个N x N的方格,每一个格子都有一些金币,只要站在格子里就能拿到里面的金币。你站在最左上角的格子里,每次可以从一个格子走到它右边或下边的格子里。请问如何走才能拿到最多的金币。
输入格式
　　第一行输入一个正整数n。
　　以下n行描述该方格。金币数保证是不超过1000的正整数。
输出格式
　　最多能拿金币数量。
样例输入
3
1 3 3
2 2 2
3 1 2
样例输出
11
数据规模和约定
　　n<=1000

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][n];
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                arr[i][j] = sc.nextInt();
            }
        }
        /*
        线性规划思想，首先确定dp[i][j]为到达arr[i][j]的最大路径。
        然后确定初始值，dp[0][0]=arr[0][0],其余的dp数组的第一行,只能是其左边的dp值加上自己的arr值，同理其余的数组第一列，只能是其上边的。。
        最后确定关系，dp[i][j]一定是dp[i-1][j]和dp[i][j-1]的最大值加上arr[i][j]。
         */
        int[][] dp = new int[n][n];
        dp[0][0] = arr[0][0];
        for(int j = 1;j < n;j++){
            dp[0][j] = dp[0][j-1] + arr[0][j];
        }
        for(int i = 1;i < n;i++){
            dp[i][0] = dp[i-1][0] + arr[i][0];
        }
        for(int i = 1;i < n;i++){
            for(int j = 1;j < n;j++){
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]) + arr[i][j];

            }
        }
        System.out.println(dp[n-1][n-1]);


    }
}

注意：写循环的时候，初始条件和最后的关系分开写，减少内存的使用。