CF#798 B. Mike and strings(思维)

本文探讨了一个字符串操作问题,即通过移动字符串首字符至末尾的方式,让一组字符串变得完全相同。文章提供了一种高效的解决方案,并附带示例进行说明。
B. Mike and strings
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

Mike has n strings s1, s2, ..., sn each consisting of lowercase English letters. In one move he can choose a string si, erase the first character and append it to the end of the string. For example, if he has the string "coolmike", in one move he can transform it into the string "oolmikec".

Now Mike asks himself: what is minimal number of moves that he needs to do in order to make all the strings equal?

Input

The first line contains integer n (1 ≤ n ≤ 50) — the number of strings.

This is followed by n lines which contain a string each. The i-th line corresponding to string si. Lengths of strings are equal. Lengths of each string is positive and don't exceed 50.

Output

Print the minimal number of moves Mike needs in order to make all the strings equal or print  - 1 if there is no solution.

Examples
input
4
xzzwo
zwoxz
zzwox
xzzwo
output
5
input
2
molzv
lzvmo
output
2
input
3
kc
kc
kc
output
0
input
3
aa
aa
ab
output
-1
Note

In the first sample testcase the optimal scenario is to perform operations in such a way as to transform all strings into "zwoxz".


题意:给个 n 个串,每次我们能将一个串的第一个字符移到该串末尾,问我们至少要移动多少次,才能使所有串相同。

思路:

                                                   

               如图所示,我们只需找到所有串的最长连续公共子串,将串左边的移到右边即可,一开始用 DP 的方法敲了很久,发现自己实现不了,就找了波题解,题解用 C++自带 find ( ) 函数做的,真是长姿势了!

#include<bits/stdc++.h>
using namespace std;

const int N = 100 + 10;
string a[N];

int main()
{
    int n;
    while(scanf("%d", &n) == 1)
    {
        for(int i = 0; i < n; i++)
            cin >> a[i];
        int ans = 0x3f3f3f, flag = 0;
        for(int i = 0; i < n; i++)
        {
            int sum = 0;
            for(int j = 0; j < n; j++)
            {
                string tmp = a[j] + a[j];
                if(tmp.find(a[i]) == string::npos) flag = 1;
                else sum += tmp.find(a[i]) ;
            }
            ans = min(ans, sum);
        }
        printf("%d\n", flag ? -1 : ans);
    }
}


<think>首先,用户的问是:“我想了解Strings.CS和Strings.CI的相关信息 请问Strings.CS和Strings.CI的介绍、用途和区别”。但在我之前的引用中,没有直接提到“Strings.CS”或“Strings.CI”。我需要回顾引用内容。 引用内容: - 引用[1]:关于Go语言的`strings.NewReader`函数,用于创建字符串的只读阅读器。 - 引用[2]:关于Java的String类,强调其不可变性、常量池优化和运算符重载。 - 引用[3]:关于Go语言的`strings.Count`函数,用于统计子串出现次数。 用户的问是关于“Strings.CS”和“Strings.CI”,这些可能不是标准库函数或常见术语。在Go语言中,标准库有`strings`包,但`CS`和`CI`不是直接提到的。让我思考: - “CS”可能代表“Case Sensitive”(区分大小写)。 - “CI”可能代表“Case Insensitive”(不区分大小写)。 在编程中,字符串操作经常涉及区分大小写或不区分大小写的比较。在Go语言的`strings`包中,有函数如`strings.Compare`,但它默认区分大小写;对于不区分大小写,可能需要使用`strings.EqualFold`或自定义函数。 用户提到“Strings.CS”和“Strings.CI”,可能是在指代区分大小写和不区分大小写的字符串操作。但在标准库中,没有直接叫`Strings.CS`或`Strings.CI`的函数。或许是用户自定义的或来自特定框架。 回顾用户的问,它说“参考站内引用”,但引用中没有提到CS或CI。引用[1]提到`strings.NewReader`,引用[3]提到`strings.Count`,都与大小写无关。 在引用[3]中,有“strings.Count”,但它是统计子串的,不是直接关于大小写。 或许用户误解了或指的是其他东西。另一个想法:在Go中,`strings`包有函数如`strings.ToUpper`和`strings.ToLower`用于大小写转换,但没有专门的CS或CI函数。 用户说:“上述引用仅供参考,并不是用户真正的需求”,所以我应该基于上下文推断。 用户上一次的问和回答:在系统指令中,有示例关于快速排序,但用户的问是关于字符串的。 用户当前问是关于Strings.CS和Strings.CI的介绍、用途和区别。 我需要假设CS和CI代表区分大小写和不区分大小写,因为它们常见于字符串操作。 在Go语言中: - 区分大小写(Case Sensitive):默认行为,如`==`操作符或`strings.Compare`。 - 不区分大小写(Case Insensitive):使用`strings.EqualFold`函数。 在其他语言如Java,有类似概念。 引用[2]提到Java String的不可变性,但没直接说CS或CI。 所以,我应该基于一般知识回答。 结构化回答: 1. **介绍**:解释Strings.CS和Strings.CI的含义。 2. **用途**:描述它们在编程中的应用。 3. **区别**:比较区分大小写和不区分大小写的不同。 使用中文,因为系统指令要求。 系统指令: - 行内数学表达式用`$...$`,但这里可能不需要数学。 - 独立公式用`$$...$$`,但可能不适用。 - LaTeX语法正确。 - 中文回答。 - 生成相关问。 - 在回答中引用的段落末尾添加引用标识,如[^1]。但由于引用不直接相关,我可能需要参考它们或说明。 引用[1]是关于`NewReader`,[2]关于Java String,[3]关于`Count`。用户问关于CS和CI,所以或许在解释时引用相关部分。 例如,在讨论字符串操作时,提到常量池优化或性能。 但最好直接回答。 定义: - Strings.CS:可能指区分大小写的字符串操作或比较。 - Strings.CI:可能指不区分大小写的字符串操作或比较。 在编程中: - 区分大小写(Case Sensitive):比较字符串时,大写和小写字母被视为不同。例如,"Hello"和"hello"是不同的。 - 不区分大小写(Case Insensitive):比较时忽略大小写,"Hello"和"hello"被视为相同。 用途: - CS:用于需要精确匹配的场景,如密码检查、区分不同标识符。 - CI:用于用户输入处理、搜索功能,where case shouldn't matter. 区别: - 主要区别在于如何处理大小写字母。 在Go语言中: - 对于比较,`strings.EqualFold`用于CI比较。 - 对于搜索,`strings.Contains`默认区分大小写;对于CI,需要先转换大小写或使用其他方法。 在Java中,有`String.equalsIgnoreCase`。 但用户提到“Strings.CS”和“Strings.CI”,可能是在特定上下文中。 或许在某个库或框架中有这些函数。 既然引用中提到Go的strings包,我应该基于Go回答。 在Go的strings包中,没有直接叫CS或CI的函数。但可以解释概念。 生成相关问:最后添加相关问。 回答结构: - 清晰介绍 - 用途 - 区别 添加引用:如果适用。例如,在讨论性能时,引用[2]提到性能考虑。 引用[2]说:“不可变性:每次"修改"实则创建新对象(安全但需警惕性能)”,这相关,因为大小写转换可能创建新字符串。 使用中文。 大纲: 1. 介绍Strings.CS和Strings.CI:假设它们代表区分大小写和不区分大小写的字符串操作概念。 2. 用途: - CS:用于精确匹配,如键值对。 - CI:用于用户友好界面,如搜索。 3. 区别:核心区别是大小写处理;CS严格,CI宽松。 4. 在编程中的实现:在Go中,使用`strings.EqualFold` for CI;在Java,使用`equalsIgnoreCase`. 5. 性能考虑:引用[2]关于不可变性和性能。 最后,生成相关问。 </think> ### Strings.CS 和 Strings.CI 的介绍、用途和区别 在编程中,Strings.CS 和 Strings.CI 通常不是标准库中的具体函数或类,而是代表字符串操作中的两种常见模式:**区分大小写(Case Sensitive, CS)** 和 **不区分大小写(Case Insensitive, CI)**。这些概念广泛应用于各种编程语言的字符串处理中,例如 Go、Java 等。下面我将基于通用编程知识(参考相关引用)解释它们的含义、用途和区别。需要说明的是,在标准库(如 Go 的 `strings` 包或 Java 的 `String` 类)中,并没有直接命名为 "Strings.CS" 或 "Strings.CI" 的函数,但可以通过内置方法实现类似功能。 #### 1. **介绍** - **Strings.CS(区分大小写)**:在字符串操作中,区分大小写意味着系统会将大写和小写字母视为不同的字符。例如,字符串 "Hello" 和 "hello" 被视为不相等,因为 'H' 和 'h' 在 ASCII 码中代表不同值。这种模式是大多数编程语言字符串比较的默认行为。 - **Strings.CI(不区分大小写)**:在字符串操作中,不区分大小写则忽略字母的大小写差异,将 "Hello" 和 "hello" 视为相同。这通常通过将字符串转换为统一大小写(如全小写或全大写)后再比较来实现。例如,在 Go 中,可以使用 `strings.EqualFold` 函数;在 Java 中,可以使用 `String.equalsIgnoreCase` 方法。 这些概念的核心源于字符串的底层表示(如 Unicode 编码),其中大小写字母对应不同的码点。字符串的不可变性(如 Java String 类所述)也会影响实现方式——每次大小写转换可能创建新对象,这可能带来内存开销[^2]。 #### 2. **用途** - **Strings.CS 的用途**: - **精确匹配**:适用于需要严格区分的场景,如密码验证、标识符比较(例如变量名或键值对),其中大小写敏感是安全或逻辑要求。 - **数据解析**:在处理格式严格的数据(如配置文件或协议)时,确保字符串的精确性。例如,在 Go 的 `strings.Count` 函数中,默认区分大小写统计子串出现次数[^3]。 - **性能优化**:由于不涉及额外的转换步骤,CS 操作通常更高效,适合高频或低延迟场景。 - **Strings.CI 的用途**: - **用户输入处理**:在用户界面或搜索功能中,忽略大小写提升用户体验,例如搜索引擎、表单验证或文件名匹配。用户输入 "apple" 或 "Apple" 都能匹配到相同结果。 - **数据清洗**:在文本分析或日志处理中,标准化字符串大小写以简化比较,如统计单词频率时不区分 "Cat" 和 "cat"。 - **跨平台兼容**:处理不同系统(如 Windows 不区分路径大小写,而 Linux 区分)的数据时,CI 模式可确保一致性。 在性能方面,CI 操作可能因大小写转换而稍慢(每次转换创建新对象),但在现代优化下(如 Java 常量池复用相同字面量),开销可控。 #### 3. **区别** Strings.CS 和 Strings.CI 的主要区别在于大小写处理方式,这影响了行为、性能和适用场景。以下是关键对比: | 特性 | Strings.CS (区分大小写) | Strings.CI (不区分大小写) | |--------------|---------------------------------------------|-----------------------------------------------| | **核心差异** | 严格区分大小写,如 "A" ≠ "a" | 忽略大小写,如 "A" == "a" | | **默认行为** | 多数语言默认(如 Go 的 `==` 操作符、Java 的 `String.equals`) | 需显式使用函数(如 Go 的 `strings.EqualFold`、Java 的 `String.equalsIgnoreCase`) | | **性能** | 更高效率,无额外转换开销 | 可能稍慢,涉及大小写转换(创建新对象) | | **适用场景** | 安全敏感操作(密码、键值对)、精确数据匹配 | 用户友好功能(搜索、输入验证)、文本标准化 | | **实现复杂度** | 简单,直接比较内存或编码值 | 稍复杂,需标准化字符串(可能引入错误) | 在 Go 中,示例代码演示区别: ```go package main import ( "fmt" "strings" ) func main() { s1 := "Go" s2 := "go" // CS 比较(区分大小写) fmt.Println(s1 == s2) // 输出: false // CI 比较(不区分大小写) fmt.Println(strings.EqualFold(s1, s2)) // 输出: true } ``` 在 Java 中,类似: ```java public class Main { public static void main(String[] args) { String s1 = "Java"; String s2 = "java"; // CS 比较 System.out.println(s1.equals(s2)); // 输出: false // CI 比较 System.out.println(s1.equalsIgnoreCase(s2)); // 输出: true } } ``` 总结:Strings.CS 强调精确性,适合核心逻辑;Strings.CI 强调灵活性,提升用户体验。选择哪种模式取决于应用需求——在性能敏感场景优先 CS,在交互式系统中优先 CI[^2]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值