字符串 on 一共十七划

题解-统计子串中的唯一字符-哈希表+栈，计算贡献

Sun, 26 Nov 2023 16:17:28 +0800

Problem: 828. 统计子串中的唯一字符

思路

注意到一个唯一字符对数个子串生效，也就是在多个子串中唯一字符是固定的那几个，很容易想到贡献法
对于子串起点和终点我们设置成$left,right$,任意字符位置为$a_i$序列,让子串生效的范围是$left-right$这个范围内,存在一个字符a,其序列满足
$$a_{i-1}<left<=a_i<=right<a_{i+1}$$,
同样可以通过枚举起点终点,得知满足这个条件子串的个数为 $(a_i-a_{i-1})*(a_{i+1}-a_{i})$,
为了计算方便我们将-1和n作为每个字符的两端,既$a_{-1}=-1,a_{n+1}=n$
该字母在$a_i$上为答案做的贡献就等于子串的数量

解题方法

使用哈希表存储每个字母的位置序列
为了前后方便我们使用栈来维护具体的字母序列

时间复杂度,O(n)
空间复杂度,O(n)

Code

class Solution:
    def uniqueLetterString(self, s: str) -> int:
        n=len(s) 
        hash=[[n] for _ in range(26)] #最右端点
        for i in range(len(s)-1,-1,-1):
            hash[ord(s[i])-ord('A')].append(i)
            #小的在顶部,大的在底部
        res=0
        for i in range(26):
            pre=-1
            while len(hash[i])>1:
                index=hash[i].pop()
                back=hash[i][-1]
                res+=(index-pre)*(back-index)
                pre=index
        return res

[A=B]攻略-第三章

Tue, 24 Oct 2023 23:02:00 +0800

前言

这个关键字相当于在找到特定的子字符串之后,删去该子字符串,并且将我们指定的新字符串插入到原字符串的开头与结尾

类似于正则表达式的^与$的应用

很像是我们在第二章的操作:将字母压之后换成其他字母往后排以使得压缩持续进行

3-1 去除

相当简单的教程

(start)a=
(end)a=

3-2 旋转

这里只针对前面不是a进行操作,可以保证

(start)b=(end)b
(start)c=(end)c

3-3 A到B 2

思路

开始上难度了,但是其实不难,我们只需要先把所有特定位置的a变成特殊的,然后再处理另一边的特殊的即可

就像是我们之前做过的一样,此时的代码如下

(start)a=x
xa=ax
(end)a=z
az=za
x=b
z=b

优化

我们很容易注意到我们的xa=ax或者之类的操作只是把所有符合要求的串找出来,保证不阻塞生成

于是我们注意到移到另一边的位置显然更好(指行数更小),更新之后如下

代码

(start)a=(end)x
(end)x=(start)b
(end)a=(start)x
(start)x=(end)b

3-5 首尾

通过上一题我们就知道弄到尾部直接判断即可

我们唯一要注意的就是判断在前,不然容易出死循环

ax=(return)true #有任意一个就是真的,能迅速检查到
by=(return)true
cz=(return)true
#以下的操作会1.在有相同的时候把除了最后一个字母之外都换成其他字母插入到后面 2.没有相同的时候所有都插入到后面
(start)a=(end)x
(start)b=(end)y
(start)c=(end)z
=(return)false

3-6 最多 2

思路

与之前的类似,但是我们需要保留所有作比较的字母来保证恢复,然后这里其实就可以

ca=ac
cb=bc
ba=ab
ab=(end)x
cx=(end)y #y代表abc,可随时换成最多的 #剩下ac和bc
#之后我们不用关心y具体是什么,只要二者消耗,剩下的那个做全员回复就行
ac=(end)y
bc=(end)y
#做一个穷举
ax=aa
cy=cc
by=bb
ay=aa
bx=bb

优化

发现ax,ay的行为是相同的,bx,by也是,优化以下

ca=ac
cb=bc
ba=ab
ab=(end)x
cx=(end)y #y代表abc,可随时换成最多的
#acy bcy ay by cy 
ac=(end)y
bc=(end)y
x=y
cy=cc
by=bb
ay=a

3-7回文串

思路

判断是不是消除之后全空即可,如3-5的加强版,我们进行全局替换,然后穷举非空情况,但是注意我们不用考虑剩下来的单个字母的情况,因为那种情况也属于回文串

cz=
by=
ax=
(start)a=(end)x
(start)b=(end)y
(start)c=(end)z
xy=(return)false
xz=(return)false
yx=(return)false
yz=(return)false
zx=(return)false
zy=(return)false
=(return)true

挑战优化

注意到我们六行代码目的都只是为了判断是否有两个字母及以上存在

[A=B]攻略-第二章

Tue, 03 Oct 2023 21:07:34 +0800

前言

我们要好好理解一下a=(return)b干了啥:

找到匹配的字符串a
将整个我们的字符串变成b
中断循环,看结果

换成函数表达就是

if a in s:
    s=b
    return s

之后判题的只能看到你返回的字符串b

2.1 你好世界

这里给出来了一个提示,在我们用空等的时候

=(return)helloworld

2.2 AAA

思路

我们需要看a的数量,也就是说我们不用管b,c,将二者全消除之后剩下的就是a,再看其是否大于等于3个即可

代码

b=
c=
aaa=(return)true
=(return)false

2.3 恰好三个

思路

不用管到底是哪个字符,我们只需要验证是不是三个字符即可,所以先把所有字符变成一样的,例如c

接下来我们要判断的不是ccc=(return)true,因为字符串cccc同样包含ccc,

我们首先就排除掉大于3个字符的,其一定包含四个及以上的字符串
这时候对只有三个字符的返回true
剩下的也是false

代码

a=c
b=c
cccc=(return)false 
ccc=(return)true  
=(return)false

2.4 余数

思路

这个是return使用的一个示例,所以我们考虑的仍然是只关心字符串长度,不关心内容

将所有都替换成同样的字符
发现求的事余3,我们只需要每次都将三个字符的串放空,剩下的字符串长度就是总长度余3的结果
将长度换成数字

代码

这个思路在后续也有用

a=c
b=c 
ccc=           
cc=(return)2
c=(return)1
=(return)0

2.5 奇数

思路

划分问题

终于开始上难度了,但是这个思想其实不难理解,我们先做一个简单的想法,我如何判断一长串a是否由奇数组成?

考虑到字符串长度为1<=n<=7,很容易知道0,1,3,5,7为可能的长度
暴力枚举虽好,但是长度有点太大了,我们可以用另一个方法:奇数减去2之后仍然为奇数
所以我们很容易想到aaa=a来清理串,为什么不能是aa=?
因为这样没有办法确认是刚开始就没有a,还是被偶数a消除掉的
此时长度0,1,2,只有2表示原串是偶数

做法

然后我们知道要去做什么了:把三个字符串相同的集中在一起,相当于按顺序再为这三个字符轮流做上述检查操作

所以需要排序,让相同字符待在一起

接下来问题就好解决了

代码

ba=ab
cb=bc
ca=ac
aaa=a
bbb=b
ccc=c
aa=(return)false
bb=(return)false
cc=(return)false
=(return)true

进阶

你肯定要回来看的,如果你看不懂2.6的话

发现了什么?我们将同样的情况循环了3遍,也就是说,在单独讨论的时候a,b,c其实是等价的,有没有什么办法将它们的等价用代码解释出来?

一个很有趣的想法是将b,c转换成等价a,最后判断三段a是否都满足奇数

一点点魔法:设置一个障碍,让所有相邻相同的字母没有障碍,而让不同的字母之间有障碍

考虑如下代码的运作

ba=ab
cb=bc
ca=ac
b=xxax
c=xaxx

这种情况下会发生什么:相邻的b变成了中间隔着3个x的a,不同字母之间隔着2个x

更加显式地能看到假设 bacacc:

[A=B]攻略-第一章

Sun, 24 Sep 2023 19:34:01 +0800

前言

A=B是一个很好的游戏,建议各位去玩,商店链接

题目从简单到困难,有的时候梯度很大,争取慢慢把这系列做出来,主要是带题解的

不是很喜欢魔数写法,所以大概会更新地很慢

最后,这个游戏真的很有意思

1.1 A到B

没什么好说的

a=b

1.2 大写

a=A
b=B
c=C

1.3 去重

思路

显然我们最后要保留的状态是没有连续字母

只需要将重复的几个压成一个就行,不过要注意A=B这个语言的特殊性

代码

aa=a
bb=b
cc=c

1.4 去重 2

思路

同理,这个是把连续的a压没,

这里之所以会有aaa,而不是直接aa=是因为假如只压缩的可能会剩下来:例如aaa会被替换成a

,我们这么做的本质是将多的字母先压成两个,再把这两个消除掉

aaa=aa
aa=

1.5 排序

思路

研究语言的必经之路,排序,注意到我们现在在做的是替换字符串

我们的目的是希望各个字母都在其应该在的位置,但我们不知道数组下标,怎么样能达成这两个条件呢?

我们需要一个只看相邻的排序算法,也就是冒泡算法,实现起来不难,如下

代码

看到了吗,本质就是大的向后挪动,这个在单步运行时候看的更清楚

ba=ab
cb=bc
ca=ac

这个排序在之后会常用到的,当我们只关心字母数量之类的而不关心其位置的时候

1.6 比较

思路

比较a和b的多少,还记得去重怎么做的吗?把两个相同的数摁在一起消除

这个题也一样,我们把两个不同的字母摁在一起消除,剩下的就是多的字母

值得一提的是压字母存在两个情况

代码

ab=
ba=
aa=a
bb=b

题解-移位字符串分组-哈希表

Tue, 14 Mar 2023 17:11:00 +0800

Problem: 249. 移位字符串分组

思路

类似于凯撒密码的归类方式,我们将所有能通过轮转得到的字符串放在一起,不难想到可以通过暴力来对每一个字符串匹配
对于字符串仔细观察可以发现每一个可以归类到一起的字符串的本质是相同的,不只是字符串长度,还有与左右字母之间的差值
综上,对于每一类字符串我们只需要将其转化为模板的样子就能判断是否能归类
我们的问题就是如何将字符转成一个标准的模板
考虑字符之间的相对关系,
- 我们设首位为0,后面的每一位对应的是字符串该位与前一位的差
- 如果小于0则加26,来保证模式字符串相等

解题方法

对于每一个字符串,计算其相对字符的模板字符串
查询哈希表,如果有则插入到相对的答案组中
没有就新开一个答案组
重复上述操作

复杂度

时间复杂度:

只遍历一次 $O(mn)$,m为字符串长度

空间复杂度:

运用了哈希表 $O(n)$

Code


class Solution {
public:
    vector<vector<string>> groupStrings(vector<string>& strings) {
        vector<vector<string>>res;
        unordered_map<string,int>hash;//模板字符串及其对应的在答案的行数
        for (auto &iter:strings){
            string tmp="0_";
            char a=iter[0];
            int now;
            for (int i=1;i<iter.size();i++){
                now=iter[i]-a;
                if (now<0)//保证模板的一致性
                    now+=26;
                tmp+=to_string(now)+"_";
                a=iter[i];
            }
            if (hash.find(tmp)!=hash.end()){
                res[hash[tmp]].emplace_back(iter);
            }
            else{
                hash[tmp]=res.size();
                res.emplace_back(vector<string>(1,iter));
            }
        }
        return res;
    }
};