华为OD机试 - 最长的完全交替连续方波信号（Java 2023 B卷 200分）

题目描述

给定一串方波信号，要求找出其中最长的完全连续交替方波信号并输出。如果有多个相同长度的交替方波信号，输出任意一个即可。方波信号的高位用1标识，低位用0标识。

说明：

1. 一个完整的信号一定以0开始并以0结尾，即010是一个完整的信号，但101,1010,0101不是。
2. 输入的一串方波信号是由一个或多个完整信号组成。
3. 两个相邻信号之间可能有0个或多个低位，如0110010,011000010。
4. 同一个信号中可以有连续的高位，如011101010111100001010，前14位是一个具有连续高位的信号。
5. 完全连续交替方波是指10交替，如01010是完全连续交替方波，0110不是。

输入描述

输入信号“字符串”（长度 >= 3 且 <= 1024）：00101010101010000101000010
注：输入总是合法的，不用考虑异常情况。

输出描述

输出最长的完全连续交替方波信号串：01010
若不存在完全连续交替方波信号串，输出-1。

解题思路

1. 遍历信号：遍历输入信号，寻找以0开始并以0结尾的子串。
2. 检查交替：对于每个符合条件的子串，检查是否为完全连续交替方波信号。
3. 记录最长：记录最长的完全连续交替方波信号。

代码实现

Java

public class LongestAlternatingSignal {
    public static String findLongestAlternatingSignal(String signal) {
        String longest = "";
        for (int i = 0; i < signal.length(); i++) {
            if (signal.charAt(i) == '0') {
                for (int j = i + 1; j < signal.length(); j++) {
                    if (signal.charAt(j) == '0') {
                        String substring = signal.substring(i, j + 1);
                        if (isAlternating(substring) && substring.length() > longest.length()) {
                            longest = substring;
                        }
                    }
                }
            }
        }
        return longest.isEmpty() ? "-1" : longest;
    }

    private static boolean isAlternating(String s) {
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i) == s.charAt(i - 1)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        String signal = "00101010101010000101000010";
        System.out.println(findLongestAlternatingSignal(signal));
    }
}

Python

def find_longest_alternating_signal(signal):
    longest = ""
    for i in range(len(signal)):
        if signal[i] == '0':
            for j in range(i + 1, len(signal)):
                if signal[j] == '0':
                    substring = signal[i:j+1]
                    if is_alternating(substring) and len(substring) > len(longest):
                        longest = substring
    return longest if longest else "-1"

def is_alternating(s):
    for i in range(1, len(s)):
        if s[i] == s[i-1]:
            return False
    return True

signal = "00101010101010000101000010"
print(find_longest_alternating_signal(signal))

C++

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

bool isAlternating(const string& s) {
    for (size_t i = 1; i < s.length(); ++i) {
        if (s[i] == s[i - 1]) {
            return false;
        }
    }
    return true;
}

string findLongestAlternatingSignal(const string& signal) {
    string longest;
    for (size_t i = 0; i < signal.length(); ++i) {
        if (signal[i] == '0') {
            for (size_t j = i + 1; j < signal.length(); ++j) {
                if (signal[j] == '0') {
                    string substring = signal.substr(i, j - i + 1);
                    if (isAlternating(substring) && substring.length() > longest.length()) {
                        longest = substring;
                    }
                }
            }
        }
    }
    return longest.empty() ? "-1" : longest;
}

int main() {
    string signal = "00101010101010000101000010";
    cout << findLongestAlternatingSignal(signal) << endl;
    return 0;
}

JavaScript

function findLongestAlternatingSignal(signal) {
    let longest = "";
    for (let i = 0; i < signal.length; i++) {
        if (signal[i] === '0') {
            for (let j = i + 1; j < signal.length; j++) {
                if (signal[j] === '0') {
                    let substring = signal.slice(i, j + 1);
                    if (isAlternating(substring) && substring.length > longest.length) {
                        longest = substring;
                    }
                }
            }
        }
    }
    return longest || "-1";
}

function isAlternating(s) {
    for (let i = 1; i < s.length; i++) {
        if (s[i] === s[i - 1]) {
            return false;
        }
    }
    return true;
}

let signal = "00101010101010000101000010";
console.log(findLongestAlternatingSignal(signal));

测试用例

测试用例1：

• 输入：0011010101001010
• 输出：01010
• 说明：虽然信号中包含了多个交替的部分，但01010是最长的交替方波。

测试用例2：

• 输入：0101010
• 输出：0101010

总结

通过遍历输入信号并检查每个可能的子串，我们可以找到最长的完全连续交替方波信号。这种方法的时间复杂度为O(n^2)，适用于输入长度在1024以内的信号。