蓝桥杯备赛(2)-二分与前缀和

蓝桥杯备赛(2)-二分与前缀和

概念

二分：其主要能解决区间问题。针对的问题：首先确定满足答案的区间，然后选择一个判决条件，使得该区间具有二段性，且我们的答案就在分界点处。
前缀和：通过累加和来确定答案，有时候有奇效。

二分模板

l=-1
r=n-1
while l!=n-1:
	mid=l+r>>1
	if ():
		l=mid
	else:
		r=mid
return l or r
#该模板是最好用的模板，无需判断是否+1或者-1

Q1

数的范围（点击链接原题）

A1

由题意，输入集合有序，故我们只需刚开始就进行特判（其是否在数组中，ps:不能特判其是否小于最小值or大于最大值，这是错误的）。由于有序且寻找分界点，故我们只需进行二分查找即可（logn的复杂度，可在较长数组中进行多次查询，常规查询（n的复杂度）一定会TLE）。
代码如下:

n,q=map(int,input().split())
lst=list(map(int,input().split()))
def get_start(num):
    l=-1
    r=n
    while l!=r-1:
        mid=l+r>>1
        if lst[mid]>=num:
            r=mid
        else:
            l=mid
    return r

def get_end(num):
    l=-1
    r=n
    while l!=r-1:
        mid=l+r>>1
        if lst[mid]<=num:
            l=mid
        else:
            r=mid
    return l

for _ in range(q):
    num=int(input())
    if num not in lst:
        #不在
        print('-1 -1')
    else:
        print('{} {}'.format(get_start(num),get_end(num)))

Q2

机器人跳跃问题（点击链接原题）

A2

由题意，我首先想到的是能否初始化为0，然后遍历每个位置，取min的相反数为res。但由于2*E的缘故，说明并非线性（此处指的是不清楚初始值跟结果的关系）结果。由于数据量不大，并且答案具有二分性（一般可行，一半不可行），由于我们是要找最值（一般是分界点），故我们可以采取二分查找算法。
代码如下:

n=int(input())
high_list=list(map(int,input().split(' ')))
l=0
r=100000
def check(init_e):
    E=init_e
    for i in range(n):
        if E<0:
            return False
        else:
            E=2*E-high_list[i]
    if E<0:
        return False
    return True
while l+1!=r:
    mid=(l+r)>>1
    if check(mid):
        r=mid
    else:
        l=mid
print(r)

Q3

四平方和（点击链接原题）

A3

如果暴力枚举四重循环的话，一定会TLE。这里优化首先构造字典序，存储下二平方和。然后再进行二重枚举，利用空间换取时间。

代码如下:（但该python代码依旧会超时）

from math import sqrt
import sys
#1221：四平方和（如何利用空间换时间）
#首先使用c^2+d^2存储下来（构造映射），然后枚举a,b，进行哈希判断+二分。
N=int(input())
dic={}
for c in range(int(sqrt(N))):
    for d in range(c,int(sqrt(N-c**2))+2):
        dic.setdefault(c**2+d**2,[c,d])
#这里必须使其有序(用冒泡排序)
dic=dict(sorted(dic.items(),key=lambda x:x[0]))
sum_list=list(dic.keys())
cd_list=list(dic.values())
for a in range(int(sqrt(N))):
    for b in range(a,int(sqrt(N-a**2))+2):
        s=N-a**2-b**2
        #此处利用二分查找(需要有序)
        l=-1
        r=len(dic)
        while l+1!=r:
            mid=(l+r)>>1
            if sum_list[mid]>=s:
                r=mid
            else:
                l=mid
        if s ==sum_list[r]:
            print('{} {} {} {}'.format(str(a),str(b),str(cd_list[r][0]),str(cd_list[r][1])))
            break

以下代码便不会超时，二分的复杂度不应该更低么？奇怪，get函数真强大！

n = int(input())
dic = {}
# 建立字典
c, d = 0, 0
while c * c <= n:
    d = c
    while c * c + d * d <= n:
        if dic.get(c * c + d * d) == None:
            dic[c * c + d * d] = (c, d)
        d += 1
    c += 1

flag = False  # 标记查询是否成立
# 查询
a, b = 0, 0
while a * a <= n:
    b = a
    while a * a + b * b <= n:
        x = n - a * a - b * b
        if dic.get(x) != None:
            flag = True
            print(a, b, dic[x][0], dic[x][1])
            break
        b += 1
    if flag:
        break
    a += 1

Q4

分巧克力（点击链接原题）

A4

该题比较简单，阔以类似机器人跳跃那题的思路，我们阔以枚举所有可行解（有区间并且具有二段性）。
代码如下:

n,k=map(int,input().split())
h_lst=[]
w_lst=[]
for _ in range(n):
    h,w=map(int,input().split())
    h_lst.append(h)
    w_lst.append(w)

def check(a):
    res=0
    for i in range(n):
        res+=(h_lst[i]//a)*(w_lst[i]//a)
    if res>=k:
        return True
    return False
l=0
r=int(1e5)
while l+1!=r:
    mid=l+r>>1
    if check(mid):
        l=mid
    else:
        r=mid
print(l)

Q4

激光炸弹（点击链接原题）

A4

该题采取前缀和进行求解，常规求解。但需要注意，需要保留h[0][0]行作为初始值，不然减出错。同时需要注意R的范围，可能大于范围。
代码如下:

n,r = map(int,input().split())
r = min(r, 5001)
mp = [[0 for i in range(5010)]for j in range(5010)]

x,y = r,r

while n:
    a,b,c = map(int,input().split())
    a += 1; b += 1
    mp[a][b] += c
    x = max(x,a); y = max(y,b)
    n -= 1

for i in range(1,x+1):
    for j in range(1,y+1):
        mp[i][j] += mp[i-1][j] + mp[i][j-1] -mp[i-1][j-1]

res = 0
for i in range(r,x+1):
    for j in range(r,y+1):
        res = max(res, mp[i][j] - mp[i-r][j] - mp[i][j-r] + mp[i-r][j-r])

print(res)

Q5

K倍区间（点击链接原题）

A5

前缀和题，特点：转换为同余–>整除。最为醒目的一步，大大降低复杂度。
代码如下:

n,k=map(int,input().split())
sum_k=[0 for _ in range(k)]
s=0
ans=0
for _ in range(n):
    s=(s+int(input()))%k
    sum_k[s]+=1
for i in range(k):
    if sum_k[i]>=2:
        ans+=sum_k[i]*(sum_k[i]-1)//2
print(ans+sum_k[0])

总结

二分用来求解区间性问题，前缀和用来求解包含和式的问题。