• P1036 [NOIP2002 普及组] 选数


    1. #include
    2. #define ff(i) for (int i=1;i<=n;i++)
    3. #define f(x,y) for (int y=x+1;y<=n;y++)
    4. using namespace std;
    5. bool zs(int x)
    6. {
    7. for (int i=2;i<=sqrt(x);i++)
    8. if (x%i==0)
    9. return 0;
    10. return 1;
    11. }
    12. int n,x,a[25],b[95000001]={0},mx=-1,c=0;
    13. int main()
    14. {
    15. cin>>n>>x;
    16. for (int i=1;i<=n;i++)
    17. cin>>a[i];
    18. if (x==1)
    19. {
    20. ff(i)
    21. {
    22. if (zs(a[i]))
    23. b[a[i]]++;
    24. if (a[i]>mx)
    25. mx=a[i];
    26. }
    27. }
    28. if (x==2)
    29. {
    30. ff(i)
    31. {
    32. f(i,j)
    33. {
    34. int m=a[i]+a[j];
    35. if (zs(m))
    36. b[m]++;
    37. if (m>mx)
    38. mx=m;
    39. }
    40. }
    41. }
    42. if (x==3)
    43. {
    44. ff(i)
    45. {
    46. f(i,j)
    47. {
    48. f(j,k)
    49. {
    50. int m=a[i]+a[j]+a[k];
    51. if (zs(m))
    52. b[m]++;
    53. if (m>mx)
    54. mx=m;
    55. }
    56. }
    57. }
    58. }
    59. if (x==4)
    60. {
    61. ff(i)
    62. {
    63. f(i,j)
    64. {
    65. f(j,k)
    66. {
    67. f(k,l)
    68. {
    69. int m=a[i]+a[j]+a[k]+a[l];
    70. if (zs(m))
    71. b[m]++;
    72. if (m>mx)
    73. mx=m;
    74. }
    75. }
    76. }
    77. }
    78. }
    79. if (x==5)
    80. {
    81. ff(i)
    82. {
    83. f(i,j)
    84. {
    85. f(j,k)
    86. {
    87. f(k,l)
    88. {
    89. f(l,ii)
    90. {
    91. int m=a[i]+a[j]+a[k]+a[l]+a[ii];
    92. if (zs(m))
    93. b[m]++;
    94. if (m>mx)
    95. mx=m;
    96. }
    97. }
    98. }
    99. }
    100. }
    101. }
    102. if (x==6)
    103. {
    104. ff(i)
    105. {
    106. f(i,j)
    107. {
    108. f(j,k)
    109. {
    110. f(k,l)
    111. {
    112. f(l,ii)
    113. {
    114. f(ii,jj)
    115. {
    116. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj];
    117. if (zs(m))
    118. b[m]++;
    119. if (m>mx)
    120. mx=m;
    121. }
    122. }
    123. }
    124. }
    125. }
    126. }
    127. }
    128. if (x==7)
    129. {
    130. ff(i)
    131. {
    132. f(i,j)
    133. {
    134. f(j,k)
    135. {
    136. f(k,l)
    137. {
    138. f(l,ii)
    139. {
    140. f(ii,jj)
    141. {
    142. f(jj,kk)
    143. {
    144. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk];
    145. if (zs(m))
    146. b[m]++;
    147. if (m>mx)
    148. mx=m;
    149. }
    150. }
    151. }
    152. }
    153. }
    154. }
    155. }
    156. }
    157. if (x==8)
    158. {
    159. ff(i)
    160. {
    161. f(i,j)
    162. {
    163. f(j,k)
    164. {
    165. f(k,l)
    166. {
    167. f(l,ii)
    168. {
    169. f(ii,jj)
    170. {
    171. f(jj,kk)
    172. {
    173. f(kk,ll)
    174. {
    175. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll];
    176. if (zs(m))
    177. b[m]++;
    178. if (m>mx)
    179. mx=m;
    180. }
    181. }
    182. }
    183. }
    184. }
    185. }
    186. }
    187. }
    188. }
    189. if (x==9)
    190. {
    191. ff(i)
    192. {
    193. f(i,j)
    194. {
    195. f(j,k)
    196. {
    197. f(k,l)
    198. {
    199. f(l,ii)
    200. {
    201. f(ii,jj)
    202. {
    203. f(jj,kk)
    204. {
    205. f(kk,ll)
    206. {
    207. {
    208. f(ll,mm)
    209. {
    210. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm];
    211. if (zs(m))
    212. b[m]++;
    213. if (m>mx)
    214. mx=m;
    215. }
    216. }
    217. }
    218. }
    219. }
    220. }
    221. }
    222. }
    223. }
    224. }
    225. }
    226. if (x==10)
    227. {
    228. ff(i)
    229. {
    230. f(i,j)
    231. {
    232. f(j,k)
    233. {
    234. f(k,l)
    235. {
    236. f(l,ii)
    237. {
    238. f(ii,jj)
    239. {
    240. f(jj,kk)
    241. {
    242. f(kk,ll)
    243. {
    244. {
    245. f(ll,mm)
    246. {
    247. f(mm,nn)
    248. {
    249. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn];
    250. if (zs(m))
    251. b[m]++;
    252. if (m>mx)
    253. mx=m;
    254. }
    255. }
    256. }
    257. }
    258. }
    259. }
    260. }
    261. }
    262. }
    263. }
    264. }
    265. }
    266. if (x==11)
    267. {
    268. ff(i)
    269. {
    270. f(i,j)
    271. {
    272. f(j,k)
    273. {
    274. f(k,l)
    275. {
    276. f(l,ii)
    277. {
    278. f(ii,jj)
    279. {
    280. f(jj,kk)
    281. {
    282. f(kk,ll)
    283. {
    284. {
    285. f(ll,mm)
    286. {
    287. f(mm,nn)
    288. {
    289. f(nn,oo)
    290. {
    291. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo];
    292. if (zs(m))
    293. b[m]++;
    294. if (m>mx)
    295. mx=m;
    296. }
    297. }
    298. }
    299. }
    300. }
    301. }
    302. }
    303. }
    304. }
    305. }
    306. }
    307. }
    308. }
    309. if (x==12)
    310. {
    311. ff(i)
    312. {
    313. f(i,j)
    314. {
    315. f(j,k)
    316. {
    317. f(k,l)
    318. {
    319. f(l,ii)
    320. {
    321. f(ii,jj)
    322. {
    323. f(jj,kk)
    324. {
    325. f(kk,ll)
    326. {
    327. {
    328. f(ll,mm)
    329. {
    330. f(mm,nn)
    331. {
    332. f(nn,oo)
    333. {
    334. f(oo,pp)
    335. {
    336. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp];
    337. if (zs(m))
    338. b[m]++;
    339. if (m>mx)
    340. mx=m;
    341. }
    342. }
    343. }
    344. }
    345. }
    346. }
    347. }
    348. }
    349. }
    350. }
    351. }
    352. }
    353. }
    354. }
    355. if (x==13)
    356. {
    357. ff(i)
    358. {
    359. f(i,j)
    360. {
    361. f(j,k)
    362. {
    363. f(k,l)
    364. {
    365. f(l,ii)
    366. {
    367. f(ii,jj)
    368. {
    369. f(jj,kk)
    370. {
    371. f(kk,ll)
    372. {
    373. {
    374. f(ll,mm)
    375. {
    376. f(mm,nn)
    377. {
    378. f(nn,oo)
    379. {
    380. f(oo,pp)
    381. {
    382. f(pp,qq)
    383. {
    384. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq];
    385. if (zs(m))
    386. b[m]++;
    387. if (m>mx)
    388. mx=m;
    389. }
    390. }
    391. }
    392. }
    393. }
    394. }
    395. }
    396. }
    397. }
    398. }
    399. }
    400. }
    401. }
    402. }
    403. }
    404. if (x==14)
    405. {
    406. ff(i)
    407. {
    408. f(i,j)
    409. {
    410. f(j,k)
    411. {
    412. f(k,l)
    413. {
    414. f(l,ii)
    415. {
    416. f(ii,jj)
    417. {
    418. f(jj,kk)
    419. {
    420. f(kk,ll)
    421. {
    422. {
    423. f(ll,mm)
    424. {
    425. f(mm,nn)
    426. {
    427. f(nn,oo)
    428. {
    429. f(oo,pp)
    430. {
    431. f(pp,qq)
    432. {
    433. f(qq,rr)
    434. {
    435. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr];
    436. if (zs(m))
    437. b[m]++;
    438. if (m>mx)
    439. mx=m;
    440. }
    441. }
    442. }
    443. }
    444. }
    445. }
    446. }
    447. }
    448. }
    449. }
    450. }
    451. }
    452. }
    453. }
    454. }
    455. }
    456. if (x==15)
    457. {
    458. ff(i)
    459. {
    460. f(i,j)
    461. {
    462. f(j,k)
    463. {
    464. f(k,l)
    465. {
    466. f(l,ii)
    467. {
    468. f(ii,jj)
    469. {
    470. f(jj,kk)
    471. {
    472. f(kk,ll)
    473. {
    474. {
    475. f(ll,mm)
    476. {
    477. f(mm,nn)
    478. {
    479. f(nn,oo)
    480. {
    481. f(oo,pp)
    482. {
    483. f(pp,qq)
    484. {
    485. f(qq,rr)
    486. {
    487. f(rr,ss)
    488. {
    489. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr]+a[ss];
    490. if (zs(m))
    491. b[m]++;
    492. if (m>mx)
    493. mx=m;
    494. }
    495. }
    496. }
    497. }
    498. }
    499. }
    500. }
    501. }
    502. }
    503. }
    504. }
    505. }
    506. }
    507. }
    508. }
    509. }
    510. }
    511. if (x==16)
    512. {
    513. ff(i)
    514. {
    515. f(i,j)
    516. {
    517. f(j,k)
    518. {
    519. f(k,l)
    520. {
    521. f(l,ii)
    522. {
    523. f(ii,jj)
    524. {
    525. f(jj,kk)
    526. {
    527. f(kk,ll)
    528. {
    529. {
    530. f(ll,mm)
    531. {
    532. f(mm,nn)
    533. {
    534. f(nn,oo)
    535. {
    536. f(oo,pp)
    537. {
    538. f(pp,qq)
    539. {
    540. f(qq,rr)
    541. {
    542. f(rr,ss)
    543. {
    544. f(ss,tt)
    545. {
    546. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr]+a[ss]+a[tt];
    547. if (zs(m))
    548. b[m]++;
    549. if (m>mx)
    550. mx=m;
    551. }
    552. }
    553. }
    554. }
    555. }
    556. }
    557. }
    558. }
    559. }
    560. }
    561. }
    562. }
    563. }
    564. }
    565. }
    566. }
    567. }
    568. }
    569. if (x==17)
    570. {
    571. ff(i)
    572. {
    573. f(i,j)
    574. {
    575. f(j,k)
    576. {
    577. f(k,l)
    578. {
    579. f(l,ii)
    580. {
    581. f(ii,jj)
    582. {
    583. f(jj,kk)
    584. {
    585. f(kk,ll)
    586. {
    587. {
    588. f(ll,mm)
    589. {
    590. f(mm,nn)
    591. {
    592. f(nn,oo)
    593. {
    594. f(oo,pp)
    595. {
    596. f(pp,qq)
    597. {
    598. f(qq,rr)
    599. {
    600. f(rr,ss)
    601. {
    602. f(ss,tt)
    603. {
    604. f(tt,uu)
    605. {
    606. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr]+a[ss]+a[tt]+a[uu];
    607. if (zs(m))
    608. b[m]++;
    609. if (m>mx)
    610. mx=m;
    611. }
    612. }
    613. }
    614. }
    615. }
    616. }
    617. }
    618. }
    619. }
    620. }
    621. }
    622. }
    623. }
    624. }
    625. }
    626. }
    627. }
    628. }
    629. }
    630. if (x==18)
    631. {
    632. ff(i)
    633. {
    634. f(i,j)
    635. {
    636. f(j,k)
    637. {
    638. f(k,l)
    639. {
    640. f(l,ii)
    641. {
    642. f(ii,jj)
    643. {
    644. f(jj,kk)
    645. {
    646. f(kk,ll)
    647. {
    648. {
    649. f(ll,mm)
    650. {
    651. f(mm,nn)
    652. {
    653. f(nn,oo)
    654. {
    655. f(oo,pp)
    656. {
    657. f(pp,qq)
    658. {
    659. f(qq,rr)
    660. {
    661. f(rr,ss)
    662. {
    663. f(ss,tt)
    664. {
    665. f(tt,uu)
    666. {
    667. f(uu,vv)
    668. {
    669. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr]+a[ss]+a[tt]+a[uu]+a[vv];
    670. if (zs(m))
    671. b[m]++;
    672. if (m>mx)
    673. mx=m;
    674. }
    675. }
    676. }
    677. }
    678. }
    679. }
    680. }
    681. }
    682. }
    683. }
    684. }
    685. }
    686. }
    687. }
    688. }
    689. }
    690. }
    691. }
    692. }
    693. }
    694. if (x==19)
    695. {
    696. ff(i)
    697. {
    698. f(i,j)
    699. {
    700. f(j,k)
    701. {
    702. f(k,l)
    703. {
    704. f(l,ii)
    705. {
    706. f(ii,jj)
    707. {
    708. f(jj,kk)
    709. {
    710. f(kk,ll)
    711. {
    712. {
    713. f(ll,mm)
    714. {
    715. f(mm,nn)
    716. {
    717. f(nn,oo)
    718. {
    719. f(oo,pp)
    720. {
    721. f(pp,qq)
    722. {
    723. f(qq,rr)
    724. {
    725. f(rr,ss)
    726. {
    727. f(ss,tt)
    728. {
    729. f(tt,uu)
    730. {
    731. f(uu,vv)
    732. {
    733. f(vv,ww)
    734. {
    735. int m=a[i]+a[j]+a[k]+a[l]+a[ii]+a[jj]+a[kk]+a[ll]+a[mm]+a[nn]+a[oo]+a[pp]+a[qq]+a[rr]+a[ss]+a[tt]+a[uu]+a[vv]+a[ww];
    736. if (zs(m))
    737. b[m]++;
    738. if (m>mx)
    739. mx=m;
    740. }
    741. }
    742. }
    743. }
    744. }
    745. }
    746. }
    747. }
    748. }
    749. }
    750. }
    751. }
    752. }
    753. }
    754. }
    755. }
    756. }
    757. }
    758. }
    759. }
    760. }
    761. for (int i=1;i<=mx;i++)
    762. {
    763. if (b[i])
    764. c+=b[i];
    765. }
    766. cout<
    767. return 0;
    768. }

  • 相关阅读:
    明势资本黄明明:创新与世界,下一代基础软件的中国突围之路
    【2022最新版】你真的会性能测试吗?这些被你忽略了吗?
    SystemVerilog学习(3)——数组
    Linux——ansible剧本
    MySQL高级SQL语句(下)
    游戏史上五个定价最高的量产型游戏机
    【数据结构】栈和队列
    基于Spring Boot 框架的试卷自动生成系统的设计与实现
    浅谈长连接负载均衡
    python mitmproxy +雷电模拟器 安装
  • 原文地址:https://blog.csdn.net/weixin_68756152/article/details/134063686