牛客题解 | [NOIP2002 普及组] 过河卒

原创已于 2025-03-10 09:51:04 修改 · 878 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #力扣 #面试 #算法力扣 #算法力扣面试

于 2025-03-10 09:50:33 首次发布

牛客笔试必刷101题单题解专栏收录该内容

72 篇文章

订阅专栏

题目## 题目## 题目

题目链接

解题思路

这是一个动态规划问题，需要考虑马的控制点：

首先计算出马的所有控制点：
- 马的位置 $(x, y)$
- 所有满足 $∣ x 1 - x ∣ + ∣ y 1 - y ∣ = 3$ 且 $x 1 \neq = x, y 1 \neq = y$ 的点
定义 $d p [i] [j]$ 表示从 $(0, 0)$ 到 $(i, j)$ 的路径数
状态转移方程：
- 如果 $(i, j)$ 不是马的控制点： $d p [i] [j] = d p [i - 1] [j] + d p [i] [j - 1]$
- 如果 $(i, j)$ 是马的控制点： $d p [i] [j] = 0$
边界条件： $d p [0] [0] = 1$ （如果起点不是马的控制点）

代码

#include <iostream>
#include <vector>
#include <set>
using namespace std;

bool isHorseControl(int i, int j, int x, int y) {
    if(i == x && j == y) return true;
    int dx = abs(i - x);
    int dy = abs(j - y);
    return (dx + dy == 3) && dx != 0 && dy != 0;
}

long long getPathNum(int n, int m, int x, int y) {
    vector<vector<long long>> dp(n + 1, vector<long long>(m + 1, 0));
    
    // 初始化起点
    dp[0][0] = isHorseControl(0, 0, x, y) ? 0 : 1;
    
    // 填充第一行和第一列
    for(int i = 1; i <= n; i++) {
        if(!isHorseControl(i, 0, x, y)) {
            dp[i][0] = dp[i-1][0];
        }
    }
    for(int j = 1; j <= m; j++) {
        if(!isHorseControl(0, j, x, y)) {
            dp[0][j] = dp[0][j-1];
        }
    }
    
    // 填充dp数组
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(!isHorseControl(i, j, x, y)) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
    }
    
    return dp[n][m];
}

int main() {
    int n, m, x, y;
    cin >> n >> m >> x >> y;
    cout << getPathNum(n, m, x, y) << endl;
    return 0;
}

import java.util.*;

public class Main {
    public static boolean isHorseControl(int i, int j, int x, int y) {
        if(i == x && j == y) return true;
        int dx = Math.abs(i - x);
        int dy = Math.abs(j - y);
        return (dx + dy == 3) && dx != 0 && dy != 0;
    }
    
    public static long getPathNum(int n, int m, int x, int y) {
        long[][] dp = new long[n + 1][m + 1];
        
        // 初始化起点
        dp[0][0] = isHorseControl(0, 0, x, y) ? 0 : 1;
        
        // 填充第一行和第一列
        for(int i = 1; i <= n; i++) {
            if(!isHorseControl(i, 0, x, y)) {
                dp[i][0] = dp[i-1][0];
            }
        }
        for(int j = 1; j <= m; j++) {
            if(!isHorseControl(0, j, x, y)) {
                dp[0][j] = dp[0][j-1];
            }
        }
        
        // 填充dp数组
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                if(!isHorseControl(i, j, x, y)) {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
            }
        }
        
        return dp[n][m];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        System.out.println(getPathNum(n, m, x, y));
        sc.close();
    }
}

def is_horse_control(i, j, x, y):
    if i == x and j == y:
        return True
    dx = abs(i - x)
    dy = abs(j - y)
    return (dx + dy == 3) and dx != 0 and dy != 0

def get_path_num(n, m, x, y):
    dp = [[0] * (m + 1) for _ in range(n + 1)]
    
    # 初始化起点
    dp[0][0] = 0 if is_horse_control(0, 0, x, y) else 1
    
    # 填充第一行和第一列
    for i in range(1, n + 1):
        if not is_horse_control(i, 0, x, y):
            dp[i][0] = dp[i-1][0]
    for j in range(1, m + 1):
        if not is_horse_control(0, j, x, y):
            dp[0][j] = dp[0][j-1]
    
    # 填充dp数组
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            if not is_horse_control(i, j, x, y):
                dp[i][j] = dp[i-1][j] + dp[i][j-1]
    
    return dp[n][m]

n, m, x, y = map(int, input().split())
print(get_path_num(n, m, x, y))

算法及复杂度

算法：动态规划
时间复杂度： $\mathcal{O}(nm)$ ，需要填充整个 $d p$ 数组
空间复杂度： $\mathcal{O}(nm)$ ，需要一个二维 $d p$ 数组

题目链接

解题思路

这是一个 $01$ 背包问题：

状态定义：
- $d p [i]$ 表示是否可以装到体积 $i$
- 最终答案是V减去最大可装体积
状态转移：
- $\lor dp[i-v_j]$
- 其中 $v_j$ 是第 $j$ 个物品的体积
边界条件：
- $d p [0] = t r u e$
- 其他初始化为 $f a l se$
最终结果：
- 找到最大的可装体积 $max_vol$
- 返回 $V - max_vol$

代码

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int minRemainingSpace(int V, vector<int>& volumes) {
        vector<bool> dp(V + 1, false);
        dp[0] = true;
        
        // 对每个物品
        for(int vol : volumes) {
            // 从大到小遍历容量
            for(int j = V; j >= vol; j--) {
                dp[j] = dp[j] || dp[j - vol];
            }
        }
        
        // 找到最大可装体积
        int max_vol = 0;
        for(int i = V; i >= 0; i--) {
            if(dp[i]) {
                max_vol = i;
                break;
            }
        }
        
        return V - max_vol;
    }
};

int main() {
    int V, n;
    cin >> V >> n;
    vector<int> volumes(n);
    for(int i = 0; i < n; i++) {
        cin >> volumes[i];
    }
    
    Solution solution;
    cout << solution.minRemainingSpace(V, volumes) << endl;
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int V = sc.nextInt();
        int n = sc.nextInt();
        int[] volumes = new int[n];
        for(int i = 0; i < n; i++) {
            volumes[i] = sc.nextInt();
        }
        
        System.out.println(minRemainingSpace(V, volumes));
        sc.close();
    }
    
    public static int minRemainingSpace(int V, int[] volumes) {
        boolean[] dp = new boolean[V + 1];
        dp[0] = true;
        
        // 对每个物品
        for(int vol : volumes) {
            // 从大到小遍历容量
            for(int j = V; j >= vol; j--) {
                dp[j] = dp[j] || dp[j - vol];
            }
        }
        
        // 找到最大可装体积
        int max_vol = 0;
        for(int i = V; i >= 0; i--) {
            if(dp[i]) {
                max_vol = i;
                break;
            }
        }
        
        return V - max_vol;
    }
}

class Solution:
    def min_remaining_space(self, V: int, volumes: list) -> int:
        dp = [False] * (V + 1)
        dp[0] = True
        
        # 对每个物品
        for vol in volumes:
            # 从大到小遍历容量
            for j in range(V, vol - 1, -1):
                dp[j] = dp[j] or dp[j - vol]
        
        # 找到最大可装体积
        max_vol = 0
        for i in range(V, -1, -1):
            if dp[i]:
                max_vol = i
                break
        
        return V - max_vol

# 输入处理
if __name__ == "__main__":
    V = int(input())
    n = int(input())
    volumes = [int(input()) for _ in range(n)]
    
    solution = Solution()
    print(solution.min_remaining_space(V, volumes))

算法及复杂度

算法：动态规划（01背包）
时间复杂度： $\mathcal{O}(VN)$ ，其中 $V$ 是箱子容量， $N$ 是物品数量
空间复杂度： $\mathcal{O}(V)$ ，需要一个 $d p$ 数组

题目链接

解题思路

状态定义：
- $d p [i] [j]$ 表示区间 $[i, j]$ 染色需要的最少次数
转移方程：
- 当 $s [i] == s [j]$ 时： $\min(dp[i+1][j], dp[i][j-1])$
- 当 $s [i]! = s [j]$ 时： $\min(dp[i][j], dp[i][k] + dp[k+1][j])$
实现要点：
- 字符串下标从 $1$ 开始，方便处理
- 初始化 $d p$ 数组为较大值
- 长度为 $1$ 的区间初始化为 $1$

代码

#include <bits/stdc++.h>
using namespace std;

int dp[51][51];

int main() {
    string s;
    cin >> s;
    int n = s.size();
    
    // 将字符串下标从1开始
    s = " " + s;
    
    // 初始化dp数组为较大值
    memset(dp, 0x3f, sizeof dp);
    
    // 初始化长度为1的区间
    for(int i = 1; i <= n; i++) {
        dp[i][i] = 1;
    }
    
    // 枚举区间长度
    for(int len = 2; len <= n; len++) {
        // 枚举左端点
        for(int i = 1; i + len - 1 <= n; i++) {
            int j = i + len - 1;  // 右端点
            
            // 如果区间两端颜色相同
            if(s[i] == s[j]) {
                dp[i][j] = min(dp[i+1][j], dp[i][j-1]);
            } else {
                // 枚举分割点
                for(int k = i; k < j; k++) {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
                }
            }
        }
    }
    
    cout << dp[1][n];
    return 0;
}

import java.util.Scanner;
import java.util.Arrays;

public class Main {
    static int[][] dp = new int[51][51];
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int n = s.length();
        
        // 将字符串下标从1开始
        s = " " + s;
        
        // 初始化dp数组为较大值
        for(int[] row : dp) {
            Arrays.fill(row, 0x3f3f3f3f);
        }
        
        // 初始化长度为1的区间
        for(int i = 1; i <= n; i++) {
            dp[i][i] = 1;
        }
        
        // 枚举区间长度
        for(int len = 2; len <= n; len++) {
            // 枚举左端点
            for(int i = 1; i + len - 1 <= n; i++) {
                int j = i + len - 1;  // 右端点
                
                // 如果区间两端颜色相同
                if(s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = Math.min(dp[i+1][j], dp[i][j-1]);
                } else {
                    // 枚举分割点
                    for(int k = i; k < j; k++) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j]);
                    }
                }
            }
        }
        
        System.out.println(dp[1][n]);
        sc.close();
    }
}

def solve(s: str) -> int:
    n = len(s)
    # 将字符串下标从1开始
    s = " " + s
    
    # 初始化dp数组
    dp = [[float('inf')] * (n + 1) for _ in range(n + 1)]
    
    # 初始化长度为1的区间
    for i in range(1, n + 1):
        dp[i][i] = 1
    
    # 枚举区间长度
    for length in range(2, n + 1):
        # 枚举左端点
        for i in range(1, n - length + 2):
            j = i + length - 1  # 右端点
            
            # 如果区间两端颜色相同
            if s[i] == s[j]:
                dp[i][j] = min(dp[i+1][j], dp[i][j-1])
            else:
                # 枚举分割点
                for k in range(i, j):
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j])
    
    return dp[1][n]

def main():
    s = input().strip()
    print(solve(s))

if __name__ == "__main__":
    main()