百度之星的奖项设置
一等奖1名 ―― 30000元 人民币二等奖2名 ―― 15000元 人民币三等奖5名 ―― 5000元 人民币晋级奖 —— 百度还将会邀请晋级的50位赛手至北京，参加为期3天的总决赛参与奖 ―― 复赛成绩前400名的选手将获得大赛限量纪念版T恤一件另：入围决赛和复赛的选手将自动进入百度公司人才库，将有机会优先参与百度实习计划，接受技术牛人指导职业发展，接触搜索引擎核心技术，并在百度公司的校园招聘活动享受“绿色通道”待遇。
中国大学生计算机设计大赛含金量高吗
高。中国大学生计算机设计大赛由教育部高等学校计算机类专业教学指导委员会、教育部高等学校软件工程专业教学指导委员会、教育部高等学校大学计算机课程教学指导委员会、教育部高等学校文科计算机基础教学指导分委员会、中国教育电视台联合主办，是全国普通高校学科竞赛排行榜榜单的赛事之一。计算机类的设计大赛对于计算机类专业，软件类专业的学生来讲，拥有莫大的吸引力，而且计算机设计大赛的含金量在全国这些大赛当中也能排的上号。该项大赛的赛制也是先从各高校内部竞争，之后就是省内竞争，最终送到全国参加决赛。参赛时间是每年一次。如果学生是计算机类专业的学生，完全可以研究这个比赛，好处真的是太多了。
计算机设计大赛哪个类容易获奖
都不容易。中国大学生计算机设计大赛竞赛内容目前分设：软件应用与开发、微课与教学辅助、物联网应用、大数据应用、人工智能应用、信息可视化设计、数媒静态设计、数媒动漫与短片、数媒游戏与交互设计，以及计算机音乐创作等类别。（一）大赛以三级竞赛形式开展，校级初赛——省级复赛——国家级决赛。省赛原则上由各省的计算机学会、省计算机教学研究会、省计算机教指委或省教育厅（市教委）主办。由省教育厅一级参与或继续主办省级选拔赛的有天津、辽宁、吉林、黑龙江、上海、江苏、安徽、福建、山东、湖南、广东、海南、四川、云南、甘肃、新疆。要求校级初赛上推省级赛的比例不能高于参加校级赛有效作品数的50%，省级赛（含省级直报赛区）上推国赛的比例不能高于参加省级赛有效作品数的30%。省级赛（含省级直报赛区）的奖项由省级赛组委会自行设置。建议省级赛一等奖占参加省级赛有效作品数10%,二等奖占20%,三等奖占30-40%。（二）大赛的参赛作品贴近实际，有些直接由企业命题，与社会需要相结合，有利于学生动手能力的提升，有利于创新创业人才的培养。参赛院校逐年增多，由2008年（第1届）的80所院校，发展到2020年（第13届）的800多所；参赛作品数，由2008年的242件，发展到2020年的1.3万余件（参加省级赛的作品数）。参赛作品质量也逐年提高，有些作品被CCTV采用，有些已商品化。（三）由于秉承公开、公平、公正的原则，大赛在全国已有良好声誉，赛事的影响力也逐年提升。目前，参赛本科院校数超过三分之二，一流大学和一流学科的参赛院校数接近七成；原211参赛院校数过半，原985大学参赛学校数过半。大赛目前是全国普通高校学科竞赛排行榜榜单的赛事之一。
百度之星题目
意思懂了
不过这个是百度之星题目吗？百度之星又不是你评的。
先占个位置，以后将答案补上！
其实做出来挺简单，做好就难，主要那个排序算法要优化。
今天比较亏，这个10分的题目花了半天！
读入一个二维数组，在读入的时候进行粗排序。
对这个数组按dat(0 ，i) (跨度) 进行排序
dim JG(1 to 5) as long
对排序后的数据进行处理
先对最后的10个元素进行比较，选出最大的重叠区；
再去掉前面跨度小于最大重叠区的；
剩下的很少了
基本上不超过10个元素，很有可能就1个；
在剩下的里面找最大重叠区；
排序的算法优化问题！
程序编得比较复杂，主要是为了占用内存少和速度快，运行起来内存需要15M左右，排序算法我自己设计的，思路是N+1位数肯定大于N位数，效果很好，50万个二维元素排序大概在15秒左右，
总共20秒不到；
CPU：Athlon xp 64位 2800+，超频到2.25G，而且在听歌和上QQ。
Private Dat() As Long
Private DatCount As Long
Private JG(1 To 5) As Long
Private tm1 As Date, tm2 As Date
Private Sub Command1_Click()
Dim Dat1() As Long
Dim Dat2() As Long
Dim Dat3() As Long
Dim Dat4() As Long
Dim Dat5() As Long
Dim Dat6() As Long
Dim Dat7() As Long
Dim Dat8() As Long
Dim Dat9() As Long
Dim Dat10() As Long
Dim MaxCD As Long
Dim N(1 To 10) As Long
Dim a As Long, b As Long, i As Long, j As Long, k As Long
'以下代码读入并粗排序
Open App.Path + "\input.txt" For Input As #1
j = 0
Do Until EOF(1)
Input #1, a, b
j = j + 1
i = i + 1
Select Case Abs(b - a)
Case Is > 1000000000
k = 10
N(k) = N(k) + 1
ReDim Preserve Dat10(0 To 3, 1 To N(k)) As Long
Dat10(0, N(k)) = Abs(b - a)
Dat10(1, N(k)) = a
Dat10(2, N(k)) = b
Dat10(3, N(k)) = Abs(b - a)
Case Is > 100000000
k = 9
N(k) = N(k) + 1
ReDim Preserve Dat9(0 To 3, 1 To N(k)) As Long
Dat9(0, N(k)) = Abs(b - a)
Dat9(1, N(k)) = a
Dat9(2, N(k)) = b
Dat9(3, N(k)) = Abs(b - a)
Case Is > 10000000
k = 8
N(k) = N(k) + 1
ReDim Preserve Dat8(0 To 3, 1 To N(k)) As Long
Dat8(0, N(k)) = Abs(b - a)
Dat8(1, N(k)) = a
Dat8(2, N(k)) = b
Dat8(3, N(k)) = Abs(b - a)
Case Is > 1000000
k = 7
N(k) = N(k) + 1
ReDim Preserve Dat7(0 To 3, 1 To N(k)) As Long
Dat7(1, N(k)) = a
Dat7(3, N(k)) = Abs(b - a)
Dat7(0, N(k)) = Abs(b - a)
Dat7(2, N(k)) = b
Case Is > 100000
k = 6
N(k) = N(k) + 1
ReDim Preserve Dat6(0 To 3, 1 To N(k)) As Long
Dat6(0, N(k)) = Abs(b - a)
Dat6(1, N(k)) = a
Dat6(2, N(k)) = b
Dat6(3, N(k)) = Abs(b - a)
Case Is > 10000
k = 5
N(k) = N(k) + 1
ReDim Preserve Dat5(0 To 3, 1 To N(k)) As Long
Dat5(0, N(k)) = Abs(b - a)
Dat5(1, N(k)) = a
Dat5(2, N(k)) = b
Dat5(3, N(k)) = Abs(b - a)
Case Is > 1000
k = 4
N(k) = N(k) + 1
ReDim Preserve Dat4(0 To 3, 1 To N(k)) As Long
Dat4(0, N(k)) = Abs(b - a)
Dat4(1, N(k)) = a
Dat4(2, N(k)) = b
Dat4(3, N(k)) = Abs(b - a)
Case Is > 100
k = 3
N(k) = N(k) + 1
ReDim Preserve Dat3(0 To 3, 1 To N(k)) As Long
Dat3(0, N(k)) = Abs(b - a)
Dat3(1, N(k)) = a
Dat3(2, N(k)) = b
Dat3(3, N(k)) = Abs(b - a)
Case Is > 10
k = 2
N(k) = N(k) + 1
ReDim Preserve Dat2(0 To 3, 1 To N(k)) As Long
Dat2(0, N(k)) = Abs(b - a)
Dat2(1, N(k)) = a
Dat2(2, N(k)) = b
Dat2(3, N(k)) = Abs(b - a)
Case Else
k = 1
N(k) = N(k) + 1
ReDim Preserve Dat1(0 To 3, 1 To N(k)) As Long
Dat1(0, N(k)) = Abs(b - a)
Dat1(1, N(k)) = a
Dat1(2, N(k)) = b
Dat1(3, N(k)) = Abs(b - a)
End Select
Loop
Close #1
ReDim Preserve Dat(0 To 2, 1 To j) As Long
'排序
tm1 = Now
DatCount = 0
PX Dat1, N(1), 1
PX Dat2, N(2), 2
PX Dat3, N(3), 3
PX Dat4, N(4), 4
PX Dat5, N(5), 5
PX Dat6, N(6), 6
PX Dat7, N(7), 7
PX Dat8, N(8), 8
PX Dat9, N(9), 9
PX Dat10, N(10), 10
MsgBox Now - tm1
'顺序合并到Dat数组
'1
For i = 1 To N(1)
Dat(0, DatCount + i) = Dat1(0, i)
Dat(1, DatCount + i) = Dat1(1, i)
Dat(2, DatCount + i) = Dat1(2, i)
Next i
DatCount = DatCount + N(1)
'2
For i = 1 To N(2)
Dat(1, DatCount + i) = Dat2(1, i)
Dat(0, DatCount + i) = Dat2(0, i)
Dat(2, DatCount + i) = Dat2(2, i)
Next i
DatCount = DatCount + N(2)
'3
For i = 1 To N(3)
Dat(1, DatCount + i) = Dat3(1, i)
Dat(0, DatCount + i) = Dat3(0, i)
Dat(2, DatCount + i) = Dat3(2, i)
Next i
DatCount = DatCount + N(3)
'4
For i = 1 To N(4)
Dat(1, DatCount + i) = Dat4(1, i)
Dat(0, DatCount + i) = Dat4(0, i)
Dat(2, DatCount + i) = Dat4(2, i)
Next i
DatCount = DatCount + N(4)
'5
For i = 1 To N(5)
Dat(0, DatCount + i) = Dat5(0, i)
Dat(1, DatCount + i) = Dat5(1, i)
Dat(2, DatCount + i) = Dat5(2, i)
Next i
DatCount = DatCount + N(5)
'6
For i = 1 To N(6)
Dat(0, DatCount + i) = Dat6(0, i)
Dat(1, DatCount + i) = Dat6(1, i)
Dat(2, DatCount + i) = Dat6(2, i)
Next i
DatCount = DatCount + N(6)
'7
For i = 1 To N(7)
Dat(0, DatCount + i) = Dat7(0, i)
Dat(1, DatCount + i) = Dat7(1, i)
Dat(2, DatCount + i) = Dat7(2, i)
Next i
DatCount = DatCount + N(7)
'8
For i = 1 To N(8)
Dat(0, DatCount + i) = Dat8(0, i)
Dat(1, DatCount + i) = Dat8(1, i)
Dat(2, DatCount + i) = Dat8(2, i)
Next i
DatCount = DatCount + N(8)
'9
For i = 1 To N(9)
Dat(0, DatCount + i) = Dat9(0, i)
Dat(1, DatCount + i) = Dat9(1, i)
Dat(2, DatCount + i) = Dat9(2, i)
Next i
DatCount = DatCount + N(9)
'10
For i = 1 To N(10)
Dat(0, DatCount + i) = Dat10(0, i)
Dat(1, DatCount + i) = Dat10(1, i)
Dat(2, DatCount + i) = Dat10(2, i)
Next i
DatCount = DatCount + N(10)
'Open App.Path + "\output.txt" For Output As #2
'For i = 1 To DatCount
'Print #2, Dat(1, i), Dat(2, i)
'Next i
'Close #2
'处理
MaxCD = 0
tm1 = Now
'提取最后10的重叠最大值
JG(1) = 0
For i = DatCount - 9 To DatCount - 1
For j = i + 1 To DatCount
If GetCD(i, j) > MaxCD Then
MaxCD = GetCD(i, j)
JG(1) = MaxCD
JG(2) = Dat(1, DatCount - 1)
JG(3) = Dat(2, DatCount - 1)
JG(4) = Dat(1, DatCount)
JG(5) = Dat(2, DatCount)
End If
Next j
Next i
j = 0
k = 0
Do Until MaxCD \ 10 ^ j < 10
k = k + N(j + 1)
j = j + 1
Loop
Do Until Dat(0, k) >= MaxCD
k = k + 1
Loop
'到目前为止，已经去掉大部分了
For i = k To DatCount - 1
For j = k + 1 To DatCount
k = GetCD(i, j)
If k > MaxCD Then
JG(1) = k
JG(2) = Dat(1, i)
JG(3) = Dat(2, i)
JG(4) = Dat(1, j)
JG(5) = Dat(2, j)
MaxCD = k
End If
Next j
Next i
'JG (1) 就是要的数据
tm2 = Now
MsgBox tm2 - tm1, , JG(1)
End Sub
Private Function GetCD(ByVal N1 As Long, ByVal N2 As Long) As Long
Dim a(1 To 2) As Long
Dim b(1 To 2) As Long
Dim c(1 To 2) As Long
If Dat(1, N1) < Dat(2, N1) Then
a(1) = Dat(1, N1)
a(2) = Dat(2, N1)
Else
a(1) = Dat(2, N1)
a(2) = Dat(1, N1)
End If
If Dat(1, N2) < Dat(2, N2) Then
b(1) = Dat(1, N2)
b(2) = Dat(2, N2)
Else
b(1) = Dat(2, N2)
b(2) = Dat(1, N2)
End If
If a(1) > b(1) Then
c(1) = a(1)
Else
c(1) = b(1)
End If
If a(2) < b(2) Then
c(2) = a(2)
Else
c(2) = b(2)
End If
GetCD = c(2) - c(1)
End Function
Private Sub PX(ByRef X() As Long, ByVal Xcount As Long, ByVal Ns As Long)
On Error GoTo PXerr
Dim Dt0() As Long
Dim Dt1() As Long
Dim Dt2() As Long
Dim Dt3() As Long
Dim Dt4() As Long
Dim Dt5() As Long
Dim Dt6() As Long
Dim Dt7() As Long
Dim Dt8() As Long
Dim Dt9() As Long
Dim Nk(0 To 9) As Long, k As Long
If Xcount = 0 Then Exit Sub
If Ns = 0 Then Exit Sub
For i = 1 To Xcount
Select Case X(3, i) \ 10 ^ (Ns - 1)
Case Is = 0
Nk(0) = Nk(0) + 1
ReDim Preserve Dt0(0 To 3, 1 To Nk(0)) As Long
Dt0(0, Nk(0)) = X(0, i)
Dt0(1, Nk(0)) = X(1, i)
Dt0(2, Nk(0)) = X(2, i)
Dt0(3, Nk(0)) = X(3, i)
Case Is = 1
Nk(1) = Nk(1) + 1
ReDim Preserve Dt1(0 To 3, 1 To Nk(1)) As Long
Dt1(0, Nk(1)) = X(0, i)
Dt1(1, Nk(1)) = X(1, i)
Dt1(2, Nk(1)) = X(2, i)
Dt1(3, Nk(1)) = X(3, i) - 1 * 10 ^ (Ns - 1)
Case Is = 2
Nk(2) = Nk(2) + 1
ReDim Preserve Dt2(0 To 3, 1 To Nk(2)) As Long
Dt2(0, Nk(2)) = X(0, i)
Dt2(1, Nk(2)) = X(1, i)
Dt2(2, Nk(2)) = X(2, i)
Dt2(3, Nk(2)) = X(3, i) - 2 * 10 ^ (Ns - 1)
Case Is = 3
Nk(3) = Nk(3) + 1
ReDim Preserve Dt3(0 To 3, 1 To Nk(3)) As Long
Dt3(0, Nk(3)) = X(0, i)
Dt3(1, Nk(3)) = X(1, i)
Dt3(2, Nk(3)) = X(2, i)
Dt3(3, Nk(3)) = X(3, i) - 3 * 10 ^ (Ns - 1)
Case Is = 4
Nk(4) = Nk(4) + 1
ReDim Preserve Dt4(0 To 3, 1 To Nk(4)) As Long
Dt4(0, Nk(4)) = X(0, i)
Dt4(1, Nk(4)) = X(1, i)
Dt4(2, Nk(4)) = X(2, i)
Dt4(3, Nk(4)) = X(3, i) - 4 * 10 ^ (Ns - 1)
Case Is = 5
Nk(5) = Nk(5) + 1
ReDim Preserve Dt5(0 To 3, 1 To Nk(5)) As Long
Dt5(0, Nk(5)) = X(0, i)
Dt5(1, Nk(5)) = X(1, i)
Dt5(2, Nk(5)) = X(2, i)
Dt5(3, Nk(5)) = X(3, i) - 5 * 10 ^ (Ns - 1)
Case Is = 6
Nk(6) = Nk(6) + 1
ReDim Preserve Dt6(0 To 3, 1 To Nk(6)) As Long
Dt6(0, Nk(6)) = X(0, i)
Dt6(1, Nk(6)) = X(1, i)
Dt6(2, Nk(6)) = X(2, i)
Dt6(3, Nk(6)) = X(3, i) - 6 * 10 ^ (Ns - 1)
Case Is = 7
Nk(7) = Nk(7) + 1
ReDim Preserve Dt7(0 To 3, 1 To Nk(7)) As Long
Dt7(0, Nk(7)) = X(0, i)
Dt7(1, Nk(7)) = X(1, i)
Dt7(2, Nk(7)) = X(2, i)
Dt7(3, Nk(7)) = X(3, i) - 7 * 10 ^ (Ns - 1)
Case Is = 8
Nk(8) = Nk(8) + 1
ReDim Preserve Dt8(0 To 3, 1 To Nk(8)) As Long
Dt8(0, Nk(8)) = X(0, i)
Dt8(1, Nk(8)) = X(1, i)
Dt8(2, Nk(8)) = X(2, i)
Dt8(3, Nk(8)) = X(3, i) - 8 * 10 ^ (Ns - 1)
Case Is = 9
Nk(9) = Nk(9) + 1
ReDim Preserve Dt9(0 To 3, 1 To Nk(9)) As Long
Dt9(0, Nk(9)) = X(0, i)
Dt9(1, Nk(9)) = X(1, i)
Dt9(2, Nk(9)) = X(2, i)
Dt9(3, Nk(9)) = X(3, i) - 9 * 10 ^ (Ns - 1)
End Select
Next i
'排序
PX Dt0, Nk(0), Ns - 1
PX Dt1, Nk(1), Ns - 1
PX Dt2, Nk(2), Ns - 1
PX Dt3, Nk(3), Ns - 1
PX Dt4, Nk(4), Ns - 1
PX Dt5, Nk(5), Ns - 1
PX Dt6, Nk(6), Ns - 1
PX Dt7, Nk(7), Ns - 1
PX Dt8, Nk(8), Ns - 1
PX Dt9, Nk(9), Ns - 1
'合并
Hb:
k = 0
'0
For i = 1 To Nk(0)
X(0, k + i) = Dt0(0, i)
X(1, k + i) = Dt0(1, i)
X(2, k + i) = Dt0(2, i)
X(3, k + i) = Dt0(3, i)
Next i
k = k + Nk(0)
'1
For i = 1 To Nk(1)
X(0, k + i) = Dt1(0, i)
X(1, k + i) = Dt1(1, i)
X(2, k + i) = Dt1(2, i)
X(3, k + i) = Dt1(3, i)
Next i
k = k + Nk(1)
'2
For i = 1 To Nk(2)
X(0, k + i) = Dt2(0, i)
X(1, k + i) = Dt2(1, i)
X(2, k + i) = Dt2(2, i)
X(3, k + i) = Dt2(3, i)
Next i
k = k + Nk(2)
'3
For i = 1 To Nk(3)
X(0, k + i) = Dt3(0, i)
X(1, k + i) = Dt3(1, i)
X(2, k + i) = Dt3(2, i)
X(3, k + i) = Dt3(3, i)
Next i
k = k + Nk(3)
'4
For i = 1 To Nk(4)
X(0, k + i) = Dt4(0, i)
X(1, k + i) = Dt4(1, i)
X(2, k + i) = Dt4(2, i)
X(3, k + i) = Dt4(3, i)
Next i
k = k + Nk(4)
'5
For i = 1 To Nk(5)
X(0, k + i) = Dt5(0, i)
X(1, k + i) = Dt5(1, i)
X(2, k + i) = Dt5(2, i)
X(3, k + i) = Dt5(3, i)
Next i
k = k + Nk(5)
'6
For i = 1 To Nk(6)
X(0, k + i) = Dt6(0, i)
X(1, k + i) = Dt6(1, i)
X(2, k + i) = Dt6(2, i)
X(3, k + i) = Dt6(3, i)
Next i
k = k + Nk(6)
'7
For i = 1 To Nk(7)
X(0, k + i) = Dt7(0, i)
X(1, k + i) = Dt7(1, i)
X(2, k + i) = Dt7(2, i)
X(3, k + i) = Dt7(3, i)
Next i
k = k + Nk(7)
'8
For i = 1 To Nk(8)
X(0, k + i) = Dt8(0, i)
X(1, k + i) = Dt8(1, i)
X(2, k + i) = Dt8(2, i)
X(3, k + i) = Dt8(3, i)
Next i
k = k + Nk(8)
'9
For i = 1 To Nk(9)
X(0, k + i) = Dt9(0, i)
X(1, k + i) = Dt9(1, i)
X(2, k + i) = Dt9(2, i)
X(3, k + i) = Dt9(3, i)
Next i
Exit Sub
PXerr:
Exit Sub
End Sub
今年百度之星的题目
1.水果开会时段
每个百度工程师团队都有一笔还算丰裕的食品经费，足够每天购置多种水果。水果往往下午送达公司前台。前台的姐姐们只要看到同时出现五种或以上的水果，就称之为“水果开会”。
从搜索引擎切词的语法角度，只要两种水果的名字中有一个字相同就属于同样的类别。例如“小雪梨”和“大雪梨”是同一种水果，而“核桃”和“水蜜桃”也被认为是同一种水果。尤其要指出的是，如果有三种水果x, y, z同时在前台出现，且x和y是同一种水果，y和z也是同一种水果的时候，x和z在此时也被认为是同一种水果（即使x和z并不包含相同的字）。现在前台的姐姐们想知道，今天是否有“水果开会”——五种或更多的水果同时在前台出现。
输入格式
输入的第一行只有一个整数n，表示购置水果的组数。接下来的n行表示水果的到达时间、取走时间（时间用1200到1900之间的正整数表示，保证取走时间大于到达时间）。剩下的字符串以空格分割每一种水果。如“1400 1600 雪梨 水蜜桃”，表示下午两点到四点（包含两点和四点这两个时间点），雪梨和水蜜桃会在前台等待开会。每种水果名称由不超过十个汉字组成。
输出格式
输出仅一行，包含一个字符串Yes或No，分别表示今天水果开会与否。
输入样例1 例
3
1200 1400 雪梨 柠檬
1300 1400 西瓜 苹果
1400 1800 花生 水蜜桃
输出样例1 例
Yes
输入样例2 例
3
1200 1400 雪梨 柠檬
1400 1500 哦 大梨 呀
1500 1800 咦 大梨
输出样例2 例
No
样例解释
在样例1中，时刻1400有六种水果在前台；在样例2中，由于雪梨和大梨在任何时刻都是同一种水果，最多只有四种水果同时在前台。
评分规则
程序将运行在一台Linux机器上（内存使用不作严格限制），在每一测试用例上运行不能超过1秒，否则该用例不得分；
要求程序能按照输入样例的格式读取标准输入数据，按照输出样例的格式将运行结果输出到标准输出上。如果不能正确读入数据和输出数据，该题将不得分；
该题共有10个测试数据集，每组数据均满足n<=10，每个时段最多有10个水果，一共不超过50个水果；
该题目20分。 2.大话西游与数字游戏
“叉烧鸡翅膀，我呀最爱吃！……”
百度spider组的“黑龙潭之行”在烤着鸡翅，唱着星爷的经典时达到高潮。大家在篝火旁围成一圈，开始玩“数7”加强版游戏，规则如下：
规则1：遇7的倍数或含7的数时pass。
规则2：遇有包含相同数字的数时pass。注意相同数字不必相邻。例如121。
数错的惩罚很残酷——吞食烤全羊。为避免惩罚，百度工程师们需要你——史上最强程序员的帮助。百度工程师想知道：
req1 x：符合规则1的第x个数是什么？
req2 y：符合规则2的第y个数是什么？
req12 z：同时符合规则1、2的第z个数是什么？
query n：数n是规则1中的第几个数，是规则2中的第几个数？
输入格式
输入的每一行为一个查询，由一个查询词和一个无符号整型数组成。共有四种查询，查询词分别为req1、req2、req12、query（区分大小写）。
输出格式
前三种查询输出一个无符号整型的解。对于“query n”的查询，若n是规则中的数则输出相应的解，否则输出-1。
输入样例 例
req1 10
req2 10
req12 10
query 14
输出样例 例
11
10
12
-1 13
评分规则
程序将运行在一台Linux机器上（内存使用不作严格限制），在每一测试用例上运行不能超过1秒，否则该用例不得分；
要求程序能按照输入样例的格式读取标准输入数据，按照输出样例的格式将运行结果输出到标准输出上。如果不能正确读入数据和输出数据，该题将不得分；
该题目共有10个测试数据集，其中数据1~5主要考查正确性，满足x,y,z,n<=1000；输入6~10主要考查时间效率，满足x<=10,000,000，y<=1,000,000，z<=240,000，n<=20,000,000。数据1和6只包含req1，数据2和7只包含req2，数据3和8只包含req12，数据4和7只包含query，数据5和10包含全部四种查询。每组数据都恰好包含100个查询。
该题目20分. 3.繁忙的会议室预定问题
百度由最开始的7人团队迅速发展为几千人的大团队，而工程师们经常需要在一起进行“头脑风暴”，这样会议室就成了紧缺资源。为了有效利用资源，大家决定制定规则， 自动安排会议室的使用。
为了公平起见，应按照申请时间从早到晚依次考虑，先到先得，且申请一旦被接受就不能取消。在处理每条请求时，只要当前请求可以和前面已接受的所有请求同时满足时就必须被接受（如有必要，可以调整给已接受申请安排的会议室和开会时间）。注意同一时间开的不同会议必须在不同的会议室，而同一个人不能同时参加两个会议。
输入格式
输入第一行为会议室总数n和请求总数m；第二行是n个整数，表示会议室能够容量的人数。以下m行每行是一个请求，按请求时间先后顺序排列（即应优先满足在输入中更早出现的请求）。
每个请求中第一个是整数，表示会议需要的时间长度（单位：小时）；之后为与会人名单。人名由不超过四个汉字组成，用半角逗号分隔（每人名字固定且唯一，有重名的也在登记时区分开）。名单后的数字表示可以安排会议的时间，也以半角逗号分隔，如 10,11,14,15 表示第10, 11, 14, 15个小时可以开会（会议时间为9到19之间的正整数）。
输出格式
输出m行，依次表示每个请求是否被接受。1表示接受，0表示不接受。
输入样例： 例
2 4
20 2
3 张三,李四,王五 10,11,12,14,15
1 张三 12
4 王六,王七,王八,王九,王十 9,10,11,12,13,14,15
2 张三 14,15
输出样例： 例
1
0
0
1
样例解释
请求1可以满足，因此接受；在请求1接受的前提下请求2和请求3都无法满足，因此不接受。请求1和请求4可以同时满足（都在会议室1，前者用时间10~12，后者用时间14~15）。需要特别注意的是：如果没有请求1，后三个请求可以同时满足。但是规则是先到先得，请求1只要可以满足就必须接受。
评分规则
程序将运行在一台Linux机器上（内存使用不作严格限制），在每一测试用例上运行不能超过2秒，否则该用例不得分；
要求程序能按照输入样例的格式读取标准数据，按照输出样例的格式将运行结果输出到标准输出上。如果不能正确读入数据和输出数据，该题将不得分；
该题共有15个测试数据集，均满足n<=10，m<=10。每个会议最多有10人参加；
该题目30分. 4.SQL中的SELECT语句
SQL中的SELECT语句用于从数据库中查询记录。某个工程项目数据库中有一个所有数据均为字符串的表，需要查询一些满足条件的记录数。本题考虑SELECT语句的简化形式，相关语句格式如下：
1. 计数语句，查询满足条件的记录条数。有两种格式：
格式1：SELECT COUNT(*) WHERE
格式2：SELECT COUNT(*)
2. 子集选择语句，选择满足条件的记录并组成一个集合。有两种格式
格式1：SELECT * WHERE
格式2：SELECT *
上述两种语句中的FROM子句具有相同的格式：
格式1：FROM
格式2：FROM (子集选择语句)
其中TABLENAME为该工程中惟一的表名，子集选择语句即上述用SELECT *开头的语句。
条件的格式为一条或多条=用关键字and连接（不区分大小写），其中FIELD为字段名，VALUE为数据值，它们均为由大小写字母和数字组成的长度不超过10的非空字符串。该条件表示所有特定的字段必须等于给定值。
给定表中的所有记录和若干条计数语句，输出所有语句的结果。
输入格式
输入第一行为三个整数c, n, q，分别表示数据库中表的列数、记录数和查询次数；第二行为表名(即TABLENAME)；第三行为表中的c个字段名(FIELD)，之间用一个或多个空格隔开，字段名各不相同；接下来n行，每行表示一个记录，有c个数据值(VALUE)，之间用空格隔开；接下去有q行，每行一条SELECT记录数语句，该语句长度（包括空格）不超过1000。输入数据保证每条语句满足题目中给出的计数语句的定义，并且FROM子句的格式1中出现的表名和输入的表名一致。
输出格式
输出q行，每行一个整数，表示相应语句输出的结果（即满足条件的记录数）。
输入样例 例
4 5 6
Book
BookName Price PublishDate Author
NBAsports 10 2004 dearboy
SQL 20 2002 absorbed
IntrotoAlgorithm 59 2002 Thomas
MultipeView 60 2002 RichardHautley
NBAsports 10 2004 dearboy
SELECT COUNT(*) FROM Book WHERE BookName=NBAsports and Author=dearboy
SELECT COUNT(*) FROM Book WHERE Price=20
SELECT COUNT(*) FROM Book WHERE Author=lala
SELECT COUNT(*) FROM (SELECT * FROM Book WHERE BookName=NBAsports)
SELECT COUNT(*) FROM (SELECT * FROM Book WHERE BookName=NBAsports) WHERE Price=20
SELECT COUNT(*) FROM Book
输出样例 例
2
1
0
2
0
5
评分规则
程序将运行在一台Linux机器上（内存使用不作严格限制），在每一测试用例上运行不能超过2秒，否则该用例不得分；
要求程序能按照输入样例的格式读取标准数据，按照输出样例的格式将运行结果输出到标准输出上。如果不能正确读入数据和输出数据，该题将不得分；
该题共有10个测试数据集，数据1的表与样例相同，并包含15条SELECT语句。数据2,3,4,5的表分别有1,2,5,7列，数据6~10的表均有8列。数据2~5的表均有恰好1000条记录，并包含100个SELECT语句。数据6~10的表不超过3000条记录，并包含不超过20000条SELECT语句。本题的后5组数据着重考查程序的时间效率；
该题目30分。
