有没有做公章的网站想学计算机怎么入门

刷题小记：

第一题怀疑测试样例不完整，贪心法不应该能够解决该题。第二题使用0-1BFS解决单源最短路径的问题，往往搭配双端队列实现。第三题是运用动态规划解决最大不重叠子区间个数的问题，难点在于满足3重判断规则，所需数据结构及相关操作较多。

1.最小测试用例集覆盖

题目分析：

题目描述：

二维cases表示测试用例的覆盖情况，cases[i][j]为 1 表示第i个测试用例覆盖了第j个模块，为 0 则表示未覆盖。

求一个最小的测试用例集合，使得该集合能够覆盖所有模块。

返回该最小的集合大小，如果不存在这样的集合，返回-1。

输入描述：

第一行给定两个整数，分别表示用例总数n和代码模块总数m

第二行开始的n行，每行有m个整数（0或1），表示覆盖情况。

n,m均属于[1,50]区间

输出描述：

输出一个整数表示最小用例集合的大小，若不存在则输出-1

解题思路：

当且仅当 存在j，对任意的i，均有cases[i][j] == 0时，不存在最小覆盖集合，此时返回-1。

第i行表示第i个测试用例对m个模块的覆盖情况，

用一个长度为m的数组mo记录样例集合对模块的覆盖情况，其值为每一列由各样例的对应列取并得到。

如果采用回溯法（暴力搜索），那么遍历全部覆盖集的时间复杂度为O(2^n)，而检查数组mo的时间复杂度为O(n)，那么总的时间复杂度为O(n * 2^n)，太大！

如果采用贪心法，每次选择覆盖模块最多的测试样例添入集合，仍然无法保证测试样例集合最小。（据说真实考试情况下，该贪心法过了？！）

2.小慕的地铁大挑战

题目分析：

题目描述：

有N条地铁线路，每条线路按顺序连接若干站点，且一条线路上不存在重复的站点名。

地铁乘坐规则如下：进入任意一条地铁线路需支付2元，每换乘一次加收1元。

现求小慕从某个出发站前往指定的目的站，规划一条最省钱的路线并返回最低票价；若不能抵达，输出"NA"。

输入描述：

第一行一个整数N表示地铁线路数量，介于[1,1000]。

接下来N行，每行描述一条地铁线路，用空格分隔若干个站点名（站点名长度不超过100个字符），最多包含100个站点。不同线路间站点名可能重复，表示是换乘站。

第N+1行包含两个站点名，分别是出发站和目的站。

输入保证：若存在可达路径，则方案唯一。

输出描述：

第一行输出“换乘路径”（除起始点外，只包含可能存在的换乘站点），站点之间用"-"连接。

第二行输出该方案的总票价。

若无可达路径，只输出一行"NA"

解题思路：

运用0-1广度优先搜索遍历所有路径，找出权值最小的路径，其中：在线路内部移动的边权为0，换乘时的边权为1。

关键步骤：

1. 构建状态图：key是(站点名,所属线路编号)，value是(下一站点,权重)的列表，其中用"虚拟线路编号-1"表示换乘口

1. 1. 对于同一条地铁线路的相邻站点(A,i)和(B,i)相连，即给(A,i)的value列表添加((B,i),0)，给(B,i)的value列表添加((A,i),0)
   2. 对于每个站点，将其与对应的虚拟换乘口相连：

1. 1. 1. 从站点(A,i)到虚拟换乘口(A,-1)的权为1，即给(A,i)的value列表添加((A,-1),1)
      2. 从虚拟换乘口(A,-1)到站点(A,i)的权为0，即给(A,-1)的value列表添加((A,i),0)

1. 路径搜索算法 0-1BFS：

1. 1. 使用双端队列Deque，优先处理权值为0的边，即将其加入队头（优先出队）；处理权值为1的边时，将其加入队尾（后出队），已访问过的节点直接跳过
   2. 用一个映射d记录每个节点的最小费用，初始化为INT_MAX
   3. 用一个映射pre记录每个节点的前置节点，以便第一次找到终点后复现路径（权值为0的节点被优先处理，广度优先搜索能确保找到目标点时路径代价最小）

1. 路径还原与票价计算：

1. 1. 找到终点时，借助pre映射还原路径，每遇到(node, -1)的节点表示为换乘节点，将其添加入路径并记录换乘代价
   2. 票价 = 2 + 换乘代价 - 1，因为(起点, -1)被视作了换乘节点加入路径，而其本身是不需要换乘的，只是为了统一写法才记为-1，因此票价公式末尾减去1

1. 如果最终最短路径映射d不包含终点，表示不存在能够从起点到达该终点的路径，输出NA。

3.满足尽可能多的业务需求的IP区间方案组

题目分析：

题目描述：

业务的网络地址需求用一个闭区间[startip, endip]表示。

由于要求不同业务的IP地址区间不能重叠，要求按照一定的顺序将这些业务需求排序，尽可能满足更多的业务需求：

• 当业务数量相同时，以IP地址占用区间最少的优先
• 当业务数量相同时且IP地址占用区间大小也相同时，按照IP范围排序，比较起始地址，起始地址最小者优先。

输入描述：

第一行为业务个数N，有效范围是[1, 1000]

接下来N行是IP地址区间，每行有startip和endip，均为合法的IPv4地址格式，即(A, B, C, D)，其中ABCD的取值范围是[0, 255]

注意：IP地址大小的比较，是按照A、B、C和D的顺序进行比较。

输出描述：

输出排序好的M个IP区间，每行一个。

解题思路：

首先将IP地址转换成32位的整数进行存储，便于比较大小。

然后将这些IP区间按照startip进行升序排序，若startip相同，那么按照endip进行升序排序，得到32位转换以及排序后的N行2列的整型数组ips。

动规五部曲：

1. 确定dp数组以及下标的含义：dp[i]表示以第i个区间结尾的最大不重叠子区间数量
2. 确定递推公式：对于以j（j < i)为结尾的最大不重叠子区间方案，如果与第i个区间不重叠，那么：

1. 1. 如果dp[j] + 1> dp[i]，那么以第i个区间为结尾的方案为在以第j个区间为结尾的最大不重叠区间数方案的基础上加上第i个区间；
   2. 如果dp[j] + 1 == dp[i]，那么比较以第i个区间为结尾的最优方案，以及以第j个区间为结尾的最优方案的基础上添加第i个区间，比较这两个方案的长度，选择较短者；如果两个方案的长度相同，比较两个方案的起始IP地址。

1. 确定遍历方向：由于dp[i]依赖于dp[j](j < i)，因此正序遍历即可。
2. dp数组初始化：遍历第i个区间时，由于一定以第i个区间结尾，因此初始化dp[i] = 1表示将第i个区间添入业务组合方案。

import java.util.*;public class Ipv4ToIntConverter {public static int ipv4ToInt(String ipAddress) {String[] parts = ipAddress.split("\\.");int result = 0;for (int i = 0; i < 4; i++) {int octet = Integer.parseInt(parts[i]);result = (result << 8) | octet;}return result;}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();scanner.nextLine(); // 消耗掉换行符int[][] ips = new int[n][2];for (int i = 0; i < n; i++) {String[] line = scanner.nextLine().split(" ");ips[i][0] = ipv4ToInt(line[0]);ips[i][1] = ipv4ToInt(line[1]);}// 按照 startip 升序排序，如果 startip 相同，按照 endip 升序排序Arrays.sort(ips, (a, b) -> {if (a[0] == b[0]) {return Integer.compare(a[1], b[1]);}return Integer.compare(a[0], b[0]);});// dp[i] 表示以第 i 个区间结尾的最大不重叠区间数量int[] dp = new int[n];// 记录每个状态下选择的区间List<List<int[]>> choices = new ArrayList<>();// 记录每个状态下选择的区间的总长度int[] lengths = new int[n];for (int i = 0; i < n; i++) {dp[i] = 1;choices.add(new ArrayList<>());choices.get(i).add(ips[i]);lengths[i] = ips[i][1] - ips[i][0];for (int j = 0; j < i; j++) {if (ips[j][1] < ips[i][0]) {// 第i个区间与第j个区间不重合if (dp[j] + 1 > dp[i]) {dp[i] = dp[j] + 1;List<int[]> newChoice = new ArrayList<>(choices.get(j));newChoice.add(ips[i]);choices.set(i, newChoice);lengths[i] = lengths[j] + (ips[i][1] - ips[i][0]);} else if (dp[j] + 1 == dp[i]) {int newLength = lengths[j] + (ips[i][1] - ips[i][0]);if (newLength < lengths[i]) {List<int[]> newChoice = new ArrayList<>(choices.get(j));newChoice.add(ips[i]);choices.set(i, newChoice);lengths[i] = newLength;} else if (newLength == lengths[i]) {if (newChoice.get(0)[0] < choices.get(i).get(0)[0]) {List<int[]> newChoice = new ArrayList<>(choices.get(j));newChoice.add(ips[i]);choices.set(i, newChoice);}}}}}}// 找到最大不重叠区间数量的方案int maxCount = 0;List<int[]> bestChoice = new ArrayList<>();int minLength = Integer.MAX_VALUE;int startIp = Integer.MAX_VALUE;for (int i = 0; i < n; i++) {if (dp[i] > maxCount) {maxCount = dp[i];bestChoice = choices.get(i);minLength = lengths[i];startIp = bestChoice.get(0)[0];} else if (dp[i] == maxCount) {if (lengths[i] < minLength) {bestChoice = choices.get(i);minLength = lengths[i];startIp = bestChoice.get(0)[0];} else if (lengths[i] == minLength) {if (choices.get(i).get(0)[0] < startIp) {bestChoice = choices.get(i);startIp = bestChoice.get(0)[0];}}}}// 输出结果for (int[] ip : bestChoice) {System.out.println(intToIpv4(ip[0]) + " " + intToIpv4(ip[1]));}scanner.close();}public static String intToIpv4(int ip) {StringBuilder sb = new StringBuilder();for (int i = 3; i >= 0; i--) {sb.append((ip >> (i * 8)) & 255);if (i > 0) {sb.append(".");}}return sb.toString();}
}