【练习】Day07

'Dream是普通小孩耶

已于 2023-01-20 15:36:29 修改

阅读量567

点赞数 1

分类专栏：日常练习文章标签： servlet dp 最小路径转发重定向

于 2023-01-17 19:47:29 首次发布

本文链接：https://blog.csdn.net/weixin_54150521/article/details/128717183

版权

日常练习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

努力经营当下，直至未来明朗！

文章目录

一、选择
二、编程
- 1. 不同路径
- 2. 三角形最小路径和 [重点理解！！]
答案
- 1. 选择
- 2. 编程

普通小孩也要热爱生活！

一、选择

以下关于 Servlet 生命周期说法错误的是 ( )

A: Servlet 容器根据 Servlet 类的位置加载 Servlet 类，成功加载后，由容器创建 Servlet 的实例
B: 对于每一个 Servlet 实例， init() 方法只被调用一次
C: 当 Servlet 容器接收到客户端请求时，调用 Servlet 的 service() 方法以及 destory() 方法处理客户端请求
D: servlet 的实例是由 servlet 容器创建的，所以实例销毁也由容器完成

以下关于转发和重定向的说法错误的是 ( )

A: 转发通过 request 的getRequestDispatcher().forward() 方法即可实现，它的作用是在多个页面交互过程中实现请求数据的共享。
B: 重定向可以理解为是浏览器至少提交了两次请求，它是在客户端发挥作用，通过请求新的地址实现页面转向
C: 转发和重定向都可以共享 request 范围内的数据
D: 转发时客户端的 URL 地址不会发生改变，而重定向时客户端浏览器中显示的是新的 URL 地址。

用HTML标记语言编写一个简单的网页，网页最基本的结构是 ( )

A: <html> <head>…</head> <frame>…</frame> </html>
B: <html> <title>…</title> <body>…</body> </html>
C: <html> <title>…</title> <frame>…</frame> </html>
D: <html> <head>…</head> <body>…</body> </html>

二、编程

1. 不同路径

LeetCode62. 不同路径
一个机器人位于一个 m * n 网格的左上角（起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？

2. 三角形最小路径和 [重点理解！！]

LeetCode120. 三角形最小路径和
给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点在这里指的是 下标与上一层结点下标相同或者等于上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

答案

1. 选择

① 客户端的每次请求，都会根据路径查找对应的Servlet实例对象，并调用service方法（service每次收到请求都会调用）。
② init和destroy分别是初始化方法及销毁方法，只执行一次
③ 补充：servlet实例的创建和销毁都是由容器完成的。
（参考：Servlet API）

故：选C

① 转发是一次请求返回，可以共享本次请求的数据。
② 重定向是两次请求，不能通过request共享数据，如果要共享数据，可以使用session。
③ 小结：转发是一次请求返回可共享；重定向是两次请求session可共享数据。

故：选C

html最基础的结构包括html，head和body标签

故：选D

2. 编程

不同路径

1）初步猜测应该是类似Fib，也就是dp动归问题，需要找出状态方程。

2）思路：

① 状态：用 f(i, j) 表示从左上角走到 (i, j) 的路径数量，其中 i 和 j 的范围分别是 [0, m) 和 [0, n) 。
② 状态方程：只有两种走法可以到达目标格，向下or向右，so： f(i, j)=f(i-1,j) + f(i,j-1)
③ 初始值：注意若i==0 or j==0，i-1 以及 j-1都是不满足要求的。f(0,0)=1，自身走到自身只有一条路。
④ 注意点：将所有边界值都设置为1，即：f(i,0)=1 && f(0,j)=1.
⑤ 所以，最后的状态方程f(m,n) = f(m-1,n) + f(m,n-1)，并且将边界值都设置为1。
⑥ 因为设置的初始值有点多，所以直接使用数组储存。

3）代码：

class Solution {
    public int uniquePaths(int m, int n) {
        // 首先创建数组用于存储数据
        int[][] f = new int[m][n];
        // 进行初始化：对边界值
        for (int i = 0; i < m; i++) {
            f[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            f[0][i] = 1;
        }
        // 然后遍历：使用状态方程
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 注意下标 以及符号！
                f[i][j] = f[i-1][j] + f[i][j-1];
            }
        }
        return  f[m-1][n-1];
    }
}

三角形最小路径和

1）思路：

① 首先明确“动归问题”
② 动归问题明确状态、状态方程以及初始值
③ 对所给的链表进行详细分析：[[2],[3,4],[6,5,7],[4,1,8,3]]，在对齐后可以得到等腰直角三角形：
[2]
[3,4]
[6,5,7]
[4,1,8,3]
④ 状态：f(i,j)表示走到第i行第j列（都是从0开始的）位置的最小路径和，而该位置又只能有两个达到位置：(i-1,j) or (i-1,j-1)。
⑤ 所以状态方程：
f(i,j) = min(f(i-1,j), f(i-1,j-1)) + c[i,j]
（其中，c[i,j] 表示(i,j)位置对应的元素值）
⑥ 注意：第 i 行有（i+1）个元素（从0开始取），所以 j 的取值范围[0,i]；并且由状态方程可知：当j==0时f(i-1,j-1))没意义，即：f(i,0) = f(i-1,0)+ c[i,0] ，也就是说：当我们在第i行最左侧的时候只能从第i-1行最左侧移动过来；
当i==j时f(i-1,j)没有意义，即：f(i,i) = f(i-1,i-1) + c[i,i]，也就是说：当我们在第i行的最右侧时只能从第i-1行最右侧移动过来。
（没有意义是因为根本不存在！）
⑦ 所以：状态转移方程： f[n-1][0] 到 f[n−1][n−1] 中的最小值，其中 n 是三角形的行数。
⑧ 初始值：f[0][0] = c[0][0]
⑨ 注意分为了三种情况：最左侧、最右侧以及中间开始。
⑩ 简言之，先找每个位置的最小路径和，然后找最后一行的各位置的最小路径和。

2）代码：

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int min = Integer.MAX_VALUE;  // 定义最小值，方便后续作比较
        int row = triangle.size(); // 行数

        // 定义二维数组，用于存储每个位置的最小路径和
        int[][] f = new int[row][row];
        // 初始化第一行：
        f[0][0] = triangle.get(0).get(0); // 0行0列

        // 开始进行遍历
        for (int i = 1; i < row; i++) { // 注意从第1行开始，第0行已经初始化过了
            // 此时可以得到每一行集合
            List<Integer> tmp = triangle.get(i);
            // 遍历每一行的每一列
            for (int j = 0; j <= i; j++) { // 注意列数和行数的对等性
                // 分三种情况判断移动的起点
                if(j == 0) {
                    //  从最左边开始移动
                    // 注意获取该位置的元素值的方法！！：tmp.get(j)
                    // 是从原链表中获取到该位置的常量值的
                    f[i][j] = f[i-1][j] + tmp.get(j);
                } else if(i == j) {
                    // 从最右边开始移动
                    f[i][j] = f[i-1][j-1] + tmp.get(j);
                } else {
                    // 从其他中间任意位置，那就取min
                    f[i][j] = Math.min(f[i-1][j],f[i-1][j-1]) + tmp.get(j);
                }
            }
        }
        // 遍历结束后已经得到所有位置的最小路径和，此时
        // 遍历判断最后一行的min即可
        for (int i = 0; i < row; i++) {
            min = Math.min(min,f[row-1][i]);
        }

        return min;
    }
}