├── Books ├── 102_Combinatorial_Problems.pdf ├── 104 Number Theory Problems.pdf ├── CP-Geometry.pdf └── Competitive Programming 3 (CP3).pdf ├── CodeForces ├── Gym │ ├── 100247A.cpp │ ├── 100247G.cpp │ ├── 100247H.cpp │ ├── 100247J.cpp │ ├── 100548G.cpp │ ├── 100712A.cpp │ ├── 100712B.cpp │ ├── 100712C.cpp │ ├── 100712E.cpp │ ├── 100712F.cpp │ ├── 100712J.cpp │ ├── 100712K.cpp │ ├── 101059C.cpp │ ├── 101086M.cpp │ ├── 101161D.cpp │ ├── 101190E.cpp │ ├── 101190H.cpp │ ├── 101350A.cpp │ ├── 101350F.cpp │ ├── 101411H.cpp │ ├── 101466E.cpp │ ├── 101615H.cpp │ ├── 101635C.cpp │ ├── 101635E.cpp │ ├── 101840D.cpp │ ├── 101840K.cpp │ ├── 101840L.cpp │ ├── 101864A.cpp │ ├── 101864D.cpp │ ├── 102012H.cpp │ ├── 102040B.cpp │ ├── 102040F.cpp │ ├── 102141B.cpp │ └── 102141E.cpp └── Solutions │ ├── 1000A.cpp │ ├── 1000B.cpp │ ├── 1000C.cpp │ ├── 1000F.cpp │ ├── 1003A.cpp │ ├── 1003B.cpp │ ├── 1003C.cpp │ ├── 1003D.cpp │ ├── 1004A.cpp │ ├── 1004B.cpp │ ├── 1004C.cpp │ ├── 1005A.cpp │ ├── 1005B.cpp │ ├── 1005C.cpp │ ├── 1005D.cpp │ ├── 1006A.cpp │ ├── 1006B.cpp │ ├── 1006C.cpp │ ├── 1006D.cpp │ ├── 1006E.cpp │ ├── 1006F.cpp │ ├── 1008A.cpp │ ├── 1008B.cpp │ ├── 1008C.cpp │ ├── 1009A.cpp │ ├── 1009B.cpp │ ├── 1009C.cpp │ ├── 1009D.cpp │ ├── 1011A.cpp │ ├── 1011B.cpp │ ├── 1011C.cpp │ ├── 1011D.cpp │ ├── 1011E.cpp │ ├── 1015A.cpp │ ├── 1015B.cpp │ ├── 1015C.cpp │ ├── 1015D.cpp │ ├── 1015E1.cpp │ ├── 1015E2.cpp │ ├── 1016B.cpp │ ├── 1017A.cpp │ ├── 1017B.cpp │ ├── 1017C.cpp │ ├── 1025B.cpp │ ├── 1027A.cpp │ ├── 1029C.cpp │ ├── 1029D.cpp │ ├── 1033C.cpp │ ├── 1041A.cpp │ ├── 1056E.cpp │ ├── 1062E.cpp │ ├── 1072B.cpp │ ├── 1076E.cpp │ ├── 1083A.cpp │ ├── 1083E.cpp │ ├── 1084A.cpp │ ├── 1084B.cpp │ ├── 1084C.cpp │ ├── 1084D.cpp │ ├── 1087A.cpp │ ├── 1087B.cpp │ ├── 1087C.cpp │ ├── 1088A.cpp │ ├── 1088B.cpp │ ├── 1088C.cpp │ ├── 1088D.cpp │ ├── 1089E.cpp │ ├── 1089F.cpp │ ├── 1089G.cpp │ ├── 1089L.cpp │ ├── 108A.cpp │ ├── 1092F.cpp │ ├── 1096C.cpp │ ├── 1097A.cpp │ ├── 1097B.cpp │ ├── 1097C.cpp │ ├── 1105D.cpp │ ├── 1107A.cpp │ ├── 1107B.cpp │ ├── 1107C.cpp │ ├── 1107D.cpp │ ├── 1113A.cpp │ ├── 1113B.cpp │ ├── 1113C.cpp │ ├── 1113D.cpp │ ├── 1114C.cpp │ ├── 1118A.cpp │ ├── 1118B.cpp │ ├── 1118C.cpp │ ├── 1118D1.cpp │ ├── 1118D2.cpp │ ├── 1118E.cpp │ ├── 1118F1.cpp │ ├── 111B.cpp │ ├── 112A.c │ ├── 112D.cpp │ ├── 1133A.cpp │ ├── 1133B.cpp │ ├── 1133C.cpp │ ├── 1133D.cpp │ ├── 1133E.cpp │ ├── 1133F1.cpp │ ├── 1133F2.cpp │ ├── 1136A.cpp │ ├── 1136B.cpp │ ├── 1136C.cpp │ ├── 1136D.cpp │ ├── 1146D.cpp │ ├── 1148D.cpp │ ├── 1152A.cpp │ ├── 1152B.cpp │ ├── 1152C.cpp │ ├── 1163D.cpp │ ├── 1167E.cpp │ ├── 1169E.cpp │ ├── 1181A.cpp │ ├── 1181B.cpp │ ├── 1187E.cpp │ ├── 118A.c │ ├── 118D.cpp │ ├── 1194E.cpp │ ├── 1215A.cpp │ ├── 1215B.cpp │ ├── 1215C.cpp │ ├── 1215D.cpp │ ├── 121A.cpp │ ├── 1221C.cpp │ ├── 1228A.cpp │ ├── 1228B.cpp │ ├── 1228C.cpp │ ├── 1228D.cpp │ ├── 122C.cpp │ ├── 1236E.cpp │ ├── 123A.cpp │ ├── 1245F.cpp │ ├── 1248F.cpp │ ├── 1255A.cpp │ ├── 1255B.cpp │ ├── 1255C.cpp │ ├── 1255D.cpp │ ├── 1255E1.cpp │ ├── 1255E2.cpp │ ├── 1257F.cpp │ ├── 1262A.cpp │ ├── 1262B.cpp │ ├── 1262C.cpp │ ├── 1262D1.cpp │ ├── 1262D2.cpp │ ├── 1265A.cpp │ ├── 1265B.cpp │ ├── 1265C.cpp │ ├── 1265D.cpp │ ├── 1266A.cpp │ ├── 1266B.cpp │ ├── 1266C.cpp │ ├── 1266D.cpp │ ├── 1266E.cpp │ ├── 1269A.cpp │ ├── 1269B.cpp │ ├── 1269C.cpp │ ├── 1269D.cpp │ ├── 126B.cpp │ ├── 1270A.cpp │ ├── 1270B.cpp │ ├── 1270C.cpp │ ├── 1270D.cpp │ ├── 1272A.cpp │ ├── 1272B.cpp │ ├── 1272C.cpp │ ├── 1272D.cpp │ ├── 1272E.cpp │ ├── 1272F.cpp │ ├── 1277A.cpp │ ├── 1277B.cpp │ ├── 1277C.cpp │ ├── 1277D.cpp │ ├── 1277E.cpp │ ├── 1278A.cpp │ ├── 1278B.cpp │ ├── 1278C.cpp │ ├── 127D.cpp │ ├── 1281A.cpp │ ├── 1281B.cpp │ ├── 1281C.cpp │ ├── 1283C.cpp │ ├── 1283D.cpp │ ├── 1284A.cpp │ ├── 1284B.cpp │ ├── 1284C.cpp │ ├── 1284D.cpp │ ├── 1285A.cpp │ ├── 1285B.cpp │ ├── 1285C.cpp │ ├── 1285D.cpp │ ├── 1286B.cpp │ ├── 1287A.cpp │ ├── 1287B.cpp │ ├── 1287C.cpp │ ├── 1287D.cpp │ ├── 1288C.cpp │ ├── 128C.cpp │ ├── 1291C.cpp │ ├── 1293A.cpp │ ├── 1293B.cpp │ ├── 1293C.cpp │ ├── 1293D.cpp │ ├── 1294D.cpp │ ├── 1294E.cpp │ ├── 1294F.cpp │ ├── 1295A.cpp │ ├── 1295B.cpp │ ├── 1295C.cpp │ ├── 1295D.cpp │ ├── 129A.cpp │ ├── 129E.cpp │ ├── 1300A.cpp │ ├── 1300B.cpp │ ├── 1300C.cpp │ ├── 1303E.cpp │ ├── 1312A.cpp │ ├── 1312B.cpp │ ├── 1312C.cpp │ ├── 1312D.cpp │ ├── 1312E.cpp │ ├── 1312F.cpp │ ├── 1312G.cpp │ ├── 131C.cpp │ ├── 131E.cpp │ ├── 1325E.cpp │ ├── 1325F.cpp │ ├── 1326A.cpp │ ├── 1326B.cpp │ ├── 1326C.cpp │ ├── 1326D1.cpp │ ├── 1326D2.cpp │ ├── 1326E.cpp │ ├── 1327A.cpp │ ├── 1327B.cpp │ ├── 1327C.cpp │ ├── 1327E.cpp │ ├── 1328A.cpp │ ├── 1328B.cpp │ ├── 1328C.cpp │ ├── 1328D.cpp │ ├── 1328E.cpp │ ├── 1330A.cpp │ ├── 1330B.cpp │ ├── 1330C.cpp │ ├── 1330D.cpp │ ├── 1332A.cpp │ ├── 1332B.cpp │ ├── 1332C.cpp │ ├── 1332D.cpp │ ├── 1333A.cpp │ ├── 1333B.cpp │ ├── 1333C.cpp │ ├── 1333D.cpp │ ├── 1334A.cpp │ ├── 1334B.cpp │ ├── 1334C.cpp │ ├── 1334D.cpp │ ├── 1334E.cpp │ ├── 1335E1.cpp │ ├── 1335E2.cpp │ ├── 1337A.cpp │ ├── 1337B.cpp │ ├── 1337C.cpp │ ├── 1337D.cpp │ ├── 1337E.cpp │ ├── 1339A.cpp │ ├── 1339B.cpp │ ├── 1339C.cpp │ ├── 1339D.cpp │ ├── 1340C.cpp │ ├── 1341A.cpp │ ├── 1341B.cpp │ ├── 1341C.cpp │ ├── 1341D.cpp │ ├── 1341E.cpp │ ├── 1342A.cpp │ ├── 1342B.cpp │ ├── 1342C.cpp │ ├── 1342D.cpp │ ├── 1342E.cpp │ ├── 1343A.cpp │ ├── 1343B.cpp │ ├── 1343C.cpp │ ├── 1343D.cpp │ ├── 1343E.cpp │ ├── 1345A.cpp │ ├── 1345B.cpp │ ├── 1345C.cpp │ ├── 1345D.cpp │ ├── 1348A.cpp │ ├── 1348B.cpp │ ├── 1348C.cpp │ ├── 1348D.cpp │ ├── 1348E.cpp │ ├── 1348F.cpp │ ├── 1349A.cpp │ ├── 1349B.cpp │ ├── 1350C.cpp │ ├── 1350D.cpp │ ├── 1354A.cpp │ ├── 1354B.cpp │ ├── 1354C1.cpp │ ├── 1354C2.cpp │ ├── 1354D.cpp │ ├── 1354E.cpp │ ├── 1354F.cpp │ ├── 1355A.cpp │ ├── 1355B.cpp │ ├── 1355C.cpp │ ├── 1355D.cpp │ ├── 1355E.cpp │ ├── 1355F.cpp │ ├── 1358A.cpp │ ├── 1358B.cpp │ ├── 1358C.cpp │ ├── 1358D.cpp │ ├── 1358E.cpp │ ├── 1359A.cpp │ ├── 1359B.cpp │ ├── 1359C.cpp │ ├── 1359D.cpp │ ├── 1359E.cpp │ ├── 135C.cpp │ ├── 1360A.cpp │ ├── 1360B.cpp │ ├── 1360C.cpp │ ├── 1360D.cpp │ ├── 1360E.cpp │ ├── 1360F.cpp │ ├── 1360G.cpp │ ├── 1360H.cpp │ ├── 1362A.cpp │ ├── 1362B.cpp │ ├── 1362C.cpp │ ├── 1362D.cpp │ ├── 1362E.cpp │ ├── 1363A.cpp │ ├── 1363B.cpp │ ├── 1363C.cpp │ ├── 1363D.cpp │ ├── 1363E.cpp │ ├── 1364A.cpp │ ├── 1364B.cpp │ ├── 1364C.cpp │ ├── 1364D.cpp │ ├── 1364E.cpp │ ├── 1365A.cpp │ ├── 1365B.cpp │ ├── 1365C.cpp │ ├── 1365D.cpp │ ├── 1365E.cpp │ ├── 1365F.cpp │ ├── 1366A.cpp │ ├── 1366B.cpp │ ├── 1366C.cpp │ ├── 1366D.cpp │ ├── 1366E.cpp │ ├── 1367A.cpp │ ├── 1367B.cpp │ ├── 1367C.cpp │ ├── 1367D.cpp │ ├── 1367E.cpp │ ├── 1367F1.cpp │ ├── 1367F2.cpp │ ├── 1368A.cpp │ ├── 1368B.cpp │ ├── 1368C.cpp │ ├── 1368D.cpp │ ├── 1369A.cpp │ ├── 1369B.cpp │ ├── 1369C.cpp │ ├── 1369D.cpp │ ├── 1369E.cpp │ ├── 136D.cpp │ ├── 136E.cpp │ ├── 1370A.cpp │ ├── 1370B.cpp │ ├── 1370C.cpp │ ├── 1370D.cpp │ ├── 1370E.cpp │ ├── 1370F1.cpp │ ├── 1370F2.cpp │ ├── 1371A.cpp │ ├── 1371B.cpp │ ├── 1371C.cpp │ ├── 1371D.cpp │ ├── 1371E1.cpp │ ├── 1371E2.cpp │ ├── 1372A.cpp │ ├── 1372B.cpp │ ├── 1372C.cpp │ ├── 1373A.cpp │ ├── 1373B.cpp │ ├── 1373C.cpp │ ├── 1373D.cpp │ ├── 1373E.cpp │ ├── 1373F.cpp │ ├── 1373G.cpp │ ├── 1374A.cpp │ ├── 1374B.cpp │ ├── 1374C.cpp │ ├── 1374D.cpp │ ├── 1374E1.cpp │ ├── 1374E2.cpp │ ├── 1374F.cpp │ ├── 1375A.cpp │ ├── 1375B.cpp │ ├── 1375C.cpp │ ├── 1375D.cpp │ ├── 1379A.cpp │ ├── 1379B.cpp │ ├── 1379C.cpp │ ├── 137E.cpp │ ├── 1381A1.cpp │ ├── 1381A2.cpp │ ├── 1381B.cpp │ ├── 1382A.cpp │ ├── 1382B.cpp │ ├── 1382C1.cpp │ ├── 1382C2.cpp │ ├── 1382D.cpp │ ├── 1384A.cpp │ ├── 1384B1.cpp │ ├── 1384B2.cpp │ ├── 1384C.cpp │ ├── 1384D.cpp │ ├── 1385C.cpp │ ├── 1388A.cpp │ ├── 1388B.cpp │ ├── 1388C.cpp │ ├── 1388D.cpp │ ├── 1389A.cpp │ ├── 1389B.cpp │ ├── 1389C.cpp │ ├── 1389D.cpp │ ├── 1396A.cpp │ ├── 1396B.cpp │ ├── 1396C.cpp │ ├── 1397A.cpp │ ├── 1397B.cpp │ ├── 1397C.cpp │ ├── 1397D.cpp │ ├── 1397E.cpp │ ├── 1398A.cpp │ ├── 1398B.cpp │ ├── 1398C.cpp │ ├── 1398D.cpp │ ├── 1398E.cpp │ ├── 1398F.cpp │ ├── 13E.cpp │ ├── 1400A.cpp │ ├── 1400B.cpp │ ├── 1400C.cpp │ ├── 1400D.cpp │ ├── 1400E.cpp │ ├── 1401A.cpp │ ├── 1401B.cpp │ ├── 1401C.cpp │ ├── 1401D.cpp │ ├── 1401E.cpp │ ├── 140C.cpp │ ├── 1418A.cpp │ ├── 1418C.cpp │ ├── 1419A.cpp │ ├── 1419B.cpp │ ├── 1419C.cpp │ ├── 1419D1.cpp │ ├── 1419D2.cpp │ ├── 1419E.cpp │ ├── 1423B.cpp │ ├── 1423J.cpp │ ├── 1423K.cpp │ ├── 142B.cpp │ ├── 143D.cpp │ ├── 145B.cpp │ ├── 145C.cpp │ ├── 145E.cpp │ ├── 146A.cpp │ ├── 146D.cpp │ ├── 146E.cpp │ ├── 148B.cpp │ ├── 148E.cpp │ ├── 149E.cpp │ ├── 14D.cpp │ ├── 154C.cpp │ ├── 155E.cpp │ ├── 156C.cpp │ ├── 156D.cpp │ ├── 157E.cpp │ ├── 158A.c │ ├── 158B.cpp │ ├── 161D.cpp │ ├── 16E.cpp │ ├── 17B.cpp │ ├── 180E.cpp │ ├── 181A.cpp │ ├── 182D.cpp │ ├── 191C.cpp │ ├── 192E.cpp │ ├── 194A.cpp │ ├── 1A.cpp │ ├── 1B.cpp │ ├── 200B.cpp │ ├── 203D.cpp │ ├── 208D.cpp │ ├── 208E.cpp │ ├── 215E.cpp │ ├── 216A.cpp │ ├── 217A.cpp │ ├── 220B.cpp │ ├── 220C.cpp │ ├── 221D.cpp │ ├── 221E.cpp │ ├── 225A.cpp │ ├── 229B.cpp │ ├── 230D.cpp │ ├── 231A.c │ ├── 231D.cpp │ ├── 234D.cpp │ ├── 236A.cpp │ ├── 237E.cpp │ ├── 242E.cpp │ ├── 244C.cpp │ ├── 246D.cpp │ ├── 246E.cpp │ ├── 251C.cpp │ ├── 252E.cpp │ ├── 258C.cpp │ ├── 258E.cpp │ ├── 259E.cpp │ ├── 263A.cpp │ ├── 264B.cpp │ ├── 264C.cpp │ ├── 265D.cpp │ ├── 265E.cpp │ ├── 268B.cpp │ ├── 269B.cpp │ ├── 269C.cpp │ ├── 270D.cpp │ ├── 270E.cpp │ ├── 271B.cpp │ ├── 271D.cpp │ ├── 272D.cpp │ ├── 273B.cpp │ ├── 274B.cpp │ ├── 275D.cpp │ ├── 276D.cpp │ ├── 279C.cpp │ ├── 27D.cpp │ ├── 280C.cpp │ ├── 281E.cpp │ ├── 282A.c │ ├── 282C.cpp │ ├── 282E.cpp │ ├── 283B.cpp │ ├── 286C.cpp │ ├── 287E.cpp │ ├── 292A.cpp │ ├── 292E.cpp │ ├── 293E.cpp │ ├── 294B.cpp │ ├── 295B.cpp │ ├── 295C.cpp │ ├── 296D.cpp │ ├── 296E.cpp │ ├── 297C.cpp │ ├── 298E.cpp │ ├── 2A.cpp │ ├── 301D.cpp │ ├── 311B.cpp │ ├── 312D.cpp │ ├── 314C.cpp │ ├── 315E.cpp │ ├── 319B.cpp │ ├── 319C.cpp │ ├── 320D.cpp │ ├── 320E.cpp │ ├── 321B.cpp │ ├── 321C.cpp │ ├── 322D.cpp │ ├── 327D.cpp │ ├── 329B.cpp │ ├── 32B.cpp │ ├── 330D.cpp │ ├── 333B.cpp │ ├── 334A.cpp │ ├── 334C.cpp │ ├── 334D.cpp │ ├── 337A.cpp │ ├── 337D.cpp │ ├── 339D.cpp │ ├── 340E.cpp │ ├── 342E.cpp │ ├── 343D.cpp │ ├── 346B.cpp │ ├── 346C.cpp │ ├── 347D.cpp │ ├── 347E.cpp │ ├── 348C.cpp │ ├── 349E.cpp │ ├── 353D.cpp │ ├── 356A.cpp │ ├── 357C.cpp │ ├── 359C.cpp │ ├── 359D.cpp │ ├── 363D.cpp │ ├── 365C.cpp │ ├── 369E.cpp │ ├── 371C.cpp │ ├── 373A.cpp │ ├── 375B.cpp │ ├── 375D.cpp │ ├── 377A.cpp │ ├── 378A.cpp │ ├── 379B.cpp │ ├── 379C.cpp │ ├── 380C.cpp │ ├── 381A.cpp │ ├── 381E.cpp │ ├── 383C.cpp │ ├── 384A.cpp │ ├── 385C.cpp │ ├── 388B.cpp │ ├── 389D.cpp │ ├── 38A.cpp │ ├── 397B.cpp │ ├── 3A.cpp │ ├── 400D.cpp │ ├── 400E.cpp │ ├── 401C.cpp │ ├── 405A.cpp │ ├── 405D.cpp │ ├── 406B.cpp │ ├── 407B.cpp │ ├── 408D.cpp │ ├── 414B.cpp │ ├── 414C.cpp │ ├── 415A.cpp │ ├── 415D.cpp │ ├── 429B.cpp │ ├── 430D.cpp │ ├── 431C.cpp │ ├── 432D.cpp │ ├── 433C.cpp │ ├── 437D.cpp │ ├── 439E.cpp │ ├── 440D.cpp │ ├── 441A.cpp │ ├── 442B.cpp │ ├── 443A.cpp │ ├── 443D.cpp │ ├── 444C.cpp │ ├── 445E.cpp │ ├── 446A.cpp │ ├── 446B.cpp │ ├── 446C.cpp │ ├── 447C.cpp │ ├── 447D.cpp │ ├── 447E.cpp │ ├── 448C.cpp │ ├── 448D.cpp │ ├── 448E.cpp │ ├── 449B.cpp │ ├── 449C.cpp │ ├── 450A.cpp │ ├── 450D.cpp │ ├── 450E.cpp │ ├── 451D.cpp │ ├── 453A.cpp │ ├── 454A.cpp │ ├── 454C.cpp │ ├── 455B.cpp │ ├── 455C.cpp │ ├── 455D.cpp │ ├── 456D.cpp │ ├── 459C.cpp │ ├── 459D.cpp │ ├── 459E.cpp │ ├── 460A.cpp │ ├── 463B.cpp │ ├── 463D.cpp │ ├── 465A.cpp │ ├── 466C.cpp │ ├── 469A.cpp │ ├── 471D.cpp │ ├── 474A.cpp │ ├── 474D.cpp │ ├── 476D.cpp │ ├── 478D.cpp │ ├── 479A.cpp │ ├── 479B.cpp │ ├── 479E.cpp │ ├── 480C.cpp │ ├── 482B.cpp │ ├── 483A.cpp │ ├── 483D.cpp │ ├── 484B.cpp │ ├── 485D.cpp │ ├── 486D.cpp │ ├── 487B.cpp │ ├── 487C.cpp │ ├── 488A.cpp │ ├── 488D.cpp │ ├── 488E.cpp │ ├── 489C.cpp │ ├── 489D.cpp │ ├── 489E.cpp │ ├── 493D.cpp │ ├── 494B.cpp │ ├── 495D.cpp │ ├── 496D.cpp │ ├── 498C.cpp │ ├── 499E.cpp │ ├── 49B.cpp │ ├── 4A.c │ ├── 4C.cpp │ ├── 507E.cpp │ ├── 508E.cpp │ ├── 50A.c │ ├── 510A.cpp │ ├── 510B.cpp │ ├── 514C.cpp │ ├── 519B.cpp │ ├── 533E.cpp │ ├── 534A.cpp │ ├── 543A.cpp │ ├── 544C.cpp │ ├── 553A.cpp │ ├── 554A.cpp │ ├── 570D.cpp │ ├── 58A.cpp │ ├── 591B.cpp │ ├── 595A.cpp │ ├── 597C.cpp │ ├── 598D.cpp │ ├── 599A.c │ ├── 59B.cpp │ ├── 600B.cpp │ ├── 600E.cpp │ ├── 61E.cpp │ ├── 622A.cpp │ ├── 628D.cpp │ ├── 631E.cpp │ ├── 632E.cpp │ ├── 652C.cpp │ ├── 659B.cpp │ ├── 660D.cpp │ ├── 660F.cpp │ ├── 665E.cpp │ ├── 66C.cpp │ ├── 676A.cpp │ ├── 677A.c │ ├── 677B.cpp │ ├── 689C.cpp │ ├── 689D.cpp │ ├── 69A.cpp │ ├── 69E.cpp │ ├── 705A.c │ ├── 707A.cpp │ ├── 716E.cpp │ ├── 71A.c │ ├── 725D.cpp │ ├── 733A.c │ ├── 744A.cpp │ ├── 747F.cpp │ ├── 748A.cpp │ ├── 758A.cpp │ ├── 761A.cpp │ ├── 762A.cpp │ ├── 766E.cpp │ ├── 768A.cpp │ ├── 772B.cpp │ ├── 776D.cpp │ ├── 776F.cpp │ ├── 778A.cpp │ ├── 77B.cpp │ ├── 782C.cpp │ ├── 785B.cpp │ ├── 785C.cpp │ ├── 785D.cpp │ ├── 78D.cpp │ ├── 794B.cpp │ ├── 796A.cpp │ ├── 797E.cpp │ ├── 798B.cpp │ ├── 799D.cpp │ ├── 801D.cpp │ ├── 805A.cpp │ ├── 808D.cpp │ ├── 80D.cpp │ ├── 812C.cpp │ ├── 816B.cpp │ ├── 817C.cpp │ ├── 817D.cpp │ ├── 818A.cpp │ ├── 855E.cpp │ ├── 862A.cpp │ ├── 862B.cpp │ ├── 863E.cpp │ ├── 868F.cpp │ ├── 869A.php │ ├── 869B.cpp │ ├── 86D.cpp │ ├── 873B.cpp │ ├── 875B.cpp │ ├── 876B.cpp │ ├── 876D.cpp │ ├── 877E.cpp │ ├── 87C.cpp │ ├── 883I.cpp │ ├── 888E.cpp │ ├── 88E.cpp │ ├── 890A.cpp │ ├── 891C.cpp │ ├── 892A.cpp │ ├── 892B.cpp │ ├── 892E.cpp │ ├── 893A.cpp │ ├── 893B.cpp │ ├── 893C.cpp │ ├── 893D.cpp │ ├── 894A.cpp │ ├── 894C.cpp │ ├── 895A.cpp │ ├── 895C.cpp │ ├── 897A.cpp │ ├── 897B.cpp │ ├── 8A.cpp │ ├── 907A.cpp │ ├── 908B.cpp │ ├── 910A.cpp │ ├── 910B.cpp │ ├── 910C.cpp │ ├── 912A.cpp │ ├── 912B.cpp │ ├── 913A.cpp │ ├── 913B.cpp │ ├── 913C.cpp │ ├── 914A.cpp │ ├── 914B.cpp │ ├── 914C.cpp │ ├── 915A.cpp │ ├── 915C.cpp │ ├── 918A.cpp │ ├── 918B.cpp │ ├── 918C.cpp │ ├── 918D.cpp │ ├── 919A.cpp │ ├── 919B.cpp │ ├── 919C.cpp │ ├── 919D.cpp │ ├── 91B.cpp │ ├── 920A.cpp │ ├── 920B.cpp │ ├── 920C.cpp │ ├── 922A.cpp │ ├── 922B.cpp │ ├── 922C.cpp │ ├── 92D.cpp │ ├── 931A.cpp │ ├── 931B.cpp │ ├── 931D.cpp │ ├── 932A.cpp │ ├── 932B.cpp │ ├── 932F.cpp │ ├── 934A.cpp │ ├── 934B.cpp │ ├── 934C.cpp │ ├── 935A.cpp │ ├── 935B.cpp │ ├── 935C.cpp │ ├── 937A.cpp │ ├── 937B.cpp │ ├── 937C.cpp │ ├── 937D.cpp │ ├── 938A.cpp │ ├── 938B.cpp │ ├── 938C.cpp │ ├── 938D.cpp │ ├── 939A.cpp │ ├── 939B.cpp │ ├── 939C.cpp │ ├── 939D.cpp │ ├── 946A.cpp │ ├── 946B.cpp │ ├── 946C.cpp │ ├── 950A.cpp │ ├── 950B.cpp │ ├── 950C.cpp │ ├── 954A.cpp │ ├── 954B.cpp │ ├── 954D.cpp │ ├── 955A.cpp │ ├── 955B.cpp │ ├── 955C.cpp │ ├── 959A.cpp │ ├── 959B.cpp │ ├── 959C.cpp │ ├── 95B.cpp │ ├── 95D.cpp │ ├── 960A.cpp │ ├── 960B.cpp │ ├── 961A.cpp │ ├── 961C.cpp │ ├── 961D.cpp │ ├── 962A.cpp │ ├── 962B.cpp │ ├── 962C.cpp │ ├── 964A.cpp │ ├── 964D.cpp │ ├── 965A.cpp │ ├── 965B.cpp │ ├── 965C.cpp │ ├── 965D.cpp │ ├── 967A.cpp │ ├── 967B.cpp │ ├── 967C.cpp │ ├── 96A.c │ ├── 975A.cpp │ ├── 975B.cpp │ ├── 975C.cpp │ ├── 977A.cpp │ ├── 977B.cpp │ ├── 977C.cpp │ ├── 977D.cpp │ ├── 977E.cpp │ ├── 977F.cpp │ ├── 978A.cpp │ ├── 978B.cpp │ ├── 978C.cpp │ ├── 978D.cpp │ ├── 978E.cpp │ ├── 978F.cpp │ ├── 978G.cpp │ ├── 979A.cpp │ ├── 979B.cpp │ ├── 979C.cpp │ ├── 979D.cpp │ ├── 980A.cpp │ ├── 980B.cpp │ ├── 981A.cpp │ ├── 981B.cpp │ ├── 981C.cpp │ ├── 981D.cpp │ ├── 982A.cpp │ ├── 982B.cpp │ ├── 982C.cpp │ ├── 982D.cpp │ ├── 984A.cpp │ ├── 984B.cpp │ ├── 987A.cpp │ ├── 987B.cpp │ ├── 987C.cpp │ ├── 987D.cpp │ ├── 988A.cpp │ ├── 988B.cpp │ ├── 988C.cpp │ ├── 988D.cpp │ ├── 989A.cpp │ ├── 989B.cpp │ ├── 989C.cpp │ ├── 990A.cpp │ ├── 990B.cpp │ ├── 990C.cpp │ ├── 990F.cpp │ ├── 992B.cpp │ ├── 998A.cpp │ ├── 998B.cpp │ ├── 998C.cpp │ ├── 999A.cpp │ ├── 999B.cpp │ ├── 999C.cpp │ ├── 999D.cpp │ └── 9D.cpp ├── LICENSE ├── LightOJ ├── 1000 - Greetings from LightOJ - 1109680.cpp ├── 1001 - Opposite Task - 1015250.c ├── 1002 - Country Roads - 1224184.cpp ├── 1003 - Drunk - 1285764.cpp ├── 1004 - Monkey Banana Problem - 1092400.cpp ├── 1005 - Rooks - 1092416.cpp ├── 1006 - Hex-a-bonacci - 1004324.cpp ├── 1007 - Mathematically Hard - 1365978.cpp ├── 1008 - Fibsieve`s Fantabulous Birthday - 989983.c ├── 1009 - Back to Underworld - 1050427.cpp ├── 1010 - Knights in Chessboard - 989999.c ├── 1011 - Marriage Ceremonies - 1092426.cpp ├── 1012 - Guilty Prince - 1355928.cpp ├── 1013 - Love Calculator - 1102991.cpp ├── 1015 - Brush (I) - 990023.c ├── 1016 - Brush (II) - 1254333.cpp ├── 1017 - Brush (III) - 1250149.cpp ├── 1018 - Brush (IV) - 1250826.cpp ├── 1019 - Brush (V) - 1238347.cpp ├── 1021 - Painful Bases - 1381065.cpp ├── 1022 - Circle in Square - 1015251.c ├── 1023 - Discovering Permutations - 1092432.cpp ├── 1024 - Eid - 1228251.java ├── 1025 - The Specials Menu - 1380895.cpp ├── 1026.cpp ├── 1027 - A Dangerous Maze - 1415689.cpp ├── 1028 - Trailing Zeroes (I) - 1015513.cpp ├── 1030 - Discovering Gold - 1416074.cpp ├── 1031 - Easy Game - 1417613.cpp ├── 1032 - Fast Bit Calculations - 1364418.cpp ├── 1033 - Generating Palindromes - 1381254.cpp ├── 1034 - Hit the Light Switches - 1102703.cpp ├── 1036 - A Refining Company - 1253804.cpp ├── 1037 - Agent 47 - 1468979.cpp ├── 1038 - Race to 1 Again - 1443451.cpp ├── 1039 - A Toy Company - 1356098.cpp ├── 1041 - Road Construction - 1241408.cpp ├── 1042 - Secret Origins - 1015502.cpp ├── 1043 - Triangle Partitioning - 1098980.cpp ├── 1044 - Palindrome Partitioning - 1469109.cpp ├── 1045 - Digits of Factorial - 1008949.cpp ├── 1046 - Rider - 1356323.cpp ├── 1047 - Neighbor House - 1469337.cpp ├── 1048 - Conquering Keokradong - 1102979.cpp ├── 1049 - One Way Roads - 1356845.cpp ├── 1050 - Marbles - 1469675.cpp ├── 1051 - Good or Bad - 1469734.cpp ├── 1053 - Higher Math - 990068.c ├── 1054 - Efficient Pseudo Code - 1254016.cpp ├── 1055 - Going Together - 1357028.cpp ├── 1056 - Olympics - 1066463.cpp ├── 1058 - Parallelogram Counting - 1277799.cpp ├── 1062 - Crossed Ladders - 1092446.cpp ├── 1065 - Number Sequence - 1453404.cpp ├── 1066 - Gathering Food - 1116517.cpp ├── 1068 - Investigation - 1364417.cpp ├── 1069 - Lift - 990075.c ├── 1072 - Calm Down - 990108.c ├── 1074 - Extended Traffic - 1223644.cpp ├── 1076 - Get the Containers - 1254381.cpp ├── 1080 - Binary Simulation - 1133802.cpp ├── 1082 - Array Queries - 1427287.cpp ├── 1083 - Histogram - 1158417.cpp ├── 1085 - All Possible Increasing Subsequences - 1159143.cpp ├── 1086 - Jogging Trails - 1259294.cpp ├── 1087 - Diablo - 1166619.cpp ├── 1088 - Points in Segments - 1353916.cpp ├── 1089 - Points in Segments (II) - 1166620.cpp ├── 1090 - Trailing Zeroes (II) - 1015514.cpp ├── 1093 - Ghajini - 1166624.cpp ├── 1094 - Farthest Nodes in a Tree - 1357107.cpp ├── 1095 - Arrange the Numbers - 1152962.cpp ├── 1096 - nth Term - 1338836.cpp ├── 1097 - Lucky Number - 1400649.cpp ├── 1098 - A New Function - 1403588.cpp ├── 1099 - Not the Best - 1238435.cpp ├── 1101 - A Secret Mission - 1396515.cpp ├── 1104 - Birthday Paradox - 1489571.cpp ├── 1107 - How Cow - 990129.c ├── 1108 - Instant View of Big Bang - 1224134.cpp ├── 1109 - False Ordering - 1014106.cpp ├── 1111 - Best Picnic Ever - 1357172.cpp ├── 1112 - Curious Robin Hood - 1158406.cpp ├── 1113 - Discover the Web - 1015490.cpp ├── 1114 - Easily Readable - 1191813.cpp ├── 1115 - Filling the Regions - 1118366.cpp ├── 1116 - Ekka Dokka - 990144.c ├── 1118 - Incredible Molecules - 1278578.cpp ├── 1120 - Rectangle Union - 1236098.cpp ├── 1122 - Digit Count - 1364416.cpp ├── 1127 - Funny Knapsack - 1497741.cpp ├── 1129 - Consistency Checker - 1191809.cpp ├── 1133 - Array Simulation - 1014400.cpp ├── 1136 - Division by 3 - 1015256.c ├── 1137 - Expanding Rods - 1066460.cpp ├── 1138 - Trailing Zeroes (III) - 1092438.cpp ├── 1140 - How Many Zeroes - 1252159.cpp ├── 1141 - Number Transformation - 1357286.cpp ├── 1146 - Closest Distance - 1343894.cpp ├── 1149 - Factors and Multiples - 1331797.cpp ├── 1150 - Ghosts! - 1348958.cpp ├── 1152 - Hiding Gold - 1346019.cpp ├── 1153 - Internet Bandwidth - 1331788.cpp ├── 1154 - Penguins - 1337898.cpp ├── 1155 - Power Transmission - 1332239.cpp ├── 1156 - Jumping Frogs - 1337458.cpp ├── 1158 - Anagram Division - 1489572.cpp ├── 1166 - Old Sorting - 1356406.cpp ├── 1171 - Knights in Chessboard (II).cpp ├── 1174 - Commandos - 1116781.cpp ├── 1175 - Jane and the Frost Giants - 1119658.cpp ├── 1176 - Getting a T-shirt - 1334657.cpp ├── 1177 - Angry Programmer - 1335220.cpp ├── 1178 - Trapezium - 1278721.cpp ├── 1182 - Parity - 1109708.cpp ├── 1183 - Computing Fast Average - 1166621.cpp ├── 1184 - Marriage Media - 1344802.cpp ├── 1185 - Escape - 1364496.cpp ├── 1186 - Incredible Chess - 1260674.cpp ├── 1187 - Lining up Students - 1191795.cpp ├── 1188 - Fast Queries - 1134650.cpp ├── 1189 - Sum of Factorials - 1109888.cpp ├── 1190 - Sleepwalking - 1331794.cpp ├── 1192 - Left Right - 1260682.cpp ├── 1198 - Karate Competition - 1255383.cpp ├── 1199 - Partitioning Game - 1274009.cpp ├── 1201 - A Perfect Murder - 1344567.cpp ├── 1202 - Bishops - 1003257.cpp ├── 1206 - Scheduling Taxi Cabs - 1351936.cpp ├── 1207 - Posters for Election - 1191798.cpp ├── 1209 - Strange Voting - 1350552.cpp ├── 1210 - Efficient Traffic System - 1396154.cpp ├── 1211 - Intersection of Cubes - 1003386.cpp ├── 1212 - Double Ended Queue - 1015491.cpp ├── 1214 - Large Division - 1014513.cpp ├── 1215 - Finding LCM - 1390585.cpp ├── 1216 - Juice in the Glass - 1003729.cpp ├── 1219 - Mafia - 1255461.cpp ├── 1221 - Travel Company - 1224175.cpp ├── 1224 - DNA Prefix - 1191818.cpp ├── 1225 - Palindromic Numbers (II) - 1015248.c ├── 1227 - Boiled Eggs - 1109817.cpp ├── 1231 - Coin Change (I) - 1092388.cpp ├── 1232 - Coin Change (II) - 1092392.cpp ├── 1233 - Coin Change (III) - 1092396.cpp ├── 1235 - Coin Change (IV) - 1497723.cpp ├── 1238 - Power Puff Girls - 1119117.cpp ├── 1241 - Pinocchio - 1015210.cpp ├── 1244 - Tiles - 1446112.cpp ├── 1247 - Matrix Game - 1260690.cpp ├── 1247 - Matrix Game - 1260691.cpp ├── 1249 - Chocolate Thief - 1015244.cpp ├── 1252 - Maintaining Communities - 1499653.cpp ├── 1253 - Misere Nim - 1260714.cpp ├── 1254 - Prison Break - 1240413.cpp ├── 1255 - Substring Frequency - 1181005.cpp ├── 1257 - Farthest Nodes in a Tree (II) - 1116729.cpp ├── 1258 - Making Huge Palindromes - 1405225.cpp ├── 1259 - Goldbach`s Conjecture - 1015515.cpp ├── 1261 - K-SAT Problem - 1005680.c ├── 1263 - Equalizing Money - 1364619.cpp ├── 1267 - Points in Rectangle (II) - 1518657.cpp ├── 1269 - Consecutive Sum - 1191815.cpp ├── 1271 - Better Tour - 1365380.cpp ├── 1278 - Sum of Consecutive Integers - 1015635.cpp ├── 1281 - New Traffic System - 1240834.cpp ├── 1289 - LCM from 1 to n - 1237056.cpp ├── 1291.cpp ├── 1292 - Laser Shot - 1331795.cpp ├── 1294 - Positive Negative Sign - 1015252.c ├── 1296 - Again Stone Game - 1274386.cpp ├── 1300.cpp ├── 1301 - Monitoring Processes - 1255563.cpp ├── 1303 - Ferris Wheel - 1104966.cpp ├── 1305 - Area of a Parallelogram - 1015253.c ├── 1307 - Counting Triangles - 1357800.cpp ├── 1311 - Unlucky Bird - 1109874.cpp ├── 1314 - Names for Babies - 1353823.cpp ├── 1325 - Distributing Chocolates - 1404101.cpp ├── 1328 - A Gift from the Setter - 1255671.cpp ├── 1331 - Agent J - 1015317.cpp ├── 1336 - Sigma Function - 1339393.cpp ├── 1338 - Hidden Secret! - 1016434.cpp ├── 1339 - Strongest Community - 1191800.cpp ├── 1347 - Aladdin and the Magical Lamp -Naive- 1354862.cpp ├── 1347 - Aladdin and the Magical Lamp -O(n) Suffix Array- 1490093.cpp ├── 1348 - Aladdin and the Return Journey - 1217376.cpp ├── 1353 - Paths in a Tree - 1489924.cpp ├── 1354 - IP Checking - 1015273.c ├── 1355 - Game of CS - 1279142.cpp ├── 1374 - Confusion in the Problemset - 1258257.cpp ├── 1379 - Toll Management - 1243232.cpp ├── 1385 - Kingdom Division - 1278883.cpp ├── 1387 - Setu - 1016454.cpp ├── 1389 - Scarecrow - 1258482.cpp ├── 1393 - Crazy Calendar - 1260823.cpp ├── 1396 - Palindromic Numbers (III) - 1258717.cpp ├── 1400 - Employment - 1343143.cpp ├── 1403 - Air Raid - 1347310.cpp ├── 1406 - Assassin`s Creed - 1430242.cpp ├── 1410 - Consistent Verdicts - 1339423.cpp ├── 1411 - Rip Van Winkle`s Code - 1231108.cpp ├── 1414 - February 29 - 1015963.cpp ├── 1423 - Olympic Swimming - 1193481.cpp ├── 1425 - The Monkey and the Oiled Bamboo - 1258738.cpp ├── 1427 - Substring Frequency (II) - 1352937.cpp ├── 1428 - Melody Comparison - 1355324.cpp └── 1433 - Minimum Arc Distance - 1015268.cpp ├── README.md ├── SPOJ ├── ACQUIRE.cpp ├── ACTIV.cpp ├── ADABRANC.cpp ├── ADACOINS.cpp ├── ADACYCLE.cpp ├── ADAFIELD.cpp ├── ADAGAME.cpp ├── ADAMATCH.cpp ├── ADAMOLD.cpp ├── ADAORANG.cpp ├── ADATRIP.cpp ├── AIBOHP.cpp ├── ALLIZWEL.cpp ├── ALTSEQ.cpp ├── APIO10A.cpp ├── APS.cpp ├── ASCDFIB.cpp ├── BALNUM.cpp ├── BAT1.cpp ├── BRDGHRD.cpp ├── BTCODE_G.cpp ├── CIRCLE_E.py ├── CIRCLE_H.py ├── CISTFILL.cpp ├── CMG.cpp ├── CNTPRIME.cpp ├── COT2.cpp ├── CVJETICI.cpp ├── DISUBSTR.cpp ├── DIV15.cpp ├── EIGHTS.cpp ├── EIUASSEMBLY.cpp ├── FASTFLOW.cpp ├── FIBOSUM.cpp ├── GIVEAWAY.cpp ├── GONE.cpp ├── GSS2.cpp ├── HOMEW.cpp ├── HORRIBLE.cpp ├── HUBULLU.cpp ├── INCARDS.cpp ├── INCSEQ.cpp ├── INVCNT.cpp ├── KDOMINO.cpp ├── KGSS.cpp ├── KOICOST.cpp ├── KQUERY2.cpp ├── KQUERYO.cpp ├── LCS.cpp ├── LCS0.cpp ├── LCS2.cpp ├── LGLOVE.cpp ├── LITE.cpp ├── LPIS.cpp ├── LUCIFER.cpp ├── MAIN111.cpp ├── MAIN112.cpp ├── MAXMATCH.cpp ├── MB1.cpp ├── MCHAOS.cpp ├── MCOINS.cpp ├── MENU.cpp ├── MIXTURES.cpp ├── MKTHNUM.cpp ├── MTOTALF.cpp ├── MUL.cpp ├── MULTQ3.cpp ├── NAKANJ.cpp ├── NFACTOR.cpp ├── NGM.cpp ├── NUMTSN.cpp ├── ORDERS.cpp ├── PARTIT.cpp ├── PKA.cpp ├── POLYMUL.cpp ├── PRIME1.cpp ├── PRMQUER.cpp ├── PT07X.cpp ├── RAONE.cpp ├── RATING.cpp ├── RENT.cpp ├── SAS001.cpp ├── SOCNETC.cpp ├── STPAR.cpp ├── STRMATCH.cpp ├── SUBXOR.cpp ├── SUMFOUR.cpp ├── SUMSUM.cpp ├── SYNC13C.cpp ├── TAXI.cpp ├── TDKPRIME.cpp ├── TEMPLEQ.cpp ├── TREEISO.cpp ├── TSUM.cpp ├── TWOKINGS.cpp └── VFMUL.cpp └── Templates ├── Aho Corasick.cpp ├── Articulation Point & Bridge.cpp ├── BIT point update and (point + range query).cpp ├── Baby-step Giant-step.cpp ├── Basis XOR.cpp ├── BigInteger.cpp ├── CHT (Convex Hull Trick).cpp ├── Centroid Decomposition.cpp ├── Chinese Remainder Theorem (CRT).cpp ├── Closest Pair of Points O(nlogn).cpp ├── Convex Hull (Monotone Chain).cpp ├── Custom Hash for Unordered_Map.cpp ├── DSU on TREE.cpp ├── Digit DP (memset per case).cpp ├── Digit DP (one time memset).cpp ├── Digit DP with bitmask.cpp ├── Dominator Tree.cpp ├── Double Hash.cpp ├── Dynamic CHT (Convex Hull Trick).cpp ├── Euler Totient from 1 to n.cpp ├── Euler Totient of N.cpp ├── Extended Euclid & Modular Inverse.cpp ├── Extra Notes.txt ├── FFT (Fast Fourier Transform).cpp ├── FWHT (Fast Walsh Hadamard Transforms).cpp ├── Fast IO.cpp ├── Find kth root.cpp ├── Gaussian Elimination.cpp ├── Geometry Basic Template.cpp ├── HLD (Heavy Light Decomposition).cpp ├── Half-Plane-Intersection.cpp ├── Initial Template.cpp ├── KMP.cpp ├── LR-Flow (Flow with [L,R] Capacity).cpp ├── Li Chao Tree.cpp ├── Line Segment Intersection Check.cpp ├── Longest Common Subsequence.cpp ├── Matrix Expo Optimized.cpp ├── Matrix Expo.cpp ├── Max Flow(Dinic's Algo).cpp ├── Maximum Bipartite Matching - Kuhn's Algorithm.cpp ├── Miller Rabin.cpp ├── Min Cost Max Flow.cpp ├── Minimum Enclosing Circle.cpp ├── Mo's Algorithm.cpp ├── Mo's On Tree.cpp ├── NTT (Number Theoretic Transform).cpp ├── Online FFT Trick.cpp ├── Order Statistics Tree.cpp ├── Palindromic Tree.cpp ├── Path Query with SEG tree (value in edges).cpp ├── Path Query with SEG tree (value in nodes).cpp ├── Persistent Segment Tree-Array Implementation.cpp ├── Persistent Segment Tree-Pointer Implementation.cpp ├── Persistent Trie.cpp ├── Pollard Rho.cpp ├── SOS (Sum of Subset) DP.cpp ├── SQUFOF.cpp ├── Suffix Array O(n).cpp ├── Suffix Array O(nlog^2n).cpp ├── Suffix Array O(nlogn).cpp ├── nCr time & space optimized.cpp ├── old_Aho Corasick.cpp └── old_HLD.cpp /Books/102_Combinatorial_Problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/risal-shefin/Competitive-Programming/861061baf74e781c90a90aafd39af1377208eeb4/Books/102_Combinatorial_Problems.pdf -------------------------------------------------------------------------------- /Books/104 Number Theory Problems.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/risal-shefin/Competitive-Programming/861061baf74e781c90a90aafd39af1377208eeb4/Books/104 Number Theory Problems.pdf -------------------------------------------------------------------------------- /Books/CP-Geometry.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/risal-shefin/Competitive-Programming/861061baf74e781c90a90aafd39af1377208eeb4/Books/CP-Geometry.pdf -------------------------------------------------------------------------------- /Books/Competitive Programming 3 (CP3).pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/risal-shefin/Competitive-Programming/861061baf74e781c90a90aafd39af1377208eeb4/Books/Competitive Programming 3 (CP3).pdf -------------------------------------------------------------------------------- /CodeForces/Gym/100247A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | struct node { 7 | ll a, b, c; 8 | } ara[200009]; 9 | 10 | ll ans[200009], tmp[3]; 11 | 12 | int main() 13 | 14 | { 15 | ll n; 16 | cin >> n; 17 | ll mxa = 0, mxb = 0, mxc = 0; 18 | for(ll i = 1; i <= n; i++) { 19 | scanf("%lld %lld %lld", &tmp[0], &tmp[1], &tmp[2]); 20 | sort(tmp, tmp + 3); 21 | ara[i].a = tmp[0], ara[i].b = tmp[1], ara[i].c = tmp[2]; 22 | mxa = max(mxa, ara[i].a); 23 | mxb = max(mxb, ara[i].b); 24 | mxc = max(mxc, ara[i].c); 25 | } 26 | 27 | ll indx = 0; 28 | for(ll i = 1; i <= n; i++) { 29 | if(ara[i].b >= mxa && ara[i].c >= mxb) 30 | ans[indx++] = i; 31 | } 32 | 33 | printf("%lld\n", indx); 34 | for(ll i = 0; i < indx; i++) { 35 | if(i != 0) 36 | printf(" "); 37 | printf("%lld", ans[i]); 38 | } 39 | 40 | cout << endl; 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100247G.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll n; 7 | scanf("%I64d", &n); 8 | ll sqt = sqrt(n); 9 | for(ll i = 1; i <= sqt; i++) { 10 | ll j = n - i * i; 11 | ll tmpsqt = sqrt(j); 12 | if(tmpsqt * tmpsqt == j) { 13 | printf("Yes\n"); 14 | return 0; 15 | } 16 | } 17 | printf("No\n"); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100247H.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int n; 6 | scanf("%d", &n); 7 | string s1, s2; 8 | cin >> s1 >> s2; 9 | bool checker = 0; 10 | long long int cnt = 0; 11 | for(int i = 0; i < n; i++) { 12 | if(s1[i] != s2[i]) { 13 | if(checker == 0) { 14 | cnt++; 15 | checker = 1; 16 | } 17 | } 18 | else { 19 | checker = 0; 20 | } 21 | } 22 | printf("%I64d\n", cnt); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100247J.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int n, ans = -1, k = -1, a, b; 6 | scanf("%d", &n); 7 | for(int i = 1; i <= n; i++) { 8 | scanf("%d %d", &a, &b); 9 | if(k < a && ans < b) 10 | ans = b; 11 | k = max(k, a); 12 | } 13 | printf("%d\n", ans); 14 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100712A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ios_base::sync_with_stdio(false); 10 | ll t; 11 | cin >> t; 12 | while(t--) { 13 | ll n, slv, tme, mx = -1, mn = 1e18; 14 | string s, ans; 15 | cin >> n; 16 | for(ll i = 1; i <= n; i++) { 17 | cin >> s >> slv >> tme; 18 | if(slv > mx) { 19 | mx = slv; 20 | mn = tme; 21 | ans = s; 22 | } 23 | else if(slv == mx && tme < mn) { 24 | mn = tme; 25 | ans = s; 26 | } 27 | } 28 | 29 | cout << ans << endl; 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100712E.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll ara[105]; 6 | 7 | int main() 8 | 9 | { 10 | ios_base::sync_with_stdio(false); 11 | ll t; 12 | cin >> t; 13 | while(t--) { 14 | ll n, mx = 0; 15 | cin >> n; 16 | for(ll i = 1; i <= n; i++) { 17 | cin >> ara[i]; 18 | mx = max(mx, ara[i]); 19 | } 20 | 21 | ll bon = 100 - mx; 22 | ll cnt = 0; 23 | for(ll i = 1; i <= n; i++) { 24 | if(ara[i] + bon >= 50) 25 | cnt++; 26 | } 27 | 28 | cout << cnt << endl; 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Gym/100712K.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll ara[100009]; 6 | 7 | int main() 8 | 9 | { 10 | ll t, n; 11 | cin >> t; 12 | while(t--) { 13 | ll n, k, in, mn = 1e18, pos; 14 | scanf("%lld %lld", &n, &k); 15 | 16 | for(ll i = 0; i < n; i++) { 17 | scanf("%lld", &ara[i]); 18 | } 19 | 20 | sort(ara, ara + n); 21 | for(ll i = 0; i < n; i++) { 22 | if(ara[i] == 0) 23 | continue; 24 | if(k % ara[i] == 0) { 25 | pos = lower_bound(ara, ara + n, k / ara[i]) - ara; 26 | if(ara[pos] == (k / ara[i]) && pos != i) { 27 | mn = min(mn, ara[i]); 28 | } 29 | } 30 | } 31 | 32 | if(mn == 1e18) 33 | printf("-1\n"); 34 | else 35 | printf("%lld %lld\n", mn, k / mn); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Gym/101840K.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | int main() 8 | 9 | { 10 | freopen("katryoshka.in", "r", stdin); 11 | ll t, caseno = 0; 12 | cin >> t; 13 | while(t--) { 14 | ll n, m, k; 15 | scanf("%lld %lld %lld", &n, &m, &k); 16 | ll mn = min(n, m); 17 | mn = min(mn, k); 18 | 19 | ll cnt = mn; 20 | n -= mn, m -= mn, k -= mn; 21 | ll tn = n / 2; 22 | mn = min(tn, k); 23 | cnt += mn; 24 | 25 | printf("Case %lld: %lld\n", ++caseno, cnt); 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Gym/101840L.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | freopen("lazy.in", "r", stdin); 10 | ll t, caseno = 0; 11 | cin >> t; 12 | while(t--) { 13 | ll n; 14 | scanf("%lld", &n); 15 | printf("Case %lld: %lld\n", ++caseno, n - 1); 16 | } 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1003A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, ara[105] = {}, ans = 0; 10 | cin >> n; 11 | for(ll i = 1; i <= n; i++) { 12 | ll in; 13 | scanf("%lld", &in); 14 | ara[in]++; 15 | ans = max(ans, ara[in]); 16 | } 17 | 18 | cout << ans << endl; 19 | return 0; 20 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1003C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[5009]; 7 | 8 | int main() 9 | 10 | { 11 | double ans = -1e18; 12 | ll n, k; 13 | scanf("%lld %lld", &n, &k); 14 | for(ll i = 1; i <= n; i++) 15 | scanf("%lld", &ara[i]); 16 | 17 | for(ll i = 1; i <= n; i++) { 18 | ll cnt = 0, sum = 0; 19 | for(ll j = i; j <= n; j++) { 20 | cnt++; 21 | sum += ara[j]; 22 | if(cnt >= k) { 23 | double tmp = (sum * 1.0) / cnt; 24 | ans = max(ans, tmp); 25 | } 26 | } 27 | } 28 | 29 | printf("%0.15f\n", ans); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1004A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[105]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, d; 12 | cin >> n >> d; 13 | 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &ara[i]); 16 | } 17 | 18 | map mark; 19 | ll cnt = 2; 20 | 21 | for(ll i = 1; i < n; i++) { 22 | ll p1 = ara[i] + d; 23 | ll p2 = ara[i + 1] - d; 24 | 25 | if(p2 == p1) { 26 | cnt++; 27 | } 28 | else if(p2 > p1) { 29 | cnt += 2; 30 | } 31 | } 32 | 33 | cout << cnt << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1004B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, m; 10 | cin >> n >> m; 11 | for(ll i = 1; i <= m; i++) { 12 | ll u, v; 13 | scanf("%lld %lld", &u, &v); 14 | } 15 | 16 | ll state = 1; 17 | for(ll i = 1; i <= n; i++) { 18 | printf("%lld", state); 19 | state ^= 1; 20 | } 21 | 22 | cout << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1005A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[1008]; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | vector ans; 14 | 15 | ara[0] = 0; 16 | 17 | for(ll i = 1; i <= n; i++) { 18 | scanf("%lld", &ara[i]); 19 | 20 | 21 | if(ara[i] - ara[i - 1] != 1) 22 | ans.push_back(ara[i - 1]); 23 | 24 | if(i == n) { 25 | ans.push_back(ara[i]); 26 | continue; 27 | } 28 | } 29 | 30 | cout << ans.size() << endl; 31 | for(ll i = 0; i < ans.size(); i++) { 32 | 33 | if(i != 0) 34 | printf(" "); 35 | printf("%lld", ans[i]); 36 | } 37 | 38 | cout << endl; 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1005B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | std::ios_base::sync_with_stdio(false); 10 | string s, t; 11 | 12 | cin >> s >> t; 13 | 14 | ll si = -1, ti = -1; 15 | for(ll i = s.length() - 1, j = t.length() - 1; i >= 0 && j >= 0; i--, j--) { 16 | if(s[i] != t[j]) { 17 | break; 18 | } 19 | 20 | si = i; 21 | ti = j; 22 | } 23 | 24 | if(si == -1) { 25 | cout << s.length() + t.length() << endl; 26 | return 0; 27 | } 28 | 29 | ll mv = si + ti; 30 | 31 | cout << mv << endl; 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1006D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | string a, b; 7 | 8 | int main() 9 | 10 | { 11 | std::ios_base::sync_with_stdio(false); 12 | ll n; 13 | cin >> n >> a >> b; 14 | for(ll i = 0, rev = n - 1; i < n; i++, rev--) { 15 | 16 | if(a[i] == b[i]) 17 | continue; 18 | if(a[rev] == b[rev]) 19 | continue; 20 | 21 | if(b[i] == b[rev]) { 22 | swap(a[i], b[i]); 23 | swap(a[i], a[rev]); 24 | } 25 | else { 26 | if(a[i] == b[rev] || a[rev] == b[i]) 27 | swap(a[i], a[rev]); 28 | } 29 | 30 | //cout << a << endl << b << endl; 31 | } 32 | 33 | ll ans = 0; 34 | for(ll i = 0; i < n; i++) 35 | if(a[i] != b[i]) 36 | ans++; 37 | 38 | cout << ans << endl; 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1008C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[100009]; 7 | 8 | int main() 9 | 10 | { 11 | multiset mul; 12 | multiset :: iterator it; 13 | ll n; 14 | cin >> n; 15 | for(ll i = 1; i <= n; i++) { 16 | scanf("%lld", &ara[i]); 17 | mul.insert( ara[i] ); 18 | } 19 | 20 | ll cnt = 0; 21 | for(ll i = 1; i <= n; i++) { 22 | it = mul.upper_bound( ara[i] ); 23 | 24 | if(it != mul.end()) { 25 | //cout << ara[i] << " " << *it << endl; 26 | cnt++; 27 | mul.erase(it); 28 | } 29 | } 30 | 31 | cout << cnt << endl; 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1009A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll c[10009], a[10009]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, m; 12 | cin >> n >> m; 13 | 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &c[i]); 16 | } 17 | 18 | for(ll i = 1; i <= m; i++) { 19 | scanf("%lld", &a[i]); 20 | } 21 | 22 | ll ii = 1, jj = 1; 23 | 24 | ll cnt = 0; 25 | while(ii <= n && jj <= m) { 26 | if(a[jj] >= c[ii]) { 27 | jj++; 28 | ii++; 29 | cnt++; 30 | } 31 | else 32 | ii++; 33 | } 34 | 35 | cout << cnt << endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1009B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll z[100009]; 6 | 7 | int main() 8 | 9 | { 10 | string s; 11 | std::ios_base::sync_with_stdio(false); 12 | 13 | cin >> s; 14 | 15 | ll flag1 = 0, flag2 = 0; 16 | 17 | for(ll i = 0; i < s.length(); i++) { 18 | if(s[i] == '1') 19 | flag1++; 20 | else if(s[i] == '2') 21 | flag2++; 22 | else 23 | z[ flag2 ]++; 24 | } 25 | 26 | for(ll i = 1; i <= z[0]; i++) 27 | cout << "0"; 28 | for(ll i = 1; i <= flag1; i++) 29 | cout << "1"; 30 | for(ll i = 1; i <= flag2; i++) { 31 | cout << "2"; 32 | for(ll j = 1; j <= z[ i ]; j++) 33 | cout << "0"; 34 | } 35 | cout << endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1009C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | 10 | ll n, m; 11 | cin >> n >> m; 12 | ll sum = 0; 13 | for(ll i = 1; i <= m; i++) { 14 | ll x, d; 15 | scanf("%lld %lld", &x, &d); 16 | 17 | ll m = n - 1; 18 | ll tmp = (m * (m + 1) ) / 2; 19 | ll tmp2 = d * tmp; 20 | if(d < 0 && n > 1) { 21 | ll half = n / 2; 22 | 23 | ll left = half; 24 | ll right = n - half - 1; 25 | 26 | left = (left * (left + 1)) / 2; 27 | right = (right * (right + 1)) / 2; 28 | 29 | tmp2 = left * d + right * d; 30 | } 31 | 32 | sum += (n * x) + tmp2; 33 | } 34 | 35 | printf("%0.15f\n", (sum * 1.0) / (n * 1.0)); 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1011E.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | vector ans; 6 | 7 | int main() 8 | 9 | { 10 | std::ios_base::sync_with_stdio(false); 11 | ll n, b, in; 12 | cin >> n >> b; 13 | ll gc = b; 14 | 15 | for(ll i = 1; i <= n; i++) { 16 | cin >> in; 17 | gc = __gcd(gc, in); 18 | } 19 | 20 | for(ll i = 0; i < b; i++) 21 | if(i % gc == 0) 22 | ans.push_back(i); 23 | 24 | cout << ans.size() << endl; 25 | for(ll i = 0; i < ans.size(); i++) 26 | cout << ans[i] << " "; 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1015A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | bool check[105]; 6 | 7 | int main() 8 | 9 | { 10 | ll n, m; 11 | cin >> n >> m; 12 | for(ll i = 1; i <= n; i++) { 13 | ll l, r; 14 | scanf("%lld %lld", &l, &r); 15 | for(ll j = l; j <= r; j++) { 16 | check[j] = 1; 17 | } 18 | } 19 | 20 | ll cnt = 0; 21 | for(ll i = 1; i <= m; i++) { 22 | if(!check[i]) 23 | cnt++; 24 | } 25 | 26 | cout << cnt << endl; 27 | for(ll i = 1; i <= m; i++) { 28 | if(!check[i]) 29 | printf("%lld ", i); 30 | } 31 | 32 | cout << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1017A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | struct node { 7 | ll id, sum; 8 | } ara[10009]; 9 | 10 | bool cmp(node a, node b) 11 | 12 | { 13 | if(a.sum != b.sum) 14 | return a.sum > b.sum; 15 | return a.id < b.id; 16 | } 17 | 18 | int main() 19 | 20 | { 21 | ll n; 22 | cin >> n; 23 | for(ll i = 1; i <= n; i++) { 24 | ll sum = 0; 25 | for(ll j = 1; j <= 4; j++) { 26 | ll in; 27 | scanf("%lld", &in); 28 | sum += in; 29 | } 30 | 31 | ara[i].id = i; 32 | ara[i].sum = sum; 33 | } 34 | 35 | sort(ara + 1, ara + n + 1, cmp); 36 | ll ans = 0; 37 | for(ll i = 1; i <= n; i++) { 38 | if(ara[i].id == 1) 39 | ans = i; 40 | } 41 | 42 | cout << ans << endl; 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1017C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n; 10 | cin >> n; 11 | if(n == 1) { 12 | cout << 1 << endl; 13 | return 0; 14 | } 15 | 16 | ll mark = 0, len = 1e9, id = n; 17 | for(ll i = 1; i <= n; i++) { 18 | ll tmp = n / i; 19 | if(n % i != 0) 20 | tmp++; 21 | if(tmp + i < len) { 22 | len = tmp + i; 23 | mark = i; 24 | } 25 | } 26 | 27 | while(1) { 28 | if(id < 0) 29 | break; 30 | 31 | ll start = max(1LL, id - mark + 1); 32 | 33 | for(ll i = start; i <= id; i++) 34 | printf("%lld ", i); 35 | 36 | id -= mark; 37 | } 38 | 39 | cout << endl; 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1029C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | struct Point { 7 | ll l, r; 8 | } ara[300009]; 9 | 10 | multiset lft, rgt; 11 | 12 | int main() 13 | 14 | { 15 | ll indx = 0; 16 | ll n; 17 | cin >> n; 18 | for(ll i = 0; i < n; i++) { 19 | scanf("%lld %lld", &ara[i].l, &ara[i].r); 20 | lft.insert(ara[i].l); 21 | rgt.insert(ara[i].r); 22 | } 23 | 24 | ll ans = 0; 25 | for(ll i = 0; i < n; i++) { 26 | lft.erase( lft.find( ara[i].l) ); 27 | rgt.erase( rgt.find(ara[i].r) ); 28 | 29 | ans = max(ans, *rgt.begin() - *(--lft.end() ) ); 30 | 31 | lft.insert( ara[i].l ); 32 | rgt.insert( ara[i].r ); 33 | } 34 | 35 | cout << ans << endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1041A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[10009]; 7 | 8 | int main() 9 | 10 | 11 | { 12 | ll n; 13 | cin >> n; 14 | for(ll i = 1; i <= n; i++) 15 | scanf("%lld", &ara[i]); 16 | 17 | sort(ara + 1, ara + n + 1); 18 | ll sum = 0; 19 | for(ll i = 2; i <= n; i++) { 20 | sum += (ara[i] - ara[i - 1] - 1); 21 | } 22 | 23 | cout << sum << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1084A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[105]; 7 | 8 | int main() 9 | 10 | { 11 | ll cst = 1e18; 12 | ll n; 13 | cin >> n; 14 | for(ll i = 1; i <= n; i++) 15 | cin >> ara[i];; 16 | 17 | for(ll i = 1; i <= n; i++) { 18 | ll x = i; 19 | 20 | ll sum = 0; 21 | for(ll i = 1; i <= n; i++) { 22 | ll tmp = abs(x - i) + abs(i - 1) + abs(x - 1); 23 | tmp *= 2; 24 | tmp *= ara[i]; 25 | 26 | sum += tmp; 27 | } 28 | 29 | cst = min(cst, sum); 30 | 31 | } 32 | 33 | cout << cst << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1084B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll vol[1009], n, mn = 1e18; 7 | 8 | ll fnd(ll s) 9 | 10 | { 11 | ll lo = 0, hi = mn, ret = -1; 12 | while(lo <= hi) { 13 | ll mid = (lo + hi) / 2; 14 | 15 | ll sm = 0; 16 | for(ll i = 1; i <= n; i++) { 17 | ll nibo = vol[i] - mid; 18 | sm += nibo; 19 | } 20 | 21 | if(sm < s) 22 | hi = mid - 1; 23 | else if(sm >= s) { 24 | ret = mid; 25 | lo = mid + 1; 26 | } 27 | } 28 | 29 | return ret; 30 | } 31 | 32 | int main() 33 | 34 | { 35 | ll s; 36 | cin >> n >> s; 37 | for(ll i = 1; i <= n; i++) { 38 | scanf("%lld", &vol[i]); 39 | mn = min(mn, vol[i]); 40 | } 41 | 42 | ll ans = fnd(s); 43 | 44 | cout << ans << endl; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1087A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | string s; 10 | cin >> s; 11 | ll len = s.length(); 12 | ll mid = len / 2; 13 | if(len % 2 == 0) 14 | mid--; 15 | 16 | string ans = ""; 17 | ll left = mid, right = mid + 1; 18 | bool state = 1; 19 | for(ll i = 1; i <= len; i++) { 20 | if(!state) { 21 | ans += s[right]; 22 | right++; 23 | } 24 | else { 25 | ans += s[left]; 26 | left--; 27 | } 28 | 29 | state ^= 1; 30 | } 31 | 32 | cout << ans << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1087B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k; 10 | cin >> n >> k; 11 | ll left, md; 12 | for(ll i = k - 1; i >= 1; i--) { 13 | if(n % i == 0) { 14 | left = n / i; 15 | md = i; 16 | break; 17 | } 18 | } 19 | 20 | 21 | ll x = k * left + md; 22 | 23 | cout << x << endl; 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1088A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll x; 10 | cin >> x; 11 | for(ll i = 1; i <= x; i++) { 12 | for(ll j = 1; j <= x; j++) { 13 | if(i % j == 0) { 14 | if(i * j > x && i < x * j) { 15 | cout << i << " " << j << endl; 16 | return 0; 17 | } 18 | } 19 | } 20 | } 21 | 22 | cout << -1 << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1088B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[100009]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, m; 12 | cin >> n >> m; 13 | for(ll i = 1; i <= n; i++) { 14 | scanf("%lld", &ara[i]); 15 | } 16 | 17 | sort(ara + 1, ara + n + 1); 18 | 19 | ll mn = 0; 20 | for(ll i = 1; i <= m; i++) { 21 | ll lo = 1, hi = n, num = 0; 22 | while(lo <= hi) { 23 | ll mid = (lo + hi) / 2; 24 | ll tmp = max(0LL, ara[mid] - mn); 25 | if(tmp != 0) { 26 | hi = mid - 1; 27 | num = ara[mid] - mn; 28 | } 29 | else 30 | lo = mid + 1; 31 | } 32 | 33 | printf("%lld\n", num); 34 | mn += num; 35 | } 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1088C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[2009]; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | 14 | for(ll i = 1; i <= n; i++) 15 | scanf("%lld", &ara[i]); 16 | 17 | ll mx; 18 | cout << n + 1 << endl; 19 | cout << 2 << " " << n << " " << 1 << endl; 20 | cout << 1 << " " << n << " " << 1000000 << endl; 21 | 22 | ll mod = 1000000 - 1; 23 | for(ll i = 1; i <= n - 1; i++) { 24 | printf("2 %lld %lld\n", i, mod); 25 | mod--; 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1088D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll big, a = 0, b = 0, q1, q2; 10 | cout << "? 0 0" << endl; 11 | cin >> big; 12 | for(ll i = 29; i >= 0; i--) { 13 | cout << "? " << (a ^ (1 << i)) << " " << b << endl; 14 | cin >> q1; 15 | cout << "? " << a << " " << (b ^ (1 << i)) << endl; 16 | cin >> q2; 17 | 18 | if(q1 == q2) { 19 | if(big == 1) 20 | a |= (1 << i); 21 | else if(big == -1) 22 | b |= (1 << i); 23 | 24 | big = q1; 25 | } 26 | else if(q1 == -1) { 27 | a |= (1 << i); 28 | b |= (1 << i); 29 | } 30 | } 31 | 32 | cout << "! " << a << " " << b << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1089F.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define pb push_back 6 | 7 | vector dv; 8 | 9 | int main() 10 | 11 | { 12 | ll n, nn; 13 | cin >> n; 14 | nn = n; 15 | 16 | for(ll i = 2; i * i <= n; i++) { 17 | if(n % i == 0) { 18 | dv.pb(i); 19 | while(n % i == 0) { 20 | n /= i; 21 | } 22 | } 23 | } 24 | 25 | if(n > 1) 26 | dv.pb(n); 27 | 28 | if(dv.size() == 1) { 29 | cout << "NO" << endl; 30 | return 0; 31 | } 32 | 33 | n = nn; 34 | 35 | ll p1 = dv[0], p2 = dv[ dv.size() - 1]; 36 | ll b = 1; 37 | while( (n - 1 - p2 * b) % p1 != 0) 38 | b++; 39 | 40 | ll a = (n - 1 - p2 * b) / p1; 41 | 42 | cout << "YES\n2" << endl; 43 | cout << a << " " << n / p1 << endl; 44 | cout << b << " " << n / p2 << endl; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1096C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | #define ll long long 7 | 8 | int main() 9 | 10 | { 11 | ll t; 12 | cin >> t; 13 | while(t--) { 14 | ll ang; 15 | scanf("%lld", &ang); 16 | 17 | ll n; 18 | for(n = 1; ; n++) { 19 | if( (n * ang) % 180 == 0) { 20 | if((n * ang) / 180 > n - 2) 21 | continue; 22 | 23 | break; 24 | } 25 | } 26 | printf("%lld\n", n); 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1097A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | string s, s1; 10 | cin >> s; 11 | bool chk = 0; 12 | for(ll i = 1; i <= 5; i++) { 13 | cin >> s1; 14 | if(s[0] == s1[0] || s[1] == s1[1]) 15 | chk = 1; 16 | } 17 | 18 | if(chk) 19 | cout << "YES" << endl; 20 | else 21 | cout << "NO" << endl; 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1097B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll deg[20], cs[20], n; 7 | 8 | ll solve(ll pos, ll val) 9 | 10 | { 11 | if(pos > n) { 12 | return val == 0; 13 | } 14 | 15 | ll nval = val + deg[pos]; 16 | ll rt = solve(pos + 1, (nval + 360) % 360); 17 | nval = val - deg[pos]; 18 | rt |= solve(pos + 1, (nval + 360) % 360); 19 | 20 | return rt; 21 | } 22 | 23 | int main() 24 | 25 | { 26 | cin >> n; 27 | for(ll i = 1; i <= n; i++) { 28 | cin >> deg[i]; 29 | } 30 | 31 | ll ans = solve(1, 0); 32 | 33 | if(ans) { 34 | cout << "YES" << endl; 35 | } 36 | else { 37 | cout << "NO" << endl; 38 | } 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1107A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | std::ios_base::sync_with_stdio(false); 10 | ll q; 11 | cin >> q; 12 | string s; 13 | while(q--) { 14 | ll k; 15 | cin >> k; 16 | cin >> s; 17 | 18 | if(k == 2) { 19 | if(s[0] >= s[1]) { 20 | cout << "NO" << endl; 21 | } 22 | else { 23 | cout << "YES" << endl; 24 | cout << 2 << endl; 25 | cout << s[0] << " " << s[1] << endl; 26 | } 27 | } 28 | else { 29 | cout << "YES" << endl; 30 | cout << 2 << endl; 31 | cout << s[0] << " "; 32 | for(ll i = 1; i < s.length(); i++) 33 | cout << s[i]; 34 | 35 | cout << endl; 36 | } 37 | 38 | } 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1113A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, v; 10 | cin >> n >> v; 11 | ll need = n - 1, cst = 0, ekhon = 0; 12 | for(ll i = 1; i <= n; i++) { 13 | if(i != 1) 14 | ekhon--; 15 | 16 | ll am = min(need, v - ekhon); 17 | //cout << am << " " << v << " " << ekhon << endl; 18 | cst += (am * i); 19 | need -= am; 20 | ekhon += am; 21 | } 22 | 23 | cout << cst << endl; 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1113C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define pb push_back 6 | 7 | ll odd[3000009], even[3000009]; 8 | 9 | ll ara[300009]; 10 | 11 | int main() 12 | 13 | { 14 | ll n; 15 | cin >> n; 16 | for(ll i = 1; i <= n; i++) { 17 | scanf("%lld", &ara[i]); 18 | } 19 | 20 | ll xr = 0, ans = 0; 21 | for(ll i = 1; i <= n; i++) { 22 | xr ^= ara[i]; 23 | if(i % 2 == 0) { 24 | ans += even[xr]; 25 | even[xr]++; 26 | //cout << i << " " << even[xr] - 1 << endl; 27 | if(xr == 0) 28 | ans++; 29 | } 30 | else { 31 | ans += odd[xr]; 32 | odd[xr]++; 33 | } 34 | 35 | } 36 | 37 | cout << ans << endl; 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1118A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll q; 10 | cin >> q; 11 | while(q--) { 12 | ll n, a, b; 13 | scanf("%lld %lld %lld", &n, &a, &b); 14 | 15 | if(2 * a <= b) { 16 | printf("%lld\n", n * a); 17 | } 18 | else { 19 | ll am = n / 2; 20 | ll cst = am * b;; 21 | if(n % 2 != 0) { 22 | cst += a; 23 | } 24 | 25 | printf("%lld\n", cst); 26 | } 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1118B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[200009], ev[200009], od[200009];; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n;; 13 | for(ll i = 1; i <= n; i++) { 14 | scanf("%lld", &ara[i]);;; 15 | } 16 | 17 | for(ll i = 1; i <= n; i++) { 18 | if(i % 2 == 0) { 19 | ev[i] = ara[i]; 20 | } 21 | else { 22 | od[i] = ara[i]; 23 | } 24 | } 25 | 26 | for(ll i = 1; i <= n; i++) { 27 | od[i] += od[i - 1]; 28 | ev[i] += ev[i - 1];; 29 | } 30 | 31 | ll cnt = 0; 32 | for(ll i = 1; i <= n; i++) { 33 | ll os = od[i - 1] + ev[n] - ev[i]; 34 | ll es = ev[i - 1] + od[n] - od[i]; 35 | 36 | if(os == es) 37 | cnt++; 38 | } 39 | 40 | 41 | cout << cnt << endl; 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1118E.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll m[200009], w[200009]; 6 | 7 | int main() 8 | 9 | { 10 | ll n, k, indx = 0; 11 | cin >> n >> k; 12 | 13 | for(ll i = 1; i <= k; i++) { 14 | for(ll j = i + 1; j <= k; j++) { 15 | if(i == j) 16 | continue; 17 | 18 | m[indx] = i; 19 | w[indx++] = j; 20 | 21 | m[indx] = j; 22 | w[indx++] = i; 23 | 24 | // cout << i << " " << j << endl; 25 | // cout << indx << endl; 26 | 27 | if(indx >= n) 28 | break; 29 | } 30 | 31 | if(indx >= n) 32 | break; 33 | } 34 | 35 | if(indx < n) { 36 | cout << "NO" << endl; 37 | } 38 | else { 39 | cout << "YES" << endl; 40 | for(ll i = 0; i < n; i++) { 41 | printf("%lld %lld\n", m[i], w[i]); 42 | } 43 | } 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/111B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | vector dv[100009]; 6 | 7 | ll ase[100009]; 8 | 9 | int main() 10 | 11 | { 12 | 13 | for(ll i = 1; i <= 100005; i++) { 14 | for(ll j = i; j <= 100005; j += i) 15 | dv[j].push_back(i); 16 | } 17 | 18 | ll n; 19 | cin >> n; 20 | for(ll i = 1; i <= n; i++) { 21 | ll x, y; 22 | scanf("%lld %lld", &x, &y); 23 | 24 | ll ans = 0; 25 | for(ll j = 0; j < dv[x].size(); j++) { 26 | ll l = i - y, r = i - 1; 27 | if(!(ase[dv[x][j]] >= l && ase[dv[x][j]] <= r) ) 28 | ans++; 29 | ase[dv[x][j]] = i; 30 | } 31 | 32 | if(y == 0) { 33 | printf("%lld\n", (ll)(dv[x].size())); 34 | 35 | continue; 36 | } 37 | else { 38 | printf("%lld\n", ans); 39 | } 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/112A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, i; 7 | char s1[110], s2[110]; 8 | scanf("%s", s1); 9 | scanf("%s", s2); 10 | 11 | for(i = 0; s1[i] != '\0'; i++) { 12 | if(s1[i] >= 'A' && s1[i] <= 'Z') { 13 | s1[i] = s1[i] + 32; 14 | } 15 | 16 | if(s2[i] >= 'A' && s2[i] <= 'Z') { 17 | s2[i] = s2[i] + 32; 18 | } 19 | 20 | if(s1[i] > s2[i]) { 21 | printf("1\n"); 22 | return 0; 23 | } 24 | 25 | else if(s1[i] < s2[i]) { 26 | printf("-1\n"); 27 | return 0; 28 | } 29 | } 30 | 31 | 32 | printf("0\n"); 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/112D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | vector dv[100009]; 6 | 7 | ll ase[100009]; 8 | 9 | int main() 10 | 11 | { 12 | 13 | for(ll i = 1; i <= 100005; i++) { 14 | for(ll j = i; j <= 100005; j += i) 15 | dv[j].push_back(i); 16 | } 17 | 18 | ll n; 19 | cin >> n; 20 | for(ll i = 1; i <= n; i++) { 21 | ll x, y; 22 | scanf("%lld %lld", &x, &y); 23 | 24 | ll ans = 0; 25 | for(ll j = 0; j < dv[x].size(); j++) { 26 | ll l = i - y, r = i - 1; 27 | if(!(ase[dv[x][j]] >= l && ase[dv[x][j]] <= r) ) 28 | ans++; 29 | ase[dv[x][j]] = i; 30 | } 31 | 32 | if(y == 0) { 33 | printf("%lld\n", (ll)(dv[x].size())); 34 | 35 | continue; 36 | } 37 | else { 38 | printf("%lld\n", ans); 39 | } 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1133A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll h1, m1, h2, m2; 10 | scanf("%lld:%lld", &h1, &m1); 11 | scanf("%lld:%lld", &h2, &m2); 12 | ll t1 = h1 * 60 + m1; 13 | ll t2 = h2 * 60 + m2; 14 | 15 | ll dif = t2 - t1; 16 | ll mid = dif / 2; 17 | 18 | ll ansh = h1 + (mid / 60); 19 | mid %= 60; 20 | ll ansm = m1 + mid; 21 | if(ansm >= 60) { 22 | ansh++; 23 | ansm %= 60; 24 | } 25 | 26 | if(ansh < 10) 27 | cout << "0"; 28 | cout << ansh << ":"; 29 | if(ansm < 10) 30 | cout << "0"; 31 | cout << ansm << endl; 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1133B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[200009], cnt[120]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, k; 12 | cin >> n >> k; 13 | for(ll i = 1; i <= n; i++) { 14 | scanf("%lld", &ara[i]); 15 | ara[i] %= k; 16 | 17 | cnt[ ara[i] ]++; 18 | } 19 | 20 | ll ans = 0; 21 | for(ll i = 0; i < k; i++) { 22 | ll lagbe = k - i; 23 | if(i == 0) 24 | lagbe = 0; 25 | ll tmp = min(cnt[i], cnt[lagbe]); 26 | if(i == lagbe) 27 | tmp /= 2; 28 | 29 | cnt[lagbe] -= tmp; 30 | cnt[i] -= tmp; 31 | 32 | ans += (2 * tmp); 33 | 34 | //cout << i << " " << tmp << endl; 35 | } 36 | 37 | cout << ans << endl; 38 | 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1133C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[200009]; 7 | 8 | ll solve(ll pos, ll n) 9 | 10 | { 11 | ll lo = pos, hi = n, rt = pos; 12 | while(lo <= hi) { 13 | ll mid = (lo + hi) / 2; 14 | if(ara[mid] > ara[pos] + 5) { 15 | hi = mid - 1; 16 | } 17 | else { 18 | lo = mid + 1; 19 | rt = mid; 20 | } 21 | } 22 | 23 | return rt; 24 | } 25 | 26 | int main() 27 | 28 | { 29 | ll n; 30 | cin >> n; 31 | for(ll i = 1; i <= n; i++) 32 | scanf("%lld", &ara[i]); 33 | 34 | sort(ara + 1, ara + n + 1); 35 | 36 | ll ans = 0; 37 | for(ll i = 1; i <= n; i++) { 38 | ll tmp = solve(i, n) - i + 1; 39 | //cout << i << " " << tmp << endl; 40 | ans = max(ans, tmp); 41 | } 42 | 43 | cout << ans << endl; 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1133D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll n, a[200009], b[200009]; 7 | 8 | map cnt; 9 | 10 | int main() 11 | 12 | { 13 | cin >> n; 14 | for(ll i = 1; i <= n; i++) 15 | scanf("%lld", &a[i]); 16 | for(ll i = 1; i <= n; i++) 17 | scanf("%lld", &b[i]); 18 | 19 | int zero = 0; 20 | for(ll i = 1; i <= n; i++) { 21 | if(a[i] == 0) { 22 | if(b[i] == 0) 23 | zero++; 24 | continue; 25 | } 26 | long double d = -b[i] / (a[i] * 1.0); 27 | cnt[d]++; 28 | } 29 | 30 | int mx = zero; 31 | for(auto it = cnt.begin(); it != cnt.end(); it++) { 32 | mx = max(mx, zero + (it -> second)); 33 | } 34 | 35 | cout << mx << endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1136A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define pii pair 6 | 7 | vector vv; 8 | 9 | int main() 10 | 11 | { 12 | ll n; 13 | cin >> n; 14 | for(ll i = 1; i <= n; i++) { 15 | ll u, v; 16 | scanf("%lld %lld", &u, &v); 17 | vv.push_back( make_pair(u, v)); 18 | } 19 | 20 | ll cnt = n; 21 | ll un; 22 | cin >> un; 23 | for(ll i = 0; i < vv.size(); i++) { 24 | if(vv[i].first <= un && un <= vv[i].second) 25 | break; 26 | 27 | //cout << vv[i].first << " " << un << endl; 28 | 29 | cnt--; 30 | } 31 | 32 | cout << cnt << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1136B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k; 10 | cin >> n >> k; 11 | ll lo = 1, hi = n; 12 | 13 | ll ld = k - lo, rd = hi - k, sum; 14 | if(ld <= rd) { 15 | sum = 2 * (ld + 1); 16 | 17 | sum += (2 * ld); 18 | 19 | sum += rd; 20 | sum += (2 * rd); 21 | sum ++; 22 | } 23 | else { 24 | sum = 2 * (rd + 1); 25 | 26 | sum += (2 * rd); 27 | 28 | sum += ld; 29 | sum += (2 * ld); 30 | sum ++; 31 | } 32 | 33 | cout << sum << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1136D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | vector g[300009]; 7 | ll ara[300009]; 8 | set st[300009]; 9 | 10 | int main() 11 | 12 | { 13 | ll n, e, lst; 14 | cin >> n >> e; 15 | for(ll i = 1; i <= n; i++) { 16 | scanf("%lld", &ara[i]); 17 | } 18 | 19 | for(ll i = 1; i <= e; i++) { 20 | ll u, v; 21 | scanf("%lld %lld", &u, &v); 22 | g[v].push_back(u); 23 | } 24 | 25 | ll p = 0, ans = 0; 26 | for(ll i = n; i >= 1; i--) { 27 | ll now = ara[i]; 28 | 29 | if(st[now].size() == p && i != n) 30 | ans++; 31 | else { 32 | for(ll j = 0; j < g[now].size(); j++) 33 | st[g[now][j]].insert(now); 34 | 35 | p++; 36 | } 37 | } 38 | 39 | cout << ans << endl; 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1152A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll a[100009], b[100009]; 7 | ll c0 = 0, c1 = 0; 8 | 9 | int main() 10 | 11 | { 12 | ll n, m; 13 | cin >> n >> m; 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &a[i]); 16 | a[i] %= 2; 17 | if(a[i] == 1) 18 | c1++; 19 | else 20 | c0++; 21 | } 22 | 23 | ll ans = 0; 24 | for(ll i = 1; i <= m; i++) { 25 | scanf("%lld", &b[i]); 26 | b[i] %= 2; 27 | 28 | if(b[i] == 1) { 29 | if(c0 > 0) { 30 | c0--; 31 | ans++; 32 | } 33 | } 34 | else { 35 | if(c1 > 0) { 36 | c1--; 37 | ans++; 38 | } 39 | } 40 | } 41 | 42 | cout << ans << endl; 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1181A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 60) 6 | 7 | int main() 8 | 9 | { 10 | ll x, y, z; 11 | cin >> x >> y >> z; 12 | 13 | if(x % z == 0 || y % z == 0) { 14 | ll tot = x / z + y / z; 15 | cout << tot << " " << 0 << endl; 16 | } 17 | else { 18 | ll rem1 = x % z, rem2 = y % z; 19 | ll need1 = z - rem1, need2 = z - rem2; 20 | ll transfer = inf, tot = x / z + y / z; 21 | 22 | if(need1 <= rem2) { 23 | transfer = min(transfer, need1); 24 | tot = x / z + y / z + 1; 25 | } 26 | if(need2 <= rem1) { 27 | transfer = min(transfer, need2); 28 | tot = x / z + y / z + 1; 29 | } 30 | 31 | cout << tot << " " << (transfer==inf? 0:transfer) << endl; 32 | } 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/118A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | char s1[110], s2[210]; 7 | int i, j; 8 | scanf("%s", s1); 9 | for(i = 0, j = 0; s1[i] != '\0'; i++) { 10 | if(s1[i] >= 'A' && s1[i] <= 'Z') { 11 | s1[i] = s1[i] + 32; 12 | } 13 | 14 | if(s1[i] == 'a' || s1[i] == 'e' || s1[i] == 'y' || s1[i] == 'i' || s1[i] == 'o' || s1[i] == 'u') { 15 | continue; 16 | } 17 | 18 | s2[j] = '.'; 19 | j++; 20 | s2[j] = s1[i]; 21 | j++; 22 | } 23 | 24 | s2[j] = '\0'; 25 | printf("%s\n", s2); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/121A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | vector lucky; 6 | 7 | void gen(ll num) 8 | 9 | { 10 | if(num > 44444444444) 11 | return; 12 | 13 | if(num > 0) 14 | lucky.push_back(num); 15 | 16 | gen(num * 10 + 4); 17 | gen(num * 10 + 7); 18 | } 19 | 20 | int main() 21 | 22 | { 23 | 24 | gen(0); 25 | sort(lucky.begin(), lucky.end()); 26 | 27 | ll l, r; 28 | cin >> l >> r; 29 | 30 | ll prv = l, ans = 0; 31 | for(ll i = 0; i < lucky.size(); i++) { 32 | if(lucky[i] < prv) 33 | continue; 34 | 35 | if(lucky[i] >= r) { 36 | ans += (r - prv + 1) * lucky[i]; 37 | break; 38 | } 39 | 40 | ans += (lucky[i] - prv + 1) * lucky[i]; 41 | prv = lucky[i] + 1; 42 | } 43 | 44 | cout << ans << endl; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1228A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | bitset <10> chk; 7 | 8 | int main() 9 | 10 | { 11 | ll l, r; 12 | cin >> l >> r; 13 | for(ll i = l; i <= r; i++) { 14 | ll n = i; 15 | chk.reset(); 16 | bool ch = 0; 17 | while(n) { 18 | ll rem = n % 10; 19 | if(chk[rem]) { 20 | ch = 1; 21 | break; 22 | } 23 | 24 | n /= 10; 25 | chk[rem] = 1; 26 | } 27 | 28 | if(!ch) { 29 | cout << i << endl; 30 | return 0; 31 | } 32 | } 33 | 34 | cout << -1 << endl; 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/122C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | vector lucky; 6 | 7 | void gen(ll num) 8 | 9 | { 10 | if(num > 44444444444) 11 | return; 12 | 13 | if(num > 0) 14 | lucky.push_back(num); 15 | 16 | gen(num * 10 + 4); 17 | gen(num * 10 + 7); 18 | } 19 | 20 | int main() 21 | 22 | { 23 | 24 | gen(0); 25 | sort(lucky.begin(), lucky.end()); 26 | 27 | ll l, r; 28 | cin >> l >> r; 29 | 30 | ll prv = l, ans = 0; 31 | for(ll i = 0; i < lucky.size(); i++) { 32 | if(lucky[i] < prv) 33 | continue; 34 | 35 | if(lucky[i] >= r) { 36 | ans += (r - prv + 1) * lucky[i]; 37 | break; 38 | } 39 | 40 | ans += (lucky[i] - prv + 1) * lucky[i]; 41 | prv = lucky[i] + 1; 42 | } 43 | 44 | cout << ans << endl; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1255A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define pb push_back 6 | #define pll pair 7 | #define inf (1LL << 60) 8 | 9 | int main() 10 | 11 | { 12 | ll t; 13 | cin >> t; 14 | while(t--) { 15 | ll a, b; 16 | scanf("%lld %lld", &a, &b); 17 | if(a > b) 18 | swap(a, b); 19 | 20 | ll diff = b - a, ans = 0; 21 | ll lagbe = diff / 5; 22 | ans += lagbe; 23 | 24 | a = a + lagbe * 5; 25 | diff = b - a; 26 | lagbe = diff / 2; 27 | ans += lagbe; 28 | 29 | a = a + lagbe * 2; 30 | 31 | diff = b - a; 32 | ans += diff; 33 | 34 | printf("%lld\n", ans); 35 | } 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1255E1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[1000009], cs[1000009], n, ans = 1e18; 7 | 8 | ll solve(ll k) 9 | 10 | { 11 | ll cost = 0; 12 | for(ll i = 1; i < n; i++) { 13 | ll dec = cs[i] % k; 14 | ll inc = k - dec; 15 | cost += min(dec, inc); 16 | } 17 | 18 | return cost; 19 | } 20 | 21 | int main() 22 | 23 | { 24 | cin >> n; 25 | for(ll i = 1; i <= n; i++) { 26 | scanf("%lld", &ara[i]); 27 | cs[i] = cs[i - 1] + ara[i]; 28 | } 29 | 30 | if(cs[n] == 1) { 31 | cout << -1 << endl; 32 | return 0; 33 | } 34 | 35 | for(ll i = 2; i * i <= cs[n]; i++) { 36 | if(cs[n] % i == 0) { 37 | while(cs[n] % i == 0) 38 | cs[n] /= i; 39 | 40 | ans = min(ans, solve(i)); 41 | } 42 | } 43 | if(cs[n] > 1) 44 | ans = min(ans, solve(cs[n])); 45 | 46 | cout << ans << endl; 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1255E2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[1000009], cs[1000009], n, ans = 1e18; 7 | 8 | ll solve(ll k) 9 | 10 | { 11 | ll cost = 0; 12 | for(ll i = 1; i < n; i++) { 13 | ll dec = cs[i] % k; 14 | ll inc = k - dec; 15 | cost += min(dec, inc); 16 | } 17 | 18 | return cost; 19 | } 20 | 21 | int main() 22 | 23 | { 24 | cin >> n; 25 | for(ll i = 1; i <= n; i++) { 26 | scanf("%lld", &ara[i]); 27 | cs[i] = cs[i - 1] + ara[i]; 28 | } 29 | 30 | if(cs[n] == 1) { 31 | cout << -1 << endl; 32 | return 0; 33 | } 34 | 35 | for(ll i = 2; i * i <= cs[n]; i++) { 36 | if(cs[n] % i == 0) { 37 | while(cs[n] % i == 0) 38 | cs[n] /= i; 39 | 40 | ans = min(ans, solve(i)); 41 | } 42 | } 43 | if(cs[n] > 1) 44 | ans = min(ans, solve(cs[n])); 45 | 46 | cout << ans << endl; 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1262A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | #define mp make_pair 7 | #define pb push_back 8 | #define pll pair 9 | 10 | int main() 11 | 12 | { 13 | ll t; 14 | cin >> t; 15 | while(t--) { 16 | ll n; 17 | scanf("%lld", &n); 18 | 19 | ll mn = inf, mx = 0; 20 | for(ll i = 1; i <= n; i++) { 21 | ll a, b; 22 | scanf("%lld %lld", &a, &b); 23 | 24 | mn = min(mn, b); 25 | mx = max(mx, a); 26 | } 27 | 28 | printf("%lld\n", max(0LL, (mx - mn))); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/129A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[109], cs[109]; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &ara[i]); 16 | cs[i] += (ara[i] + cs[i - 1]); 17 | } 18 | 19 | ll ans = 0; 20 | for(ll i = 1; i <= n; i++) { 21 | if( (cs[n] - ara[i]) % 2 == 0) 22 | ans++; 23 | } 24 | 25 | cout << ans << endl; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/131C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll comb(ll n, ll r) 7 | 8 | { 9 | if(n < r) return 0; 10 | ll ans = 1; 11 | r = min(r, n - r); 12 | for(ll i = 1; i <= r; i++) { 13 | ans = (ans * (n - i + 1) ) / i; 14 | } 15 | 16 | return ans; 17 | } 18 | 19 | int main() 20 | 21 | { 22 | ll n, m, t, ans = 0; 23 | cin >> n >> m >> t; 24 | 25 | for(ll i = 4; i < t; i++) { 26 | ll girl = t - i; 27 | ans += comb(n, i) * comb(m, girl); 28 | } 29 | 30 | cout << ans << endl; 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/146A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | string s; 10 | ll n; 11 | cin >> n >> s; 12 | ll f = 0, l = 0; 13 | for(ll i = 0; i < n; i++) { 14 | if(s[i] != '4' && s[i] != '7') { 15 | cout << "NO" << endl; 16 | return 0; 17 | } 18 | if(i < n / 2) 19 | f += (s[i] - '0'); 20 | else 21 | l += (s[i] - '0'); 22 | } 23 | 24 | if(f == l) 25 | cout << "YES" << endl; 26 | else 27 | cout << "NO" << endl; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/148B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll vp, vd, t, f, c; 10 | cin >> vp >> vd >> t >> f >> c; 11 | double girld = vp * t * 1.0; 12 | double drag= 0.0; 13 | ll cnt = 0; 14 | if(vd <= vp) { 15 | printf("0\n"); 16 | return 0; 17 | } 18 | 19 | while(1) { 20 | if(girld >= c) { 21 | printf("%lld\n", cnt); 22 | break; 23 | } 24 | 25 | double t = (girld * 1.0) / (vd - vp); 26 | double sd = t * vd; 27 | girld = sd; 28 | if(sd < c) { 29 | cnt++; 30 | double tot = t + f; 31 | girld += (tot * vp); 32 | } 33 | else { 34 | printf("%lld\n", cnt); 35 | break; 36 | } 37 | } 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/158A.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | 4 | { 5 | int n, k, i, count = 0; 6 | int a[100]; 7 | scanf("%d %d", &n, &k); 8 | for(i = 0; i < n; i++) { 9 | scanf("%d", &a[i]); 10 | if(a[i] > 0) { 11 | if(i < k) { 12 | count++; 13 | } 14 | 15 | if(i >= k && a[k - 1] == a[i]) { 16 | count++; 17 | } 18 | } 19 | } 20 | 21 | printf("%d\n", count); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/194A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, k; 8 | cin >> n >> k; 9 | int tmp = k / n; 10 | if(tmp == 2) { 11 | int ans = n - k % n; 12 | cout << ans << endl; 13 | } 14 | else 15 | cout << 0 << endl; 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/1A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | long long n, m, a, c1, c2; 8 | cin >> n >> m >> a; 9 | c1 = ceil((double)n / (double)a); 10 | c2 = ceil((double)m / (double)a); 11 | c1 = c1 * c2; 12 | cout << c1 << endl; 13 | 14 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/200B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int n, sum = 0, in; 6 | scanf("%d", &n); 7 | for(int i = 1; i <= n; i++) { 8 | scanf("%d", &in); 9 | sum += in; 10 | } 11 | printf("%f\n", (double)( (sum * 1.0) / (n * 1.0) ) ); 12 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/216A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int a, b, c; 6 | cin >> a >> b >> c; 7 | cout << ( a * b * c - (a - 1) * (b - 1) * (c - 1) ) << endl; 8 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/217A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct node { 5 | int x; 6 | int y; 7 | } snow[109]; 8 | 9 | bool visit[109]; 10 | int n; 11 | 12 | void dfs(int indx) 13 | 14 | { 15 | if(visit[indx] == 1) return; 16 | visit[indx] = 1; 17 | 18 | for(int i = 0; i < n; i++) { 19 | if( (snow[i].x == snow[indx].x) || (snow[i].y == snow[indx].y) ) 20 | dfs(i); 21 | } 22 | } 23 | 24 | int main() 25 | 26 | { 27 | cin >> n; 28 | for(int i = 0; i < n; i++) { 29 | scanf("%d %d", &snow[i].x, &snow[i].y); 30 | } 31 | 32 | int cnt = 0; 33 | for(int i = 0; i < n; i++) { 34 | if(visit[i] == 1) 35 | continue; 36 | cnt++; 37 | dfs(i); 38 | } 39 | cnt--; 40 | 41 | cout << cnt << endl; 42 | return 0; 43 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/225A.cpp: -------------------------------------------------------------------------------- 1 | try -------------------------------------------------------------------------------- /CodeForces/Solutions/231A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, p, v, t, i, count = 0; 7 | scanf("%d", &n); 8 | 9 | for(i = 1; i <= n; i++) { 10 | scanf("%d %d %d", &p, &v, &t); 11 | if((p == 1 && v == 1) || (p == 1 && t == 1) || (v == 1 && t == 1)) { 12 | count++; 13 | } 14 | } 15 | 16 | printf("%d\n", count); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/236A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | string s; 10 | cin >> s; 11 | set st; 12 | for(int i = 0; i < s.length(); i++) { 13 | st.insert(s[i]); 14 | } 15 | 16 | if(st.size() % 2 == 0) { 17 | cout << "CHAT WITH HER!" << endl; 18 | } 19 | else { 20 | cout << "IGNORE HIM!" << endl; 21 | } 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/263A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll row, col, in; 10 | for(ll i = 1; i <= 5; i++) { 11 | for(ll j = 1; j <= 5; j++) { 12 | scanf("%lld", &in); 13 | if(in == 1) { 14 | row = i; 15 | col = j; 16 | } 17 | } 18 | } 19 | 20 | ll mov = abs(row - 3); 21 | mov += abs(col - 3); 22 | 23 | cout << mov << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/268B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int n; 5 | scanf("%d", &n); 6 | int ans = (n * (n + 1)) / 2; 7 | for(int i = n - 2, j = 1; i >= 1; i--, j++) ans += i * j; 8 | printf("%d\n", ans); 9 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/282A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, i, x = 0; 7 | char s[5]; 8 | scanf("%d", &n); 9 | 10 | for(i = 1; i <= n; i++) { 11 | scanf("%s", s); 12 | if(s[0] == '+' || s[2] == '+') 13 | x++; 14 | else if(s[0] == '-' || s[2] == '-') 15 | x--; 16 | } 17 | 18 | printf("%d\n", x); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/282C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ios::sync_with_stdio(false); 10 | string s1, s2; 11 | cin >> s1 >> s2; 12 | if(s1.length() != s2.length()) { 13 | cout << "NO" << endl; 14 | return 0; 15 | } 16 | 17 | if(s1.length() == 1) { 18 | if(s1 != s2) { 19 | cout << "NO" << endl; 20 | } 21 | else 22 | cout << "YES" << endl; 23 | 24 | return 0; 25 | } 26 | 27 | bool state1 = 0, state2 = 0; 28 | for(ll i = 0; i < s1.length(); i++) { 29 | if(s1[i] == '1') 30 | state1 = 1; 31 | if(s2[i] == '1') 32 | state2 = 1; 33 | } 34 | 35 | if(state1 == state2) 36 | cout << "YES" << endl; 37 | else 38 | cout << "NO" << endl; 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/292A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | struct node { 7 | ll t; 8 | ll num; 9 | } ara[1009]; 10 | 11 | int main() 12 | 13 | { 14 | ll n; 15 | cin >> n; 16 | for(ll i = 1; i <= n; i++) 17 | scanf("%lld %lld", &ara[i].t, &ara[i].num); 18 | 19 | if(n == 1) { 20 | printf("%lld %lld\n", ara[1].t + ara[1].num, ara[1].num); 21 | return 0; 22 | } 23 | 24 | ll mx = 0, tot = 0, prt = 0; 25 | for(ll i = 1; i <= n; i++) { 26 | 27 | ll tmp = min(tot, ara[i].t - prt); 28 | tot -= tmp; 29 | 30 | prt = ara[i].t; 31 | tot += ara[i].num; 32 | mx = max(mx, tot); 33 | if(i == 1) 34 | continue; 35 | } 36 | 37 | printf("%lld %lld\n", ara[n].t + tot, mx); 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/2A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | vector < pair > round; 8 | map m; 9 | map :: iterator it; 10 | int n; 11 | cin >> n; 12 | 13 | for(int i = 1; i <= n; i++) { 14 | pair tmp; 15 | cin >> tmp.first >> tmp.second; 16 | round.push_back(tmp); 17 | m[tmp.first] += tmp.second; 18 | } 19 | 20 | int mx = INT_MIN; 21 | for(it = m.begin(); it != m.end(); it++) { 22 | mx = max(it -> second, mx); 23 | } 24 | 25 | 26 | map m2; 27 | for(int i = 0; i < n; i++) { 28 | m2[round[i].first] += round[i].second; 29 | 30 | if(m2[round[i].first] >= mx && m[round[i].first] >= mx) { 31 | cout << round[i].first << endl; 32 | return 0; 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/32B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | std::ios_base::sync_with_stdio(false); 10 | string s; 11 | cin >> s; 12 | 13 | ll start = 0; 14 | for(ll i = 0; i < s.length(); i++) { 15 | if(s[i] == '.') { 16 | if(start == i) { 17 | cout << 0; 18 | start = i + 1; 19 | continue; 20 | } 21 | else { 22 | cout << 1; 23 | start = i + 1; 24 | continue; 25 | } 26 | } 27 | else { 28 | if(start == i) 29 | continue; 30 | 31 | cout << 2; 32 | start = i + 1; 33 | continue; 34 | } 35 | } 36 | 37 | cout << endl; 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/334A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define pb push_back 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | ll tot = n * n; 13 | vector v[n + 5]; 14 | 15 | ll id = 1, pls = 1; 16 | for(ll i = 1; i <= tot; i++) { 17 | v[id].pb(i); 18 | id += pls; 19 | if(id > n) { 20 | pls = -1; 21 | id = n; 22 | } 23 | if(id == 0) { 24 | pls = 1; 25 | id = 1; 26 | } 27 | } 28 | 29 | for(int i = 1; i <= n; i++) { 30 | for(int j = 0; j < v[n].size(); j++) { 31 | printf("%lld", v[i][j]); 32 | if(j != v[i].size() - 1) 33 | printf(" "); 34 | } 35 | printf("\n"); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/334C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll coin[40]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, ans = 1; 12 | cin >> n; 13 | 14 | ll pw = 3; 15 | coin[0] = 1; 16 | for(ll i = 1; ; i++) { 17 | coin[i] = coin[i - 1] * pw; 18 | if(coin[i] > n) 19 | break; 20 | } 21 | 22 | for(ll i = 1; ; i++) { 23 | if(coin[i] > n) 24 | break; 25 | if(n % coin[i] == 0) 26 | continue; 27 | 28 | ans = (n / coin[i] + 1); 29 | break; 30 | } 31 | 32 | printf("%lld\n", ans); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/373A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll cnt[15] = {}; 10 | ll k, in; 11 | cin >> k; 12 | for(ll i = 1; i <= 16; i++) { 13 | char ch; 14 | scanf(" %c", &ch); 15 | if(ch == '.') 16 | continue; 17 | else 18 | in = ch - '0'; 19 | cnt[in]++; 20 | } 21 | 22 | for(ll i = 1; i <= 9; i++) { 23 | if(cnt[i] > 2 * k) { 24 | //cout << cnt[i] << " " << i << endl; 25 | cout << "NO" << endl; 26 | return 0; 27 | } 28 | } 29 | cout << "YES" << endl; 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/378A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll a, b; 10 | cin >> a >> b; 11 | ll ca = 0, cb = 0, cc = 0; 12 | for(ll i = 1; i <= 6; i++) { 13 | if(abs(a-i) < abs(b-i)) 14 | ca++; 15 | else if(abs(a-i) == abs(b - i)) 16 | cb++; 17 | else 18 | cc++; 19 | } 20 | 21 | cout << ca << " " << cb << " " << cc << endl; 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/379B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | cin >> n; 9 | int ara[n + 5]; 10 | for(int i = 0; i < n; i++) 11 | cin >> ara[i]; 12 | 13 | for(int i = 0; i < n; i++) { 14 | 15 | if(i < n - 1) { 16 | 17 | if(ara[i] >= 1) { 18 | printf("P"); 19 | ara[i]--; 20 | } 21 | while(ara[i] > 0) { 22 | printf("RLP"); 23 | ara[i]--; 24 | } 25 | 26 | printf("R"); 27 | } 28 | 29 | else { 30 | if(ara[i] >= 1) { 31 | printf("P"); 32 | ara[i]--; 33 | } 34 | while(ara[i] > 0) { 35 | printf("LRP"); 36 | ara[i]--; 37 | } 38 | } 39 | 40 | } 41 | printf("\n"); 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/381A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | deque card; 8 | int sareja = 0, dima = 0; 9 | int n; 10 | cin >> n; 11 | while(n--) { 12 | int in; 13 | cin >> in; 14 | card.push_back(in); 15 | } 16 | 17 | bool state = 0; 18 | while(!card.empty()) { 19 | int tmp; 20 | if(card.front() > card.back()) { 21 | tmp = card.front(); 22 | card.pop_front(); 23 | } 24 | else { 25 | tmp = card.back(); 26 | card.pop_back(); 27 | } 28 | 29 | if(state == 0) { 30 | state = 1; 31 | sareja += tmp; 32 | } 33 | else { 34 | state = 0; 35 | dima += tmp; 36 | } 37 | 38 | } 39 | 40 | cout << sareja << " " << dima << endl; 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/38A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | ll d[n + 5]; 13 | for(ll i = 2; i <= n; i++) 14 | cin >> d[i]; 15 | ll a, b; 16 | cin >> a >> b; 17 | 18 | ll ans = 0; 19 | for(ll i = a + 1; i <= b; i++) { 20 | ans += d[i]; 21 | } 22 | 23 | cout << ans << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/397B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll t; 10 | cin >> t; 11 | while(t--) { 12 | ll n, l, r; 13 | scanf("%lld %lld %lld", &n, &l, &r); 14 | 15 | ll lo = 1, hi = 1e9; 16 | bool check = 0; 17 | while(lo <= hi) { 18 | ll mid = (lo + hi) / 2; 19 | double avg = n / (mid * 1.0); 20 | //cout << avg << " " << mid << endl; 21 | if(avg < (double)l) 22 | hi = mid - 1; 23 | else if(avg > (double)r) 24 | lo = mid + 1; 25 | else { 26 | check = 1; 27 | break; 28 | } 29 | 30 | } 31 | 32 | if(check) 33 | printf("Yes\n"); 34 | else 35 | printf("No\n"); 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/415A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[105]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, m; 12 | cin >> n >> m; 13 | for(ll i = 1; i <= m; i++) { 14 | ll inp; 15 | scanf("%lld", &inp); 16 | for(ll j = inp; j <= n; j++) { 17 | if(ara[j] != 0) 18 | break; 19 | ara[j] = inp; 20 | } 21 | } 22 | 23 | for(ll i = 1; i <= n; i++) { 24 | if(i != 1) 25 | printf(" "); 26 | printf("%lld", ara[i]); 27 | } 28 | 29 | cout << endl; 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/441A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll mark[55]; 6 | vector ans; 7 | 8 | int main() 9 | 10 | { 11 | ll n, v; 12 | cin >> n >> v; 13 | for(ll i = 1; i <= n; i++) { 14 | ll m; 15 | scanf("%lld", &m); 16 | for(ll j = 1; j <= m; j++) { 17 | ll inp; 18 | scanf("%lld", &inp); 19 | if(v > inp && mark[i] != 1) { 20 | ans.push_back(i); 21 | mark[i] = 1; 22 | } 23 | } 24 | } 25 | 26 | cout << ans.size() << endl; 27 | for(ll i: ans) 28 | cout << i << " "; 29 | 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/443A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | char ara[1009]; 10 | gets(ara); 11 | set st; 12 | for(int i = 0; ara[i] != '\0'; i++) { 13 | if(ara[i] >= 'a' && ara[i] <= 'z') { 14 | st.insert(ara[i]); 15 | } 16 | } 17 | 18 | cout << st.size() << endl; 19 | return 0; 20 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/450A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n, m; 11 | cin >> n >> m; 12 | ll ara[n + 5], ans, last; 13 | for(ll i = 1; i <= n; i++) 14 | scanf("%lld", &ara[i]); 15 | 16 | while(1) { 17 | bool test = 1; 18 | for(ll i = 1; i <= n; i++) { 19 | if(ara[i] != 0) { 20 | test = 0; 21 | last = i; 22 | } 23 | 24 | if(m >= ara[i]) { 25 | ara[i] = 0; 26 | } 27 | else { 28 | ara[i] -= m; 29 | } 30 | } 31 | if(test) 32 | break; 33 | } 34 | 35 | cout << last << endl; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/476D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k, mx = 0; 10 | cin >> n >> k; 11 | 12 | cout << k * (6 * (n - 1) + 5) << endl; 13 | for(ll i = 1; i <= n; i++) { 14 | 15 | for(ll j = 1; j <= 4; j++) { 16 | if(j != 1) 17 | printf(" "); 18 | if(j != 4) 19 | printf("%lld", k * (6 * (i - 1) + j) ); 20 | else 21 | printf("%lld", k * (6 * (i - 1) + 5) ); 22 | 23 | } 24 | printf("\n"); 25 | 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/485D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int ara[200009], mark[1000009]; 5 | 6 | int main() 7 | 8 | { 9 | int m, n = 0; 10 | cin >> m; 11 | for(int i = 0; i < m; i++) { 12 | int in; 13 | scanf("%d", &in); 14 | if(!mark[in]) { 15 | ara[n++] = in; 16 | mark[in] = 1; 17 | } 18 | } 19 | 20 | int mx = 0, pos = 0; 21 | sort(ara, ara + n); 22 | for(int i = 0; i < n; i++) { 23 | pos = i; 24 | for(int j = ara[i] * 2; pos < n; j += ara[i]) { 25 | pos = lower_bound(ara + pos, ara + n, j) - ara; 26 | 27 | mx = max(mx, ara[pos - 1] % ara[i]); 28 | } 29 | } 30 | 31 | printf("%d\n", mx); 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/488A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll a; 10 | cin >> a; 11 | 12 | for(ll i = a + 1; i <= a + 1000; i++) { 13 | bool check = 0; 14 | ll num = abs(i); 15 | while(num) { 16 | ll rem = num % 10; 17 | if(rem == 8) { 18 | check = 1; 19 | break; 20 | } 21 | num /= 10; 22 | } 23 | if(check) { 24 | cout << (i - a) << endl; 25 | return 0; 26 | } 27 | } 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/4A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int w; 7 | scanf("%d", &w); 8 | 9 | if(w % 2 != 0 || w == 2) { 10 | printf("NO\n"); 11 | return 0; 12 | } 13 | 14 | printf("YES\n"); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/4C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | map m; 9 | string s; 10 | scanf("%d", &n); 11 | for(int i = 1; i <= n; i++) { 12 | cin >> s; 13 | if(m[s] == 0) { 14 | printf("OK\n"); 15 | } 16 | else { 17 | cout << s; 18 | cout << m[s] << endl; 19 | } 20 | m[s]++; 21 | } 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/50A.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | 4 | { 5 | int M, N, row1, col1, row2, col2; 6 | int xtr1 = 0, xtr2 = 0, dm1, dm2; 7 | scanf("%d %d", &M, &N); 8 | 9 | col1 = M; 10 | row1 = N / 2; 11 | if(N % 2 != 0) { 12 | xtr1 = M / 2; 13 | } 14 | dm1 = row1 * col1 + xtr1; 15 | 16 | col2 = M / 2; 17 | row2 = N; 18 | if(M % 2 != 0) { 19 | xtr2 = N / 2; 20 | } 21 | dm2 = row2 * col2 + xtr2; 22 | 23 | if(dm1 >= dm2) { 24 | printf("%d\n", dm1); 25 | } 26 | 27 | else { 28 | printf("%d\n", dm2); 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/553A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define mod 1000000007 6 | 7 | ll comb[1005][1005], ara[1005]; 8 | 9 | int main() 10 | 11 | { 12 | for(ll i = 0; i < 1005; i++) { 13 | 14 | comb[i][0] = comb[i][i] = 1; 15 | for(ll j = 1; j <= i / 2; j++) { 16 | comb[i][j] = comb[i][i - j] = (comb[i - 1][j] % mod + comb[i - 1][j - 1] % mod) % mod; 17 | } 18 | } 19 | 20 | ll n, total = 0; 21 | cin >> n; 22 | for(ll i = 0; i < n; i++) { 23 | cin >> ara[i]; 24 | total += ara[i]; 25 | } 26 | 27 | ll ans = 1; 28 | for(ll i = n -1; i >= 1; i--) { 29 | ans = (ans % mod * ( comb[total - 1][ ara[i] - 1] % mod) ) % mod; 30 | total -= ara[i]; 31 | } 32 | 33 | cout << ans << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/554A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | string s; 10 | cin >> s; 11 | 12 | ll ans = 0; 13 | for(ll i = 0; i < s.length(); i++) { 14 | ans += 25; 15 | } 16 | ans += 26; 17 | 18 | cout << ans << endl; 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/595A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n, m, cnt = 0; 11 | cin >> n >> m; 12 | for(ll i = 1; i <= n; i++) { 13 | for(ll j = 1; j <= m; j++) { 14 | ll a, b; 15 | scanf("%lld %lld", &a, &b); 16 | if( !(a == 0 && b == 0) ) { 17 | cnt++; 18 | } 19 | } 20 | } 21 | 22 | cout << cnt << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/599A.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | 4 | { 5 | int d1, d2, d3, d; 6 | scanf("%d %d %d", &d1, &d2, &d3); 7 | if((d1 + d3) < d2) { 8 | d = d1 + d3 + d3 + d1; 9 | printf("%d\n", d); 10 | return 0; 11 | } 12 | 13 | else if((d2 + d3) < d1) { 14 | d = d2 + d3 + d3 +d2; 15 | printf("%d\n", d); 16 | return 0; 17 | } 18 | 19 | d = d1; 20 | if((d + d2 + d2) < (d3 + d2)) { 21 | d += d + d2 + d2; 22 | } 23 | else { 24 | d += d3 + d2; 25 | } 26 | printf("%d\n", d); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/59B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll odd[105], even[105], oid = 1, eid = 1; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | for(ll i = 1; i <= n; i++) { 14 | ll in; 15 | cin >> in; 16 | if(in & 1) 17 | odd[oid++] = in; 18 | else 19 | even[eid++] = in; 20 | } 21 | 22 | sort(odd + 1, odd + oid); 23 | sort(even + 1, even + eid); 24 | 25 | ll sum = 0; 26 | for(ll i = oid - 1; i >= 1; i--) 27 | sum += odd[i]; 28 | 29 | if( (oid - 1) % 2 == 0) 30 | sum -= odd[1]; 31 | 32 | for(ll i = 1; i < eid; i++) 33 | sum += even[i]; 34 | 35 | if(sum & 1) 36 | cout << sum << endl; 37 | else 38 | cout << "0" << endl; 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/600B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int a, b; 8 | cin >> a >> b; 9 | int ara1[a + 5], ara2[b + 5]; 10 | 11 | for(int i = 0; i < a; i++) 12 | scanf("%d", &ara1[i]); 13 | 14 | sort(ara1, ara1 + a); 15 | 16 | for(int j = 0; j < b; j++) { 17 | scanf("%d", &ara2[j]); 18 | printf("%d", upper_bound(ara1, ara1 + a, ara2[j]) - ara1); 19 | 20 | if(j != b - 1) 21 | printf(" "); 22 | else 23 | printf("\n"); 24 | } 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/677A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, h, i, row = 0; 7 | scanf("%d %d", &n, &h); 8 | 9 | int ara[n]; 10 | for(i = 0; i < n; i++) { 11 | scanf("%d", &ara[i]); 12 | if(ara[i] > h) row += 2; 13 | else row++; 14 | } 15 | 16 | printf("%d\n", row); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/677B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, h, k; 10 | 11 | cin >> n >> h >> k; 12 | ll cur = 0, time = 0; 13 | for(int i = 1 ; i <= n; i++) { 14 | ll p; 15 | scanf("%I64d", &p); 16 | 17 | if(cur + p > h) { 18 | cur = 0; 19 | time++; 20 | } 21 | cur += p; 22 | time += cur / k; 23 | cur = cur % k; 24 | } 25 | 26 | if(cur > 0) 27 | time++; 28 | cout << time << endl; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/689C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll m, ans = -1; 10 | cin >> m; 11 | ll lo = 1, hi = 1e18; 12 | while(lo <= hi) { 13 | ll mid = (lo + hi) / 2; 14 | 15 | ll cnt = 0; 16 | for(ll i = 2; ; i++) { 17 | if(mid / (i * i * i) == 0) 18 | break; 19 | 20 | cnt += ( mid / (i * i * i) ); 21 | } 22 | 23 | if(cnt == m) { 24 | ans = mid; 25 | hi = mid - 1; 26 | } 27 | else if(cnt < m) 28 | lo = mid + 1; 29 | else if(cnt > m) 30 | hi = mid - 1; 31 | } 32 | 33 | cout << ans << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/69A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll x = 0, y = 0, z = 0, n; 10 | cin >> n; 11 | for(int i = 1; i <= n; i++) { 12 | ll a, b, c; 13 | cin >> a >> b >> c; 14 | x += a; 15 | y += b; 16 | z += c; 17 | } 18 | 19 | if(x == 0 && y == 0 && z == 0) 20 | cout << "YES" << endl; 21 | else 22 | cout << "NO" << endl; 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/705A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, i; 7 | scanf("%d", &n); 8 | 9 | for(i = 1; i <= n; i++) { 10 | if(i > 1) { 11 | printf(" that "); 12 | } 13 | 14 | if(i & 1) { 15 | printf("I hate"); 16 | } 17 | else { 18 | printf("I love"); 19 | } 20 | } 21 | 22 | printf(" it\n"); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/707A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n, m; 11 | cin >> n >> m; 12 | char ch; 13 | bool test = 0; 14 | 15 | for(int i = 1; i <= n; i++) { 16 | for(int j = 1; j <= m; j++) { 17 | scanf(" %c", &ch); 18 | if( ! (ch == 'W' || ch == 'B' || ch == 'G') ) { 19 | test = 1; 20 | } 21 | } 22 | } 23 | 24 | if(test) { 25 | cout << "#Color" << endl; 26 | } 27 | else { 28 | cout << "#Black&White" << endl; 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/71A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int n, i, j, count; 7 | char s[110]; 8 | scanf("%d", &n); 9 | 10 | for(i = 1; i <= n; i++) { 11 | scanf("%s", s); 12 | count = 0; 13 | for(j = 0 ; s[j] != '\0'; j++) { 14 | count++; 15 | } 16 | 17 | if(count <= 10) { 18 | printf("%s\n", s); 19 | } 20 | 21 | else { 22 | printf("%c%d%c\n", s[0], count - 2, s[count - 1]); 23 | } 24 | } 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/733A.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | 4 | { 5 | char s[110]; 6 | int count = 0, count1 = 0, i; 7 | scanf("%s", s); 8 | for(i = 0; s[i] != '\0'; i++) { 9 | if(s[i] == 'A' || s[i] == 'E' || s[i] == 'I' || s[i] == 'O' || s[i] == 'U' || s[i] == 'Y') { 10 | if(count1 > 0) { 11 | if(count1 > count) { 12 | count = count1; 13 | } 14 | count1 = 0; 15 | } 16 | 17 | count1++; 18 | //printf("%d\t%c\t", count1, s[i]); 19 | } 20 | 21 | else { 22 | if(i == 0) count1++; 23 | count1++; 24 | //printf("%d\t%c\t", count1, s[i]); 25 | } 26 | 27 | } 28 | 29 | if(count1 > count) count = count1; 30 | printf("%d\n", count); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/748A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, m, k; 8 | cin >> n >> m >> k; 9 | int tmp = m * 2; 10 | 11 | int ln = 0; 12 | if(k % tmp != 0) { 13 | ln = k / tmp + 1; 14 | } 15 | 16 | else { 17 | ln = k / tmp; 18 | } 19 | 20 | int rem; 21 | int tmp2 = (ln - 1) * tmp; 22 | if(tmp2 == 0) { 23 | rem = k - 0; 24 | } 25 | else 26 | rem = k - tmp2; 27 | 28 | int rw; 29 | if(rem % 2 == 0) { 30 | rw = rem / 2; 31 | } 32 | else 33 | rw = rem / 2 + 1; 34 | 35 | char c; 36 | if(k % 2 == 1) 37 | c= 'L'; 38 | else 39 | c = 'R'; 40 | 41 | printf("%d %d %c\n", ln, rw, c); 42 | 43 | return 0; 44 | 45 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/758A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[105]; 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | ll mx = 0; 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &ara[i]); 16 | mx = max(mx, ara[i]); 17 | } 18 | 19 | ll sum = 0; 20 | for(ll i = 1; i <= n; i++) { 21 | sum += (mx - ara[i]); 22 | } 23 | 24 | cout << sum << endl; 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/761A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll a, b; 10 | cin >> a >> b; 11 | if(a == 0 && b == 0) { 12 | cout << "NO" << endl; 13 | } 14 | else if(abs(a - b) <= 1) 15 | cout << "YES" << endl; 16 | else 17 | cout << "NO" << endl; 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/762A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k; 10 | cin >> n >> k; 11 | vector div; 12 | ll sqt = sqrt(n); 13 | for(ll i = 1; i <= sqt; i++) { 14 | if(n % i == 0) { 15 | div.push_back(i); 16 | ll tmp = n / i; 17 | if(tmp != i) 18 | div.push_back(tmp); 19 | } 20 | 21 | } 22 | 23 | sort(div.begin(), div.end()); 24 | 25 | if(div.size() < k) 26 | cout << -1 << endl; 27 | else 28 | cout << div[k - 1] << endl; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/768A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n; 10 | cin >> n; 11 | ll ara[n + 5]; 12 | for(ll i = 0; i < n; i++) 13 | scanf("%lld", &ara[i]); 14 | sort(ara, ara + n); 15 | 16 | ll cnt = 0; 17 | for(ll i = 0; i < n; i++) { 18 | ll indx = lower_bound(ara, ara + n, ara[i]) - ara; 19 | ll indx2 = upper_bound(ara, ara + n, ara[i]) - ara; 20 | 21 | if(indx == 0) 22 | continue; 23 | if(indx2 == n) 24 | continue; 25 | 26 | cnt++; 27 | } 28 | 29 | cout << cnt << endl; 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/785B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, m; 8 | scanf("%d", &n); 9 | 10 | int mn1 = INT_MAX, mn2 = INT_MIN; 11 | for(int i = 1; i <= n; i++) { 12 | int a, b; 13 | scanf("%d %d", &a, &b); 14 | mn1 = min(mn1, b); 15 | mn2 = max(mn2, a); 16 | } 17 | 18 | //cout << " " << mn1 << " " << mn2 << endl; 19 | 20 | scanf("%d", &m); 21 | 22 | int mn3 = INT_MIN, mn4 = INT_MAX; 23 | for(int j = 1; j <= m; j++) { 24 | int a, b; 25 | scanf("%d %d", &a, &b); 26 | mn3 = max(mn3, a); 27 | mn4 = min(mn4, b); 28 | } 29 | 30 | //cout << " " << mn3 << " " << mn4 << endl; 31 | int ans1 = 0, ans2 = 0; 32 | if(mn3 > mn1) { 33 | ans1 = mn3 - mn1; 34 | } 35 | 36 | if(mn2 > mn4) 37 | ans2 = mn2 - mn4; 38 | 39 | cout << max(ans1, ans2) << endl; 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/785C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | long long n, m, k = 1, day = 0; 8 | cin >> n >> m; 9 | 10 | if(n <= m) { 11 | cout << n << endl; 12 | return 0; 13 | } 14 | 15 | n -= m; 16 | long long ans; 17 | long long lo = 0, hi = INT_MAX, mid; 18 | while(lo <= hi) { 19 | mid = (lo + hi) / 2; 20 | long long tmp = mid * (mid + 1) / 2; 21 | if(tmp >= n) { 22 | hi = mid - 1; 23 | ans = m + mid; 24 | } 25 | else 26 | lo = mid + 1; 27 | } 28 | 29 | cout << ans << endl; 30 | 31 | return 0; 32 | 33 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/796A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n, m, k; 11 | cin >> n >> m >> k; 12 | ll ara[n + 5]; 13 | for(ll i = 1; i <= n; i++) 14 | cin >> ara[i]; 15 | 16 | ll ans = 1e18; 17 | for(ll i = m + 1; i <= n; i++) { 18 | if(!ara[i]) 19 | continue; 20 | 21 | if(ara[i] <= k) { 22 | ans = min( ans, abs(m - i) * 10 ); 23 | break; 24 | } 25 | } 26 | 27 | for(ll i = m - 1; i >= 1; i--) { 28 | if(!ara[i]) 29 | continue; 30 | if(ara[i] <= k) { 31 | ans = min( ans, abs(m - i) * 10 ); 32 | break; 33 | } 34 | } 35 | 36 | if(ans == 1e18) 37 | ans = 0; 38 | 39 | cout << ans << endl; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/805A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | 7 | { 8 | long long l, r, result = 0; 9 | cin >> l >> r; 10 | if(l == r) 11 | cout << l << endl; 12 | else 13 | cout << 2 << endl; 14 | return 0; 15 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/816B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k, q; 10 | cin >> n >> k >> q; 11 | ll cm[200009] = {}; 12 | memset(cm, 0, sizeof(cm)); 13 | for(int i = 0; i < n; i++) { 14 | int a, b; 15 | cin >> a >> b; 16 | cm[a]++; 17 | cm[b + 1]--; 18 | } 19 | 20 | for(int i = 1; i <= 200000; i++) { 21 | cm[i] += cm[i - 1]; 22 | } 23 | 24 | for(int i = 1; i <= 200000; i++) { 25 | if(cm[i] >= k) 26 | cm[i] = 1; 27 | else 28 | cm[i] = 0; 29 | cm[i] += cm[i - 1]; 30 | } 31 | 32 | for(int i = 0; i < q; i++) { 33 | int a, b; 34 | cin >> a >> b; 35 | cout << cm[b] - cm[a - 1] << endl; 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/818A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | 9 | { 10 | ll n, k; 11 | cin >> n >> k; 12 | ll tmp = n / 2; 13 | ll dpl = tmp / (k + 1); 14 | ll crt = dpl * k; 15 | cout << dpl << ' ' << crt << ' ' << (n - dpl - crt) << endl; 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/862A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | 7 | { 8 | int n, x; 9 | cin >> n >> x; 10 | int ans = x; 11 | int in; 12 | for(int i = 1; i <= n; i++) { 13 | scanf("%d", &in); 14 | if(in < x) 15 | ans--; 16 | else if(in == x) 17 | ans++; 18 | } 19 | cout << ans << endl; 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/869A.php: -------------------------------------------------------------------------------- 1 | Karen -------------------------------------------------------------------------------- /CodeForces/Solutions/869B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll a, b; 10 | cin >> a >> b; 11 | 12 | if(a == b) { 13 | cout << 1 << endl; 14 | return 0; 15 | } 16 | 17 | ll mul = 1; 18 | for(ll i = a + 1, j = 1; i <= b && j <= 20; i++, j++) { 19 | ll num = i % 10; 20 | mul *= num; 21 | mul %= 10; 22 | } 23 | 24 | cout << mul << endl; 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/873B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | char c; 9 | 10 | int sum = 0, result = 0; 11 | map m; 12 | 13 | for(int i = 1; i <= n; i++) { 14 | scanf(" %c", &c); 15 | if(c == '1') 16 | sum++; 17 | else 18 | sum--; 19 | if(sum == 0) 20 | result = max(result, i); 21 | if(m[sum] == 0) m[sum] = i; 22 | else result = max(result, i - m[sum]); 23 | } 24 | 25 | printf("%d\n", result); 26 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/876B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, k, m; 8 | cin >> n >> k >> m; 9 | 10 | int ara[n + 5]; 11 | vector ans[m + 5]; 12 | 13 | for(int i = 0; i < n; i++) { 14 | scanf("%d", &ara[i]); 15 | int rem = ara[i] % m; 16 | ans[rem].push_back(ara[i]); 17 | } 18 | 19 | bool checker = 0; 20 | int ansi; 21 | for(int i = 0; i <= m; i++) { 22 | if(ans[i].size() >= k) { 23 | checker = 1; 24 | ansi = i; 25 | break; 26 | } 27 | } 28 | 29 | if(checker == 1) { 30 | printf("Yes\n"); 31 | for(int i = 0; i < k; i++) { 32 | printf("%d", ans[ansi][i]); 33 | 34 | if(i != k - 1) 35 | printf(" "); 36 | else 37 | printf("\n"); 38 | } 39 | } 40 | 41 | else 42 | printf("No\n"); 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/883I.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll indx[300009], ara[300009], n, k; 7 | 8 | bool isPossible(ll dif) 9 | 10 | { 11 | ll last = 0; 12 | for(ll i = k; i <= n; i++) { 13 | ll j = indx[ i - k ]; 14 | if(ara[i] - ara[j + 1] <= dif) 15 | last = i; 16 | 17 | indx[i] = last; 18 | } 19 | 20 | return indx[n] == n; 21 | } 22 | 23 | int main() 24 | 25 | { 26 | cin >> n >> k; 27 | for(ll i = 1; i <= n; i++) 28 | scanf("%lld", &ara[i]); 29 | 30 | sort(ara + 1, ara + n + 1); 31 | 32 | ll lo = 0, hi = 2e9, ans; 33 | while(lo <= hi) { 34 | ll mid = (lo + hi) / 2; 35 | if( isPossible(mid) ) { 36 | ans = mid; 37 | hi = mid - 1; 38 | } 39 | else { 40 | lo = mid + 1; 41 | } 42 | } 43 | 44 | cout << ans << endl; 45 | return 0; 46 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/890A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int ara[8]; 6 | 7 | int main() 8 | 9 | { 10 | for(int i = 1; i <= 6; i++) { 11 | scanf("%d", &ara[i]); 12 | } 13 | 14 | int sum = 0; 15 | for(int i = 1; i <= 6; i++) { 16 | for(int j = 1; j <= 6; j++) { 17 | for(int k = 1; k <= 6; k++) { 18 | if(i != k && k != j && j != i) { 19 | sum = ara[i] + ara[j] + ara[k]; 20 | 21 | int tmp = 0; 22 | for(int l = 1; l <= 6; l++) { 23 | if(l != i && l != j && l != k) 24 | tmp += ara[l]; 25 | } 26 | 27 | if(sum == tmp) { 28 | printf("YES\n"); 29 | return 0; 30 | } 31 | } 32 | 33 | } 34 | } 35 | } 36 | 37 | printf("NO\n"); 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/892A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool compare(int a, int b) 5 | 6 | { 7 | return a > b; 8 | } 9 | 10 | int main() 11 | 12 | { 13 | int t; 14 | scanf("%d", &t); 15 | int vol, siz[t + 5]; 16 | long long sum = 0; 17 | for(int i = 0; i < t; i++) { 18 | scanf("%d", &vol); 19 | sum += vol; 20 | } 21 | 22 | for(int i = 0; i < t; i++) 23 | scanf("%d", &siz[i]); 24 | 25 | sort(siz, siz + t, compare); 26 | long long tmp = siz[0] + siz[1]; 27 | if(tmp >= sum) 28 | printf("YES\n"); 29 | else 30 | printf("NO\n"); 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/892B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | 7 | { 8 | int n; 9 | scanf("%d", &n); 10 | int ara[n + 5]; 11 | for(int i = 1; i <= n; i++) 12 | scanf("%d", &ara[i]); 13 | 14 | int kllpwr = 0, klld = 0; 15 | for(int i = n; i >= 1; i--) { 16 | if(kllpwr > 0) { 17 | kllpwr--; 18 | klld++; 19 | } 20 | 21 | if(ara[i] > kllpwr) 22 | kllpwr = ara[i]; 23 | } 24 | 25 | printf("%d\n", n - klld); 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/893A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | cin >> n; 9 | map m; 10 | m[1] = 1, m[2] = 1, m[3] = 0; 11 | bool check = 1; 12 | for(int i = 1; i <= n; i++) { 13 | int a; 14 | scanf("%d", &a); 15 | if(m[a] == 0) 16 | check = 0; 17 | 18 | for(int i = 1; i <= 3; i++) { 19 | if(m[i] == 0) 20 | m[i] = 1; 21 | else 22 | m[i] = 0; 23 | } 24 | m[a] = 1; 25 | 26 | } 27 | 28 | if(check == 1) 29 | cout << "YES" << endl; 30 | else 31 | cout << "NO" << endl; 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/893D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, d; 8 | int sum = 0; 9 | int checker = 1, cnt = 0, cnt2 = 0; 10 | scanf("%d %d", &n, &d); 11 | for(int i = 1; i <= n; i++) { 12 | int t; 13 | scanf("%d", &t); 14 | sum += t; 15 | if(sum > d) 16 | checker = 0; 17 | 18 | if(t == 0) { 19 | if(sum < 0) { 20 | cnt++; 21 | } 22 | 23 | sum = 0; 24 | } 25 | } 26 | 27 | if(checker == 1) 28 | cout << cnt << endl; 29 | else 30 | cout << -1 << endl; 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/894A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string s; 5 | char a[10]; 6 | //bool vis[120][6]; 7 | long long int len, cnt = 0; 8 | 9 | void comb(int indx, int indx2) 10 | 11 | { 12 | //cout << indx2 << endl; 13 | if(indx2 == 3) { 14 | a[indx2] = '\0'; 15 | //cout << a << endl; 16 | if(strcmp(a, "QAQ") == 0) 17 | cnt++; 18 | 19 | return; 20 | } 21 | 22 | for(int i = indx; i < len; i++) { 23 | /*if(vis[i][indx2]) 24 | continue;*/ 25 | a[indx2] = s[i]; 26 | //cout << a << endl; 27 | //vis[i][indx2] = 1; 28 | comb(i + 1, indx2 + 1); 29 | } 30 | } 31 | 32 | int main() 33 | 34 | { 35 | cin >> s; 36 | len = s.length(); 37 | comb(0, 0); 38 | 39 | printf("%I64d\n", cnt); 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/894C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | cin >> n; 9 | int ara[n]; 10 | cin >> ara[0]; 11 | int g = ara[0]; 12 | for(int i = 1; i < n; i++) { 13 | cin >> ara[i]; 14 | g = __gcd(g, ara[i]); 15 | } 16 | 17 | if(g != ara[0]) { 18 | cout << -1 << endl; 19 | return 0; 20 | } 21 | 22 | cout << 2 * n << endl; 23 | for(int i = 0; i < n; i++) { 24 | cout << ara[0] << " " << ara[i]; 25 | if(i != n - 1) 26 | cout << " "; 27 | } 28 | 29 | cout << endl; 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/895A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | scanf("%d", &n); 9 | int ara[n + 5]; 10 | 11 | for(int i = 0; i < n; i++) { 12 | scanf("%d", &ara[i]); 13 | 14 | } 15 | 16 | int half = 180; 17 | 18 | int checker[half + 5] = {}; 19 | int mx = 0; 20 | int ans = INT_MAX; 21 | 22 | for(int i = 0; i < n; i++) { 23 | int sum = ara[i]; 24 | ans = min(ans, abs(360 - sum - sum) ); 25 | for(int j = i + 1; j < n; j++) { 26 | sum += ara[j]; 27 | ans = min(ans, abs(360 - sum - sum)); 28 | } 29 | } 30 | 31 | 32 | cout << ans << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/897A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n, m; 7 | scanf("%d %d", &n, &m); 8 | 9 | string s; 10 | cin >> s; 11 | 12 | 13 | while(m--) { 14 | int l, r; 15 | char a, b; 16 | scanf("%d %d", &l, &r); 17 | scanf(" %c %c", &a, &b); 18 | 19 | for(int i = l; i <= r; i++) { 20 | if(s[i - 1] == a) 21 | s[i - 1] = b; 22 | } 23 | } 24 | 25 | cout << s << endl; 26 | return 0; 27 | 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/897B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll k, p; 10 | cin >> k >> p; 11 | ll sum = 0; 12 | for(int i = 1; i <= k; i++) { 13 | 14 | ll tmp = i, n = i; 15 | while(tmp != 0) { 16 | ll dig = tmp % 10; 17 | n = n * 10 + dig; 18 | tmp /= 10; 19 | } 20 | 21 | sum = (sum % p + n % p) % p; 22 | 23 | } 24 | 25 | cout << sum << endl; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/907A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int ara[4]; 8 | scanf("%d %d %d %d", &ara[0], &ara[1], &ara[2], &ara[3]); 9 | 10 | for(int i = ara[0]; i <= 2 * ara[0]; i++) { 11 | 12 | for(int j = ara[1]; j < i && j <= 2 * ara[1]; j++) { 13 | 14 | for(int k = ara[2]; k < j && k <= 2 * ara[2]; k++) { 15 | 16 | if(ara[3] <= k && 2 * ara[3] >= k && 2 * ara[3] < j) { 17 | printf("%d\n%d\n%d\n", i, j, k); 18 | return 0; 19 | } 20 | 21 | } 22 | } 23 | } 24 | 25 | printf("-1\n"); 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/910A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll dp[105], n, d; 7 | char s[105]; 8 | 9 | ll solve(ll indx) 10 | 11 | { 12 | if(indx == n) 13 | return 0; 14 | ll &ret = dp[indx]; 15 | if(ret != -1) 16 | return ret; 17 | 18 | ll rt = 1e15; 19 | 20 | for(ll i = indx + 1; i <= n; i++) { 21 | if(i - indx > d) 22 | break; 23 | if(s[i] != '1') 24 | continue; 25 | 26 | rt = min(rt, solve(i) + 1); 27 | } 28 | 29 | return ret = rt; 30 | } 31 | 32 | int main() 33 | 34 | { 35 | memset(dp, -1, sizeof(dp)); 36 | cin >> n >> d; 37 | scanf("%s", s + 1); 38 | ll ret = solve(1); 39 | 40 | if(ret >= 1e15) 41 | cout << -1 << endl; 42 | else 43 | cout << ret << endl; 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/910B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n, h, w; 8 | cin >> n >> h >> w; 9 | int cnth = 0, cntw = 0, cnt = 0, rest = n; 10 | 11 | while(1) { 12 | 13 | if(rest >= h && cnth < 4) { 14 | rest -= h; 15 | cnth++; 16 | } 17 | 18 | if(rest >= w && cntw < 2) { 19 | rest -= w; 20 | cntw++; 21 | } 22 | 23 | if( (rest < h || cnth == 4) && (rest < w || cntw == 2) ) { 24 | rest = n; 25 | cnt++; 26 | } 27 | 28 | if(cnth == 4 && cntw == 2) { 29 | cout << cnt << endl; 30 | return 0; 31 | } 32 | } 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/912A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll ylw, bl; 10 | cin >> ylw >> bl; 11 | ll y, g, b; 12 | cin >> y >> g >> b; 13 | ll ylw2 = y * 2 + g; 14 | ll bl2 = g + 3 * b; 15 | 16 | ll ans1 = ylw2 - ylw; 17 | ll ans2 = bl2 - bl; 18 | 19 | ans1 = max((ll)0, ans1); 20 | ans2 = max((ll)0, ans2); 21 | cout << ans1 + ans2 << endl; 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/912B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll power(ll a, ll n) 7 | 8 | { 9 | ll ans = 1; 10 | for(ll i = 1; i <= n; i++) { 11 | ans *= a; 12 | //cout << a << endl; 13 | } 14 | 15 | return ans; 16 | } 17 | 18 | int main() 19 | 20 | { 21 | ll n, k; 22 | cin >> n >> k; 23 | if(k == 1) 24 | cout << n << endl; 25 | else { 26 | ll cnt = 0; 27 | ll tmp = n; 28 | while(tmp != 0) { 29 | tmp /= 2; 30 | cnt++; 31 | } 32 | 33 | cout << power(2, cnt) - 1 << endl; 34 | } 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/913A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll power(ll a, ll n) 7 | 8 | { 9 | ll ans = 1; 10 | for(ll i = 1; i <= n; i++) { 11 | ans *= a; 12 | //cout << a << endl; 13 | } 14 | 15 | return ans; 16 | } 17 | 18 | int main() 19 | 20 | { 21 | 22 | ll n, m, ans; 23 | cin >> n >> m; 24 | if(n < 64) { 25 | ll p = power(2, n); 26 | ans = m % p; 27 | } 28 | 29 | else { 30 | ans = m; 31 | } 32 | 33 | cout << ans << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/914A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | bool cmp(ll a, ll b) 7 | 8 | { 9 | return a > b; 10 | } 11 | 12 | int main() 13 | 14 | { 15 | ll ara[1010]; 16 | ll n; 17 | cin >> n; 18 | for(ll i = 0; i < n; i++) 19 | cin >> ara[i]; 20 | 21 | sort(ara, ara + n, cmp); 22 | 23 | for(ll i = 0; i < n; i++) { 24 | if(ara[i] < 0) { 25 | cout << ara[i] << endl;; 26 | return 0; 27 | } 28 | 29 | ll tmp = sqrt(ara[i]); 30 | if(tmp * tmp != ara[i]) { 31 | cout << ara[i] << endl;; 32 | return 0; 33 | } 34 | 35 | } 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/914B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int ara[100009]; 5 | 6 | int main() 7 | 8 | { 9 | int n, tmp = 0; 10 | cin >> n; 11 | for(int i = 0; i < n; i++) { 12 | cin >> ara[i]; 13 | } 14 | 15 | bool mark = 0; 16 | sort(ara, ara + n); 17 | for(int i = n - 1; i >= 0; i--) { 18 | int cnt = lower_bound(ara, ara + n, ara[i]) - ara; 19 | if( (n - cnt - 1) % 2 == 0) { 20 | mark = 1; 21 | break; 22 | } 23 | } 24 | if(mark == 1) 25 | cout << "Conan" << endl; 26 | else 27 | cout << "Agasa" << endl; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/915A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll n, m; 11 | cin >> n >> m; 12 | ll ans = 2e18; 13 | for(ll i = 1; i <= n; i++) { 14 | ll in; 15 | cin >> in; 16 | if(m % in == 0) { 17 | ans = min(ans, m / in); 18 | } 19 | } 20 | 21 | cout << ans << endl; 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/918A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | int x = 1, y = 1; 10 | map mark; 11 | mark[1] = 1; 12 | for(int i = 1; i <= 1020; i++) { 13 | int tmp = x+ y; 14 | mark[tmp] = 1; 15 | x = y; 16 | y = tmp; 17 | } 18 | 19 | int n; 20 | cin >> n; 21 | for(int i = 1; i <= n; i++) { 22 | if(mark[i] == 1) 23 | cout << "O"; 24 | else 25 | cout << "o"; 26 | } 27 | 28 | cout << endl; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/918B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | struct node { 7 | string s1; 8 | string s2; 9 | }; 10 | 11 | int main() 12 | 13 | { 14 | map m1; 15 | map m2; 16 | int n, m; 17 | cin >> n >> m; 18 | for(int i = 1; i <= n; i++) { 19 | string s1, s2; 20 | cin >> s1 >> s2; 21 | m1[s2] = s1; 22 | } 23 | 24 | node str[m + 5]; 25 | for(int i = 0; i < m; i++) { 26 | string s1, s2; 27 | cin >> s1 >> s2; 28 | string tmp = ""; 29 | for(int j = 0; j < s2.length() - 1; j++) 30 | tmp += s2[j]; 31 | str[i].s1 = s1; 32 | str[i].s2 = tmp; 33 | } 34 | 35 | for(int i = 0; i < m; i++) { 36 | cout << str[i].s1 << " " << str[i].s2 << ";" << " #" << m1[ str[i].s2 ] << endl; 37 | } 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/918C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string s; 6 | cin >> s; 7 | long long ans = 0; 8 | for(int i = 0; i < s.length(); i++) { 9 | int b1 = 0, b2 = 0; 10 | for(int j = i; j < s.length(); j++) { 11 | if(s[j] == '(') b1++, b2++; 12 | else if(s[j] == ')') b1--, b2--; 13 | else b1++, b2--; 14 | if(b1 < 0) break; 15 | if(b2 < 0) b2 += 2; 16 | if(b2 == 0) ans++; 17 | } 18 | } 19 | 20 | cout << ans << endl; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/919A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | int n, m; 10 | cin >> n >> m; 11 | vector v; 12 | for(int i = 1; i <= n; i++) { 13 | int a, b; 14 | cin >> a >> b; 15 | double cost = (a * 1.0) / (b * 1.0); 16 | v.push_back(cost); 17 | } 18 | 19 | sort(v.begin(), v.end()); 20 | double ans = v[0] * m; 21 | printf("%0.10f\n", ans); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/919B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ans[10009]; 7 | 8 | int main() 9 | 10 | { 11 | ll start = 10; 12 | for(int i = 1; i <= 10000; i++) { 13 | 14 | while(1) { 15 | start += 9; 16 | ll sum = 0, n = start; 17 | while(n != 0) { 18 | ll tmp = n % 10; 19 | sum += tmp; 20 | n /= 10; 21 | } 22 | if(sum == 10) 23 | break; 24 | } 25 | ans[i] = start; 26 | } 27 | 28 | int k; 29 | cin >> k; 30 | cout << ans[k] << endl; 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/920A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int ara[209]; 7 | 8 | int main() 9 | 10 | { 11 | int t; 12 | cin >> t; 13 | while(t--) { 14 | int n, k; 15 | scanf("%d %d", &n, &k); 16 | for(int i = 0; i < k; i++) { 17 | scanf("%d", &ara[i]); 18 | } 19 | 20 | int time; 21 | for(int i = 0; i < k; i++) { 22 | if(i == 0) { 23 | time = ara[i]; 24 | } 25 | if(i == k - 1) { 26 | time = max(time, n - ara[i] + 1); 27 | } 28 | 29 | if(i != k - 1) { 30 | int tmp = ara[i + 1] - ara[i]; 31 | tmp = tmp / 2 + 1; 32 | time = max(time, tmp); 33 | } 34 | } 35 | 36 | printf("%d\n", time); 37 | } 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/920C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int ara[200009]; 5 | int mark[200009]; 6 | 7 | int main() 8 | 9 | { 10 | int n; 11 | scanf("%d", &n); 12 | for(int i = 0; i < n; i++) { 13 | scanf("%d", &ara[i]); 14 | } 15 | for(int i = 0; i < n - 1; i++) { 16 | char ch; 17 | scanf(" %c", &ch); 18 | mark[i] = ch - '0'; 19 | } 20 | 21 | bool state = 1; 22 | for(int i = 0; i < n - 1; i++) { 23 | if(ara[i] > ara[i + 1] && mark[i] == 0) { 24 | state = 0; 25 | break; 26 | } 27 | if(ara[i] > ara[i + 1] && mark[i] == 1) { 28 | swap(ara[i], ara[i + 1]); 29 | } 30 | } 31 | 32 | if(state == 1) 33 | printf("YES\n"); 34 | else 35 | printf("NO\n"); 36 | return 0; 37 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/922A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | int x, y; 10 | cin >> x >> y; 11 | 12 | if(y == 0) { 13 | printf("No\n"); 14 | return 0; 15 | } 16 | if(y == 1) { 17 | if(x == 0) { 18 | printf("Yes\n"); 19 | return 0; 20 | } 21 | else { 22 | printf("No\n"); 23 | return 0; 24 | } 25 | } 26 | if(y > x + 1) { 27 | printf("No\n"); 28 | return 0; 29 | } 30 | 31 | int ori = y - 1; 32 | int cop = ori; 33 | if((x - cop) % 2 == 0) 34 | printf("Yes\n"); 35 | else 36 | printf("No\n"); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/922C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool check[35]; 5 | #define ll long long 6 | 7 | int main() { 8 | 9 | ll n, k; 10 | cin >> n >> k; 11 | ll p = min(k, 22LL); 12 | for(ll i = 1; i <= p; i++) { 13 | ll tmp = n % i; 14 | if(check[tmp]) { 15 | cout << "No" << endl; 16 | return 0; 17 | } 18 | check[tmp] = 1; 19 | } 20 | cout << "Yes" << endl; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/931A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | int main() 8 | 9 | { 10 | ll a, b; 11 | cin >> a >> b; 12 | if(a > b) 13 | swap(a, b); 14 | 15 | ll mid = (a + b) / 2; 16 | ll n1 = (mid - a), n2 = b - mid; 17 | ll ans = (n1 * (n1 + 1)) / 2 + (n2 * (n2 + 1)) / 2; 18 | 19 | cout << ans << endl; 20 | 21 | return 0; 22 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/932A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | string s1, tmp; 11 | cin >> s1; 12 | tmp = s1; 13 | reverse(tmp.begin(), tmp.end()); 14 | cout << s1 << tmp << endl; 15 | return 0; 16 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/934A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | ll n, m; 11 | cin >> n >> m; 12 | ll ara[n + 5], ara2[m + 5]; 13 | 14 | for(ll i = 0; i < n; i++) 15 | scanf("%I64d", &ara[i]); 16 | 17 | for(ll i = 0; i < m; i++) 18 | scanf("%I64d", &ara2[i]); 19 | 20 | ll mx = -1000000000000000009, tmp = 0; 21 | for(ll i = 0; i < n; i++) { 22 | for(ll j = 0; j < m; j++) { 23 | ll tmp1 = ara[i] * ara2[j]; 24 | if(tmp1 > mx) { 25 | mx = tmp1; 26 | tmp = i; 27 | } 28 | } 29 | } 30 | 31 | mx = -1000000000000000009; 32 | for(ll i = 0; i < n; i++) { 33 | if(tmp == i) 34 | continue; 35 | for(ll j = 0; j < m; j++) { 36 | mx = max(mx, ara[i] * ara2[j]); 37 | 38 | } 39 | } 40 | 41 | cout << mx << endl; 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/934B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | ll k; 11 | cin >> k; 12 | if(k > 36) { 13 | cout << "-1" << endl; 14 | return 0; 15 | } 16 | if(k == 0) { 17 | cout << "1" << endl; 18 | return 0; 19 | } 20 | 21 | if(k == 1) { 22 | cout << "4" << endl; 23 | return 0; 24 | } 25 | 26 | 27 | while(k != 0) { 28 | k -= 2; 29 | cout << "8"; 30 | if(k == 1) { 31 | cout << "4"; 32 | break; 33 | } 34 | } 35 | 36 | cout << endl; 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/935A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | #define inf 1 << 62 7 | 8 | int main() 9 | 10 | { 11 | ll n, cnt = 0; 12 | cin >> n; 13 | for(ll i = 2; i <= n; i++) { 14 | if(n % i == 0) { 15 | cnt++; 16 | } 17 | } 18 | 19 | cout << cnt << endl; 20 | return 0; 21 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/937A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | int main() 8 | 9 | { 10 | int n; 11 | cin >> n; 12 | ll cnt = 0; 13 | unordered_map mark; 14 | for(int i = 0; i < n; i++) { 15 | int in; 16 | cin >> in; 17 | if(mark[in] == 0&& in > 0) { 18 | cnt++; 19 | mark[in] = 1; 20 | } 21 | } 22 | 23 | cout << cnt << endl; 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/938A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | int n; 11 | string s; 12 | cin >> n >> s; 13 | bool mark = 0; 14 | if(s[0] == 'a' || s[0] == 'e' || s[0] == 'i' || s[0] == 'o' || s[0] == 'u' || s[0] == 'y') 15 | mark = 1; 16 | cout << s[0]; 17 | 18 | for(int i = 1; i < n; i++) { 19 | if(mark == 1 && ( s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u' || s[i] == 'y' ) ) { 20 | continue; 21 | } 22 | 23 | cout << s[i]; 24 | 25 | if(mark == 0 && ( s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' || s[i] == 'u' || s[i] == 'y' ) ) { 26 | mark = 1; 27 | continue; 28 | } 29 | 30 | mark = 0; 31 | 32 | } 33 | 34 | cout << endl; 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/938B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | int n; 11 | cin >> n; 12 | int mx = INT_MIN; 13 | int pos1 = 1, pos2 = 1000000; 14 | int time1 = 0, time2 = 0; 15 | 16 | for(int i = 1; i <= n; i++) { 17 | int in; 18 | scanf("%d", &in); 19 | 20 | int tmp1 = abs(in - pos1); 21 | int tmp2 = abs(in - pos2); 22 | 23 | if(tmp1 < tmp2) { 24 | mx = max(mx, tmp1); 25 | } 26 | else { 27 | 28 | mx = max(mx, tmp2); 29 | } 30 | } 31 | 32 | cout << mx << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/939A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | int n; 11 | cin >> n; 12 | int ara[n + 5]; 13 | for(int i = 1; i <= n; i++) { 14 | int in; 15 | scanf("%d", &in); 16 | ara[i] = in; 17 | } 18 | 19 | bool flag = 0; 20 | for(int i = 1; i <= n; i++) { 21 | int tmp = ara[i]; 22 | int tmp2 = ara[tmp]; 23 | //cout << i << " " << tmp << " " << tmp2 << endl; 24 | if(ara[tmp2] == i) { 25 | flag = 1; 26 | break; 27 | } 28 | } 29 | 30 | if(flag == 1) 31 | cout << "YES" < 2 | 3 | using namespace std; 4 | 5 | #define ll long long 6 | #define inf 1000000000000000000 7 | 8 | int main() 9 | 10 | { 11 | ll n, k, ans, am; 12 | cin >> n >> k; 13 | 14 | ll mn = inf; 15 | for(ll i = 1; i <= k; i++) { 16 | ll in; 17 | scanf("%I64d", &in); 18 | 19 | ll tmp = n % in; 20 | //cout << tmp << endl; 21 | if(mn > tmp) { 22 | mn = tmp; 23 | ans = i; 24 | am = n / in; 25 | } 26 | } 27 | 28 | cout << ans << " " << am << endl; 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/946A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | int main() 8 | 9 | { 10 | ll n, sum1 = 0, sum2 = 0; 11 | cin >> n; 12 | while(n--) { 13 | ll in; 14 | cin >> in; 15 | if(in >= 0) 16 | sum1 += in; 17 | else { 18 | sum2 += in; 19 | } 20 | } 21 | 22 | 23 | cout << (sum1 - sum2) << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/946B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | ll n, m; 8 | 9 | int main() 10 | 11 | { 12 | cin >> n >> m; 13 | 14 | if(n == 0 || m == 0) { 15 | cout << n << " " << m << endl; 16 | return 0; 17 | } 18 | 19 | while(1) { 20 | if(n >= 2 * m) { 21 | ll tmp = 2 * m; 22 | n = n % tmp; 23 | } 24 | else { 25 | if(m >= 2 * n) { 26 | ll tmp = 2 * n; 27 | m = m % tmp; 28 | } 29 | else { 30 | cout << n << " " << m << endl; 31 | return 0; 32 | } 33 | } 34 | 35 | if(n == 0 || m == 0) { 36 | cout << n << " " << m << endl; 37 | return 0; 38 | } 39 | } 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/946C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | 7 | { 8 | char ch = 'a'; 9 | string s; 10 | cin >> s; 11 | 12 | for(int i = 0; i < s.length(); i++) { 13 | if(s[i] == 'z') 14 | continue; 15 | if(s[i] == ch) { 16 | ch++; 17 | } 18 | else if(s[i] == (ch - 1)) { 19 | s[i] = ch; 20 | ch++; 21 | } 22 | } 23 | 24 | if(ch >= 'z') 25 | cout << s << endl; 26 | else 27 | cout << -1 << endl; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/950A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf (1LL << 62) 6 | 7 | int main() 8 | 9 | { 10 | ll l, r, a; 11 | cin >> l >> r >> a; 12 | if(l > r) 13 | swap(l, r); 14 | ll ans = l; 15 | ll dif = r - l; 16 | if(dif > a) { 17 | ans += a; 18 | } 19 | else { 20 | ans += dif; 21 | ll tmp = a - dif; 22 | tmp = tmp / 2; 23 | ans += tmp; 24 | } 25 | 26 | cout << 2 * ans << endl; 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/954A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | cin >> n; 9 | string s; 10 | cin >> s; 11 | 12 | for(int i = 0; i < s.length() - 1; i++) { 13 | if(s[i] == 'U' && s[i + 1] == 'R') { 14 | s[i] = '#'; 15 | s[i + 1] = '#'; 16 | n--; 17 | i++; 18 | } 19 | 20 | else if(s[i] == 'R' && s[i + 1] == 'U') { 21 | s[i] = '#'; 22 | s[i + 1] = '#'; 23 | n--; 24 | i++; 25 | } 26 | } 27 | 28 | printf("%d\n", n); 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/954B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | 6 | { 7 | int n; 8 | cin >> n; 9 | string s; 10 | cin >> s; 11 | 12 | int half = n / 2, ans = n; 13 | for(int i = half; i >= 1; i--) { 14 | bool test = 1; 15 | for(int j = 0, k = i; j < i; j++, k++) { 16 | if(s[j] != s[k]) { 17 | test = 0; 18 | break; 19 | } 20 | } 21 | 22 | if(test) { 23 | ans = ans - i + 1; 24 | break; 25 | } 26 | } 27 | 28 | printf("%d\n", ans); 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/959A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 1e18 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | if(n == 1) { 13 | printf("Ehab\n"); 14 | return 0; 15 | } 16 | bool state = 0; 17 | while(1) { 18 | if(n == 0) { 19 | if(state == 0) { 20 | printf("Ehab\n"); 21 | return 0; 22 | } 23 | else { 24 | printf("Mahmoud\n"); 25 | return 0; 26 | } 27 | } 28 | if(state == 0) { 29 | if(n % 2 == 1) 30 | n = 1; 31 | else 32 | n = 0; 33 | } 34 | 35 | else { 36 | if(n % 2 == 0) 37 | n = 1; 38 | else 39 | n = 0; 40 | } 41 | 42 | state ^= 1; 43 | } 44 | return 0; 45 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/959C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 1e18 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | if(n < 6) 13 | printf("-1\n"); 14 | else { 15 | printf("1 2\n2 3\n2 4\n"); 16 | for(ll i = 5; i <= n; i++) 17 | printf("1 %lld\n", i); 18 | } 19 | for(ll i = 2; i <= n; i++) { 20 | printf("1 %lld\n", i); 21 | } 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/960A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define inf 2e18 5 | #define ll long long 6 | 7 | int main() 8 | 9 | { 10 | string s; 11 | cin >> s; 12 | ll cnt[5] = {}; 13 | 14 | char ch = 'a'; 15 | if(s[0] != 'a') { 16 | cout << "NO" << endl; 17 | return 0; 18 | } 19 | for(int i = 0; i < s.length(); i++) { 20 | if(s[i] > ch + 1) { 21 | cout << "NO" << endl; 22 | return 0; 23 | } 24 | if(s[i] == ch + 1) 25 | ch++; 26 | 27 | if(s[i] != ch) { 28 | cout << "NO" << endl; 29 | return 0; 30 | } 31 | 32 | cnt[ s[i] - 'a']++; 33 | } 34 | 35 | if(ch != 'c') { 36 | cout << "NO" << endl; 37 | return 0; 38 | } 39 | 40 | if(cnt[0] == cnt[2] || cnt[1] == cnt[2]) 41 | cout << "YES" << endl; 42 | else 43 | cout << "NO" << endl; 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/964A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | ll lo = 1, hi = n, ans; 13 | while(lo <= hi) { 14 | ll mid = (lo + hi) / 2; 15 | ll dv = n / mid; 16 | if(dv > 1) { 17 | lo = mid + 1; 18 | } 19 | else { 20 | ans = mid; 21 | hi = mid - 1; 22 | } 23 | } 24 | 25 | cout << ans << endl; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/965A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | ll k, n, s, p; 11 | cin >> k >> n >> s >> p; 12 | ll bana = n / s; 13 | if(n % s != 0) 14 | bana++; 15 | ll tot = bana * k; 16 | ll pck = tot / p; 17 | if(tot % p != 0) 18 | pck++; 19 | 20 | cout << pck << endl; 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/96A.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | 5 | { 6 | int i, count = 1; 7 | char s[110]; 8 | scanf("%s", s); 9 | 10 | for(i = 1; s[i] != '\0'; i++) { 11 | if(s[i] == '1') { 12 | if(s[i - 1] == '0') { 13 | count = 0; 14 | } 15 | count++; 16 | } 17 | 18 | else if(s[i] == '0') { 19 | if(s[i - 1] == '1') { 20 | count = 0; 21 | } 22 | count++; 23 | } 24 | 25 | if(count == 7) { 26 | break; 27 | } 28 | } 29 | 30 | if(count == 7) { 31 | printf("YES\n"); 32 | } 33 | 34 | else { 35 | printf("NO\n"); 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/975A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | char s[1009]; 8 | 9 | int main() 10 | 11 | { 12 | set root; 13 | ll n; 14 | cin >> n; 15 | for(ll i = 1; i <= n; i++) { 16 | scanf("%s", s); 17 | unordered_map check; 18 | string tmp = ""; 19 | for(ll j = 0; s[j] != '\0'; j++) { 20 | if(check[ s[j] ] == 0) { 21 | check[ s[j] ] = 1; 22 | tmp += s[j]; 23 | } 24 | } 25 | sort(tmp.begin(), tmp.end()); 26 | root.insert(tmp); 27 | } 28 | 29 | cout << root.size() << endl; 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/978C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[200009], cs[200009]; 7 | ll ara2[200009]; 8 | 9 | int main() 10 | 11 | { 12 | ll n, m; 13 | cin >> n >> m; 14 | for(ll i = 1; i <= n; i++) { 15 | scanf("%lld", &ara[i]); 16 | cs[i] += (ara[i] + cs[i - 1]); 17 | } 18 | 19 | for(ll i = 1; i <= m; i++) { 20 | scanf("%lld", &ara2[i]); 21 | 22 | ll lo = 1, hi = n, shef = -1; 23 | while(lo <= hi) { 24 | ll mid = (lo + hi) / 2; 25 | if(cs[mid] >= ara2[i]) { 26 | hi = mid - 1; 27 | shef = mid; 28 | } 29 | else { 30 | lo = mid + 1; 31 | } 32 | } 33 | 34 | printf("%lld %lld\n", shef, ara2[i] - cs[shef - 1]); 35 | } 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/979A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 1e18 6 | #define sl(val) scanf("%lld", &val) 7 | 8 | int main() 9 | 10 | { 11 | ll n; 12 | cin >> n; 13 | if(n == 0) { 14 | printf("0\n"); 15 | return 0; 16 | } 17 | n++; 18 | if(n % 2 == 0) { 19 | printf("%lld\n", n / 2); 20 | return 0; 21 | } 22 | else { 23 | printf("%lld\n", n); 24 | return 0; 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/980A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 2e18 6 | 7 | int main() 8 | 9 | { 10 | string s; 11 | cin >> s; 12 | ll prl = 0, lnk = 0; 13 | for(ll i = 0; i < s.length(); i++) { 14 | if(s[i] == 'o') 15 | prl++; 16 | else 17 | lnk++; 18 | } 19 | 20 | if(prl <= 1) { 21 | cout << "YES" << endl; 22 | return 0; 23 | } 24 | if(lnk == 0) { 25 | cout << "YES" << endl; 26 | return 0; 27 | } 28 | 29 | if(lnk % prl == 0) { 30 | cout << "YES" << endl; 31 | } 32 | else { 33 | cout << "NO" << endl; 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/981A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 1e18 6 | 7 | int main() 8 | 9 | { 10 | string s; 11 | cin >> s; 12 | ll ans = 0; 13 | for(ll i = 0; i < s.length(); i++) { 14 | string s2 = ""; 15 | for(ll j = i; j < s.length(); j++) { 16 | s2 += s[j]; 17 | } 18 | 19 | string tmp = s2; 20 | reverse(s2.begin(), s2.end()); 21 | 22 | ll len = s2.length(); 23 | if(tmp != s2) { 24 | ans = max(ans, len); 25 | } 26 | } 27 | 28 | cout << ans << endl; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/981B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define inf 1e18 6 | 7 | struct node { 8 | ll id; 9 | ll val; 10 | }ara[200009]; 11 | 12 | bool cmp(node a, node b) 13 | 14 | { 15 | return a.val > b.val; 16 | } 17 | 18 | int main() 19 | 20 | { 21 | ll n, indx = 0; 22 | cin >> n; 23 | for(ll i = 0; i < n; i++) { 24 | scanf("%lld %lld", &ara[indx].id, &ara[indx].val); 25 | indx++; 26 | } 27 | ll m; 28 | cin >> m; 29 | for(ll i = 0; i < m; i++) { 30 | scanf("%lld %lld", &ara[indx].id, &ara[indx].val); 31 | indx++; 32 | } 33 | 34 | map mark; 35 | ll ans = 0; 36 | sort(ara, ara + indx, cmp); 37 | 38 | for(ll i = 0; i < indx; i++) { 39 | if(mark[ ara[i].id] == 0) { 40 | mark[ ara[i].id ] = 1; 41 | ans += ara[i].val; 42 | } 43 | 44 | } 45 | 46 | cout << ans << endl; 47 | return 0; 48 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/982C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | #define sl(val) scanf("%lld", &val) 6 | #define inf 2e18 7 | #define pb push_back 8 | 9 | vector graph[100009]; 10 | ll n, cnt = 0; 11 | 12 | ll dfs(ll u, ll p) 13 | 14 | { 15 | ll ret = 1; 16 | 17 | for(ll i = 0; i < graph[u].size(); i++) { 18 | ll nd = graph[u][i]; 19 | if(nd == p) 20 | continue; 21 | ll num = dfs(nd, u); 22 | if(num % 2 == 0 && (n - num) % 2 == 0) 23 | cnt++; 24 | ret += num; 25 | } 26 | 27 | return ret; 28 | } 29 | 30 | int main() 31 | 32 | { 33 | ll u ,v; 34 | cin >> n; 35 | 36 | for(ll i = 1; i < n; i++) { 37 | sl(u), sl(v); 38 | graph[u].pb(v); 39 | graph[v].pb(u); 40 | } 41 | 42 | dfs(1, -1); 43 | 44 | if(n % 2 != 0 && cnt == 0) { 45 | printf("-1\n"); 46 | } 47 | else { 48 | printf("%lld\n", cnt); 49 | } 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/984A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | 7 | int main() 8 | 9 | { 10 | ll n; 11 | cin >> n; 12 | ll ara[1009]; 13 | for(ll i = 0; i < n; i++) { 14 | scanf("%lld", &ara[i]); 15 | } 16 | 17 | sort(ara, ara + n); 18 | deque dq; 19 | for(ll i = 0; i < n; i++) { 20 | dq.push_back( ara[i] ); 21 | } 22 | 23 | bool turn = 0; 24 | ll num; 25 | while(!dq.empty()) { 26 | if(!turn) { 27 | num = dq.back(); 28 | dq.pop_back(); 29 | } 30 | else { 31 | num = dq.front(); 32 | dq.pop_front(); 33 | } 34 | 35 | turn ^= 1; 36 | } 37 | 38 | cout << num << endl; 39 | return 0; 40 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/987B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll unsigned long long 5 | #define inf 1e18 6 | 7 | long long bigmod(int b, int p) 8 | 9 | { 10 | if(p == 0) 11 | return 1; 12 | 13 | else if(p & 1) 14 | return (b * bigmod(b, p - 1)); 15 | 16 | else { 17 | long long r = bigmod(b, p / 2); 18 | return (r * r); 19 | } 20 | } 21 | 22 | int main() 23 | 24 | { 25 | ll x, y; 26 | cin >> x >> y; 27 | ll left = bigmod(x, y); 28 | ll right = bigmod(y, x); 29 | if(left > right) 30 | cout << ">" << endl; 31 | else if(right > left) 32 | cout << "<" << endl; 33 | else 34 | cout << "=" << endl; 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/988A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[105], ans[105]; 7 | bool mark[105]; 8 | 9 | int main() 10 | 11 | { 12 | ios::sync_with_stdio(false); 13 | ll n, k; 14 | cin >> n >> k; 15 | ll indx = 0; 16 | for(ll i = 1; i <= n; i++) { 17 | cin >> ara[i]; 18 | if(mark[ ara[i] ] == 0) { 19 | mark[ ara[i] ] = 1; 20 | ans[indx++] = i; 21 | } 22 | } 23 | 24 | if(indx < k) 25 | cout << "NO" << endl; 26 | else { 27 | cout << "YES" << endl; 28 | for(ll i = 0; i < k; i++) { 29 | if(i != 0) 30 | cout << " "; 31 | cout << ans[i]; 32 | } 33 | cout << endl; 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/990A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, m, a, b; 10 | cin >> n >> m >> a >> b; 11 | 12 | if(n % m == 0) { 13 | printf("0\n"); 14 | return 0; 15 | } 16 | 17 | if(n < m) { 18 | ll ca = (m - n) * a; 19 | ll cb = n * b; 20 | //cout << ca << " " << cb << endl; 21 | cout << min(ca, cb) << endl; 22 | return 0; 23 | } 24 | 25 | ll mul = n / m; 26 | ll rem = n - (mul * m); 27 | 28 | ll cb = rem * b; 29 | 30 | ll rema = (mul + 1) * m - n; 31 | ll ca = rema * a; 32 | 33 | cout << min(ca, cb) << endl; 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/992B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | #define ll long long 7 | 8 | vector v; 9 | 10 | int main() 11 | 12 | { 13 | ll l, r, x, y; 14 | cin >> l >> r >> x >> y; 15 | ll sqt = sqrt(y); 16 | 17 | ll cnt = 0, mns = 0; 18 | for(ll i = 1; i <= sqt; i++) { 19 | if(y % i != 0) 20 | continue; 21 | ll d = y / i; 22 | if(i >= l && i <= r) 23 | v.push_back(i); 24 | if(d != i && d >= l && d <= r) 25 | v.push_back(d); 26 | } 27 | 28 | for(ll i = 0; i < v.size(); i++) { 29 | for(ll j = 0; j < v.size(); j++) { 30 | if(__gcd(v[i], v[j]) != x) 31 | continue; 32 | ll lcm = (v[i] * v[j]) / x; 33 | if(lcm != y) 34 | continue; 35 | cnt++; 36 | } 37 | } 38 | 39 | cout << cnt << endl; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/999A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n, k; 10 | cin >> n >> k; 11 | vector v; 12 | for(ll i = 1; i <= n; i++) { 13 | ll num; 14 | scanf("%lld", &num); 15 | v.push_back(num); 16 | } 17 | 18 | while(v.size() > 0) { 19 | ll x = v[0]; 20 | if(x > k) { 21 | ll y = v[ v.size() - 1]; 22 | 23 | if(y > k) 24 | break; 25 | 26 | v.erase( v.end() - 1); 27 | } 28 | else { 29 | v.erase(v.begin()); 30 | } 31 | 32 | } 33 | 34 | cout << n - v.size() << endl; 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /CodeForces/Solutions/999B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n; 10 | string s; 11 | cin >> n >> s; 12 | 13 | vector div; 14 | ll sqt = sqrt(n); 15 | for(ll i = 1; i <= sqt; i++) { 16 | 17 | if(n % i == 0) { 18 | 19 | div.push_back(i); 20 | ll y = n / i; 21 | if(y != i) 22 | div.push_back(y); 23 | } 24 | } 25 | 26 | sort(div.begin(), div.end()); 27 | 28 | for(ll i = 0; i < div.size(); i++) { 29 | reverse(s.begin(), s.begin() + div[i]); 30 | } 31 | 32 | cout << s << endl; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /LightOJ/1000 - Greetings from LightOJ - 1109680.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t; 6 | cin >> t; 7 | int caseno = 0; 8 | while(t--) { 9 | int a, b; 10 | scanf("%d %d", &a, &b); 11 | printf("Case %d: %d\n", ++caseno, a + b); 12 | } 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /LightOJ/1001 - Opposite Task - 1015250.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, n; 5 | scanf("%d", &T); 6 | while(T--) { 7 | scanf("%d", &n); 8 | if(!(n ^ 0)) { 9 | printf("%d %d\n", n, n); 10 | } 11 | else if(n > 10) { 12 | printf("10 %d\n", (n - 10)); 13 | } 14 | else { 15 | printf("%d %d\n", 1, n - 1); 16 | } 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /LightOJ/1005 - Rooks - 1092416.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t, no = 0; 6 | scanf("%d", &t); 7 | while(t--) { 8 | int n, k; 9 | scanf("%d %d", &n, &k); 10 | long long unsigned way = 0; 11 | if(n * n >= k) { 12 | way = 1; 13 | for(int pown = 1; pown <= k; pown++) { 14 | way = (n * n * way) / pown; 15 | n--; 16 | } 17 | } 18 | printf("Case %d: %llu\n", ++no, way); 19 | } 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /LightOJ/1006 - Hex-a-bonacci - 1004324.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | scanf("%d", &T); 7 | for(int i = 1; i <= T; i++) { 8 | int n; 9 | long long int ara[10009]; 10 | for(int j = 0; j < 6; j++) { 11 | scanf("%lld", &ara[j]); 12 | } 13 | scanf("%d", &n); 14 | for(int j = 6; j <= n; j++) { 15 | ara[j] = (ara[j - 1] + ara[j - 2] + ara[j - 3] + ara[j - 4] + ara[j - 5] + ara[j - 6]) % 10000007; 16 | } 17 | printf("Case %d: %lld\n", i, ara[n] % 10000007); 18 | } 19 | return 0; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /LightOJ/1007 - Mathematically Hard - 1365978.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll unsigned long long 4 | ll pwr[5000009]; 5 | int phi[5000009]; 6 | int main() 7 | { 8 | for(ll i = 1; i <= 5000000; i++) 9 | phi[i] = i; 10 | for(ll i = 2; i <= 5000000; i++) { 11 | if(phi[i] == i) { 12 | phi[i] = i - 1; 13 | for(ll j = 2 * i; j <= 5000000; j += i) 14 | phi[j] = (phi[j] / i) * (i - 1); 15 | } 16 | } 17 | for(ll i = 1; i <= 5000000; i++) { 18 | pwr[i] = (ll)phi[i] * (ll)phi[i] + pwr[i - 1]; 19 | } 20 | ll t, cs = 0; 21 | cin >> t; 22 | while(t--) { 23 | ll a, b; 24 | scanf("%llu %llu", &a, &b); 25 | ll ans = pwr[b] - pwr[a - 1]; 26 | printf("Case %llu: %llu\n", ++cs, ans); 27 | } 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /LightOJ/1011 - Marriage Ceremonies - 1092426.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | int ara[20][20]; 5 | int dp[18][1 << 18]; 6 | int marriage(int i, int btmask) 7 | { 8 | if(dp[i][btmask] != -1) 9 | return dp[i][btmask]; 10 | if(i == n) 11 | return 0; 12 | int sum = INT_MIN; 13 | for(int j = 0; j < n; j++) { 14 | if( (btmask & (1 << j) ) == 0) { 15 | sum = max(sum, marriage(i + 1, (1 << j) | btmask) + ara[i][j] ); 16 | } 17 | } 18 | return dp[i][btmask] = sum; 19 | } 20 | int main() 21 | { 22 | int t; 23 | scanf("%d", &t); 24 | int caseno = 0; 25 | while(t--) { 26 | scanf("%d", &n); 27 | for(int i = 0; i < n; i++) { 28 | for(int j = 0; j < n; j++) { 29 | scanf("%d", &ara[i][j]); 30 | } 31 | } 32 | memset(dp, -1, sizeof(dp)); 33 | printf("Case %d: %d\n", ++caseno, marriage(0, 0) ); 34 | } 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /LightOJ/1015 - Brush (I) - 990023.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, i, N, j, sum; 5 | int ara[1020]; 6 | scanf("%d", &T); 7 | for(i = 1; i <= T; i++) { 8 | scanf("%d", &N); 9 | sum = 0; 10 | for(j = 0; j < N; j++) { 11 | scanf("%d", &ara[j]); 12 | if(ara[j] > 0) 13 | sum += ara[j]; 14 | } 15 | printf("Case %d: %d\n", i, sum); 16 | } 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /LightOJ/1016 - Brush (II) - 1254333.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll t, caseno = 0; 7 | cin >> t; 8 | while(t--) { 9 | set point; 10 | set :: iterator it; 11 | ll n, w, x, y, hi, lo, mv = 0; 12 | scanf("%lld %lld", &n, &w); 13 | for(ll i = 1; i <= n; i++) { 14 | scanf("%lld %lld", &x, &y); 15 | point.insert(y); 16 | } 17 | while(!point.empty()) { 18 | it = --point.end(); 19 | hi = *it; 20 | lo = hi - w; 21 | for(ll i = hi; i >= lo; i--) { 22 | it = point.find(i); 23 | if(it == point.end()) 24 | continue; 25 | point.erase(it); 26 | } 27 | mv++; 28 | } 29 | printf("Case %lld: %lld\n", ++caseno, mv); 30 | } 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /LightOJ/1022 - Circle in Square - 1015251.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | int i, T; 6 | double r, ans, pi; 7 | scanf("%d", &T); 8 | pi = 2.0 * acos(0.0); 9 | for(i = 1; i <= T; i++) { 10 | scanf("%lf", &r); 11 | ans = ((4.0 * r * r) - (pi * r * r)) + 0.000001; 12 | printf("Case %d: %0.2lf\n",i, ans); 13 | } 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /LightOJ/1023 - Discovering Permutations - 1092432.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int N, K, cnt; 4 | bool used[30]; 5 | char ara[30]; 6 | void permut(int n) 7 | { 8 | if(cnt == K) 9 | return; 10 | if(n == N) { 11 | for(int j = 0; j < N; j++) { 12 | printf("%c", ara[j]); 13 | } 14 | printf("\n"); 15 | cnt++; 16 | return; 17 | } 18 | for(int i = 0; i < N; i++) { 19 | if(used[i]) 20 | continue; 21 | ara[n] = 'A' + i; 22 | used[i] = 1; 23 | permut(n + 1); 24 | used[i] = 0; 25 | if(cnt == K) 26 | break; 27 | } 28 | } 29 | int main() 30 | { 31 | int T; 32 | scanf("%d", &T); 33 | int caseno = 0; 34 | while(T--) { 35 | scanf("%d %d", &N, &K); 36 | cnt = 0; 37 | printf("Case %d:\n",++caseno); 38 | permut(0); 39 | } 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /LightOJ/1025 - The Specials Menu - 1380895.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll dp[70][70]; 5 | char ara[70]; 6 | ll solve(ll left, ll right) 7 | { 8 | if(left > right) return 0; 9 | if(left == right) return 1; 10 | ll &ret = dp[left][right]; 11 | if(ret != -1) return ret; 12 | ret = solve(left + 1, right) + solve(left, right - 1) - solve(left + 1, right - 1); 13 | if(ara[left] == ara[right]) 14 | ret += 1 + solve(left + 1, right - 1); 15 | return ret; 16 | } 17 | int main() 18 | { 19 | ll t, cs = 0; 20 | cin >> t; 21 | while(t--) { 22 | memset(dp, -1, sizeof(dp)); 23 | scanf("%s", ara); 24 | printf("Case %lld: %lld\n", ++cs, solve(0, strlen(ara) - 1)); 25 | } 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /LightOJ/1033 - Generating Palindromes - 1381254.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll dp[110][110]; 5 | string s; 6 | ll solve(ll left, ll right) 7 | { 8 | if(left >= right) 9 | return 0; 10 | ll &ret = dp[left][right]; 11 | if(ret != -1) 12 | return ret; 13 | if(s[left] != s[right]) 14 | ret = min(1 + solve(left + 1, right), 1 + solve(left, right - 1)); 15 | else 16 | ret = solve(left + 1, right - 1); 17 | return ret; 18 | } 19 | int main() 20 | { 21 | std::ios_base::sync_with_stdio(false); 22 | ll t, cs = 0; 23 | cin >> t; 24 | while(t--) { 25 | memset(dp, -1, sizeof(dp)); 26 | cin >> s; 27 | ll right = s.length() - 1; 28 | ll ans = solve(0, right); 29 | printf("Case %lld: %lld\n", ++cs, ans); 30 | } 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /LightOJ/1042 - Secret Origins - 1015502.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | long long N, dec; 6 | int T, i, j; 7 | cin >> T; 8 | for(i = 1; i <= T; i++) { 9 | deque b; 10 | deque :: iterator it; 11 | dec = 0; 12 | scanf("%lld", &N); 13 | while(N != 0) { 14 | b.push_front(N % 2); 15 | N = N / 2; 16 | } 17 | b.push_front(0); 18 | next_permutation(b.begin(), b.end()); 19 | for(it = b.end() - 1, j = 0; it >= b.begin(); it--, j++) { 20 | dec += (*it * pow(2, j)); 21 | } 22 | printf("Case %d: %lld\n", i, dec); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /LightOJ/1045 - Digits of Factorial - 1008949.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define siz 1000009 4 | double ara[siz]; 5 | int main() 6 | { 7 | int T; 8 | scanf("%d", &T); 9 | double r; 10 | for(int i = 1; i < siz; i++) 11 | ara[i] = ara[i - 1] + log(i+0.0); 12 | for(int i = 1; i <= T; i++) { 13 | int n, b; 14 | scanf("%d %d", &n, &b); 15 | r = floor(ara[n]/log(b*1.0)) + 1; 16 | printf("Case %d: %0.0lf\n", i, r); 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LightOJ/1047 - Neighbor House - 1469337.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll dp[23][3], cst[23][3], n; 5 | ll solve(ll pos, ll prv) 6 | { 7 | if(pos <= 0) 8 | return 0; 9 | ll &ret = dp[pos][prv]; 10 | if(ret != -1) 11 | return ret; 12 | ret = 1e18; 13 | for(ll i = 0; i < 3; i++) { 14 | if(i != prv || n == pos) 15 | ret = min(ret, cst[pos][i] + solve(pos - 1, i)); 16 | } 17 | return ret; 18 | } 19 | int main() 20 | { 21 | ll t, cs = 0; 22 | cin >> t; 23 | while(t--) { 24 | memset(dp, -1, sizeof(dp)); 25 | scanf("%lld", &n); 26 | for(ll i = 1; i <= n; i++) { 27 | for(ll j = 0; j < 3; j++) 28 | scanf("%lld", &cst[i][j]); 29 | } 30 | printf("Case %lld: %lld\n", ++cs, solve(n, 0)); 31 | } 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /LightOJ/1053 - Higher Math - 990068.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, a, b, c, n1, n2, mx, i; 5 | scanf("%d", &T); 6 | for(i = 1; i <= T; i++) { 7 | scanf("%d %d %d", &a, &b, &c); 8 | mx = a; 9 | n1 = b; 10 | n2 = c; 11 | if(mx < b) { 12 | mx = b; 13 | n1 = a; 14 | n2 = c; 15 | } 16 | if(mx < c) { 17 | mx = c; 18 | n1 = a; 19 | n2 = b; 20 | } 21 | if(n1 * n1 + n2 * n2 == mx * mx) 22 | printf("Case %d: yes\n", i); 23 | else 24 | printf("Case %d: no\n", i); 25 | } 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /LightOJ/1056 - Olympics - 1066463.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | int main() 5 | { 6 | int t, i, a, b, s; 7 | double l, w, ld, th, sm, cr; 8 | scanf("%d", &t); 9 | for(i = 1; i<= t; i++) { 10 | scanf("%d : %d", &a, &b); 11 | s = a + b; 12 | ld = sqrt(a * a + b * b) / 2.0; 13 | th = acos((2.0 * ld * ld - b * b) / (2.0 * ld * ld)); 14 | sm = ld * th; 15 | cr = a + sm; 16 | l = (200.0 * a) / cr; 17 | w = (b * l) / (a * 1.0); 18 | printf("Case %d: %lf %lf\n", i, l, w); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /LightOJ/1062 - Crossed Ladders - 1092446.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define er 1e-12 4 | int main() 5 | { 6 | double x, y, c; 7 | int i, n; 8 | scanf("%d", &n); 9 | for(int i = 1; i <= n; i++) { 10 | scanf("%lf %lf %lf", &x, &y, &c); 11 | int tmp = 100; 12 | double lo = 0, hi = min(x, y), w; 13 | while(tmp--) { 14 | double mid = (lo + hi) / 2; 15 | double h1 = sqrt(x * x - mid * mid); 16 | double h2 = sqrt(y * y - mid * mid); 17 | double ct = (h1 * h2) / (h1 + h2); 18 | if(abs(ct - c) <= er) { 19 | w = mid; 20 | } 21 | if(ct > c) 22 | lo = mid; 23 | else 24 | hi = mid; 25 | } 26 | printf("Case %d: %f\n", i, w); 27 | } 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /LightOJ/1069 - Lift - 990075.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, i, m, l, time; 5 | scanf("%d", &T); 6 | for(i = 1; i <= T; i++) { 7 | scanf("%d %d", &m, &l); 8 | if(m <= l) 9 | time = l * 4 + 19; 10 | else 11 | time = m * 4 + (m - l) * 4 + 19; 12 | printf("Case %d: %d\n", i, time); 13 | } 14 | return 0; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /LightOJ/1072 - Calm Down - 990108.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define pi acos(-1.) 4 | int main() 5 | { 6 | int T, i; 7 | double r, R, n, s; 8 | scanf("%d", &T); 9 | for(i = 1; i <= T; i++) { 10 | scanf("%lf %lf", &R, &n); 11 | s = sin(pi / n); 12 | r = (R * s) / (1 + s); 13 | if(r - (int)r > 0) 14 | printf("Case %d: %0.10lf\n", i, r); 15 | else 16 | printf("Case %d: %0.0lf\n", i, r); 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LightOJ/1090 - Trailing Zeroes (II) - 1015514.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define siz 1000000 4 | long long t[siz + 10]; 5 | long long f[siz + 10]; 6 | int main() 7 | { 8 | for(int i = 2; i <= siz; i++) { 9 | int j = i; 10 | int temp = 0; 11 | while(j % 2 == 0) { 12 | j /= 2; 13 | temp++; 14 | } 15 | t[i] = t[i - 1] + temp; 16 | temp = 0; 17 | while(j % 5 == 0) { 18 | j /= 5; 19 | temp++; 20 | } 21 | f[i] = f[i - 1] + temp; 22 | } 23 | int T; 24 | scanf("%d", &T); 25 | for(int i = 1; i <= T; i++) { 26 | int n, r, p, q, n2, n5; 27 | scanf("%d %d %d %d", &n, &r, &p, &q); 28 | n2 = (t[p] - t[p - 1]) * q + t[n] - t[r] - t[n - r]; 29 | n5 = (f[p] - f[p - 1]) * q + f[n] - f[r] - f[n - r]; 30 | r = min(n2, n5); 31 | printf("Case %d: %d\n", i, r); 32 | } 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /LightOJ/1098 - A New Function - 1403588.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll t, cs = 0; 7 | cin >> t; 8 | while(t--) { 9 | ll n; 10 | scanf("%lld", &n); 11 | ll lim = sqrt(n); 12 | ll ans = 0; 13 | for(ll i = 2; i <= lim; i++) { 14 | ans += ( (n / i - 1) * i); 15 | } 16 | ll mxOccur = n / (lim + 1); 17 | for(ll i = 2; i <= mxOccur; i++) { 18 | ll beforeStart = n / (i + 1); 19 | ll stop = n / i; 20 | ll occur = i - 1; 21 | ll sumOfRange = stop * (stop + 1) / 2 - beforeStart * (beforeStart + 1) / 2; 22 | ans += (occur * sumOfRange); 23 | } 24 | printf("Case %lld: %lld\n", ++cs, ans); 25 | } 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /LightOJ/1104 - Birthday Paradox - 1489571.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | #define eps 1e-6 5 | int main() 6 | { 7 | ll t, cs = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n; 11 | scanf("%lld", &n); 12 | ll ans = 1; 13 | double prob = 1; 14 | for(ll i = 2; i <= n; i++) { 15 | prob *= ((n - i + 1) / (n * 1.0)); 16 | if(prob < 0.5) { 17 | ans = i - 1; 18 | break; 19 | } 20 | } 21 | printf("Case %lld: %lld\n", ++cs, ans); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /LightOJ/1107 - How Cow - 990129.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, i, j, M, x1, y1, x2, y2, x3, y3; 5 | scanf("%d", &T); 6 | for(i = 1; i <= T; i++) { 7 | scanf("%d %d %d %d", &x1, &y1, &x2, &y2); 8 | scanf("%d", &M); 9 | printf("Case %d:\n", i); 10 | for(j = 1; j <= M; j++) { 11 | scanf("%d %d", &x3, &y3); 12 | if(x3 > x1 && x3 < x2 && y3 > y1 && y3 < y2) 13 | printf("Yes\n"); 14 | else 15 | printf("No\n"); 16 | } 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LightOJ/1116 - Ekka Dokka - 990144.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, i; 5 | long long W, j, k; 6 | scanf("%d", &T); 7 | for(i = 1; i <= T; i++) { 8 | scanf("%lld", &W); 9 | if(W & 1) 10 | printf("Case %d: Impossible\n", i); 11 | else { 12 | for(j = W / 2; j >= 3; j /= 2) { 13 | if(W % j == 0 && j % 2 != 0) { 14 | k = W / j; 15 | break; 16 | } 17 | } 18 | printf("Case %d: %lld %lld\n", i, j, k); 19 | } 20 | } 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /LightOJ/1122 - Digit Count - 1364416.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | #define pb push_back 5 | ll dp[12][12], m, n, dig[10]; 6 | ll solve(ll pos, ll last) 7 | { 8 | if(pos == 0) 9 | return 1; 10 | ll &ret = dp[pos][last]; 11 | if(ret != -1) 12 | return ret; 13 | ll pos2 = n - pos; 14 | ll rt = 0; 15 | for(ll i = 1; i <= m; i++) { 16 | if(last == 0 || abs(dig[i] - last) <= 2) 17 | rt += solve(pos - 1, dig[i]); 18 | } 19 | return ret = rt; 20 | } 21 | int main() 22 | { 23 | ll t, caseno = 0; 24 | cin >> t; 25 | while(t--) { 26 | memset(dp, -1, sizeof(dp)); 27 | scanf("%lld %lld", &m, &n); 28 | for(ll i = 1; i <= m; i++) 29 | scanf("%lld", &dig[i]); 30 | printf("Case %lld: %lld\n", ++caseno, solve(n, 0) ); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /LightOJ/1138 - Trailing Zeroes (III) - 1092438.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t; 6 | cin >> t; 7 | for(int i = 1; i <= t; i++) { 8 | int n; 9 | scanf("%d", &n); 10 | int lo = 0, hi = INT_MAX, r = -1; 11 | while(lo <= hi) { 12 | int mid = lo / 2 + hi / 2, cnt = 0; 13 | int tmp = mid; 14 | while(tmp != 0) { 15 | tmp /= 5; 16 | cnt += tmp; 17 | } 18 | if(cnt == n) { 19 | r = mid; 20 | hi = mid - 1; 21 | } 22 | else if(cnt > n) 23 | hi = mid - 1; 24 | else 25 | lo = mid + 1; 26 | } 27 | if(r != -1) 28 | printf("Case %d: %d\n", i , r); 29 | else 30 | printf("Case %d: impossible\n", i); 31 | } 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /LightOJ/1166 - Old Sorting - 1356406.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll pos[105], ara[105]; 5 | int main() 6 | { 7 | ll t, cs = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n; 11 | scanf("%lld", &n); 12 | for(ll i = 1; i <= n; i++) { 13 | scanf("%lld", &ara[i]); 14 | pos[ ara[i] ] = i; 15 | } 16 | ll cnt = 0; 17 | for(ll i = 1; i <= n; i++) { 18 | if(i == ara[i]) 19 | continue; 20 | //cout << ara[i] << endl; 21 | ll tmp = pos[ i]; 22 | swap(ara[i], ara[ tmp ]); 23 | pos[ ara[ tmp] ] = tmp; 24 | pos[i] = i; 25 | cnt++; 26 | } 27 | printf("Case %lld: %lld\n", ++cs, cnt); 28 | } 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /LightOJ/1178 - Trapezium - 1278721.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll t, caseno = 0; 7 | cin >> t; 8 | while(t--) { 9 | double a, b, c, d; 10 | cin >> a >> b >> c >> d; 11 | double base = abs(a - c); 12 | double th = acos( (d * d + base * base - b * b) / (2 * d * base) ); 13 | double h = d * sin(th); 14 | printf("Case %lld: %0.9f\n", ++caseno, 0.5 * (a + c) * h); 15 | } 16 | return 0; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /LightOJ/1182 - Parity - 1109708.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int n, t, caseno = 0; 6 | scanf("%d", &t); 7 | while(t--) { 8 | scanf("%d", &n); 9 | long long int x = 1, cnt = 0; 10 | while(x <= n) { 11 | if(n & x) 12 | cnt++; 13 | x = x << 1; 14 | } 15 | printf("Case %d: ", ++caseno); 16 | if(cnt % 2 == 0) 17 | printf("even\n"); 18 | else 19 | printf("odd\n"); 20 | } 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /LightOJ/1186 - Incredible Chess - 1260674.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll w[105], b[105]; 5 | int main() 6 | { 7 | ll t, caseno = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n; 11 | scanf("%lld", &n); 12 | for(ll i = 1; i <= n; i++) 13 | scanf("%lld", &w[i]); 14 | for(ll i = 1; i <= n; i++) 15 | scanf("%lld", &b[i]); 16 | ll sum = 0; 17 | for(ll i = 1; i <= n; i++) 18 | sum ^= (b[i] - w[i] - 1); 19 | if(sum == 0) 20 | printf("Case %lld: black wins\n", ++caseno); 21 | else 22 | printf("Case %lld: white wins\n", ++caseno); 23 | } 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /LightOJ/1187 - Lining up Students - 1191795.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t, caseno = 0; 6 | cin >> t; 7 | while(t--) { 8 | int n; 9 | scanf("%d", &n); 10 | int id = 1; 11 | for(int i = 1; i <= n; i++) { 12 | int in; 13 | scanf("%d", &in); 14 | if(i - in <= id && i != 1) id++; 15 | } 16 | printf("Case %d: %d\n", ++caseno, id); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /LightOJ/1192 - Left Right - 1260682.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll a[105], b[105]; 5 | int main() 6 | { 7 | ll t, caseno = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n; 11 | scanf("%lld", &n); 12 | bool state = 0; 13 | ll indx1 = 1, indx2 = 1; 14 | for(ll i = 1; i <= n + n; i++) { 15 | if(state) 16 | scanf("%lld", &b[indx1++]); 17 | else 18 | scanf("%lld", &a[indx2++]); 19 | state ^= 1; 20 | } 21 | ll sum = 0; 22 | for(ll i = 1; i <= n; i++) 23 | sum ^= (b[i] - a[i] - 1); 24 | if(sum == 0) 25 | printf("Case %lld: Bob\n", ++caseno); 26 | else 27 | printf("Case %lld: Alice\n", ++caseno); 28 | } 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /LightOJ/1202 - Bishops - 1003257.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | cin >> T; 7 | for(int i = 1; i <= T; i++) { 8 | int r1, r2, c1, c2; 9 | cin >> r1 >> c1 >> r2 >> c2; 10 | if((r1 & 1) == (r2 & 1)) { 11 | if((c1 & 1) != (c2 & 1)) { 12 | printf("Case %d: impossible\n", i); 13 | continue; 14 | } 15 | } 16 | else { 17 | if((c1 & 1) == (c2 & 1)) { 18 | printf("Case %d: impossible\n", i); 19 | continue; 20 | } 21 | } 22 | printf("Case %d: ", i); 23 | if(abs(r2 - r1) == abs(c2 - c1)) 24 | printf("1\n"); 25 | else 26 | printf("2\n"); 27 | } 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /LightOJ/1211 - Intersection of Cubes - 1003386.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | scanf("%d", &T); 7 | for(int j = 1; j <= T; j++) { 8 | int n; 9 | scanf("%d", &n); 10 | int x1[n], x2[n], y1[n], y2[n], z1[n], z2[n]; 11 | for(int i = 0; i < n; i++) 12 | scanf("%d %d %d %d %d %d", &x1[i], &y1[i], &z1[i], &x2[i], &y2[i], &z2[i]); 13 | int xl = INT_MIN, xh = INT_MAX, yl = INT_MIN, yh = INT_MAX, zl = INT_MIN, zh = INT_MAX; 14 | for(int i = 0; i < n; i++) { 15 | xl = max(xl, x1[i]); 16 | xh = min(xh, x2[i]); 17 | yl = max(yl, y1[i]); 18 | yh = min(yh, y2[i]); 19 | zl = max(zl, z1[i]); 20 | zh = min(zh, z2[i]); 21 | } 22 | int vol = (xh - xl) * (yh - yl) * (zh - zl); 23 | printf("Case %d: %d\n", j, vol > 0 ? vol : 0); 24 | } 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /LightOJ/1214 - Large Division - 1014513.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | long long int b; 7 | scanf("%d", &T); 8 | for(int i = 1; i <= T; i++) { 9 | char a[250]; 10 | long long int num = 0, mod = 0; 11 | scanf("%s %lld", a, &b); 12 | int j = 0; 13 | if(a[j] == '-') 14 | j = 1; 15 | for(; a[j] != '\0'; j++) { 16 | num += a[j] - 48; 17 | mod = num % b; 18 | num = mod * 10; 19 | } 20 | printf("Case %d: ", i); 21 | if(mod == 0) 22 | printf("divisible\n"); 23 | else 24 | printf("not divisible\n"); 25 | } 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /LightOJ/1216 - Juice in the Glass - 1003729.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define pi acos(-1) 4 | int main() 5 | { 6 | int T; 7 | cin >> T; 8 | for(int i = 1; i <= T; i++) { 9 | double r1, r2, h, p, vol; 10 | double x, r3; 11 | cin >> r1 >> r2 >> h >> p; 12 | x = (h * r2) / (r1 - r2); 13 | r3 = ((p + x) * r2) / x; 14 | vol = (1.0 / 3.0) * pi * r3 * r3 * (p + x) - ((1.0 / 3.0) * pi * r2 * r2 * x); 15 | printf("Case %d: %0.9lf\n", i, vol); 16 | } 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /LightOJ/1225 - Palindromic Numbers (II) - 1015248.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, n, i, rem, n2, num; 5 | scanf("%d", &T); 6 | for(i = 1; i <= T; i++) { 7 | num = 0; 8 | scanf("%d", &n); 9 | n2 = n; 10 | while(n2 > 0) { 11 | rem = n2 % 10; 12 | n2 = n2 / 10; 13 | num = num * 10 + rem; 14 | } 15 | if(num == n) { 16 | printf("Case %d: Yes\n", i); 17 | } 18 | else { 19 | printf("Case %d: No\n", i); 20 | } 21 | } 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /LightOJ/1227 - Boiled Eggs - 1109817.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t, caseno = 0; 6 | scanf("%d", &t); 7 | while(t--) { 8 | int N, P, Q, w, sumw = 0, cnt = 0; 9 | scanf("%d %d %d", &N, &P, &Q); 10 | for(int i = 1; i <= N; i++) { 11 | scanf("%d", &w); 12 | sumw += w; 13 | if(sumw <= Q && i <= P) 14 | cnt++; 15 | } 16 | printf("Case %d: %d\n", ++caseno, cnt); 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LightOJ/1232 - Coin Change (II) - 1092392.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int coin[105]; 4 | int ans[10005]; 5 | int main() 6 | { 7 | int t; 8 | int n, k; 9 | scanf("%d", &t); 10 | for(int i = 1; i <= t; i++) { 11 | scanf("%d %d", &n, &k); 12 | for(int j = 1; j <= n; j++) 13 | scanf("%d", &coin[j]); 14 | for(int j = 1; j <= 10005; j++) 15 | ans[j] = 0; 16 | ans[0] = 1; 17 | for(int j = 1; j <= n; j++) { 18 | for(int l = 1; l <= k; l++) { 19 | if(coin[j] <= l) { 20 | ans[l] += ans[l - coin[j]]; 21 | if(ans[l] >= 100000007) 22 | ans[l] %= 100000007; 23 | } 24 | } 25 | } 26 | printf("Case %d: %d\n", i, ans[k]); 27 | } 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /LightOJ/1241 - Pinocchio - 1015210.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T, n; 6 | scanf("%d", &T); 7 | for(int i = 1; i <= T; i++) { 8 | scanf("%d", &n); 9 | int ara[n], count = 0, cnt; 10 | for(int j = 1; j <= n; j++) { 11 | scanf("%d", &ara[j - 1]); 12 | if(j != 1) { 13 | if(ara[j - 1] > ara[j - 2]) { 14 | cnt = ara[j - 1] - ara[j - 2]; 15 | count += ceil(cnt / 5.0); 16 | } 17 | } 18 | else { 19 | cnt = ara[0] - 2; 20 | count = ceil(cnt / 5.0); 21 | } 22 | } 23 | printf("Case %d: %d\n", i, count); 24 | } 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /LightOJ/1247 - Matrix Game - 1260690.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll row[55]; 5 | int main() 6 | { 7 | ll t, caseno = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n, m; 11 | scanf("%lld %lld", &n, &m); 12 | for(ll i = 1; i <= n; i++) { 13 | ll sum = 0; 14 | for(ll j = 1; j <= m; j++) { 15 | ll in; 16 | scanf("%lld", &in); 17 | sum += in; 18 | } 19 | row[i] = sum; 20 | } 21 | ll xor2 = 0; 22 | for(ll i = 1; i <= n; i++) { 23 | xor2 ^= row[i]; 24 | } 25 | if(xor2 == 0) { 26 | printf("Case %lld: Bob\n", ++caseno); 27 | } 28 | else 29 | printf("Case %lld: Alice\n", ++caseno); 30 | } 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /LightOJ/1247 - Matrix Game - 1260691.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll row[55]; 5 | int main() 6 | { 7 | ll t, caseno = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n, m; 11 | scanf("%lld %lld", &n, &m); 12 | for(ll i = 1; i <= n; i++) { 13 | ll sum = 0; 14 | for(ll j = 1; j <= m; j++) { 15 | ll in; 16 | scanf("%lld", &in); 17 | sum += in; 18 | } 19 | row[i] = sum; 20 | } 21 | ll xor2 = 0; 22 | for(ll i = 1; i <= n; i++) { 23 | xor2 ^= row[i]; 24 | } 25 | if(xor2 == 0) { 26 | printf("Case %lld: Bob\n", ++caseno); 27 | } 28 | else 29 | printf("Case %lld: Alice\n", ++caseno); 30 | } 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /LightOJ/1294 - Positive Negative Sign - 1015252.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int T, j; 5 | long long int sum, n, m; 6 | scanf("%d", &T); 7 | for(j = 1; j <= T; j++) { 8 | scanf("%lld %lld", &n, &m); 9 | sum = (n * m) / 2; 10 | printf("Case %d: %lld\n", j, sum); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /LightOJ/1305 - Area of a Parallelogram - 1015253.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | int T, i; 6 | double Ax, Ay, Bx, By, Cx, Cy, Dx, Dy; 7 | double AB, BC, AC, area, s; 8 | scanf("%d", &T); 9 | for(i = 1; i <= T; i++) { 10 | scanf("%lf %lf %lf %lf %lf %lf", &Ax, &Ay, &Bx, &By, &Cx, &Cy); 11 | Dx = Ax + Cx - Bx; 12 | Dy = Ay + Cy - By; 13 | AB = sqrt(((Ax - Bx) * (Ax - Bx)) + ((Ay - By) * (Ay - By))); 14 | BC = sqrt(((Bx - Cx) * (Bx - Cx)) + ((By - Cy) * (By - Cy))); 15 | AC = sqrt(((Ax - Cx) * (Ax - Cx)) + ((Ay - Cy) * (Ay - Cy))); 16 | s = (AB + BC + AC) / 2.0; 17 | area = sqrt(s * (s- AB) * (s - BC) * (s - AC)); 18 | area *= 2.0; 19 | printf("Case %d: %0.0lf %0.0lf %0.0lf\n", i, Dx, Dy, area); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /LightOJ/1307 - Counting Triangles - 1357800.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll ara[2009]; 5 | int main() 6 | { 7 | ll t, cs = 0; 8 | cin >> t; 9 | while(t--) { 10 | ll n; 11 | scanf("%lld", &n); 12 | for(ll i = 1; i <= n; i++) 13 | scanf("%lld", &ara[i]); 14 | sort(ara + 1, ara + n + 1); 15 | ll ans = 0; 16 | for(ll i = 1; i <= n; i++) { 17 | for(ll j = i + 1; j <= n; j++) { 18 | ll sum = ara[i] + ara[j]; 19 | ll pos = lower_bound(ara + 1, ara + n + 1, sum) - ara; 20 | ans += max(0LL, pos - 1 - j); 21 | } 22 | } 23 | printf("Case %lld: %lld\n", ++cs, ans); 24 | } 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /LightOJ/1311 - Unlucky Bird - 1109874.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int t, caseno = 0; 6 | scanf("%d", &t); 7 | while(t--) { 8 | double u1, u2, v3, a1, a2; 9 | scanf("%lf %lf %lf %lf %lf", &u1, &u2, &v3, &a1, &a2); 10 | double t1 = u1 / a1; 11 | double t2 = u2 / a2; 12 | double t = max(t1, t2); 13 | double distb = v3 * t; 14 | double s1 = (u1 * u1) / (2.0 * a1); 15 | double s2 = (u2 * u2) / (2.0 * a2); 16 | printf("Case %d: %0.8f %0.8f\n", ++caseno, s1 + s2, distb); 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LightOJ/1331 - Agent J - 1015317.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | int T, i; 6 | double r1, r2, r3, a, b, c, s; 7 | double circar, triar; 8 | scanf("%d", &T); 9 | for(i = 1; i <= T; i++) { 10 | scanf("%lf %lf %lf", &r1, &r2, &r3); 11 | a = r1 + r2; 12 | b = r2 + r3; 13 | c = r1 + r3; 14 | s = (a + b + c) / 2.0; 15 | triar = sqrt(s * (s - a) * (s - b) * (s - c)); 16 | circar = (r1 * r1) / 2.0 * acos((c * c + a * a - b * b) / (2.0 * c * a)) + (r3 * r3) / 2.0 * acos((b * b + c * c - a * a) / (2.0 * b * c)) + (r2 * r2) / 2.0 * acos((a * a + b * b - c * c) / (2.0 * a * b)); 17 | printf("Case %d: %lf\n", i, triar - circar); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /LightOJ/1336 - Sigma Function - 1339393.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll t, cs = 0; 7 | cin >> t; 8 | while(t--) { 9 | ll n, cnt = 0; 10 | scanf("%lld", &n); 11 | ll sqt = sqrt(n); 12 | sqt++; 13 | for(ll i = 1; i <= sqt; i++) { 14 | if(i * i <= n) 15 | cnt++; 16 | if(2 * i * i <= n) 17 | cnt++; 18 | } 19 | printf("Case %lld: %lld\n", ++cs, n - cnt); 20 | } 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /LightOJ/1385 - Kingdom Division - 1278883.cpp: -------------------------------------------------------------------------------- 1 | /// a / d1 = b / c --> (Triangles' base BE) 2 | /// (a + d1) / d2 = (a + b) / (c + d1 + d2) --> (Triangle's base AB) 3 | /// d1 = TRI XFE, d2 = TRI AFE 4 | #include 5 | using namespace std; 6 | #define ll long long 7 | int main() 8 | { 9 | ll t, caseno = 0; 10 | cin >> t; 11 | while(t--) { 12 | double a, b, c; 13 | scanf("%lf %lf %lf", &a, &b, &c); 14 | if(b == 0) { 15 | printf("Case %lld: -1\n", ++caseno); 16 | continue; 17 | } 18 | else { 19 | double d1 = (a * c) / b; 20 | double ad1 = a + d1, cd1 = c + d1, ab = a + b; 21 | if(ab - ad1 <= 0.000000000) { 22 | printf("Case %lld: -1\n", ++caseno); 23 | continue; 24 | } 25 | double d2 = (ad1 * cd1) / (ab - ad1); 26 | printf("Case %lld: %0.10f\n", ++caseno, d1 + d2); 27 | } 28 | } 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /LightOJ/1387 - Setu - 1016454.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | scanf("%d", &T); 7 | for(int i = 1; i <= T; i++) { 8 | int n, l; 9 | long long k = 0; 10 | scanf("%d", &n); 11 | printf("Case %d:\n", i); 12 | for(int j = 1; j <= n; j++) { 13 | char s[10]; 14 | scanf("%s", s); 15 | if(!strcmp(s, "report")) 16 | printf("%lld\n", k); 17 | else { 18 | scanf("%d", &l); 19 | k += l; 20 | } 21 | } 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /LightOJ/1389 - Scarecrow - 1258482.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | char ara[109]; 5 | int main() 6 | { 7 | ll t, caseno = 0; 8 | cin >> t; 9 | ll n; 10 | while(t--) { 11 | scanf("%lld", &n); 12 | scanf("%s", ara + 1); 13 | ll cnt = 0; 14 | bool ase = 0, crow = 0; 15 | for(ll i = 1; i <= n + 1; i++) { 16 | bool check = 0; 17 | if(ase) { 18 | cnt++; 19 | //cout << i << " " << ara[i] << endl; 20 | crow = 1; 21 | check = 1; 22 | } 23 | if(ase) 24 | ase = 0; 25 | if(ara[i] == '.' && !crow) 26 | ase = 1; 27 | if(crow && !check) 28 | crow = 0; 29 | } 30 | printf("Case %lld: %lld\n", ++caseno, cnt); 31 | } 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /LightOJ/1393 - Crazy Calendar - 1260823.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | int main() 5 | { 6 | ll t, caseno = 0; 7 | cin >> t; 8 | while(t--) { 9 | ll n, m; 10 | scanf("%lld %lld", &n, &m); 11 | ll sum = 0; 12 | for(ll i = 1; i <= n; i++) { 13 | for(ll j = 1; j <= m; j++) { 14 | ll in; 15 | scanf("%lld", &in); 16 | if( (i + j) % 2 != (n + m) % 2) 17 | sum ^= in; 18 | } 19 | } 20 | if(sum == 0) 21 | printf("Case %lld: lose\n", ++caseno); 22 | else 23 | printf("Case %lld: win\n", ++caseno); 24 | } 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /LightOJ/1414 - February 29 - 1015963.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main() 4 | { 5 | int T; 6 | scanf("%d", &T); 7 | for(int i = 1; i <= T; i++) { 8 | string m1, m2; 9 | int d1, d2, y1, y2, lp, check = 0; 10 | cin >> m1; 11 | scanf("%d, %d", &d1, &y1); 12 | cin >> m2; 13 | scanf("%d, %d", &d2, &y2); 14 | y1--; 15 | lp = (y2 / 4 - y2 / 100 + y2 / 400) - (y1 / 4 - y1 / 100 + y1/ 400); 16 | y1++; 17 | if(y1 % 4 == 0 && (y1 % 100 != 0 || y1 % 400 == 0)) 18 | check = 1; 19 | if(m1 != "January" && m1 != "February" && check == 1) 20 | lp--; 21 | if(y2 % 4 == 0 && (y2 % 100 != 0 || y2 % 400 == 0)) 22 | check = 2; 23 | if(m2 == "January" && check == 2) 24 | lp--; 25 | if(m2 == "February" && d2 < 29 && check == 2) 26 | lp--; 27 | printf("Case %d: %d\n", i, lp); 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /LightOJ/1425 - The Monkey and the Oiled Bamboo - 1258738.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ll long long 4 | ll ara[100009], n; 5 | bool pos(ll k) 6 | { 7 | for(ll i = 1; i <= n; i++) { 8 | if(ara[i]- ara[i - 1] > k) 9 | return false; 10 | if(ara[i] - ara[i - 1] == k) 11 | k--; 12 | } 13 | return true; 14 | } 15 | int main() 16 | { 17 | ll t, caseno = 0; 18 | cin >> t; 19 | while(t--) { 20 | scanf("%lld", &n); 21 | for(ll i = 1; i <= n; i++) 22 | scanf("%lld", &ara[i]); 23 | ll lo = 1, hi = 1e9, ans = -1; 24 | while(lo <= hi) { 25 | ll mid = (lo + hi) / 2; 26 | if(pos(mid)) { 27 | hi = mid - 1; 28 | ans = mid; 29 | } 30 | else 31 | lo = mid + 1; 32 | } 33 | printf("Case %lld: %lld\n", ++caseno, ans); 34 | } 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /LightOJ/1433 - Minimum Arc Distance - 1015268.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | int T, i, Ox, Oy, Ax, Ay, Bx, By; 6 | double a, c, pi, th, arc; 7 | pi = 2.0 * acos(0.00); 8 | scanf("%d", &T); 9 | for(i = 1; i <= T; i++) { 10 | scanf("%d %d %d %d %d %d", &Ox, &Oy, &Ax, &Ay, &Bx, &By); 11 | a = (Ox - Bx) * (Ox - Bx) + (Oy - By) * (Oy - By); 12 | a = sqrt(a); 13 | c = (Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By); 14 | c = sqrt(c); 15 | th = (a * a + a * a - c * c) / (2.0 * a * a); 16 | th = acos(th); 17 | arc = th * a; 18 | printf("Case %d: %lf\n",i, arc); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Competitive-Programming 2 | 1. Some of My Accepted Submissions in Various Online Judges 3 | 2. The Templates I've Used (Collected From Several Sources) 4 | 3. Some Useful Books 5 | -------------------------------------------------------------------------------- /SPOJ/ADACOINS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | bitset <100009> posSum; 7 | ll cumsum[100009]; 8 | 9 | int main() 10 | 11 | { 12 | ll n, q; 13 | cin >> n >> q; 14 | 15 | posSum[0] = 1; 16 | for(ll i = 1; i <= n; i++) { 17 | ll in; 18 | scanf("%lld", &in); 19 | posSum |= (posSum << in); 20 | } 21 | 22 | for(ll i = 1; i <= 100000; i++) 23 | cumsum[i] = posSum[i] + cumsum[i - 1]; 24 | 25 | for(ll i = 1; i <= q; i++) { 26 | ll l, r; 27 | scanf("%lld %lld", &l, &r); 28 | printf("%lld\n", cumsum[r] - cumsum[l - 1]); 29 | } 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /SPOJ/AIBOHP.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll int 5 | 6 | ll dp[6105][6105]; 7 | string s; 8 | 9 | ll solve(ll l, ll r) 10 | 11 | { 12 | if(l >= r) return 0; 13 | ll &ret = dp[l][r]; 14 | if(ret != -1) return ret; 15 | 16 | ret = 1e8; 17 | if(s[l] != s[r]) ret = min(1 + solve(l, r - 1), 1 + solve(l + 1, r)); 18 | else ret = solve(l + 1, r - 1); 19 | 20 | return ret; 21 | } 22 | 23 | int main() 24 | 25 | { 26 | std::ios_base::sync_with_stdio(false); 27 | ll t; 28 | cin >> t; 29 | while(t--) { 30 | memset(dp, -1, sizeof(dp)); 31 | cin >> s; 32 | cout << solve(0, s.length() - 1) << endl; 33 | } 34 | 35 | return 0; 36 | -------------------------------------------------------------------------------- /SPOJ/ALTSEQ.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll ara[100009], n, dp[5009][5009]; 6 | 7 | ll solve(ll pos, ll last) 8 | 9 | { 10 | if(pos > n) 11 | return 0; 12 | ll &ret = dp[pos][last]; 13 | if(ret != -1) 14 | return ret; 15 | 16 | ret = 0; 17 | if(last == 0 || ( abs(ara[last]) < abs(ara[pos]) && ( (ara[last] < 0 && ara[pos] > 0) || (ara[last] > 0 && ara[pos] < 0) ) ) ) 18 | ret = 1 + solve(pos + 1, pos); 19 | 20 | ret = max(ret, solve(pos + 1, last)); 21 | 22 | return ret; 23 | } 24 | 25 | int main() 26 | 27 | { 28 | memset(dp, -1, sizeof(dp)); 29 | cin >> n; 30 | for(ll i = 1; i <= n; i++) 31 | scanf("%lld", &ara[i]); 32 | 33 | cout << solve(1, 0) << endl; 34 | 35 | return 0; 36 | -------------------------------------------------------------------------------- /SPOJ/APS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll int 5 | 6 | ll dv[10000009]; 7 | long long ans[10000009]; 8 | bool mark[3170]; 9 | 10 | int main() 11 | 12 | { 13 | for(ll i = 2; i <= 3163; i++) { 14 | if(mark[i] == 0) { 15 | for(ll j = i + i; j <= 10000000; j += i) { 16 | if(j < 3170) 17 | mark[j] = 1; 18 | 19 | if(dv[j] == 0) 20 | dv[j] = i; 21 | else 22 | dv[j] = min(dv[j], i); 23 | } 24 | } 25 | } 26 | 27 | for(ll i = 2; i <= 10000000; i++) { 28 | if(dv[i] == 0) 29 | ans[i] = ans[i - 1] + (long long)i; 30 | else 31 | ans[i] = ans[i - 1] + (long long)dv[i]; 32 | } 33 | 34 | ll t; 35 | cin >> t; 36 | while(t--) { 37 | ll n; 38 | scanf("%d", &n); 39 | printf("%lld\n", ans[n]); 40 | } 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /SPOJ/CIRCLE_E.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | t = int(input()) 4 | i = 1 5 | while i <= t: 6 | inp = input() 7 | li = inp.split() 8 | r1 = float( li[0]); r2 = float(li[1]); r3 = float(li[2]) 9 | d = (r1 * r2) + (r2 * r3) + (r3 * r1) + 2.0 * math.sqrt( (r1 + r2 + r3) * (r1 * r2 * r3) ) 10 | ans = (r1 * r2 * r3) / d 11 | print ( format(ans, '.6f')) 12 | -------------------------------------------------------------------------------- /SPOJ/CIRCLE_H.py: -------------------------------------------------------------------------------- 1 | import math 2 | import decimal 3 | 4 | t = int(input()) 5 | i = 1 6 | decimal.getcontext().prec = 85 7 | while i <= t: 8 | inp = input() 9 | li = inp.split() 10 | r1 = decimal.Decimal(li[0]); r2 = decimal.Decimal(li[1]); r3 = decimal.Decimal(li[2]) 11 | ans = (r1 * r2) + (r2 * r3) + (r3 * r1) + 2 * decimal.Decimal( (r1 + r2 + r3) * (r1 * r2 * r3) ).sqrt() 12 | ans = (r1 * r2 * r3) / ans 13 | print ( decimal.Decimal(str(ans)).quantize(decimal.Decimal('.00000000000000000000000000000000000000000000000001'), rounding = decimal.ROUND_DOWN)) 14 | -------------------------------------------------------------------------------- /SPOJ/DISUBSTR.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char ara[1009]; 5 | #define ll unsigned long long 6 | unordered_map ase; 7 | 8 | int main() 9 | 10 | { 11 | int n; 12 | scanf("%lld", &n); 13 | while(n--) { 14 | scanf("%s", ara); 15 | ll len = strlen(ara); 16 | ll cnt = 0, hsh, gun; 17 | 18 | for(ll i = 0; i < len; i++) { 19 | hsh = 0, gun = 1; 20 | for(ll j = i; j < len; j++) { 21 | hsh += (ara[j] - 32) * gun; 22 | gun *= 101; 23 | 24 | if(ase.find(hsh) == ase.end()) { 25 | cnt++; 26 | ase[hsh] = 1; 27 | } 28 | } 29 | } 30 | 31 | printf("%lld\n", cnt); 32 | ase.clear(); 33 | } 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /SPOJ/EIGHTS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | ll pat[] = {192, 442, 692, 942}; 6 | 7 | int main() 8 | 9 | { 10 | ll t; 11 | cin >> t; 12 | while(t--) { 13 | ll k; 14 | scanf("%lld", &k); 15 | ll num = (k - 1) % 4; 16 | ll mult = (k - 1) / 4; 17 | printf("%lld\n", mult * 1000 + pat[num]); 18 | } 19 | 20 | return 0; 21 | -------------------------------------------------------------------------------- /SPOJ/HUBULLU.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll t; 10 | cin >> t; 11 | while(t--) { 12 | ll n, state; 13 | scanf("%lld %lld", &n, &state); 14 | if(state == 0) 15 | printf("Airborne wins.\n"); 16 | else 17 | printf("Pagfloyd wins.\n"); 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /SPOJ/LPIS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll cnt[1000009]; 7 | 8 | int main() 9 | 10 | { 11 | ll n, ans = 0; 12 | cin >> n; 13 | for(ll i = 1; i <= n; i++) { 14 | ll in; 15 | scanf("%lld", &in); 16 | cnt[in] = max(1LL, cnt[in - 1] + 1); 17 | ans = max(ans, cnt[in]); 18 | } 19 | 20 | cout << ans << endl; 21 | 22 | return 0; 23 | -------------------------------------------------------------------------------- /SPOJ/MCOINS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int dp[1000001], n, k, l, m, i; 5 | 6 | int solve(int c) 7 | 8 | { 9 | if(c < 0) 10 | return 0; 11 | 12 | if(dp[c] != -1) { 13 | //cout << c << " " << dp[c] << endl; 14 | return !dp[c]; 15 | } 16 | 17 | return dp[c] = solve(c - 1) | solve(c - k) | solve(c - l); 18 | } 19 | 20 | int main() 21 | 22 | { 23 | memset(dp, -1, sizeof(dp)); 24 | dp[0] = 0; 25 | dp[1] = 1; 26 | scanf("%d %d %d", &k, &l, &m); 27 | for(i = 2; i <= 1000000; i++) { 28 | /*if(i - 1 >= 0) 29 | dp[i] |= !dp[i - 1]; 30 | if(i - k >= 0) 31 | dp[i] |= !dp[i - k]; 32 | if(i - l >= 0) 33 | dp[i] |= !dp[i - l];*/ 34 | solve(i); 35 | } 36 | 37 | for(i = 1; i <= m; i++) { 38 | scanf("%d", &n); 39 | if(dp[n]) 40 | printf("A"); 41 | else 42 | printf("B"); 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /SPOJ/NGM.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | int main() 7 | 8 | { 9 | ll n; 10 | cin >> n; 11 | if(n < 10) { 12 | cout << 1 << endl << n << endl; 13 | } 14 | else if(n % 10 == 0) { 15 | printf("2\n"); 16 | } 17 | else { 18 | cout << 1 << endl << n % 10 << endl; 19 | } 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /SPOJ/ORDERS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | #define ll long long 7 | ll val[200009]; 8 | 9 | int main() 10 | 11 | { 12 | ll t; 13 | cin >> t; 14 | while(t--) { 15 | vector v; 16 | ll n; 17 | scanf("%lld", &n); 18 | v.push_back(0); 19 | for(ll i = 1; i <= n; i++) { 20 | ll in; 21 | scanf("%lld", &in); 22 | ll pos = i - in; 23 | v.insert(v.begin() + pos, i); 24 | } 25 | 26 | for(ll i = 1; i <= n; i++) { 27 | val[ v[i] ] = i; 28 | } 29 | 30 | for(ll i = 1; i <= n; i++) { 31 | if(i != 1) 32 | printf(" "); 33 | printf("%lld", val[i]); 34 | } 35 | printf("\n"); 36 | 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /SPOJ/STPAR.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll long long 5 | 6 | ll ara[1009]; 7 | 8 | stack st; 9 | 10 | int main() 11 | 12 | { 13 | ll n; 14 | while(scanf("%lld", &n) && n != 0) { 15 | for(ll i = 1; i <= n; i++) 16 | scanf("%lld", &ara[i]); 17 | 18 | ll last = 0; 19 | for(ll i = 1; i <= n; i++) { 20 | if(ara[i] - last != 1) 21 | st.push(ara[i]); 22 | else { 23 | last = ara[i]; 24 | while(!st.empty() && st.top() - last == 1) { 25 | last = st.top(); 26 | st.pop(); 27 | } 28 | } 29 | } 30 | 31 | if(st.empty()) { 32 | printf("yes\n"); 33 | } 34 | else { 35 | printf("no\n"); 36 | 37 | while(!st.empty()) 38 | st.pop(); 39 | } 40 | } 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /SPOJ/SYNC13C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define ll int 5 | 6 | int main() 7 | 8 | { 9 | ll t; 10 | 11 | scanf("%d", &t); 12 | ll c1, c2; 13 | while(t--) { 14 | scanf("%d %d", &c1, &c2); 15 | 16 | if( (c1 & 1) && (c2 & 1) ) 17 | printf("Ramesh\n"); 18 | else 19 | printf("Suresh\n"); 20 | 21 | } 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /SPOJ/TDKPRIME.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | long long int B[100000005]; 4 | bool A[100000005]; 5 | int main() 6 | { 7 | long long int X=100000000,i,j,p=2,q,Y; 8 | for(i=0; i<=X; i++) 9 | { 10 | A[i]=1; 11 | } 12 | for(i=2; i*i<=X; ) 13 | { 14 | if(A[i] != 0) 15 | { 16 | for(j=i; (i*j) <= X; j++) 17 | { 18 | if(A[i*j]!=0) 19 | { 20 | A[i*j]=0; 21 | } 22 | } 23 | } 24 | if(i==2) 25 | { 26 | i++; 27 | } 28 | else 29 | { 30 | i+=2; 31 | } 32 | } 33 | B[1]=2; 34 | for(i=3; i<=X; i+=2) 35 | { 36 | if(A[i]!=0) 37 | { 38 | B[p]=i; 39 | p++; 40 | } 41 | } 42 | scanf("%lld",&q); 43 | for(i=0; i0) 10 | { 11 | // Add current element of BITree to sum 12 | sum += BITree[index]; 13 | 14 | // Move index to parent node in getSum View 15 | index -= index & (-index); 16 | } 17 | return sum; 18 | } 19 | 20 | void updateBIT(ll n, ll index, ll val) 21 | 22 | { 23 | 24 | // Traverse all ancestors and add 'val' 25 | while (index <= n) 26 | { 27 | // Add 'val' to current node of BI Tree 28 | BITree[index] += val; 29 | 30 | // Update index to that of parent in update View 31 | index += index & (-index); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /Templates/Basis XOR.cpp: -------------------------------------------------------------------------------- 1 | // Source: https://codeforces.com/blog/entry/68953 2 | int basis[d]; // basis[i] keeps the mask of the vector whose f value is i 3 | int sz; // Current size of the basis 4 | 5 | void insertVector(int mask) { 6 | for (int i = 0; i < d; i++) { 7 | if (((mask>>i)&1) == 0) continue; // continue if i != f(mask) 8 | 9 | if (!basis[i]) { // If there is no basis vector with the i'th bit set, then insert this vector into the basis 10 | basis[i] = mask; 11 | ++sz; 12 | return; 13 | } 14 | mask ^= basis[i]; // Otherwise subtract the basis vector from this vector 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Templates/Euler Totient from 1 to n.cpp: -------------------------------------------------------------------------------- 1 | // C++ program to compute Totient function for 2 | // all numbers smaller than or equal to n. 3 | #include 4 | using namespace std; 5 | 6 | // Computes and prints totien of all numbers 7 | // smaller than or equal to n. 8 | 9 | #define sz 10000000 10 | #define ll long long 11 | 12 | ll prime[sz + 9], etf[sz + 9]; 13 | 14 | void computeTotient() { 15 | etf[1] = 1; 16 | for(ll i = 2; i <= sz; i++){ 17 | if(!prime[i]){ 18 | etf[i] = i - 1; 19 | for(ll j = 1; j * i <= sz; j++) 20 | if(!prime[j*i])prime[j*i] = i; 21 | } 22 | else{ 23 | etf[i] = etf[prime[i]] * etf[ i/prime[i] ]; 24 | ll g = 1; 25 | if(i % (prime[i]*prime[i]) == 0) g = prime[i]; 26 | etf[i] *= g; 27 | etf[i] /= etf[g]; 28 | } 29 | } 30 | } 31 | 32 | // Driver program to test above function 33 | int main() 34 | { 35 | computeTotient(); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /Templates/Extended Euclid & Modular Inverse.cpp: -------------------------------------------------------------------------------- 1 | #define ll long long 2 | typedef pair pii; 3 | #define x first 4 | #define y second 5 | 6 | pii extendedEuclid(ll a, ll b) // returns x, y for ax + by = gcd(a,b) 7 | { 8 | if(b == 0) return pii(1, 0); 9 | else 10 | { 11 | pii d = extendedEuclid(b, a % b); 12 | return pii(d.y, d.x - d.y * (a / b)); 13 | } 14 | } 15 | 16 | ll modularInverse(ll a, ll m) 17 | { 18 | pii ret = extendedEuclid(a, m); 19 | return ((ret.x % m) + m) % m; 20 | } 21 | -------------------------------------------------------------------------------- /Templates/Fast IO.cpp: -------------------------------------------------------------------------------- 1 | //#define gc getchar_unlocked 2 | #define gc getchar // for windows 3 | inline void read_int(int &x) 4 | 5 | { 6 | x=0; 7 | register char c=gc(); 8 | for(;c<'0' || c>'9';c=gc()); 9 | for(;c>='0' && c<='9';c=gc()) 10 | x=(x<<3)+(x<<1)+(c-'0'); 11 | } 12 | 13 | //#define pc(x) putchar_unlocked(x); 14 | #define pc(x) putchar(x); // for windows 15 | inline void writeInt (int n) 16 | { 17 | register int N = n, rev, count = 0; 18 | rev = N; 19 | if (N == 0) { pc('0'); pc('\n'); return ;} 20 | while ((rev % 10) == 0) { count++; rev /= 10;} //obtain the count of the number of 0s 21 | rev = 0; 22 | while (N != 0) { rev = (rev<<3) + (rev<<1) + N % 10; N /= 10;} //store reverse of N in rev 23 | while (rev != 0) { pc(rev % 10 + '0'); rev /= 10;} 24 | while (count--) pc('0'); 25 | pc('\n'); 26 | } 27 | -------------------------------------------------------------------------------- /Templates/Find kth root.cpp: -------------------------------------------------------------------------------- 1 | #define ll long long 2 | vector graph[100009]; 3 | 4 | ll table[100009][20], sz[100009], MLOG, n; /// MLOG = log(n) + 1 5 | 6 | void szdfs(ll u, ll p, ll lv) 7 | 8 | { 9 | sz[u] = 1; 10 | table[u][0] = p; 11 | for(ll i = 0; i < graph[u].size(); i++) { 12 | ll nd = graph[u][i]; 13 | if(nd == p) 14 | continue; 15 | 16 | szdfs(nd, u, lv + 1); 17 | sz[u] += sz[nd]; 18 | } 19 | } 20 | 21 | void build() 22 | 23 | { 24 | for(ll i = 1; i <= n; i++) { 25 | for(ll j = 1; j <= MLOG; j++) { 26 | table[i][j] = table[ table[i][j - 1] ][j - 1]; 27 | } 28 | } 29 | } 30 | 31 | ll kth(ll u, ll k) 32 | 33 | { 34 | for(ll i = MLOG; i >= 0; i--) { 35 | if( (1 << i) <= k) { 36 | u = table[u][i]; 37 | k -= (1 << i); 38 | } 39 | } 40 | 41 | return u; 42 | } 43 | -------------------------------------------------------------------------------- /Templates/nCr time & space optimized.cpp: -------------------------------------------------------------------------------- 1 | int nCr(int n, int k) 2 | { 3 | int res = 1; 4 | 5 | // Since C(n, k) = C(n, n-k) 6 | if ( k > n - k ) 7 | k = n - k; 8 | 9 | // Calculate value of [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1] 10 | for (int i = 0; i < k; ++i) 11 | { 12 | res *= (n - i); 13 | res /= (i + 1); 14 | } 15 | 16 | return res; 17 | } 18 | --------------------------------------------------------------------------------