利用DeepSeek修改数据结构提升求解集合程序效率

为了精确翻译SQL，DeepSeek采用了复杂的字典作为循环中列表的元素，以达到用列名访问的效果，这降低了效率。

让他把b的元素由字典改成列表，用索引0代替cnt,1代替bit,2代替bit2,去掉判断重复逻辑，代new_rows用生成式代替两重for循环，while循环每步结束若new_rows有值，用它覆盖b，而不是扩展，不做别的。

python 复制代码

def main():
    # with n as (select level n from dual connect by level<=5)
    n_list = [i for i in range(1, 8)]  # level从1开始
    
    # A as (select n1.n x, n2.n y, power(2,rownum-1) bit from n n1,n n2)
    A = []
    bit_value = 1
    for x in n_list:
        for y in n_list:
            A.append({'x': x, 'y': y, 'bit': bit_value})
            bit_value *= 2
    
    # C as (select a1.bit,a1.x,a1.y, sum(a2.bit) bit2 from a a1,a a2 where (a1.x-a2.x)*(a1.y-a2.y)<=0 group by a1.bit,a1.x,a1.y)
    C = []
    for a1 in A:
        bit2_sum = 0
        for a2 in A:
            if (a1['x'] - a2['x']) * (a1['y'] - a2['y']) <= 0:
                bit2_sum += a2['bit']
        C.append({
            'bit': a1['bit'],
            'x': a1['x'],
            'y': a1['y'],
            'bit2': bit2_sum
        })
    
    # 递归CTE b(cnt,bit,bit2) - 用列表代替字典
    # 初始部分: select 1,c.bit,c.bit2 from c
    b = [[1, c_row['bit'], c_row['bit2']] for c_row in C]
    
    # 递归部分: 模拟递归CTE
    changed = True
    while changed:
        changed = False
        # 用生成式代替两重for循环
        new_rows = [
            [b_row[0] + 1, b_row[1] + c_row['bit'], b_row[2] & c_row['bit2']]
            for b_row in b
            for c_row in C
            if c_row['bit'] > b_row[1] and (b_row[2] & c_row['bit']) > 0
        ]
        
        if new_rows:
            b = new_rows  # 覆盖而不是扩展
            changed = True
    
    # 找到cnt最大的行: select * from (select b.*,rank() over(order by cnt desc) rnk from b) where rnk=1
    if not b:
        return
    
    max_cnt = max(row[0] for row in b)
    max_rows = [row for row in b if row[0] == max_cnt]
    
    # 为每个最大集合生成点坐标字符串
    results = []
    for r in max_rows:
        points = []
        for a_row in A:
            # where bitand(r.bit, a.bit) > 0
            if r[1] & a_row['bit'] > 0:
                points.append(f"({a_row['x']},{a_row['y']})")
        # listagg within group(order by r.bit) - 这里按bit值排序可能没有意义，改为按坐标排序
        points.sort()
        results.append(''.join(points))
    
    # 输出结果
    print(f"最大集合大小: {max_cnt}")
    print(f"找到 {len(results)} 个最大集合:")
    #for i, result in enumerate(results, 1):
     #   print(f"{i}: {result}")

if __name__ == "__main__":
    main()

执行结果又快了0.2秒，同时节省一半内存

复制代码

C:\d>timer64 python sql2py5.py
最大集合大小: 13
找到 924 个最大集合:


Kernel  Time =     0.015 =    0%
User    Time =     2.468 =   98%
Process Time =     2.484 =   99%    Virtual  Memory =     96 MB
Global  Time =     2.493 =  100%    Physical Memory =    101 MB

C:\d>timer64 python sql2py4b.py
最大集合大小: 13
找到 924 个最大集合:


Kernel  Time =     0.062 =    2%
User    Time =     2.578 =   93%
Process Time =     2.640 =   95%    Virtual  Memory =    145 MB
Global  Time =     2.756 =  100%    Physical Memory =    149 MB

用pypy运行则差距更大

复制代码

C:\d>timer64 pypy/pypy sql2py5.py
鏈€澶ч泦鍚堝ぇ灏? 13

鎵惧埌 924 涓渶澶ч泦鍚?



Kernel  Time =     0.031 =    3%
User    Time =     0.718 =   71%
Process Time =     0.750 =   74%    Virtual  Memory =    114 MB
Global  Time =     1.008 =  100%    Physical Memory =    111 MB

C:\d>timer64 pypy/pypy sql2py4b.py
鏈€澶ч泦鍚堝ぇ灏? 13

鎵惧埌 924 涓渶澶ч泦鍚?



Kernel  Time =     0.078 =    4%
User    Time =     1.437 =   88%
Process Time =     1.515 =   92%    Virtual  Memory =    328 MB
Global  Time =     1.630 =  100%    Physical Memory =    322 MB