P10296 [CCC 2024 S2] Heavy-Light Composition-CSDN博客

本文链接：https://blog.csdn.net/KARRAS/article/details/140664990

题目传送门

思路：

统计字符频率：
- 遍历字符串，统计每个字母在字符串中出现的次数。
标记字母的类型：
- 根据出现次数，将字母分为“重”或“轻”。
检查交替模式：
- 检查字符串的位置序列，确保重的字母和轻的字母交替出现。

具体步骤如下：

读取输入：
- 从输入中读取字符串的数量和每个字符串的长度。
处理每个字符串：
- 对每个字符串，统计每个字符在字符串中出现的频率。
- 根据字符的频率，确定每个字符的类型（重或轻）。
检查交替条件：
- 遍历字符串，检查每个位置上的字符是否符合交替出现的规则：
  - 情况1：所有奇数位是重的，所有偶数位是轻的。
  - 情况2：所有奇数位是轻的，所有偶数位是重的。
- 如果满足任一条件，输出 'T'；否则，输出 'F'。

代码&解释

c++代码：

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

bool isAlternating(const string& s) {
    map<char, int> freq;
    for (char c : s) {
        freq[c]++;
    }

    bool heavyFirst = freq[s[0]] > 1;
    for (size_t i = 0; i < s.size(); ++i) {
        if (heavyFirst) {
            if (i % 2 == 0 && freq[s[i]] <= 1) return false; // 偶数位应是重的字母
            if (i % 2 == 1 && freq[s[i]] > 1) return false; // 奇数位应是轻的字母
        } else {
            if (i % 2 == 0 && freq[s[i]] > 1) return false; // 偶数位应是轻的字母
            if (i % 2 == 1 && freq[s[i]] <= 1) return false; // 奇数位应是重的字母
        }
    }
    return true;
}

int main() {
    int T, N;
    cin >> T >> N;
    vector<string> strings(T);
    for (int i = 0; i < T; ++i) {
        cin >> strings[i];
    }

    for (const string& s : strings) {
        cout << (isAlternating(s) ? 'T' : 'F') << endl;
    }

    return 0;
}

代码解释：

读取输入：
- 读取两个整数 T 和 N，分别表示字符串数量和每个字符串的长度。
- 读取 T 个字符串并存储在 vector<string> 中。
isAlternating 函数：
- 使用 map<char, int> 统计每个字母在字符串中出现的频率。
- 确定字符串第一个字母的类型是重还是轻。
- 遍历字符串，按照重轻交替的规则检查每个位置的字母是否符合要求：
  - 偶数位与奇数位的字母类型必须交替出现。
主循环：
- 对每个输入的字符串调用 isAlternating 函数，输出结果 'T' 或 'F'。

Python代码：

def is_alternating(s):
    # 统计每个字符的频率
    freq = {}
    for c in s:
        if c in freq:
            freq[c] += 1
        else:
            freq[c] = 1
    
    heavy_first = freq[s[0]] > 1  # 判断第一个字母是重的还是轻的
    for i in range(len(s)):
        if heavy_first:
            if i % 2 == 0 and freq[s[i]] <= 1:  # 偶数位应是重的字母
                return False
            if i % 2 == 1 and freq[s[i]] > 1:   # 奇数位应是轻的字母
                return False
        else:
            if i % 2 == 0 and freq[s[i]] > 1:   # 偶数位应是轻的字母
                return False
            if i % 2 == 1 and freq[s[i]] <= 1:  # 奇数位应是重的字母
                return False
    return True

# 读取输入
T, N = map(int, input().split())
strings = [input().strip() for _ in range(T)]

# 检查并输出结果
for s in strings:
    print('T' if is_alternating(s) else 'F')

代码解释：

定义函数 is_alternating：
- 使用字典 freq 统计每个字符在字符串中的出现频率。
- 判断字符串第一个字母是重的还是轻的。
- 遍历字符串，检查每个位置的字符是否符合交替出现的规则。
读取输入：
- 使用 input() 读取输入的字符串数量 T 和每个字符串的长度 N。
- 使用列表推导式读取每个字符串。
检查并输出结果：
- 对每个输入的字符串调用 is_alternating 函数，输出结果 'T' 或 'F'。

Pascal代码：

program HeavyLightComposition;

uses SysUtils;

function isAlternating(const s: string): boolean;
var
  freq: array['a'..'z'] of integer;
  i: integer;
  heavyFirst, lightFirst: boolean;
begin
  FillChar(freq, SizeOf(freq), 0);
  
  // 统计每个字符的频率
  for i := 1 to Length(s) do
    Inc(freq[s[i]]);
  
  heavyFirst := True;
  lightFirst := True;
  
  // 第一种情况：奇数位为重字母，偶数位为轻字母
  for i := 1 to Length(s) do
  begin
    if (i mod 2 = 1) and (freq[s[i]] <= 1) then
      heavyFirst := False;  // 奇数位应是重字母
    if (i mod 2 = 0) and (freq[s[i]] > 1) then
      heavyFirst := False;  // 偶数位应是轻字母
  end;
  
  // 第二种情况：奇数位为轻字母，偶数位为重字母
  for i := 1 to Length(s) do
  begin
    if (i mod 2 = 1) and (freq[s[i]] > 1) then
      lightFirst := False;  // 奇数位应是轻字母
    if (i mod 2 = 0) and (freq[s[i]] <= 1) then
      lightFirst := False;  // 偶数位应是重字母
  end;
  
  // 判断是否满足任意一种情况
  isAlternating := heavyFirst or lightFirst;
end;

var
  T, N, i: integer;
  s: string;
begin
  ReadLn(T, N);
  for i := 1 to T do
  begin
    ReadLn(s);
    if isAlternating(s) then
      WriteLn('T')
    else
      WriteLn('F');
  end;
end.

代码解释：

定义函数 isAlternating：
- 使用数组 freq 统计每个字符在字符串中的出现频率。
- 判断字符串第一个字母是重的还是轻的。
- 遍历字符串，检查每个位置的字符是否符合交替出现的规则。
读取输入：
- 使用 ReadLn 读取输入的字符串数量 T 和每个字符串的长度 N。
- 逐个读取字符串并存储在变量 s 中。
检查并输出结果：
- 对每个输入的字符串调用 isAlternating 函数，输出结果 'T' 或 'F'。