Kiawem's questions

这是问题陈述：

在她的生日那天，Mila 收到了一个字符串 S，由字符“0”和“1”组成。但米拉觉得这条线不美，所以她决定改正！ Mila 对美丽线条的定义如下：

1. 让我们将字符串拆分为由相同字符组成的最长可能的子字符串。
2. 如果所有这些子串的长度相同，则原始字符串被认为是漂亮的，否则被认为是丑陋的。

例如，字符串 '010101' 被拆分为子字符串 '0', '1', '0', '1', '0', '1' 因此很漂亮，而字符串 '000101' 被拆分为子字符串'000', '1', '0', '1' 因此很难看。漂亮字符串的其他示例：“1”、“110011”、“00001111”、“00000000”。丑陋字符串的其他示例：“011”、“010011”、“00110100”。 Mila 要求您计算字符串 S 中需要更改的最少字符数才能使其美观。

这是解决问题的代码：

public class Main {
    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       String line = sc.next();
       int ans = Integer.MAX_VALUE;
       for (int i = 1; i <= line.length(); i++) {
           if (line.length() % i == 0) {
               int minChanges = minChanges(i, line);
               ans = Math.min(ans, minChanges);
           }
       }
        System.out.println(ans);
    }

    private static int minChanges(int rangeLength, String line) {
        int rangeCount = line.length() / rangeLength;
        int startWithOnes = 0;
        int startWithZeroes = 0;
        for (int i = 0; i < rangeCount; i++) {
            int zeros = 0;
            int ones = 0;
            for (int j = 0; j < rangeLength; j++) {
                char c = line.charAt(j + i * rangeLength);

                if (c == '0') {
                    zeros++;
                }

                if (c == '1') {
                    ones++;
                }

                startWithZeroes += (i % 2 == 0 ? zeros : ones);
                startWithOnes += (i % 2 == 0 ? ones : zeros);
            }
        }
        return Math.min(startWithOnes, startWithZeroes);
    }
}

我无法弄清楚 startWithZeroes 和 startWithOnes 变量到底算什么。我相信它计算一条线需要执行多少个操作，以便每个小节（变量 i）以 0 或 1 开头。如果我们让 i 将线分成 1 个元素的段，那么它与手动计算一致（您可以从例子中看出）。 000101是第一行，据我了解，每个偶数段都需要以 0 开头，并且由于该段最初是基于段中的一个数字来考虑的，因此我们得到 010101 （花费了 1 个替换）。如果它以 1 开头，那么我们得到 101010（花费了 5 个替换）。一切都汇聚到了这里。

接下来我们取一段 2(i = 2)。如果偶数段为零。我们将通过花费 3 次行动来获得 001100。如果有偶数段1，则110011，花费4，通过查看调试将是startWithOnes = 3，startWithZeroes = 6。请告诉我如何继续以匹配算法。

我正在解决一个问题，我的问题是在某个测试中出现TL（时间限制）错误（代码在条件之后呈现），我不知道如何加速算法以便测试通过，也许我的逻辑有问题——我无法否认这一点。

问题条件：给定两个数组a和b，长度为N，由整数组成。考虑一个由连接点 (0, ai) 和 (1, bi) 的线段组成的集合，其中 1 <= i <= N。找出该集合中不与其他线段相交的线段的数量。

相交是指至少有一个公共点的线段，即具有相同端点的线段相交。

输入格式

在第一行中输入 N (1 <= N <= 3 * 10^5) - 段数。接下来，N 行包含由空格 ai 和 bi 分隔的 2 个整数（1 <= ai, bi <= 2 * N），指定第 i 段的坐标。保证输入中指定的所有段都不同，即对于 i != j，至少满足条件 ai != aj 和 bi != bj 之一

代码：

import java.util.*;


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Map<Integer, ArrayList<Integer>> nums = new HashMap<>();
        int amount = sc.nextInt();
        sc.nextLine();
        for (int i = 0; i < amount; i++) {
            String[] point = sc.nextLine().split(" ");
            int x = Integer.parseInt(point[0]);
            int y = Integer.parseInt(point[1]);
            if (!nums.containsKey(x)) {
                nums.put(x, new ArrayList<>());
            }
            nums.get(x).add(y);
        }

        int count = 0;
        for (int key1 : nums.keySet()) {
            boolean intersects = false;
            ArrayList<Integer> values1 = nums.get(key1);
            for (int key2 : nums.keySet()) {
                if (key1 != key2) {
                    ArrayList<Integer> values2 = nums.get(key2);
                    for (int value1 : values1) {
                        for (int value2 : values2) {
                            if ((key1 < key2 && value1 >= value2) || (key1 > key2 && value2 >= value1)) {
                                intersects = true;
                                break;
                            }
                        }
                        if (intersects) {
                            break;
                        }
                    }
                    if (intersects) {
                        break;
                    }
                }
            }
            if (!intersects) {
                count++;
            }
        }

        System.out.println(count);
    }
}

我无法想出解决问题的想法，请告诉我你可以为下面的问题想出什么逻辑

输入是一个字符串，如果一个字符串的子字符串具有相同的长度，并且具有相同的字符集，则该字符串被认为是漂亮的。优美线条示例：011011011；101101101；1010; 1; 0000; 111 丑行：000101；10101；0001001 问题目的：打印可以纠正丑线的最少步骤数。

示例：000101 - 1 因为我们可以将第二个位置的 0 更改为 1 并得到 010101 0001001 - 2，所以我们可以将所有 1 替换为 0。

计算零和一，然后从较大的数字中减去较小的数字的想法是不合适的，因为在第一个示例中，4（零）减去2（单位）将得到答案2，但作为你可以看到，你可以一步纠正它。我以为它可以创建空白（比方说“漂亮”的空白，例如 11；00 等等），但事实上，有时你可以简单地将所有数字更改为相反的数字，结果就会更短。预先感谢您的回复。

我不明白如何解决这个问题

弗拉基米尔在一场科学展览上展示了他的装置，该装置由连接在一个电路中的 N 个灯泡组成。突然，他意识到展览中展出的像他这样的装置一定很漂亮。如果一个装置从头开始连续具有一定数量（可能为零）的灯泡，这些灯泡被关闭，其余的灯泡被打开，则该装置被认为是漂亮的。例如：电路0000111很漂亮，但电路00010011则不然，其中0是灯泡关闭，1是打开。装置上的每个灯泡都可以打开或关闭。展览即将开始，弗拉基米尔需要用最少数量的灯光开/关来让他的装置变得漂亮。下面我提供了解决问题的代码，但我不明白为什么要这样编写代码的算法逻辑。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();

        int totalDisabled = 0;
        for (char c : s.toCharArray()) {
            if (c == '0') {
                totalDisabled++;
            }
        }

        int answer = totalDisabled;
        int disabled = 0;
        int abled = 0;
        for (char c : s.toCharArray()) {
            if (c == '1') {
                abled++;
            } else {
                disabled++;
            }
            answer = Math.min(answer,  + totalDisabled - abled);
        }
    }
}