她是从阁楼的窗户翻出去的。窗框上的绿漆已经斑驳了，像干燥的皮肤。她把裙子撩起来一点，跨过窗台，脚尖探出去，踩住外面的瓦瓦。瓦是温的，太阳晒了一整天的余温，隔着薄薄的袜子传上来，像谁的手心贴着她的脚掌。

她向前走了几步, 蹲在屋顶的斜坡上，抱住了自己的膝盖。

西边的天正在烧。像一个人在炉火前打瞌睡，脸上的光一寸一寸地暗下去，又一寸一寸地红起来。最底下是橘黄，厚厚的，像抹了一层橘子酱；往上变成橘红，稀薄一些，透出底下的粉；再往上就紫了，是那种洗了很多遍的旧绸缎的颜色，灰扑扑的紫，紫里还藏着一点不肯走的蓝。整片天就那样铺着，瓦也是灰的，远处的楼也是灰的，只有这一片橘黄和橘红，把整个屋顶都染了。她的手背上落了一层光，薄薄的，像涂了蜜。

那个人明天就走了。

这个念头像一粒石子丢进水里，涟漪一圈一圈地荡开。信她看了太多遍，折痕的地方字迹已经模糊了，那个人的名字只剩下一个大概的形状。信上写，南边的树冬天也不落叶，绿的，绿得很满，满得快要溢出来。信上写，听说那边的海很蓝。

海。

她把这个字含在嘴里，悄悄念了一下。海。轻轻的，像叹气。

她没见过海。她见过的最大的水就是运河，灰的，浑的，慢慢地流，像一个永远不着急的人。运河能流到海吗？她盯着那条灰色的带子，它拐了一个弯，被楼房挡住了，又露出来，越来越细，最后消失在橘黄和灰的交界处。她想象河一直流，流过一个又一个傍晚，流过很多她不认识的城市和田野，慢慢变宽，变蓝，变咸，变成那个人正在看的那片海。

风又来了。这一次她闭上眼睛。

她深吸一口气。把所有味道都吸进去。存起来。存在肺的最底下，存在心脏旁边那个她自己都不知道名字的地方。等她老了，等她把这件事忘了很久很久以后，这个味道还会自己跑出来，在某个傍晚，某个起风的时刻，忽然就来了，带着灰色的瓦、橘黄的天、混着水腥气和栀子香的风，带着那个人的名字，带着她十八岁那一年的全部黄昏。

她从口袋里摸出一张纸。

纸被她折了很多次，折成了一个小小的方块，边角都毛了。展开的时候，折痕像地图上的路，一条一条，交错着，把她写过的话切割成碎片。她写了很多遍。第一遍写的是名字，写完了觉得太直白，涂掉了。第二遍写了一整句话，写了又觉得太重，涂得更黑。第三遍写了一个问号，写了又觉得太轻，轻得像什么都没说。最后只剩下角落里的七个字，写得很小，但每个字都用力，纸都被笔尖划破了。

她把纸重新折好。然后爬到屋脊上，骑坐在最高的那条线上。整个小城都在脚下了。

她把那张纸塞进瓦缝里。第三行第五片瓦，从左边数起，太阳晒得最多的那一片。瓦片的边缘有一点青苔，摸上去茸茸的，像什么小动物的背。她把纸塞得很深，藏在温热的瓦片底下，像这个傍晚的一个秘密。

很多年以后，会有人掀开这片瓦吗？会有人发现这张纸吗？那时候她会在哪里？那个人会在哪里？掀开瓦片的那个人，会不会也是一个十八岁的女孩，在某个夏天的傍晚，骑着屋脊，看着西边的天一点一点暗下去？她会读懂这七个字吗？会为这七个字觉得胸口发紧吗？会觉得这个傍晚也变得很长很长，长得像一辈子也过不完吗？

她坐在屋脊上，两只手撑在身后，手心按着温热的瓦。风吹过来，把她的裙摆吹得鼓起来，像一朵倒扣的花，像一只张开的翅膀，像有什么东西要从她身体里飞出去。

她觉得自己快要飞起来了。

但她没有。她只是坐着，坐在灰色和橘黄之间，坐在天空和屋顶之间，坐在这个长得像一辈子的夏天的傍晚里。远处那颗星已经亮了，很淡，像谁在水面上点了一笔白颜料。运河还在流，灰的，慢慢地，往南，往那片她没见过的蓝。

她从口袋里摸出一颗糖，是水果硬糖，橘子味的。剥开玻璃纸的时候，纸在手里窸窣作响，皱成一团亮闪闪的小球。她把糖放进嘴里，硬硬的，在舌头上滚了一圈，甜味慢慢渗出来。

是甜的。是橘子的甜，和天边的橘黄一样甜。

她含着那颗糖，咽了一下口水，喉咙里咕咚一声，像咽下了一小块傍晚。瓦片温着她的掌心，风凉着她的脚踝，嘴里那颗糖越来越小，越来越小，甜味却越来越浓，浓得她眯起了眼睛。

她把玻璃纸展开，对着天看。纸是皱的，但光穿过它的时候，变成了金色。她把那张纸举高一点，再举高一点，举到那片橘黄里去。金色的光斑落在她脸上，落在她的眉毛上、鼻尖上、嘴唇上，像谁在亲她，轻轻地，一个一个地。

然后她把手收回来，把那张皱巴巴的玻璃纸也塞进瓦缝里，和那张纸条放在一起。第三行第五片瓦底下，太阳晒过的地方。纸条上是七个字，玻璃纸上是一个橘子味的傍晚。

她会记住这个味道的。她会的。

风最后来了一次，把她的头发吹到脸上来。发丝贴在嘴角，痒痒的，她把它们拨开，指尖沾上了一点糖的甜。她舔了一下指尖。

甜的。

她笑了一下。然后她站起身，裙子上沾了灰，拍拍，灰飞起来，在橘黄的光里飘了一瞬，就不见了。

她往阁楼走。走到边缘的时候停了一下，回头看了一眼。

第三行第五片瓦。她数了一遍。一、二、三、四、五。

然后她翻过窗台，脚踩在阁楼的地板上。地板是凉的，和瓦片完全不一样的温度。她把窗户关上，把那片橘黄关在外面，把运河的腥气、柴火的烟味、迟开的栀子的香、还有那个橘子味的傍晚，都关在外面。

她靠在窗边，听了一会儿。风在窗外呜呜地响，像在说什么，说了一遍又一遍，她听不清。

但她知道，那片瓦底下有她的七个字，有一颗糖的玻璃纸，有一个十八岁夏天的傍晚。

风会替她记住的。

Problem: 100164.通过操作使数组长度最小

思路

1. 观察有如下的可能性
   • 如果,最后只是将数组中的踢出
   • 则是二者踢出,进入数组,且显然
2. 因为没有限定ij的关系,发现这种操作要么是小数将大数从数组中踢掉,要么是引入一个更小的数,将二者踢掉
3. 最后剩下的长度应该和数组中最小值有关,且这个最小值包括操作中可能产生的
4. 如果没有产生新的最小值,则很容易知道最后剩下的数就是原始数组中最小值的数量,然后将其两两组合,引进0,就能得到答案
5. 如何产生更小值:
   • 回顾1,我们将所有数与最小值相模
   • 如果余数不为0,就为新的最小值
   • 如果余数全为0,说明所有数都是最小值的倍数,则它们之间两两相模的最小值大于等于原始数组的最小值
6. 我们只需要产生一个新的更小值就能把所有其他数都踢掉,此时答案是1

时间复杂度:

Code

1
2
3
4
5
6
7
8

class Solution:
    def minimumArrayLength(self, nums: List[int]) -> int:
        m=min(nums)
        for num in nums:
            if num%m!=0:# 可以产生新的最小值
                return 1
        length=nums.count(m)
        return length//2+length%2  

Problem: 100153.需要添加的硬币的最小数量

思路

• 这题和LeetCode-1798.你能构造出连续值的最大数目很像,很经典的想法
• 是子序列所以先排序
• 先考虑我们手里的硬币能构造出来多少
• 假设我们手里的硬币足够我们构造出来[0,x),接下来我们又拿到了一个硬币,数值为y,
  • 如果我们把y放进之前的所有序列之中,会发现我们能够构造[y,x+y)
  • 再加上刚才的区间,我们手里的硬币加y之后能构造的数的范围为
  • 如果y<=x则我们能够构造的数就能达到[0,x+y)
  • 如果y>x则会有一段空缺
• 为了填补这段空缺,我们应该往里面放另一块硬币,假设为z,根据上面的推论,我们很容易得到z会生成的片段为[z,x+z),而且z的取值范围应该为[y-x,x],为了让填补有效,且最大化填补的内容,应该让z=x,因为这样能最大化填补的空缺
  • 取最大更有可能单次填补完空缺
• 而我们遇到的问题只是将y换成了target,所有遇到的大于当前x的也认为是y即可

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution:
    def minimumAddedCoins(self, coins: List[int], target: int) -> int:
        coins.sort()
        res=0
        canMake=0 #能生成的范围是[0,canMake]
        i=0
        while i<(len(coins)):
            val=coins[i]
            if val<=canMake+1:
                canMake+=val
                i+=1
            else:
                res+=1 #这里补的硬币就是canMake+1
                canMake+=canMake+1
        while canMake<target:
            res+=1
            canMake+=canMake+1
        return res

Problem: 1927.求和游戏

• 初始思路
• Code

初始思路

• 考虑一些等价:我们先把这个数分为两个部分,分别是左右两边数字的和,形式化写为剩下的问号数量分别为
• 我们要做的实际上是对分别操作n次,其中我们允许的操作就是对该数加上0-9的任意一个数
• 显然操作是对称的,所以我们只考虑有效的操作数,也就是,而且显然有效的操作数只会存在于一个数身上:如果出现在两个身上就会对称消除
• 我们可以先除去一些情况:
  • 如果剩下的有效操作是奇数,则Alice一定赢,因为她一定不会选择让数相等的操作(只有一个选择),而Alice有10个合法选择
  • 然后我们发现操作一定会让数增加,也就是说,如果存在有效操作的是较大的那个数,则一定不可能相等
• 现在我们只剩下了一种情况:有一个较小的数能够让双方都操作次,如何让较小的数变为较大的数
• 设两数相差的绝对值为,每个人能操作次
• Alice有两个选择:
  • 一个是积极加,在自己的回合里都加9,这样会让较小的数飞快增长,如果两数相差比较小,就能让这个数超过大点的数,从而Bob不能选出来:也就是,Alice能赢
  • 另一个是完全消极,每次都加0,这样会让数缓慢增长,单靠Bob变数增加,如果,此时Alice也赢
• 我们惊讶地发现此时出现了9x大于小于gap,Bob都会输,就只剩下了,所幸,我们能发现此时Bob会赢,因为不管此时Alice如何操作,Bob后手都能补齐9

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Solution:
    def sumGame(self, num: str) -> bool:
        n=len(num)
        nums=0
        left=0
        right=0
        for i in range(n//2):
            if num[i]=='?':
                nums+=1
            else:
                left+=ord(num[i])-ord('0')
        for i in range(n//2,n):
            if num[i]=='?':
                nums-=1
            else:
                right+=ord(num[i])-ord('0')
        if nums%2!=0 or (left>right and nums>0) or (left<right and nums<0):
            #最后轮到Alice或者一定不能赢的情况
            return True
        AliceCan=abs(nums)//2
        want=abs(left-right)
        if AliceCan*9!=want:
            return True
        return False

Problem: 2661.找出叠涂元素

• 思路:中途检查
  • 解法
  • Code
• 思路:最后查询
  • 解法
  • Code

思路:中途检查

解法

• 数据量不大,看着可以在每次涂色时候查询是否合法
• 但是每次都查询显然会超时,我们选择一个更有效的优化
• 已经说明各个数各不相同,不会出现一个格子被涂两遍的情况
• 我们用数组来记录每一行和每一列已经被涂的格子数量,就能知道这一行列是否被全涂满

时间复杂度:

空间复杂度:
## Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        matMap={} 
        m=len(mat)
        n=len(mat[0])
        row=[0]*m
        col=[0]*n
        for i in range(m):
            for j in range(n):
                matMap[mat[i][j]]=(i,j) 
        for index in range(len(arr)):
            num=arr[index]
            x,y=matMap[num]
            row[x]+=1
            col[y]+=1
            if row[x]==n or col[y]==m:
                return index
            
        return -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Solution {
public:
    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
        int res=arr.size();
        unordered_map<int,int>hash;
        for (int i=0;i<arr.size();i++){
            hash[arr[i]]=i;
        }
        for (int i=0;i<mat.size();i++){
            int tmp=0;
            for (int j=0;j<mat[0].size();j++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        for (int j=0;j<mat[0].size();j++){
            int tmp=0;
            for (int i=0;i<mat.size();i++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        
        return res;
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        res=len(arr)
        m=len(mat)
        n=len(mat[0])
        arrLocation={}
        for i,a in enumerate(arr):
            arrLocation[a]=i
        for i in range(m):
            nowColNeedSteps=0
            for j in range(n):
                nowColNeedSteps=max(nowColNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowColNeedSteps)
        for j in range(n):
            nowRowNeedSteps=0
            for i in range(m):
                nowRowNeedSteps=max(nowRowNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowRowNeedSteps)           
        return res

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

• 思路
• 解题方法
• Code

思路

• 注意到一个唯一字符对数个子串生效，也就是在多个子串中唯一字符是固定的那几个，很容易想到贡献法

• 对于子串起点和终点我们设置成,任意字符位置为序列,让子串生效的范围是这个范围内,存在一个字符a,其序列满足
  ,

  • 同样可以通过枚举起点终点,得知满足这个条件子串的个数为

    ,

  • 为了计算方便我们将-1和n作为每个字符的两端,既

• 该字母在上为答案做的贡献就等于子串的数量

解题方法

• 使用哈希表存储每个字母的位置序列
• 为了前后方便我们使用栈来维护具体的字母序列
  > 时间复杂度,
  > 空间复杂度,

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

Problem: 100110.找到 Alice 和 Bob 可以相遇的建筑

• 思路
• 解题方法
• 代码细节
• Code

思路

• 分解一下题目,发现和Alice和Bob二人顺序没关系,为了方便,我们假设Alice所在建筑位置在左边,称为a,bob就会在右边,称为b
• 假设a,b相等,则所在的位置就是b
• 若b所在高度大于a,则答案是b
• 剩下的就是我们要考虑的一般情况:b的高度小于a,

解题方法

• 我们要做的明确,查b的右侧大于a的第一个建筑

• 每次都向后查询显然时间复杂度不够,遍历q又是必须的,所以我们想把这个查询压到log级别

• 显然可以通过维护右侧单调栈+二分的模式

  • 但是为每一个点都配单调栈内存不够

• 我们发现左边的单调栈一定是右边的转过来的

• 所以我们只需要维护一个单调栈,在遇到对于要处理的点的查询的时候直接查询就行

• 也就是我们总体过程是离线查询+单调栈+二分

代码细节

• 我们先用哈希表记录查询,保证不漏:
  1. 先保证a<=b
  2. 以b为key,存储想查询的值:a和答案位置i
  3. 需要注意的是可能存在多个a的情况,需要用列表而不是一一对应
• 从后向前遍历,维护单调栈
  1. 对于遍历的点,如果在哈希表内,说明其是b
  2. 现在维护的单调栈满足需求
  3. 二分查到的答案再写回相应的位置

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class Solution:    
    def leftmostBuildingQueries(self, heights: List[int], queries: List[List[int]]) -> List[int]:
        n=len(queries)  
        hash={}#记录b对应的a和index
        for i in range(n):
            a=min(queries[i])
            b=max(queries[i])
            if b not in hash:
                hash[b]=[]
            hash[b].append([a,i])
          
        #记录右边单调递增
        st=[]
        res=[-1]*n
        for i in range(len(heights)-1,-1,-1):
            h=heights[i]
            while st and h>heights[st[-1]]:
                st.pop()
            st.append(i)
            if i in hash:
                b=i
                for a,index in hash[i]:
                    if heights[b]>heights[a] or a==b:
                        res[index]=b
                    else:
                        l,r=0,len(st)-1
                        while l<=r:
                            mid=(l+r)//2
                            if heights[st[mid]]>heights[a]:
                                l=mid+1
                            else:
                                r=mid-1
                        if (l-1<0):
                            res[index]=-1
                        else:
                            res[index]=st[l-1]
        return res

Problem: 2258.逃离火灾

• 思路
• 细节
• 解题方法
• Code

思路

• 由题意可知需要计算一条最短路,耗时最短以保证后续火传过来的时候让火传递的时间足够长来接近答案
• 火的蔓延时间用DFS求解,可以求出来火到各个节点的最少用时
• 应该考虑每次刷新一下出发时间来看此次最短路是否被烧掉吗?其实不用
  • 只需要考虑在终点人能否比火早到即可
  • 假如人在路上遇到火,则火到终点的用时一定小于等于人
• 保证了到终点的时候火耗时大于人可以反推出
  1. 人和火相遇的路都能保证有如此长的等待时间
  2. 若人和火不相遇则显然

细节

1. 如果起点起火不可达
2. 对于只有人可达的情况,是等待多久都可以的情况
3. 重点:因为允许人和火同时进安全屋,但是不能要求其他格子里人和火同时到
   1. 考虑将终点旁边的两格当做终点,如果他们到达终点所剩下的时间大于等于1,显然可以在外面等一分钟

解题方法

• 两遍BFS求火和人到各个节点的距离
• 对于起点和终点的几种情况特判
• 查询以终点左边和上边的点是否允许多等一分钟
• 返回答案

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

class Solution:
    def maximumMinutes(self, grid: List[List[int]]) -> int:
        n=len(grid[0])
        m=len(grid)
        times=[[0x7fffffff]*n for _ in range(m)]
        q=deque()
        directions=[[0,-1],[0,1],[1,0],[-1,0]]
        for i in range(m):
            for j in range(n):
                if grid[i][j]==1:
                    q.append([i,j])
                elif grid[i][j]==2:
                    times[i][j]=-1#不可达
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                times[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        #然后我们求人到各个节点用时
        people=[[0x7fffffff]*n for _ in range(m)]
        q.append((0,0))
        h.clear()
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                people[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and grid[x][y]!=1 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        if times[-1][-1]<people[-1][-1] or people[-1][-1]==0x7fffffff:
            return -1 
        if times[0][0]==0:
            return -1
        if times[-1][-1]==0x7fffffff:
            return 1000000000#火不可达,说明人到火这一路都没有火
        maxNeed=times[-1][-1]-people[-1][-1]
        if times[-1][-2]>people[-1][-2]+maxNeed or times[-2][-1]>people[-2][-1]+maxNeed:
            return maxNeed
        return maxNeed-1

Problem: 1402.做菜顺序

• 思路
• 解题方法
• Code

思路

• 注意到没有要求顺序,先排序
• 朴素思想是将大的数越往后放越好,但对于负数,虽然也是越大越往后放越好,但其有可能增加答案,也有可能减少答案,需要一些证明

解题方法

• 注意到对于负数的选取一定是连续而非跳跃的:假设存在数组,三者均小于0,假如一定要取两个元素,(这种假定的含义是我需要后面的正数有足够的倍数,期望前面提供倍数的负数(代价)最小),选取元素代价大于选取
• 推广可知我们会选取所有的正数和部分负数,且负数在排序后的数组中是连续的,并且和正数部分相连
• 实际上是求一个子数组的这个操作最大能多大,可以枚举每一次从哪选,结束一定是在最大的数结束
• 然后简化:注意到相关操作实际上是对于之前结果再加上一次已经遍历的数,所以可以将其转化为一遍扫描的方式

时间复杂度,

Code

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution:
    def maxSatisfaction(self, satisfaction: List[int]) -> int:
        satisfaction.sort(reverse=True) #方便操作
        res=0
        pre=0
        now=0
        for num in satisfaction:
            pre+=num
            now+=pre
            res=max(now,res)
            if now<0:
                break #之后一定小于0
        return res

Problem: 100077.最长相邻不相等子序列 II

• 思路
• 解题方法
• Code

思路

• 注意到数据范围很小,1000,可用的复杂度较高
• 对于常见的求最长合法子序列可以用DP尝试(一般这种解法是)的

解题方法

1. 设计状态转移方程,设表示以i为结尾的最长子序列的长度,由题意可知 和同时满足三个条件
2. 能得出答案的长度,为了得到字符串数组需要更多信息
3. 这里用pre数组记录每一个以为结尾的最长子序列的倒数第二个元素,如果不存在就为
   > 时间复杂度,
   > 空间复杂度,

Code

将最后查找答案的那一步放在dp计算之中也可以保证计算正确

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Solution:
    def getWordsInLongestSubsequence(self, n: int, words: List[str], groups: List[int]) -> List[str]:
        def isLegaldistance(a:str,b:str):
            #这里将两个条件混合起来,更方便一些
            if len(a)!=len(b):
                return False
            res=0
            for x,y in zip(a,b):
                if x!=y:
                    res+=1
                    if res>1:
                        return False
            return True
        #dp[i]表示以i为结尾的子序列的最大长度
        #pre[i]表示以i为结尾的子序列的倒数第二个元素在words中的序列
        resIndex=0
        dp=[1]*n
        pre=[-1]*n
        for i in range(n):
            s1=words[i]
            for j in range(i):
                if groups[i]!=groups[j] and dp[j]+1>dp[i] and isLegaldistance(s1,words[j]):
                    dp[i]=dp[j]+1
                    if (dp[i]>dp[resIndex]):
                        resIndex=i #只有更新时才有可能出现最大值
                    pre[i]=j
        
        res=[]
        while resIndex!=-1:
            res.append(words[resIndex])
            resIndex=pre[resIndex]
        return res[::-1]#从后向前做的遍历,所以要返回反转后数组
        

Problem: 2731.移动机器人

• 前述条件
• 两种对于距离的计算方法
  • 动态规划
    • 思考方式与证明
    • 代码
  • 贡献距离法
    • 思考方式
    • 证明
    • Code
• 前缀和的形式化证明
  • 代码

前述条件

1. 碰撞和1503.所有蚂蚁掉下来前的最后一刻类似,注意到对于身份没有要求,所以可以直接认为两个机器人碰撞是交换了二者的身份,也可以认为是穿过去了
2. 因此能够得到机器人的最终位置,为了方便计算,我们排序
3. 数据量为,暴力求解不现实
4. 以下是三种常用的解决方法,这三种思路最开始的进入方式不同,但是都能得出正确结果

# 两种对于距离的计算方法
算法的时间复杂度均为
## 动态规划
### 思考方式与证明
1. 假设已经计算出来了之前所有的机器人两两之间距离之和为
2. 增加一个元素,观察其和之前的所有机器人之间的距离之和,能够发现
1. 实际上就是与之前的每个元素计算距离
2. 与之间的距离实际上分别是是与之间的距离加上与之间的距离,共个
3. 上述结论可以推导:
设表示和之间的距离之和,有

### 代码
可以看出来这个公式只与前一个状态有关,因此可以优化空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution:
    def sumDistance(self, nums: List[int], s: str, d: int) -> int:
        mod=1000000007
        n=len(nums)
        for i,a in enumerate(s):
            nums[i]+=d if s[i]=='R' else -d  
        nums.sort()
        res=0
        distance=0
        for i in range(1,n):
            distance+=i*(nums[i]-nums[i-1]) 
            #这个方法对于只int的话4*(10**9)会超范围
            distance%=mod  
            res+=distance
        return res%mod

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
  def sumDistance(self, nums: List[int], s: str, d: int) -> int:
      mod=1000000007
      n=len(nums)
      for i,a in enumerate(s):
          nums[i]+=d if s[i]=='R' else -d  
      nums.sort()
      pre=0
      res=0
      for i in range(n-1):
          pre=(pre+n-2*i-1)%mod
          res=(res+(nums[i+1]-nums[i])*pre)%mod
      return res

1
2
3
4
5
6
7
8
9
10

class Solution:
    def sumDistance(self, nums: List[int], s: str, d: int) -> int:
        for i, c in enumerate(s):
            nums[i] += d if c == 'R' else -d
        nums.sort()
        ans = s = 0
        for i, x in enumerate(nums):
            ans += i * x - s
            s += x
        return ans % (10 ** 9 + 7)

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

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

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

3-1 去除

相当简单的教程

1
2

(start)a=
(end)a=

3-2 旋转

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

1
2

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

3-3 A到B 2

思路

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

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

1
2
3
4
5
6

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

优化

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

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

代码

1
2
3
4

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

3-5 首尾

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

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

1
2
3
4
5
6
7
8
9

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

思路

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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也是,优化以下

1
2
3
4
5
6
7
8
9
10
11
12
13

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的加强版,我们进行全局替换,然后穷举非空情况,但是注意我们不用考虑剩下来的单个字母的情况,因为那种情况也属于回文串

1
2
3
4
5
6
7
8
9
10
11
12
13

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

挑战优化

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

修改字符串使之存在首尾标识符即可,也就是说能保证显示出来两个字母不同且存在

1
2
3
4
5
6
7
8

cuZn=
buYn=
auXn=
(start)a=(end)uXn
(start)b=(end)uYn #不影响排空
(start)c=(end)uZn
nu=(return)false  #出现这个说明仍有多个字母存在,整个字符串非空,
=(return)true

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

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

换成函数表达就是

1
2
3

if a in s:
s=b
return s

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

2.1 你好世界

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

1

=(return)helloworld

2.2 AAA

思路

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

代码

1
2
3
4

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

2.3 恰好三个

思路

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

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

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

代码

1
2
3
4
5

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

2.4 余数

思路

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

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

代码

这个思路在后续也有用

1
2
3
4
5
6

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

2.5 奇数

思路

划分问题

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

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

做法

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

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

接下来问题就好解决了

代码

1
2
3
4
5
6
7
8
9
10

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是否都满足奇数

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

考虑如下代码的运作

1
2
3
4
5

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

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

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

1
2
3

aabccc
-> aaxxaxxxaxxxaxxxaxx
-> a|a| xxax |xaxx|xaxx|xaxx

仔细观察,发现相隔3个x的都能去掉!,此时会变成用两个x阻隔的三个段,每个段里面的a的个数是a或b或c的个数,此时bacacc变成aaxxaxxaaaxx

然后判断即可

得出来新的代码如下

1
2
3
4
5
6
7
8
9

ba=ab
cb=bc
ca=ac
b=xxax
c=xaxx
xxx=
aaa=a #等价处理
aa=(return)false
=(return)true

这种等价思想很重要,在之后会多次使用

其实这种等价想法在于什么:在于让相同字母之间的间隔一样,不同字母的间隔不一样,以这种思路你完全可以设计如下方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#其中()表示重复几次
b=x(n)ax(m)
#则c和b之间的距离也应为n,b和b之间距离为m+n
#所以
c=x(n-m)ax(2m)
#符合以上要求的都可以替换
#比如以下代码n=6,m=3,一样可以通过
ba=ab
cb=bc
ca=ac
b=xxxxxxaxxx
c=xxxaxxxxxx
xxxxxxxxx=
aaa=a
aa=(return)false
=(return)true

2.6 独一无二

思路

这里建议先看一下上面的拓展

然后我们先翻译一下题目:希望这个长字符串出现的单字符字符串有且只有一个:

• aaabccc:只有一个a,是我们需要的
• aaabacc:b和a都有,是错误的
• 实际上我们要做的是在aaa=aa;bbb=bb;ccc=cc之后,看单个的不成对字母有几个

我们只需要知道是不是等于1

和上题拓展法类似,我们等价之后再做类似操作,现在得出来的因为没有排序,我们现在能保证的是

1. 相同字母之间x个数为0或者3
2. 不同字母之间x个数为1或者2

由上述两条我们将串收敛一下,把相等相邻的聚在一块,然后格式一下彼此之间距离

此时出现的就是axaaaxaaxa之类的东西,更进一步地,我们将所有长串都收成空串

此时我们要找的是此时里面是不是只有一个a

看到a就return肯定不行,但是我们能先把多个a存在的删掉,其格式一定为axaxa之类,因为我们上述操作不相同的单字符串串之间一定有一个x阻隔

这时候就有只剩下a的情况了,此时是我们想要的

剩下的情况就是全是长串,也是我们不想要的

代码

1
2
3
4
5
6
7
8
9

b=xxax
c=xaxx
xxx= #这之后相邻的同字符的串就是相邻的a
xx=x #此时不同串之间相差1x
aaa=aa 
aa= #两步除长串
axa=(return)false
a=(return)true
=(return)false

2.7上升

思路

排序

1. 做之后还会有效的两两对比
2. 先确定是不是c比d多,再确定是不是b比a多
3. 建议先看下面的两个

实现上面的体现

1. c比b多则b全部化为d,此时还有c剩余
2. d比a多则a全消失,d还有剩余
3. 也就是说dc存在的时候其实是(bcc)还有剩,合法性足够强
4. 我或许需要一些更加显然的理解,但是现在没有...以后可能试试

1
2
3
4
5
6
7
8

ca=ac
cb=bc
ba=ab #先排序
bc=d   #合法情况是adc
bd=db  #此时d代表的是bc
ad=    #消去abc 此时如果合法一定是dc
dc=(return)true
=(return)false #其他就都不合法

2.8最多

思路

1. 对于这种考虑总体字母的,我们先把他们放在一起,先排序
2. 我们考虑到排序,所以我们只要比较三者的多少,很明显能考虑到两两对比
3. 接下来我们最好看代码讲解

代码

1
2
3
4
5
6
7
8
9
10
11
12
13

ca=ac
cb=bc
ba=ab #先排序

bc=d    
bd=db  #此时d代表的是bc
ad=    #消去abc,接下来剩下的就只有一个或两个字母,一定,而且不是bc,把三种组合罗列一下就是结果,只有一个字母显然是答案
ac=
ab=

a=(return)a
b=(return)b
c=(return)c

2.9最少

思路

思路与上面的类似

直接看代码吧

1
2
3
4
5
6
7
8
9
10
11
12

ca=ac
cb=bc
ba=ab #先排序

ab=d
db=bd
dc=  #销去了abc,可能剩下ad,ac,bc
 
d=(return)c #d存在说明d比c多,也就是ab组合都比c多
ac=(return)b 
bc=(return)a

A=B语言也较为特殊,可以认为整体是个循环体,但是是每次循环只要能够执行一条命令就去执行,然后就重新回到循环开头

这个性质会在后续不断应用

而且其本质在做的就是字符串替换

1.1 A到B

1

a=b

1.2 大写

1
2
3

a=A
b=B
c=C

1.3 去重

思路

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

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

代码

1
2
3

aa=a
bb=b
cc=c

1.4 去重 2

思路

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

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

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

1
2

aaa=aa
aa=

1.5 排序

思路

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

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

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

代码

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

1
2
3

ba=ab
cb=bc
ca=ac

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

1.6 比较

思路

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

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

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

代码

1
2
3
4

ab=
ba=
aa=a
bb=b

Problem: 2681.英雄的力量

• 思路
• 解题方法
• Code

思路

• 选取与顺序无关先排序
• 接下来只要枚举所有子序列的最大值的平方和最小值的乘积之和
• 注意到只和最大值和最小值有关

解题方法

1. 确定了子序列的最大值之后,我们只需要确定子序列里面各个值最小值出现了几次
2. 也就是确定排序后的必选且为最大值时,我们假设此时在答案中与除自身之外他的平方相乘的所有值之和为,此时有答案
3. 不去管现在为多少,我们假设现在要选取的是为最大值,则注意到对于子序列
   1. 如果不选,也会和相乘
   2. 如果选取,对于所有不是最小值的情况,也会和相乘,而是最小值的情况只有一个(也就是选取和两个)
4. 根据以上的两个推理,我们能够得出,既

• 时间复杂度
• 空间复杂度

Code

1
2
3
4
5
6
7
8
9
10

class Solution:
    def sumOfPower(self, nums: List[int]) -> int:
        mod=1000000007
        nums.sort()
        pre=0
        res=0
        for num in nums:
            res=(res+(pre+num)*(num**2))%mod
            pre=(pre*2+num)%mod
        return res

1
2
3
4
5
6
7
8
9
10
11
12
13

class Solution {
public:
    int sumOfPower(vector<int>& nums) {
        const int mod=1e9+7;
        sort(nums.begin(),nums.end());
        int res=0,pre=0;
        for (long num:nums){
            res=(res+(num*num%mod)*(pre+num))%mod;
            pre=(pre*2+num)%mod;
        }
        return res;
    }
};

来自链接

• 摘要
• 1. 介绍
• 2.问题定义
  • 2.1图(Graph)
  • 2.2 GED操作
    • 2.2.1隐含的边操作
  • 2.3成本函数
  • 2.4图编辑距离
  • 2.5举例
• 3.相关工作
• 4.GED的B&B算法
  • 4.1 分支
• 5.提出的GED问题的B&B并行算法
• 6.表现分析
• 7.结论和展望
• 引用

摘要

图编辑算法(Graph Edit Distance,GED)是一种在图匹配领域广泛使用的方法.它通过计算将一个图转化成另一个图的最小编辑成本来衡量两个图的相似性或差异性.这个过程看起来很简单,但是是NP难问题并且非常耗时,因为它的搜索空间是指数级增加的.一个解决这个问题的最优算法是分支限界法(BranchandBound，B&B),通过对搜索空间进行隐式枚举而不是而不是基于剪枝技术的全部枚举,来减少探索整个搜索空间的实践.然而当处理大型问题实例的时候,B&B算法探索整个搜索空间所需要的时间仍然太长了,它在此时依然是不够有效的.为了解决这个问题,在本文中我们提出了三种基于共享内存的B&B并行方法来利用多核CPU处理器.第一种是一种工作窃取的方法,多个B&B实例并发搜索单个搜索树,比顺序版本最多快24倍.其次是一种基于树的方法,由独立的B&B实例同时搜索搜索树的多个部分,能够提速28倍,最后,由于GED问题的不规则特性,提出了两种负载均衡策略来保证并行进程之间的负载均衡,达到了令人惊叹的300倍,所有的实验都在知名的数据集上进行过了.

1. 介绍

图编辑算法(Graph Edit Distance,GED)是一种在图匹配领域广泛使用的方法来计算两个图之间的最小距离.GED算法的目的是计算两个图之间的不相似的总和.换句话说,它代表将一个图编辑成另一个图所需要的最优操作集的成本¹.允许的操作包括插入,删除和增加,这三种操作可以运用在顶点或者边上.这个问题由于其NP难特性而被认为是非常具有挑战性的²,这意味着计算两个图之间最小距离的时间复杂度随着顶点数量的增加呈指数级增长.GED的重要性来自于它的多种使用用例.它可以用于精确匹配也可以用于能容忍一定错误的非精确匹配.并且,GED可以用于多种领域³,特别是在与模式识别相关的领域,比如手写识别⁴⁵⁶,个人识别和认证(例如指纹识别)⁷,文档分析⁸⁹¹⁰,和图数据库搜索¹¹.它也可以被用于机器学习,最近邻居分类和数据挖掘领域.¹²

为了计算两个图之间的最佳编辑距离,蚊香¹³经常使用的基于A*¹⁴的搜索算法.然而,这种方法需要大量内存资源,这使得其不能被用于处理大型的图.分支限界法(B&B)是一种广为人知的技术,它通过智能枚举搜索空间来解决最优化问题.这个方法用两个组件,分支(branching)和界限(bounding),将搜索空间建模成一棵树.分支是一个递归的过程,它将一个给定问题的搜索空间划分成多个更小的子问题,并对这些子问题用同样的方式处理,知道找到解决方法.在分支过程结束后,界限操作符评估每一个生成的子问题是否可能包含好的解决方案.B&B算法使用多种技术(消除和选择)来避免探索没有最优解可能的子问题(分支)并家扩搜索过程.由于GED问题的复杂性,它对于一般图来说是NP难问题¹⁵,B&B算法需要很长的实践去找到最优解,特别是在解决大型图问题的时候.为了客服这个缺点,我们认为并行计算是一个减少这类问题的运行时间的有趣的方法.

在这片论文之中,我们研究了利用单台计算机的计算资源所带来的影响和可能的收益.事实上,现在的的大部分计算机从硬件上来看都是并行的,能够提供可观的计算能力,尽管在大部分情况下都没能被利用.因此.也为了评估使用并行方法可能得到的收益,我们提出了几种B&B算法.这里的目的是评估每一个并行方法在减少执行时间和有效探索整个搜索空间的影响和行为.我们给出的方法可以归类成高级并行化,其中多个B&B算法的实例同时探索搜索空间.

本文提出了两个并行算法,第一种是基于工作窃取策略,用以在不额外增加内存使用的条件下加快对搜索树的顺序搜索.因此,我们用多个B&B实例同时探索同一颗存储在共享内存空间中的搜索树,所有并行的B&B实例都可以对这个搜索树进行读/写操作.在参考数据集上使用16核CPU的实验显示,相对于顺序版本,速度提升24倍.为了更有效地探索这个搜索空间,也为了研究多样化的影响,我们提出了第二个B&B算法.后者用基于树的方法表示,用多个独立的B&B实例并行地探索整个搜索树的多个部分.因此,更新上界(UB),这最终能够改善一定复杂度.这个算法基于主从策略(Master-Worker),主节点将搜索树分成多个B&B实例,也就是工作者(Workers),在这之后,每一个工作者在自己的内存空间之中构建自己独有的搜索树,进程间唯一共享的信息就是更新的上界的值,这在每一次一个更优路径被发现的时候更新.这个算法得到的结果显示多样化探索过程对性能产生了积极的影响,相比于顺序B&B实例,提速了约28倍.然而,因为搜索树中的子问题的负载不均衡,许多工作者很快地结束了工作(空闲),然而其他会需要运行很长的时间.解决GED问题的负载平衡策略的影响在Abu-Aisheh等人的研究¹⁶，¹⁷中没有得到很好的研究.因此,我们提出了两种原创的负载均衡策略来避免工作者的共线.我们的第一种负载均衡策略包括将主节点当做负载均衡器,听过改变它的搜索策略来保证子问题的大量可用性.这个避免空闲的想法就是给所有的并行工作者读写权限来让它们在自己的工作池为空的时候从负载均衡器的工作池之中选取一个子问题.第二种保证工作者之间的负载平衡的方法是将前两个并行算法结合起来.这里的想法是允许工作者在本地进行次迭代,接着将它们自己本地工作池整合进一个共享的全局工作池.用参看数据集刨出来的结果显示了将多样性和负载均衡结合起来带来的好的影响,并且,增加负载均衡算法能够将基于树的并行算法提升高达11倍.

本文余下的内容总结如下.在第二节提出了一些基础的有关GED的符号和定义,在第三节中,我们讨论相关的工作.在第四节描述了串行B&B算法和它的组成,在第五节我们详细介绍我们提出的并行B&B算法和负载均衡策略.在第六节报告计算结果,最终,在第七节提出了结论和展望.

2.问题定义

在接下来的部分,我们首先定义了一些基本的概念接下来去正式地定义GED问题

2.1图(Graph)

一个图是一个用于建模对象之间的成对关系的结构.¹⁸,它包含了一组由一组边连接起来顶点,

正式定义中,一个带标签的图可被表示为,在其中

• ,表示包含n个顶点的集合
• .表示包含个边的集合
• 是顶点的标记函数，也就是将每个顶点映射到一个标记的函数，表示为:
• 是边的标记函数，也就是将每个边映射到一个标记的函数，表示为:. 和被限制为可以由一组整数描述的标签,向量空间或者符号标签

在这篇论文之中,我们考虑简单的无向无环标记图.

2.2 GED操作

在GED问题之中,一个将图转换成图的编辑路径由一组图的编辑操作组成.每一个编辑操作对顶点,边或者顶点和边执行一次操作.在本文之中,我们采用一种以顶点为中心的方法,其变形都是在顶点上进行的,而其中隐含了对边的操作.因此,只有一下三种基本备案及操作是被允许的:插入(),删除()和替换()

我们描述一个顶点来自于图,以及领一个顶点来自于图,我们表示为

1. 将顶点替换为
2. ,顶点从之中删除
3. 顶点加入到之中

2.2.1隐含的边操作

在以顶点为中心的算法之中,对于边的编辑操作是隐含的,事实上,一个边的替换,删除或者增加取决于它的相关顶点的编辑操作¹⁹.让我们考虑图之中的两个顶点,和另外两个顶点在图之中.如果我们在顶点和进行如下的两个编辑操作和.可以分别区分出三种边的隐含操作:

1. 如果在中和之间存在一个边,也存在一个边连接和,那么就被替换掉,表示为
2. 如果在中和之间存在一个边,而之中没有连接和的边,那么就在之中删除,表示为
3. 如果如果在中和之间不存在边而存在一个边,那么就被加入到了之中,表示为

注意当一个顶点从之中删除的时候,与它相连的所有边都被自动删除,类似地,吐过一个顶点被插入进所有在之中预期相连的边会被插入,如果这个边的另一个端点已经存在于之中

2.3成本函数

在GED之中,成本函数是一个重要的组成部分.成本函数为每一个对于边或者顶点的操作分配一个值(成本).因此,图编辑的成本分配影响着最优编辑路径.成本函数提供了一个将与对象相似性有关的领域信息融入进来的有效方法.对于一个特定操作的成本实在底层标签字母表的层面定义的,三种编辑操作的成本给出如下