├── A.py
├── B.py
├── C.py
├── D.py
├── E.py
├── F.py
├── G.py
├── H.py
├── README.md
└── 第十五届蓝桥杯大赛软件赛省赛_PA.pdf


/A.py:
--------------------------------------------------------------------------------
 1 | #A
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | tot=7385137888721*4+10470245
 5 | print(tot**0.5)
 6 | print(int(7385137888721**0.5)*2)
 7 | res=7385137888721-int(7385137888721**0.5)**2
 8 | print(res)
 9 | '''
10 | 5435123.0
11 | 5435122
12 | 100000
13 | '''


--------------------------------------------------------------------------------
/B.py:
--------------------------------------------------------------------------------
 1 | #B
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | sum,lc,cnt=0,1,0
 5 | for i in range(1,10001):
 6 |     sum+=i
 7 |     lc*=i
 8 |     if (sum-lc)%100==0:
 9 |         print(i)
10 |         cnt+=1
11 |     if i%200==0:
12 |         print(i,cnt)
13 |         cnt=0
14 | print(2+2024041331404202//200*4)
15 | '''
16 | 40480826628086
17 | '''


--------------------------------------------------------------------------------
/C.py:
--------------------------------------------------------------------------------
 1 | #C
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | # ans=set()
 5 | # for st in range(1,101):
 6 | #     for ed in range(st+1,101):
 7 | #         ans.add((st+ed)*(ed-st+1)//2)
 8 | # for i in range(1,101):
 9 | #     if i not in ans:
10 | #         print(i)
11 | n=int(input())
12 | nums=list(map(int,input().split()))
13 | ans=0
14 | for i in nums:
15 |     x=i
16 |     flag=0
17 |     while x>1:
18 |         if x%2:
19 |             flag=1
20 |             break
21 |         x//=2
22 |     if not flag: ans+=1
23 | print(ans)
24 | '''
25 | 3
26 | 3 6 8
27 | '''
28 | 


--------------------------------------------------------------------------------
/D.py:
--------------------------------------------------------------------------------
 1 | #D
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | n=int(input())
 5 | a=list(map(int,input().split()))
 6 | ans=0
 7 | for i in range(0,n):
 8 |     if i>=n-1-i:break
 9 |     nxt=n-1-i
10 |     if a[i]==a[nxt]:continue
11 |     if a[i]>a[nxt] and i+1<n-2-i and a[i+1]>a[n-2-i]:
12 |         mn=min(a[i]-a[nxt],a[i+1]-a[n-2-i])
13 |         a[i]-=mn
14 |         a[i+1]-=mn
15 |         ans+=mn
16 |     if a[i]<a[nxt] and i+1<n-2-i and a[i+1]<a[n-2-i]:
17 |         mn=min(a[nxt]-a[i],a[n-2-i]-a[i+1])
18 |         a[i]+=mn
19 |         a[i+1]+=mn
20 |         ans+=mn
21 |     ans+=abs(a[i]-a[nxt])
22 | print(ans)
23 | '''
24 | 4
25 | 1 2 3 4
26 | '''


--------------------------------------------------------------------------------
/E.py:
--------------------------------------------------------------------------------
 1 | #E
 2 | import sys
 3 | from heapq import *
 4 | sys.setrecursionlimit(int(1e6))
 5 | n,m=map(int,input().split())
 6 | s=[]
 7 | Q=[]
 8 | heapify(Q)
 9 | fa=[i for i in range(n)]
10 | ans=0
11 | for i in range(n):
12 |     s.append(input())
13 | def calc(s1,s2):
14 |     s1+=s1
15 |     s2+=s2
16 |     mx=0
17 |     dp=[[0]*(2*m+1) for i in range(2*m+1)]
18 |     for i in range(1,2*m+1):
19 |         for j in range(1,2*m+1):
20 |             if s1[i-1]==s2[j-1]:
21 |                 dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1)
22 |                 mx=max(mx,dp[i][j])
23 |     return min(m,mx)
24 | 
25 | def find(x):
26 |     if x==fa[x]:return x
27 |     fa[x]=find(fa[x])
28 |     return fa[x]
29 | 
30 | for i in range(n):
31 |     for j in range(i+1,n):
32 |         heappush(Q,(-calc(s[i],s[j]),i,j))
33 | while Q:
34 |     #print(Q)
35 |     x=find(Q[0][1])
36 |     y=find(Q[0][2])
37 |     if x!=y:
38 |         ans-=Q[0][0]
39 |         fa[x]=y
40 |     heappop(Q)
41 | print(ans)
42 | '''
43 | 4 4
44 | aabb
45 | abba
46 | acca
47 | abcd
48 | '''


--------------------------------------------------------------------------------
/F.py:
--------------------------------------------------------------------------------
 1 | #F
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | 
 5 | n=int(1e5)
 6 | isPrime=[1]*int(1e5+10)
 7 | prime=[]
 8 | isPrime[1]=0
 9 | for i in range(2,n+1):
10 |     if isPrime[i]:prime.append(i)
11 |     for j in prime:
12 |         if i*j>n:break
13 |         isPrime[i*j]=0
14 |         if i%j==0:break
15 | 
16 | win=[0]*int(1e5+10)
17 | def dfs(x):
18 |     if x<=1:return 0
19 |     if win[x]==1:return 1
20 |     if win[x]==-1:return 0
21 |     if isPrime[x] or isPrime[x-1]:
22 |         win[x]=1
23 |         return 1
24 |     for i in prime:
25 |         if i>x:break
26 |         if not dfs(x-i):
27 |             win[x]=1
28 |             return 1
29 |     win[x]=-1
30 |     return 0
31 | 
32 | T=int(input())
33 | a=[]
34 | for _ in range(T):
35 |     print(dfs(int(input())))
36 | '''
37 | 3
38 | 1
39 | 2
40 | 6
41 | '''


--------------------------------------------------------------------------------
/G.py:
--------------------------------------------------------------------------------
 1 | #G
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | n,m,T=map(int,input().split())
 5 | R=list(map(int,input().split()))
 6 | C=list(map(int,input().split()))
 7 | 
 8 | mp={}
 9 | cnt=0
10 | a=R.copy()
11 | a.sort()
12 | for x in a:
13 |     if x not in mp:
14 |         cnt+=1
15 |         mp[x]=cnt
16 | for i in range(n):R[i]=mp[R[i]]
17 | 
18 | mp.clear()
19 | cnt=0
20 | a=C.copy()
21 | a.sort()
22 | for x in a:
23 |     if x not in mp:
24 |         cnt+=1
25 |         mp[x]=cnt
26 | for i in range(n):C[i]=mp[C[i]]
27 | 
28 | #print(R)
29 | #print(C)
30 | 
31 | mod=int(1e9+7)
32 | jc=[1]
33 | for i in range(1,int(2e5)+1):
34 |     jc.append(jc[-1]*i%mod)
35 | 
36 | def ksm(T,n):
37 |     S=1
38 |     while n:
39 |         if n%2:S=S*T%mod
40 |         T=T*T%mod
41 |         n//=2
42 |     return S
43 | 
44 | def calc(x,y):
45 |     return jc[x]*ksm(jc[y],mod-2)%mod*ksm(jc[x-y],mod-2)%mod
46 | 
47 | for _ in range(T):
48 |     str,stc,edr,edc=map(int,input().split())
49 |     str=R[str-1]
50 |     stc=C[stc-1]
51 |     edr=R[edr-1]
52 |     edc=C[edc-1]
53 |     if edr-str<=0 or edc-stc<=0:print(0)
54 |     else: print(calc(edr-str+edc-stc,edr-str))
55 | 
56 | '''
57 | 4 4 2
58 | 4 2 3 1
59 | 2 1 2 1
60 | 4 4 1 1
61 | 2 2 2 4
62 | '''


--------------------------------------------------------------------------------
/H.py:
--------------------------------------------------------------------------------
 1 | #H
 2 | import sys
 3 | sys.setrecursionlimit(int(1e6))
 4 | n=int(input())
 5 | X=list(map(int,input().split()))
 6 | tnxt=[[0,0] for i in range(int(1e5+10))]
 7 | End=[[0,0]]*int(1e5+10)
 8 | cnt=0
 9 | for i in range(n):
10 |     x=X[i]
11 |     u=0
12 |     for d in range(30,-1,-1):
13 |         if x&(2**d):sta=1
14 |         else:sta=0
15 |         if not tnxt[u][sta]:
16 |             cnt+=1
17 |             tnxt[u][sta]=cnt
18 |         u=tnxt[u][sta]
19 |     End[u]=[1,i]
20 | 
21 | E=[[] for i in range(int(1e5+10))]
22 | f=list(map(int,input().split()))
23 | for i in range(n):
24 |     if f[i]==-1:continue
25 |     E[f[i]].append(i)
26 |     E[i].append(f[i])
27 | 
28 | def dfs(u,x,d,ban):
29 |     if d<0:
30 |         if End[u][0] and End[u][1] not in ban:
31 |             return X[End[u][1]]
32 |         return -1
33 |     if x&(2**d):sta=1
34 |     else:sta=0
35 |     if tnxt[u][sta^1]:
36 |         tmp=dfs(tnxt[u][sta^1],x,d-1,ban)
37 |         if tmp!=-1:return tmp
38 |     if tnxt[u][sta]:
39 |         tmp=dfs(tnxt[u][sta],x,d-1,ban)
40 |         if tmp!=-1:return tmp
41 |     return -1
42 | 
43 | ans=0
44 | for i in range(n):
45 |     tmp=dfs(0,X[i],30,E[i])
46 |     if tmp!=-1:ans=max(ans,X[i]^tmp)
47 | print(ans)
48 | '''
49 | 5
50 | 1 0 5 3 4
51 | -1 0 1 0 1
52 | '''


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 2024年第十五届蓝桥杯Python A组省赛题目+参赛代码
 2 | 
 3 | 高位进国赛啦，happyhappyhappy!
 4 | 
 5 | 目前知道的是G智商检测没过关哈哈，鼠鼠考场写的答案只有组合数；其它的题目似乎都不难
 6 | 
 7 | 附一个鼠鼠脑补的大致题解：
 8 | 
 9 | A. 总面积开根号-1
10 | 
11 | B. 除了前200是6个，后面每个200都是4，所以2+x//200
12 | 
13 | C. 2ⁿ不行
14 | 
15 | D. 贪心，按从左到右顺序处理左半边，能两个一起就两个一起，不能就单个
16 | 
17 | E：最大子串dp+最大生成树
18 | 
19 | F：用线性筛打质数表，然后记忆化搜索(win[i]表示长度为i时先手是否能赢，如果后继状态有输的，该状态就赢；否则输）
20 | 
21 | G：离散化，然后排列组合* 行前缀积 *列前缀积
22 | 
23 | H：字典树，如果搜到相邻点不返回结果接着搜
24 | 
25 | 如果感觉这个项目对您有帮助（如了解了什么库可以用or提供了题面or提供了做题思路），烦请您到右上角点个Star。祝点star的同学蓝桥杯国赛都能冲到国一哈哈。
26 | 
27 | PS：相关项目还有 
28 | 
29 | [2023年第十四届蓝桥杯全国总决赛 Python A组全国一等奖纪念（省赛国赛题目+考场代码）](https://github.com/shannany0606/2023_Lanqiao_Cup)
30 | 
31 | [2024年第十五届蓝桥杯全国总决赛 Python A组全国一等奖纪念（题目+考场代码）](https://github.com/shannany0606/2024_LanQiao_Cup_Nation)
32 | 


--------------------------------------------------------------------------------
/第十五届蓝桥杯大赛软件赛省赛_PA.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/shannany0606/2024_LanQiao_Cup_Province/8249972b86cb7da9860b68e5ea4b38abbfb24c1e/第十五届蓝桥杯大赛软件赛省赛_PA.pdf


--------------------------------------------------------------------------------