├── 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll, bool> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | ll ara[100009];
 7 | 
 8 | int main()
 9 | 
10 | {
11 |     multiset <ll> mul;
12 |     multiset <ll> :: 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | vector <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | struct Point {
 7 |     ll l, r;
 8 | } ara[300009];
 9 | 
10 | multiset <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | #define pb push_back
 6 | 
 7 | vector <ll> 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 <iostream>
 2 | #include <cstdio>
 3 | #include <vector>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | vector <ll> 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 <stdio.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | vector <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | ll n, a[200009], b[200009];
 7 | 
 8 | map <long double, int> 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | #define pii pair <ll, ll>
 6 | 
 7 | vector <pii> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | vector <ll> g[300009];
 7 | ll ara[300009];
 8 | set <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | vector <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | vector <ll> 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 <bits/stdc++.h>
 2 | using namespace std;
 3 |  
 4 | #define ll long long
 5 | #define pb push_back
 6 | #define pll pair <ll, ll>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll, ll>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | int main()
 7 | 
 8 | {
 9 |     string s;
10 |     cin >> s;
11 |     set <char> 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 <bits/stdc++.h>
 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 <stdio.h>
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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | 
 6 | {
 7 |     vector < pair<string, int> > round;
 8 |     map <string, int> m;
 9 |     map <string, int> :: iterator it;
10 |     int n;
11 |     cin >> n;
12 |     
13 |     for(int i = 1; i <= n; i++) {
14 |        pair<string, int> 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 <string, int> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | 
 6 | {
 7 |     deque <int> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | ll mark[55];
 6 | vector <ll> 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 <bits/stdc++.h>
 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 <char> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | 
 6 | {
 7 |     int n;
 8 |     map <string, int> 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <iostream>
 2 | #include <bits/stdc++.h>
 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 <int, int> 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 <bits/stdc++.h>
 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 <int> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | 
 6 | {
 7 |     int n;
 8 |     cin >> n;
 9 |     map <int, bool> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | int main()
 7 | 
 8 | {
 9 |     int x = 1, y = 1;
10 |     map <int, bool> 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 <bits/stdc++.h>
 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 <string, string> m1;
15 |     map <string, string> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <double> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <int, bool> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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" <<endl;
32 |     else
33 |         cout << "NO" << endl;
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/CodeForces/Solutions/939B.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <string> root;
13 |     ll n;
14 |     cin >> n;
15 |     for(ll i = 1; i <= n; i++) {
16 |         scanf("%s", s);
17 |         unordered_map <char, bool> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <ll, bool> 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <iostream>
 2 | #include <math.h>
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | 
 6 | #define ll long long 
 7 | 
 8 | vector <ll> 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <ll> 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <ll> point;
10 |         set <ll> :: 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 <stdio.h>
 2 | #include <math.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <int> b;
10 |         deque <int> :: 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <stdio.h>
 2 | #include <math.h>
 3 | #include <stdlib.h>
 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  <bits/stdc++.h>
 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 <stdio.h>
 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 <stdio.h>
 2 | #include <math.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 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 <stdio.h>
 2 | #include <math.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 2 | #include <math.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <stdio.h>
 2 | #include <math.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | char ara[1009];
 5 | #define ll unsigned long long
 6 | unordered_map <ll, bool> 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <bits/stdc++.h>
 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 <iostream>
 2 | #include <cstdio>
 3 | #include <vector>
 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 <ll> 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 <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | #define ll long long
 5 | 
 6 | ll ara[1009];
 7 | 
 8 | stack <ll> 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 <bits/stdc++.h>
 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<stdio.h>
 2 | #include<stdbool.h>
 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; i<q; i++)
44 |     {
45 |         scanf("%lld",&Y);
46 |         printf("%lld\n",B[Y]);
47 |     }
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Templates/BIT point update and (point + range query).cpp:
--------------------------------------------------------------------------------
 1 | ll BITree[100009];
 2 | 
 3 | ///do this for range: getSum(r) - getSum(l - 1)
 4 | ll getSum(ll index)
 5 | {
 6 |     ll sum = 0; // Iniialize result
 7 | 
 8 |     // Traverse ancestors of BITree[index]
 9 |     while (index>0)
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<iostream>
 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<ll, ll> 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 <ll> 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 | 


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