codevs 1065 01字符串 题解报告

最新推荐文章于 2022-12-07 14:14:16 发布
最新推荐文章于 2022-12-07 14:14:16 发布
阅读量678 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： NOIP codevs 深度优先搜索 文章标签： noip dfs codevs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xu326057825/article/details/52973485
博客探讨了Codevs上的01字符串问题，要求字符串长度为n且不能有三个连续相同的字符。博主通过样例解释了问题，并提到只要避免出现"000"或"111"即可。解决方案是使用深度优先搜索（DFS）策略，关注前两个字符的状态来生成满足条件的字符串。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

0.0
0.0
0.0
题目描述 Description
输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。

输入描述 Input Description
输入文件只有一行一个整数n，表示有0和1组成的字符串的长度。0<=n<=30。

输出描述 Output Description
输出文件只有一行一个整数，表示所有满足条件的字符串的个数。

样例输入 Sample Input
1

样例输出 Sample Output
2

数据范围及提示 Data Size & Hint

0.0
0.0
0.0
说实话我 没 看 懂 题!!
问了他们做过的，
才知道。
只要字符串里没有 000 111 就好了。

嗯，
直接dfs
记录上一个和上上个是什么就行。

0.0.0
代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
#include<queue>
最低0.47元/天 解锁文章

200万优质内容无限畅学
问题 G(1203): 【基础算法】0/1字符串问题
你的心，如何追逐？
06-08 2449
问题 G(1203): 【基础算法】0/1字符串问题 时间限制: 5 Sec 内存限制: 64 MB 提交: 127 解决: 25 [提交][状态][我的提交] 题目描述输出仅由0和1组成的长度为N的字符串，并且其中不可含有三个连续的相同子串。例如，110101就不含有三个连续的相同子串。而111010就含有一组长度为1的连续相同子串：111输入第1行：字符串长度n（n≤40） 输出第
【日常学习】【字符串处理】noip2011普及组第2题 统计单词数题解
西家家
02-16 3130
这又是一道成功加入“容易吗”系列的基础题= =原本很简单，可是我一开始太大意看错了题，以为是让输出该单词是第几个单词，实际上应该输出该单词的首字母在第几个位置；改过后只得了二十分，看了一组数据，原来第一个单词前面可以有前导空格——幸亏其他单词前没有，否则还真不知道怎么办；实现的时候又出了各种问题。于是我决定总结一下。 题目： 给定一个单词，请你输出它在给定的文章中出现的次数和第一次出现的位置。
【codevs 1065】01字符串
yyx2000的博客
03-27 336
1065 01字符串 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题解 查看运行结果 题目描述 Description 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。输入描述 Input Description 输入文件只有一行一个整数n，表示有0和1组成的字符串的长度。0<=n<=30。输出描述 Outpu
深度优先搜索 codevs 1065 01字符串
weixin_30612769的博客
06-16 240
codevs 1065 01字符串 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述Description 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 输入描述Input Description 输入文件只有一...
Codevs 1065 01字符串
weixin_30786657的博客
06-10 159
1065 01字符串 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 传送门 题目描述 Description 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 输入描述 Input Description 输入文件只有一行一个整数n，表示有0和1组成的字符...
CODE[VS] 1065 01字符串
Dextrad_ihacker的博客
03-23 975
题目链接： CODE[VS] 1065 01字符串 题目描述 Description 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 输入描述 Input Description 输入文件只有一行一个整数n，表示有0和1组成的字符串的长度。0<=n<=30。 输出描述 Output Description 输出文件只有一行一个整数，表示所有满足条件的字符串
Codevs　1065 01字符串
Starlight
09-24 495
Codevs 1065 01字符串题目描述 Description输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。输入描述 Input Description输入文件只有一行一个整数n，表示有0和1组成的字符串的长度。0<=n<=30。输出描述 Output Description输出文件只有一行一个整数，表示所有满足条件的字符串的个数。样例输入 Sample Input1
01字符串
08-30 290
【题目描述】 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 【输入格式】 一行一个整数n表示有0和1组成的字符串的长度 【输出格式】 一行一个整数表示所有满足条件的字符串的个数，并对1000000007取模 【样例输入】 1 【样例输出】 2 【数据范围】 0<=n<=2^63-1 【分析】 比较直接...
八数码难题 （codevs 1225）题解
PbTfcLx
01-10 769
【问题描述】 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 【样例输入】     283104765 【样例输出】      4 【解题
【日常学习】【区间DP+高精】codevs1166 矩阵取数游戏题解
西家家
08-14 6487
题目来自NOIP2007TG3 如果在考场上我现在已经歇菜了吧 今天一整天的时间全部投在这道题上，收获不小。 先上题目 题目描述 Description 【问题描述】 帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的n*m 的矩阵，矩阵中的每个元素aij均 为非负整数。游戏规则如下： 1. 每次取数时须从每行各取走一个元素，共n个。m次后取完矩阵所有
乘积最大【题解】
【Aspire to revive MZOI】
08-03 1727
代码已经摆上去了。【原题】请点击这里 下面简单说一下题目内容： 给定一个长为N（6 使形成的算式结果（乘积）最大。 区间DP与其余DP有别，所以在理解与解题是不应该以其他的DP思路为基础（不然会很凌乱）。 首先要抓住DP的共性：求出子问题最优解，使每个子问题包含其子问题中的最优解。区间DP
python 编程 小葱的01串
boydreaming的博客
12-07 895
python L2 研发工程师 小葱的01串
【Wikioi】1065-01字符串
oooooops
08-13 841
输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 简单的方法是
1065 01字符串
weixin_33863087的博客
06-10 126
1065 01字符串 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题解 查看运行结果 题目描述Description 输出仅有0和1组成的长度为n的字符串，并且其中不能含有3个连续的相同子串。 输入描述Input Descrip...
tyvj 1170 0/1字符串问题 字符串中仅包含0和1两个字符；②字符串的长度为n；③字符串中不含有三个连续的相同子串 搜索
kongming_acm的专栏
10-05 4391
 FromAdmin☆0/1字符串问题        描述 Description    编程找出符合下列条件的字符串：①字符串中仅包含0和1两个字符；②字符串的长度为n；③字符串中不含有三个连续的相同子串。       输入格式 Input Format   输入文件仅包含一个整数n（0＜n≤35），表示字符串的长度。        输出格式 Output Format   输出文件仅包含一个整数，表示符合上述条件的字符串的总数。       样例输入 Sample Input    2       样例
【codevs1065】01字符串
K1385170的博客
12-07 252
题目大意：输出仅由 0 和 1 组成的长度为 N 的字符串个数，并且其中不能含有 3 个连续的相同子串。 题解：数据太水，正规解法应该是枚举后缀进行判断。 代码如下 #include <bits/stdc++.h> using namespace std; const int maxn=31; int n,s[maxn],ans; void dfs(int cur){ ...
有一个长度为 n 的 01 串，其中有一些位置标记为 ?，这些位置上可以任意填充 0 或者 1，请问如何填充这些位置使得这个 01 串中出现互不重叠的 00 和 11 子串最多，输出子串个数。 输入格式 输入一行包含一个字符串。 输出格式 输出一行包含一个整数表示答案。 样例输入 1110?0 样例输出 2 提示 如果在问号处填 0 ，则最多出现一个 00 和一个 11：111000 。 对于所有评测用例，1 ≤ n ≤ 1000000 。暴力求解，或者贪心求解，当我什么都不会，c语言
最新发布
03-27
<think>好的，我现在要解决这个问题。题目是说，给定一个长度为n的01串，其中有一些位置是问号，可以填0或1。我需要填充这些问号，使得最终的字符串中互不重叠的00和11子串的数量最多。然后输出这个最大的数量。比如样例输入是1110?0，填0得到111000，其中有一个00和一个11，但输出是2，可能样例中的正确填法可能是填1？或者是不是我理解错了？或者可能样例的输出是2，比如填0得到两个11的情况？ 首先，我得仔细看样例。原输入是1110?0。样例输出是2。提示说填0的话得到111000，里面有一个00和一个11，但输出是2？可能我的理解有问题。或者可能提示中的说法是说填0的话会有两个可能的子串？或者可能我的理解方式不对。或者可能这个样例的正确填充方式是填1，比如变成111010，这时候可能有两个互不重叠的子串？比如11（前两位）和11（第二位到第三位），但这样的话会有重叠，所以不行。或者可能正确的填法是让两个子串不重叠。比如，假设填充问号为0，得到111000。这时候，可能的子串是111中的前两个1构成11，中间的两个1构成另一个11？但是这两个11是重叠的，所以只能算其中一个。或者可能填充后的字符串中11和00各出现一次，总共有两个？比如，例如，原题中的样例输出是2，说明这个情况。例如，111000中有三个连续的1，可以拆分成两个11吗？比如第一个和第二个字符是11，第三个和第四个是10，这样可能不行。或者可能这个样例中的正确填法其实是填0得到三个1和三个0，那么其中的互不重叠的11和00的数量是1+1=2？ 这个时候，我需要先理清楚题目中的子串如何计算。题目中的互不重叠的00和11子串，也就是说，每个子串必须是两个连续的相同字符，并且这些子串之间不能有重叠的部分。例如，在字符串111中，可以有11（前两位）和后面的两位（第二、第三位），但是这两个子串是重叠的，所以只能算其中一个。或者可能是否可以拆分多个，比如如何选择才能得到最多的不重叠的子串？ 例如，字符串111中可以有两个不重叠的11吗？比如前两位是第一个子串，第三位剩下的无法组成，所以只能是两个？或者可能不行，因为前两位用了之后，剩下的第三位无法再组成一个子串。比如，假设字符串是111，那么可能的子串是11（位置0-1）和1无法使用，或者位置1-2的11，但这样两个子串是重叠的。所以只能选一个。 那在样例输入1110?0中，当填充问号为0时，得到字符串111000。这时候可能的子串情况： - 前面的三个1，可以选两个11：比如位置0-1的11，然后位置2-3的10（不行），或者位置1-2的11？但是这两个11子串是相邻的，不是重叠的。例如，假设选0-1的11，那么接下来的子串可以从位置2开始。那位置2是1，后面是0，所以无法组成。或者第三个字符是1，后面是0，所以无法。因此，前面的三个1只能组成一个11子串。然后后面是三个0，可以组成两个00子串吗？比如位置3-4的00，位置4-5的00。这两个是不重叠的吗？是的，但它们的长度是两个，所以这两个子串是相邻的，是否允许这样？ 比如，假设字符串是0000，那么可以分成00（0-1）和00（2-3），这两个不重叠，所以总共有两个。这样的话，在样例中，当填充为111000时，前面的三个1可以组成一个11，后面的三个0可以组成两个00。总共有三个子串？但是样例的输出是2。这时候说明我的理解可能有错误。 或者，可能题目中的每个子串必须是两个连续的字符，并且每个字符只能属于一个子串。例如，当有三个连续的0时，最多只能有一个00子串吗？比如，取前两位，那么第三位单独剩下，无法组成另一个。或者可以拆分为0-1和1-2？但这样这两个子串是重叠的，所以不允许。或者，题目中的子串必须是互不重叠的，即每个字符最多属于一个子串。因此，对于三个连续的0，可以有两个00子串吗？例如，第一个和第二个0组成第一个子串，第三个0无法单独使用。或者可能不行，因为三个连续的0只能组成一个长度为2的子串，剩下的第三个无法组成。或者是否允许相邻的两个？比如，0-1是00，然后2-3也是00？比如在四个0的情况下，可以分成前两位和后两位，这样是两个不重叠的子串。例如，0000可以分成0-1和2-3，所以是两个。这时候，当有三个连续的0，比如000，只能取一个00子串，然后第三个0无法使用。所以在这种情况下，三个连续的0只能有一个00子串。这样，在样例中，当填充为111000时，前面三个1可以组成一个11（比如0-1），剩下的第三个1无法组成另一个。后面的三个0只能组成一个00（比如3-4），剩下的第五个0无法组成。所以总共有两个子串。这样，样例的输出是2，符合要求。所以这说明，在计算时，对于连续的多个相同字符，可以分割成多个不重叠的两位子串。例如，四个连续的0可以分割成两个不重叠的00子串，每个占据两位。而三个连续的0只能分割成一个00子串，剩下的一个0无法使用。 那么，问题转化为如何填充问号，使得将整个字符串分割成尽可能多的不重叠的两位的00或11子串。 现在，问题转化为，如何填充问号，使得这样的子串数量最大。这是一个典型的动态规划问题，或者贪心问题。因为对于每个位置，我们需要决定是否与前面的字符形成一个有效的子串，或者保留到后面的位置。 可能的贪心策略是尽可能多地在每个可能的位置形成子串。例如，从前往后扫描，每当可以形成00或11子串时，就立即取这个子串，并跳过下一个字符。这样可以确保尽可能多的子串被选取。但是，是否这种贪心策略是正确的？或者是否存在某些情况需要延迟选择以获得更大的总数？ 例如，考虑字符串0000。贪心策略会先取前两位的00，然后后两位的00，这样得到两个，是正确的。而对于另一种情况，例如01000。假设问号填充的情况是01000。那么，如果按照贪心的策略，第一个字符0和第二位1无法组成子串，第二位1和第三位0也无法，第三位0和第四位0可以组成00，然后第五位0无法组成，所以总共有1。但是如果第三位不取，而是第四和第五位组成00，那么可能得到1。所以结果一样。或者可能存在更复杂的情况？ 或者例如，字符串000。贪心策略取前两位的00，剩下的第三位无法，总数1。而另一种分割方式无法更好，所以正确。 另一个例子，字符串00000。贪心策略取0-1，跳过2，取3-4，总共有两个。而整个字符串五个0，可以被分割为0-1， 2-3，剩下一个，无法。所以总共有两个。或者是否存在更好的分割方式？比如，分割为1-2和3-4，这样也是两个。所以无论怎样分割，只能得到两个子串。因此，贪心策略正确。 那么，贪心策略是否适用于本题？ 可能的贪心策略是：从左到右扫描字符串，每次尽可能取当前位置和下一个位置组成一个有效的子串（即00或11）。如果这两个字符中有一个是问号，则填充相应的值使得这两个字符相同。如果这两个字符已经是相同的，或者可以通过填充问号得到相同，那么取这个子串，并跳过后面的一个字符。否则，就跳过当前字符，继续处理下一个。 这样的策略是否能够最大化子串的数量？ 例如，对于样例输入1110?0，原始字符串是1 1 1 0 ? 0。当处理到前两位1和1，可以组成11，计数加1，然后跳过第三位。接下来处理第四位的0和第五位的？。此时，第五位是？，可以填0或者1。假设填0的话，这两个位置是0和0，形成00，计数加1，然后跳过第六位。这样总共有2，符合样例的输出。或者可能处理方式不同？ 那按照这个策略，当处理到前两位的1和1，组成11，计数加1，然后处理第三位的1和第四位的0？这时候可能第三位已经被跳过？ 或者，贪心策略的处理方式可能是在处理到i的位置时，尝试将i和i+1的位置组成子串。如果可以的话，则计数加1，并且i增加2；否则，i增加1。例如，这样： i从0开始： 当i=0，查看i和i+1的位置是否可以组成00或11。例如，原字符串中的字符是否可以通过填充问号形成相同的两个字符。如果可以的话，填充这两个位置的问号为相同的值，并计数加1，然后i +=2。否则，i +=1。 这个处理方式的正确性如何？ 比如，对于字符串0?0。原字符串的三个字符是0、?、0。i=0时，检查i和i+1的位置：0和？。可以填充？为0，形成00，计数加1，然后i跳到2。此时，i=2，已经到末尾，结束。总共有1个子串。如果处理方式是不填充问号为0，而是后面的？和0填充为0，那么是否有更好的结果？例如，原字符串0?0，如果i=0的时候处理0和？，填充为0，得到00，然后剩下的0单独，所以总共有1。或者i=0的时候不处理，而处理i=1和i=2的位置？，此时i=1的位置是？，i+1是0。可以填充？为0，形成00，计数加1。此时，总共有1。所以无论哪种方式，总数一样。所以贪心策略正确。 另一个例子，字符串0?1。i=0时，0和？，可以填充？为0，组成00，计数加1。剩下的1无法处理，总数1。或者，如果填充？为1，则0和1无法组成，但？和1可以组成11吗？原字符串是0 ? 1。如果i=0，无法组成00或11，所以i增加到1。此时，i=1和i=2是？和1。填充？为1，组成11，计数加1。总共有1。所以两种方式结果一样。所以贪心策略会得到正确的答案。 这说明，贪心策略可能有效。那么，现在的问题转化为，如何实现这个贪心策略，同时处理问号的情况。 具体来说，当处理到i位置时，需要检查i和i+1的位置是否可以组成00或11。如果有问号，则允许填充这两个位置的问号为相同的值。然后，如果确实可以组成这样的子串，则计数加1，并跳过i+1的位置。否则，不处理，继续下一个位置。 那么，如何判断i和i+1的位置是否可以组成00或11？ 对于这两个字符来说，可能有以下几种情况： 1. 两个都是确定的字符（0或1）。如果相同，则可以组成子串。否则，不能。 2. 其中一个或两个是问号。此时，需要判断是否可以填充问号使得两个字符相同。 例如： a. i是0，i+1是？：可以将i+1的？填为0，组成00。 b. i是？，i+1是1：可以将i填为1，组成11。 c. i和i+1都是？：可以都填为0或1，组成00或11。 在这种情况下，只要存在至少一个字符是0或1，或者两个都是问号，那么就可以填充形成相同的字符。 综上，只要这两个位置中至少有一个字符是确定的，且它们可能被填充为相同的，或者两个都是问号，那么就可以形成子串。 所以，当处理i和i+1的位置时，只要这两个字符可以被填充为相同，那么就可以形成一个子串。 所以，对于每个i，从0到n-2： 如果i和i+1的位置可以组成相同的字符（即两个字符中有至少一个确定的值，或者两个都是？），则取这两个字符作为一个子串，填充问号使得它们相同，然后i +=2。 否则，i +=1。 这样处理下去，得到的子串数量是否是最大的？ 假设这样的贪心策略是有效的，那么如何实现？ 现在，我需要用C语言编写一个程序，按照这个贪心策略处理字符串，填充问号，并统计最多子串数目。 需要注意，因为字符串长度可能达到1e6，所以算法必须是O(n)的时间复杂度。 现在，具体的实现步骤： 初始化计数器ans=0，i=0。 循环，当i < n-1： 检查i和i+1的位置是否可以组成相同的字符： - 如果s[i]和s[i+1]都是确定的字符，并且相等，则ans++，i+=2。 - 否则，如果至少有一个字符是问号，并且可以通过填充使得两者相同： 例如： 情况1：s[i]是0，s[i+1]是？。填充？为0，形成00。ans++，i +=2. 情况2：s[i]是？，s[i+1]是1。填充？为1，形成11.ans++，i +=2. 情况3：s[i]和s[i+1]都是？。可以填为0或1。比如，填为0，形成00。ans++，i +=2. 如果上述情况满足，则ans++，i +=2. 否则，无法形成子串，i +=1. 这样处理是否正确？ 例如，对于样例输入： 字符串是1110?0。索引0~5： 0:1, 1:1 → 11，ans+1=1，i=2. i=2，此时查看s[2]=1，s[3]=0 → 不相同，无法组成。所以无法处理。i +=1 → i=3. i=3，s[3]=0，s[4]=? → 可以填？为0，组成00。ans=2，i=5. i=5，已经到最后一个位置（n-1=5），无法处理，结束。总共有2，符合样例。 另一个例子：原字符串0?0的处理： i=0，s[0]=0，s[1]=? → 可以填为0，ans=1，i=2. s[2]=0，此时i=2，无法处理i+1=3，结束。总共有1. 另一个例子：字符串???的处理： i=0，s[0]和s[1]都是? → 可以填为0，组成00。ans=1，i=2. 此时i=2，是否还有i+1=3？假设字符串长度是3，则i=2时无法处理。总共有1。而整个字符串可以分成三个?，填充成000，那么可以形成两个00？例如，前两位00，然后两位00（i=0和1，然后i=2无法处理）。或者贪心处理的话，只能得到一个。这似乎不是最优解。例如，填充为0000的话，可以形成两个00子串。比如，假设字符串长度是4，那么处理i=0和1得到00，i=2和3得到00，总共有2。而如果字符串长度是3，填充为000，则只能有一个00子串，无法得到两个。所以贪心策略在这种情况下是正确的？ 这可能说明，贪心策略无法处理某些情况。例如，当处理i=0和i=1的??时，形成00，但剩下的i=2的？无法组成。而如果选择i=0的？和i=1的？填为00，或者填为11，那么后面无法组成。而另一种情况，如果处理i=0的时候跳过，然后在i=1和i=2的??填为00，这样可以得到一个子串。总数一样。 所以，贪心策略在这种情况下正确。 可能，贪心策略是正确的，因为它总是尽可能多地选择子串，从而最大化总数。 现在，我需要将这个逻辑转化为代码。 具体来说，在代码中如何处理每个i的位置： 对于每个i，从0开始： 如果i >= n-1，break. 检查s[i]和s[i+1]是否可以形成相同的字符： 条件： (s[i] == s[i+1]) 或者 (s[i] == '?' 或 s[i+1] == '?') 或者 两个都是 '?'. 因为，如果两个字符中有至少一个是问号，那么可以填成相同的字符。例如，如果一个是0，另一个是?，则填?为0；如果一个1，另一个是?，填为1；如果两个都是?，填为0或1都行。所以，只要两个字符中可以变成相同，就可以形成一个子串。 所以，只要s[i]和s[i+1]中有至少一个不是确定的不同字符，就可以组成子串。例如，如果s[i]是0，s[i+1]是1，则无法；如果s[i]是0，s[i+1]是?，则可以。 所以，条件判断是：s[i] == s[i+1] 或者其中至少一个是问号。但是，这可能不完全正确。例如，当s[i]是0，s[i+1]是1时，它们不同，且都不是问号，所以无法组成子串。因此，只有当s[i]和 s[i+1]中至少有一个是问号，或者它们本身相同的时候，才可以组成子串。 因此，在代码中，当处理i和i+1的位置时： if (s[i] == s[i+1] || s[i] == '?' || s[i+1] == '?')： ans +=1 i +=2 else： i +=1 但是，这可能有问题。例如，当s[i]是0，s[i+1]是1，那么无法组成相同的，所以必须跳过。只有当至少有一个是问号，或者他们本身相同的时候，才能组成子串。 例如，当s[i]和s[i+1]中有至少一个问号，或者它们本身相同，则可以组成。否则不行。 所以，条件判断应写为： if (s[i] == s[i+1] || (s[i] == '?' || s[i+1] == '?')) 在这种情况下，即可形成子串。 例如，当s[i]是0，s[i+1]是? →可以填充？为0，形成00。满足条件。 当s[i]是0，s[i+1]是1 →不满足条件，无法形成。 当s[i]和s[i+1]都是? →可以填为相同，形成00或11，满足条件。 所以，这样判断是正确的。 因此，代码的大体结构是： 初始化ans=0，i=0。 循环，当i < len-1： 检查当前i和i+1的位置是否满足条件： if (s[i] == s[i+1] || s[i] == '?' || s[i+1] == '?')： ans +=1 i +=2 else: i +=1 这样处理后，ans即为所求。 但是，是否正确？例如，对于样例输入1110?0： 原字符串是 '1','1','1','0','?','0' i=0: s[0]和s[1]都是1 →满足条件，ans=1，i=2. i=2: s[2]是1，s[3]是0 →不满足条件，所以i +=1 →i=3. i=3: s[3]是0，s[4]是? →满足条件，ans=2，i=5. i=5 →超过n-2（假设n=6，索引5是最后一个字符，i=5时无法处理i+1=6），循环结束。总ans=2，正确。 另一个测试用例，输入是0000： 处理i=0: s[0]和s[1]都是0 →ans=1，i=2. i=2，s[2]和s[3]都是0 →ans=2，i=4。循环结束。正确。 另一个测试用例，输入是0?0: i=0: s[0]是0，s[1]是? →条件满足，ans=1，i=2. i=2，无法处理。总ans=1，正确。 另一个测试用例，输入是0?1: i=0: s[0]是0，s[1]是? →条件满足，ans=1，i=2. i=2，无法处理。总ans=1. 但是，如果填充？为1的话，后面的？和1可以组成11吗？例如，原字符串是0 ? 1。按照上述处理方式，i=0时，取0和?，填充为0，得到00。此时i=2是1，无法处理。所以总数1。而如果i=0不处理，而是处理i=1和i=2的位置？和1，填充？为1，得到11。此时总数1。所以两种方式结果相同，所以贪心策略是正确的。 那，这样看来，这个贪心策略是正确的。因此，代码可以按照这个逻辑编写。 接下来，代码的实现。由于输入的字符串长度可能很大（1e6），需要用C语言高效处理。 步骤： 读取输入字符串：可以用fgets或者逐字符读取，注意去掉可能的换行符。 遍历字符串，按照上述贪心逻辑处理。 例如，代码的大致结构： #include <stdio.h> #include <string.h> int main() { char s[1000001]; scanf("%s", s); int n = strlen(s); int ans = 0; for (int i = 0; i < n - 1; ) { if (s[i] == s[i+1] || s[i] == '?' || s[i+1] == '?') { ans++; i += 2; } else { i++; } } printf("%d\n", ans); return 0; } 这样是否正确？ 例如，样例输入1110?0： 字符串各字符：索引0:1, 1:1 →条件满足，ans=1，i=2. i=2时，字符是1和0 →条件不满足，i增加1到3. i=3时，字符是0和? →条件满足，ans=2，i=5. 循环结束，输出2。正确。 另一个测试用例输入0000： i=0和i=1都0 →条件满足，ans=1，i=2. i=2和i+1=3 →0和0 →条件满足，ans=2，i=4。循环结束，输出2. 输入0?0： i=0和i+1是0和? →条件满足，ans=1，i=2。循环结束，输出1. 输入0?1： i=0和i+1是0和? →条件满足，ans=1，i=2。循环结束，输出1. 输入??? →三个问号： i=0和i+1是?和? →条件满足，ans=1，i=2。i=2时，i+1是3，超过长度。所以输出1. 这可能不是最优的，例如，如果三个问号填充为000，可以得到两个子串吗？例如，i=0和i+1是00 →ans=1，i=2。无法继续处理。所以总共有1。而如果填充为 00 0，那么只能一个。所以贪心算法正确。 但是如果字符串是四个问号，例如????： i=0和1 →ans=1，i=2. i=2和3 →条件满足，ans=2，i=4。循环结束。输出2。这正确，因为填充为0000，可以得到两个子串。 那这说明代码是正确的？ 综上，这个贪心算法是正确的。因为每次尽可能地在当前位置取一个子串，从而保证全局最优。 因此，最终的答案就是这个贪心算法的实现。</think>要解决这个问题，我们需要填充字符串中的问号（`?`），使得互不重叠的 `00` 和 `11` 子串数量最多。通过贪心策略，我们可以高效地实现这一目标。 ### 方法思路 **贪心策略**：从前往后遍历字符串，尽可能在每个位置形成有效的子串（`00` 或 `11`）。具体步骤如下： 1. **判断条件**：当前位置 `i` 和 `i+1` 的字符可以相同（包括两者相同、至少有一个是问号的情况）。 2. **填充处理**：若满足条件，则视为形成一个有效子串，计数器加1，并跳过下一个字符；否则继续处理下一个位置。 这种方法确保每次尽可能多地形成子串，从而最大化总数。 ### 解决代码 ```c #include <stdio.h> #include <string.h> int main() { char s[1000001]; scanf("%s", s); int n = strlen(s); int ans = 0; for (int i = 0; i < n - 1;) { if (s[i] == s[i + 1] || s[i] == '?' || s[i + 1] == '?') { ans++; i += 2; } else { i++; } } printf("%d\n", ans); return 0; } ``` ### 代码解释 1. **输入读取**：读取输入的字符串并计算其长度。 2. **遍历处理**：使用循环遍历字符串，检查每对相邻字符是否符合形成有效子串的条件。 3. **计数与跳过**：当条件满足时，计数器增加，并跳过下一个字符；否则继续处理下一个字符。 4. **结果输出**：最终输出最大子串数量。 该方法的时间复杂度为 O(n)，适用于处理大规模输入，确保高效运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值