最大最小位数差异计算：从超大字符串数相加到位差分析 | 豆包MarsCode AI刷题

最大最小位数差异计算：从超大字符串数相加到位差分析

在计算机科学与生物信息学等领域，处理和分析大型数据字符串是常见且重要的任务。本文将深入探讨一个有趣的问题：给定两个由数字字符组成的超大字符串数，计算它们相加后得到的字符串数中最大数字与最小数字之间的位数差距。我们将详细解释问题的思路、解决方法、Java代码实现以及算法的时间与空间复杂度分析。

问题描述

小R遇到了一个问题，她有两个由数字字符组成的超大字符串数string1和string2。她需要计算这两个数相加后得到的字符串数中的最大数和最小数之间的位数差距。具体要求如下：

1. 编辑步骤包括：

   • 增加一个数字字符。
   • 删除一个数字字符。
   • 替换一个数字字符。

2. 位数差距定义：

   • 如果结果中所有数字都相同，则差距为 0。
   • 如果存在多个符合最大或最小条件的数字，应选择最小的位置差。
   • 位置差定义为两个数字在字符串中的索引差减一（基于 0 索引）。

示例

样例1：

• 输入：string1 = "111", string2 = "222"
• 相加结果："333"
• 输出：0
• 解释：所有数字相同，差距为 0。

样例2：

• 输入：string1 = "111", string2 = "34"
• 相加结果："145"
• 最大数字：5 位于第 2 位（0 索引）。
• 最小数字：1 位于第 0 位（0 索引）。
• 位置差：|2 - 0| - 1 = 1
• 输出：1

样例3：

• 输入：string1 = "999", string2 = "1"
• 相加结果："1000"
• 最大数字：1 位于第 0 位（0 索引）。
• 最小数字：0 位于第 1 位（0 索引）。
• 位置差：|1 - 0| - 1 = 0
• 输出：0

样例4：

• 输入：string1 = "525", string2 = "474"
• 相加结果："999"
• 输出：0（所有数字相同）

问题分析

要解决这个问题，我们可以将其分解为以下几个步骤：

1. 大数相加：由于输入的字符串数可能非常大，直接将其转换为整数进行相加可能会导致溢出。因此，我们需要模拟手动相加的过程，逐位相加并处理进位。

2. 找到最大和最小数字及其位置：

   • 遍历相加后的字符串，记录所有最大和最小数字的位置。
   • 如果存在多个最大或最小数字，选择位置差最小的那一对。

3. 计算位数差距：

   • 位置差距定义为两个数字在字符串中的索引差减一。
   • 如果所有数字相同，则差距为 0。

具体步骤

1. 大数相加：

   • 从两个字符串的末尾开始逐位相加。
   • 处理进位，直到所有位都被处理完。
   • 如果最后有进位，则在结果前添加 1。

2. 查找最大和最小数字及其位置：

   • 遍历相加后的字符串，记录最大和最小数字。
   • 记录所有最大和最小数字的索引位置。
   • 遍历所有可能的最大和最小数字组合，找到位置差最小的那一对。

3. 计算位数差距：

   • 使用最小的位置差计算位数差距。
   • 如果最大和最小数字相同，差距为 0。

算法实现

下面是基于上述思路的Java代码实现：

public class Main {
    public static int solution(String string1, String string2) {
        // Step 1: Add the two large numbers represented as strings
        String sum = addStrings(string1, string2);
        
        // Step 2: Find max and min digits and their positions
        char maxDigit = '0';
        char minDigit = '9';
        int length = sum.length();
        
        // First, identify the max and min digits
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current > maxDigit) {
                maxDigit = current;
            }
            if (current < minDigit) {
                minDigit = current;
            }
        }
        
        // If all digits are the same
        if (maxDigit == minDigit) {
            return 0;
        }
        
        // Collect all positions of max and min digits
        List<Integer> maxPositions = new ArrayList<>();
        List<Integer> minPositions = new ArrayList<>();
        
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current == maxDigit) {
                maxPositions.add(i);
            }
            if (current == minDigit) {
                minPositions.add(i);
            }
        }
        
        // Step 3: Find the minimum position difference
        int minDifference = Integer.MAX_VALUE;
        for (int maxPos : maxPositions) {
            for (int minPos : minPositions) {
                int diff = Math.abs(maxPos - minPos) - 1;
                if (diff < minDifference) {
                    minDifference = diff;
                }
                // Early exit if difference is 0
                if (minDifference == 0) {
                    return 0;
                }
            }
        }
        
        return minDifference;
    }
    
    // Helper function to add two numeric strings
    private static String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        
        int i = num1.length() -1;
        int j = num2.length() -1;
        int carry =0;
        
        while (i >=0 || j >=0 || carry !=0) {
            int digit1 = (i >=0) ? num1.charAt(i) - '0' : 0;
            int digit2 = (j >=0) ? num2.charAt(j) - '0' : 0;
            int total = digit1 + digit2 + carry;
            carry = total /10;
            sb.append(total %10);
            i--;
            j--;
        }
        
        return sb.reverse().toString();
    }
    
    public static void main(String[] args) {
        // 测试样例
        System.out.println(solution("111", "222") == 0); // 样例1
        System.out.println(solution("111", "34") == 1); // 样例2
        System.out.println(solution("999", "1") == 0); // 样例3
        System.out.println(solution("525", "474") == 0); // 样例4
        
        // 额外测试
        System.out.println(solution("5976762424003073", "6301027308640389") == 6);
    }
}

代码解释

1. 大数相加 (addStrings 方法) ：

   • 使用 StringBuilder 从两个字符串的末尾开始逐位相加。
   • 处理进位，直到所有位都被处理完。
   • 最后将结果反转以获得正确的顺序。

2. 查找最大和最小数字及其位置：

   • 首先遍历相加后的字符串，找出最大和最小数字。
   • 如果最大和最小数字相同，直接返回 0。
   • 否则，记录所有最大和最小数字的索引位置。

3. 计算位数差距：

   • 遍历所有最大和最小数字的位置组合，计算 |maxPos - minPos| - 1。
   • 选择最小的差距作为结果。
   • 如果差距为 0，则可以提前返回。

运行结果

运行上述代码，所有测试用例将输出 true，表示实现正确。例如：

true
true
true
true
true

时间复杂度分析

算法的时间复杂度主要由以下几个部分构成：

1. 大数相加 (addStrings 方法) ：

   • 需要遍历两个字符串的所有位，因此时间复杂度为 O(max(m, n))，其中 m 和 n 分别是 string1 和 string2 的长度。

2. 查找最大和最小数字：

   • 遍历相加后的字符串一次，时间复杂度为 O(l)，其中 l 是结果字符串的长度。

3. 记录最大和最小数字的位置：

   • 再次遍历字符串，时间复杂度为 O(l)。

4. 计算最小位置差：

   • 遍历所有最大和最小数字的位置组合，最坏情况下时间复杂度为 O(k * p)，其中 k 是最大数字的数量，p 是最小数字的数量。

综合上述，整体时间复杂度为 O(max(m, n) + l + k * p)。由于 l 大致等于 max(m, n) + 1（进位的影响），可以认为时间复杂度为 O(max(m, n) + k * p)。在最坏情况下，k 和 p 都接近 l，使得时间复杂度趋近于 O(l^2)。

然而，在实际应用中，k 和 p 通常远小于 l，因此平均时间复杂度接近 O(max(m, n))。

空间复杂度分析

算法的空间复杂度主要由以下几个部分构成：

1. 存储相加结果的 StringBuilder：

   • 需要 O(l) 的空间。

2. 记录最大和最小数字的位置列表：

   • 最坏情况下，需要 O(l) 的空间。

3. 其他辅助变量：

   • 常数级别的空间。

综合上述，整体空间复杂度为 O(l)，其中 l 是结果字符串的长度。

优化建议

虽然当前的算法在大多数情况下表现良好，但在极端情况下，尤其是当结果字符串非常长且最大或最小数字频繁出现时，时间复杂度可能接近 O(l^2)。以下是一些优化建议：

1. 提前终止：

   • 在计算位置差时，如果发现差距为 0，可以立即返回，无需继续计算。

2. 双指针法：

   • 利用双指针方法，可以在单次遍历中找到最小位置差，减少时间复杂度。

下面是基于双指针法的优化代码：

public class Main {
    public static int solution(String string1, String string2) {
        // Step 1: Add the two large numbers represented as strings
        String sum = addStrings(string1, string2);
        
        // Step 2: Find max and min digits and their positions
        char maxDigit = '0';
        char minDigit = '9';
        int length = sum.length();
        
        // Identify the max and min digits
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current > maxDigit) {
                maxDigit = current;
            }
            if (current < minDigit) {
                minDigit = current;
            }
        }
        
        // If all digits are the same
        if (maxDigit == minDigit) {
            return 0;
        }
        
        // Collect all positions of max and min digits
        List<Integer> maxPositions = new ArrayList<>();
        List<Integer> minPositions = new ArrayList<>();
        
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current == maxDigit) {
                maxPositions.add(i);
            }
            if (current == minDigit) {
                minPositions.add(i);
            }
        }
        
        // Step 3: Find the minimum position difference using two pointers
        int iPtr = 0;
        int jPtr = 0;
        int minDifference = Integer.MAX_VALUE;
        
        while (iPtr < maxPositions.size() && jPtr < minPositions.size()) {
            int maxPos = maxPositions.get(iPtr);
            int minPos = minPositions.get(jPtr);
            int diff = Math.abs(maxPos - minPos) -1;
            if (diff < minDifference) {
                minDifference = diff;
                if (minDifference == 0) {
                    break; // Early exit
                }
            }
            // Move the pointer that points to the smaller index
            if (maxPos < minPos) {
                iPtr++;
            } else {
                jPtr++;
            }
        }
        
        return minDifference;
    }
    
    // Helper function to add two numeric strings
    private static String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        
        int i = num1.length() -1;
        int j = num2.length() -1;
        int carry =0;
        
        while (i >=0 || j >=0 || carry !=0) {
            int digit1 = (i >=0) ? num1.charAt(i) - '0' : 0;
            int digit2 = (j >=0) ? num2.charAt(j) - '0' : 0;
            int total = digit1 + digit2 + carry;
            carry = total /10;
            sb.append(total %10);
            i--;
            j--;
        }
        
        return sb.reverse().toString();
    }
    
    public static void main(String[] args) {
        // 测试样例
        System.out.println(solution("111", "222") == 0); // 样例1
        System.out.println(solution("111", "34") == 1); // 样例2
        System.out.println(solution("999", "1") == 0); // 样例3
        System.out.println(solution("525", "474") == 0); // 样例4
        
        // 额外测试
        System.out.println(solution("5976762424003073", "6301027308640389") == 6);
    }
}

优化点解释

1. 双指针法：

   • 通过同时遍历 maxPositions 和 minPositions 列表，使用双指针方法找到最小位置差。
   • 这种方法在两个列表均有序的情况下，可以在 O(k + p) 时间内完成查找，比原先的 O(k * p) 更高效。

2. 早期终止：

   • 一旦发现位置差为 0，立即返回，避免不必要的计算。

通过这些优化，算法在大多数情况下能够更高效地运行，特别是在处理极大数据时。

结论

本文详细介绍了如何解决两个超大字符串数相加后，计算结果中最大数字与最小数字之间的位数差距的问题。通过分步骤分析和动态编程方法，我们成功实现了高效的Java解决方案。此外，通过时间和空间复杂度的分析，我们了解了算法的性能表现，并提出了进一步的优化策略。

这种类型的问题不仅在算法竞赛中常见，也在实际应用中具有重要价值。例如，在金融数据分析、基因序列比对等领域，处理和分析大规模字符串数据是日常任务。掌握这种算法思路和实现方法，能够帮助开发者更好地应对类似的挑战。

完整代码

以下是最终优化后的完整Java代码：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static int solution(String string1, String string2) {
        // Step 1: Add the two large numbers represented as strings
        String sum = addStrings(string1, string2);
        
        // Step 2: Find max and min digits and their positions
        char maxDigit = '0';
        char minDigit = '9';
        int length = sum.length();
        
        // Identify the max and min digits
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current > maxDigit) {
                maxDigit = current;
            }
            if (current < minDigit) {
                minDigit = current;
            }
        }
        
        // If all digits are the same
        if (maxDigit == minDigit) {
            return 0;
        }
        
        // Collect all positions of max and min digits
        List<Integer> maxPositions = new ArrayList<>();
        List<Integer> minPositions = new ArrayList<>();
        
        for (int i = 0; i < length; i++) {
            char current = sum.charAt(i);
            if (current == maxDigit) {
                maxPositions.add(i);
            }
            if (current == minDigit) {
                minPositions.add(i);
            }
        }
        
        // Step 3: Find the minimum position difference using two pointers
        int iPtr = 0;
        int jPtr = 0;
        int minDifference = Integer.MAX_VALUE;
        
        while (iPtr < maxPositions.size() && jPtr < minPositions.size()) {
            int maxPos = maxPositions.get(iPtr);
            int minPos = minPositions.get(jPtr);
            int diff = Math.abs(maxPos - minPos) -1;
            if (diff < minDifference) {
                minDifference = diff;
                if (minDifference == 0) {
                    break; // Early exit
                }
            }
            // Move the pointer that points to the smaller index
            if (maxPos < minPos) {
                iPtr++;
            } else {
                jPtr++;
            }
        }
        
        return minDifference;
    }
    
    // Helper function to add two numeric strings
    private static String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        
        int i = num1.length() -1;
        int j = num2.length() -1;
        int carry =0;
        
        while (i >=0 || j >=0 || carry !=0) {
            int digit1 = (i >=0) ? num1.charAt(i) - '0' : 0;
            int digit2 = (j >=0) ? num2.charAt(j) - '0' : 0;
            int total = digit1 + digit2 + carry;
            carry = total /10;
            sb.append(total %10);
            i--;
            j--;
        }
        
        return sb.reverse().toString();
    }
    
    public static void main(String[] args) {
        // 测试样例
        System.out.println(solution("111", "222") == 0); // 样例1
        System.out.println(solution("111", "34") == 1); // 样例2
        System.out.println(solution("999", "1") == 0); // 样例3
        System.out.println(solution("525", "474") == 0); // 样例4
        
        // 额外测试
        System.out.println(solution("5976762424003073", "6301027308640389") == 6);
    }
}

通过上述步骤和代码实现，我们能够高效地解决两个超大字符串数相加后，计算最大与最小数字之间的位数差距的问题。这不仅提升了算法的理解和实现能力，也为应对类似的复杂字符串处理任务提供了有力的工具。