├── contest ├── opencup │ ├── XVI │ │ ├── Baltics │ │ │ ├── j.in │ │ │ ├── a.in │ │ │ ├── f.in │ │ │ └── d.in │ │ ├── Ekaterinburg │ │ │ ├── g.py │ │ │ ├── b.cpp │ │ │ ├── d.cpp │ │ │ ├── c.cpp │ │ │ └── j.cpp │ │ ├── Eurasia │ │ │ ├── l.py │ │ │ ├── g.cpp │ │ │ ├── l.dump │ │ │ ├── k.cpp │ │ │ └── f.cpp │ │ ├── Ukraine │ │ │ ├── g.cpp │ │ │ ├── f.py │ │ │ ├── d.cpp │ │ │ └── c.cpp │ │ ├── SPb │ │ │ ├── h.cpp │ │ │ └── a.cpp │ │ ├── Siberia │ │ │ ├── 10.cpp │ │ │ ├── 2.cpp │ │ │ ├── 11.cpp │ │ │ └── 4.cpp │ │ ├── Europe │ │ │ ├── aa.cc │ │ │ ├── aa.py │ │ │ └── d.cpp │ │ ├── Peterhof │ │ │ ├── d.cpp │ │ │ └── e.cpp │ │ └── Japan │ │ │ └── a.cpp │ ├── XVIII │ │ ├── Baltic │ │ │ ├── i.py │ │ │ ├── tokens.py │ │ │ ├── f.cpp │ │ │ ├── gene.py │ │ │ └── i.cpp │ │ ├── Peterhof │ │ │ ├── f.cpp │ │ │ ├── genj.py │ │ │ ├── j.py │ │ │ ├── i.cpp │ │ │ └── a.cpp │ │ ├── Khamovniki │ │ │ ├── e.py │ │ │ └── h.cpp │ │ ├── Korea │ │ │ ├── genf.py │ │ │ └── d.cpp │ │ ├── Europe │ │ │ └── l_gen.cpp │ │ ├── Eastern │ │ │ ├── e.cpp │ │ │ ├── i.cpp │ │ │ ├── d.cpp │ │ │ └── b.cpp │ │ ├── Urals │ │ │ └── b.cpp │ │ ├── Eurasia │ │ │ ├── a.cpp │ │ │ ├── b.cpp │ │ │ └── 6.cpp │ │ ├── Belarus │ │ │ ├── j.cpp │ │ │ ├── g.py │ │ │ ├── b.cpp │ │ │ └── e.cpp │ │ ├── SPb │ │ │ ├── c.cpp │ │ │ ├── a.cpp │ │ │ └── g.cpp │ │ └── Saratov │ │ │ ├── b.py │ │ │ └── d.cpp │ ├── XVII │ │ ├── SPb │ │ │ ├── c.py │ │ │ ├── f.cpp │ │ │ ├── k.cpp │ │ │ └── i.cpp │ │ ├── Eastern │ │ │ ├── a.cpp │ │ │ ├── l.py │ │ │ ├── f.cpp │ │ │ ├── h.cpp │ │ │ └── i.cpp │ │ ├── America │ │ │ └── j.cpp │ │ ├── MoscowWorkshop │ │ │ ├── j.cpp │ │ │ ├── g.cpp │ │ │ └── i.cpp │ │ ├── 2Capitals │ │ │ └── c.cpp │ │ ├── Siberia │ │ │ ├── 9.cpp │ │ │ ├── 1.cpp │ │ │ └── 2.cpp │ │ ├── Tatarstan │ │ │ └── j.cpp │ │ └── Europe │ │ │ └── k.cpp │ └── XV │ │ ├── CEurope │ │ ├── genh.py │ │ ├── d.cpp │ │ ├── e.cpp │ │ ├── a.cpp │ │ └── c.cpp │ │ ├── Europe │ │ ├── l_gen.cpp │ │ └── k.cpp │ │ ├── Tatarstan │ │ ├── h.cpp │ │ ├── g.cpp │ │ ├── l2.cpp │ │ └── b.cpp │ │ ├── 3Capitals │ │ ├── a.cpp │ │ ├── c.cpp │ │ └── e.cpp │ │ ├── Udmurtia │ │ └── b.cpp │ │ ├── Peterhof │ │ └── b.cpp │ │ ├── America │ │ ├── j.cpp │ │ ├── g.cpp │ │ └── e.cpp │ │ └── Karelia │ │ └── f2.cpp ├── NTUPK │ ├── h2.cpp │ ├── def.cpp │ └── e.cpp ├── Shanghai │ ├── a.in │ ├── j.in │ └── gen.cpp ├── WorldFinals │ ├── 2008 │ │ └── f.cpp │ ├── 2010 │ │ └── geni.py │ ├── 2011 │ │ └── geng.py │ ├── 2013 │ │ └── b.cpp │ ├── 2014 │ │ └── e2.cpp │ ├── 2015 │ │ ├── f.cp │ │ ├── b2.cpp │ │ └── a.cpp │ └── 2017 │ │ └── e.cpp ├── SEERC │ └── 2015 │ │ └── g.cpp ├── CCPC2017 │ ├── .f.in.swp │ ├── a.cpp │ └── d.cpp ├── NCPC2015 │ ├── scoreboard.pdf │ ├── a.cpp │ └── f.cpp ├── Petr2018ITMOU │ ├── .l.py.swp │ ├── l.py │ └── d.cpp ├── NEERC │ ├── Subregional │ │ ├── Northern │ │ │ ├── 2009 │ │ │ │ ├── b.cpp │ │ │ │ └── h.cpp │ │ │ ├── 2013 │ │ │ │ ├── a.cpp │ │ │ │ ├── g.cpp │ │ │ │ └── e.cpp │ │ │ └── 2016 │ │ │ │ ├── genh.py │ │ │ │ ├── a.cpp │ │ │ │ └── k.cpp │ │ └── Moscow │ │ │ ├── 2010 │ │ │ ├── h.cpp │ │ │ ├── a.cpp │ │ │ └── c.cpp │ │ │ ├── 2016 │ │ │ ├── b.cpp │ │ │ ├── a.cpp │ │ │ ├── g.cpp │ │ │ └── l.cpp │ │ │ └── 2017 │ │ │ ├── a.cpp │ │ │ ├── d.cpp │ │ │ └── i.cpp │ └── Regional │ │ ├── 2012 │ │ ├── g.cpp │ │ ├── b.cpp │ │ └── a.cpp │ │ ├── 2015 │ │ ├── b.py │ │ └── a.cpp │ │ ├── 2016 │ │ ├── k2.cpp │ │ ├── f.cpp │ │ └── i.cpp │ │ └── 2017 │ │ ├── e2.cpp │ │ ├── e.cpp │ │ └── b.cpp ├── BSUIR2017 │ ├── g.cpp │ ├── g.py │ ├── i.cpp │ ├── c.cpp │ ├── b.cpp │ └── g2.cpp ├── Vietnam │ └── National2ndRound │ │ └── gen.py ├── ASC │ ├── ASC25 │ │ └── rung.sh │ ├── ASC30 │ │ ├── b.py │ │ ├── b.cpp │ │ └── f.cpp │ ├── ASC28 │ │ ├── d.py │ │ ├── j.cpp │ │ ├── h.cpp │ │ └── e.cpp │ ├── ASC29 │ │ └── i.cpp │ ├── ASC38 │ │ ├── b.cpp │ │ └── e.cpp │ ├── ASC43 │ │ ├── c.cpp │ │ └── j.cpp │ ├── ASC42 │ │ ├── b.cpp │ │ └── f.cpp │ ├── ASC31 │ │ ├── d.py │ │ └── a.cpp │ ├── ASC33 │ │ └── e.py │ ├── ASC32 │ │ └── a.cpp │ └── ASC34 │ │ └── c.py ├── BSUIR2016 │ ├── e.cpp │ └── g.cpp ├── Bangkok2016 │ ├── c.py │ └── c.cpp ├── ECFinal2016 │ ├── a.cpp │ ├── e.cpp │ └── e.py ├── Jakarta │ ├── 2014 │ │ └── kgen.py │ ├── 2015 │ │ ├── b.cpp │ │ └── l.cpp │ └── 2016 │ │ ├── genb.py │ │ ├── d.cpp │ │ └── e.cpp ├── ITSA2018 │ ├── 5.cpp │ ├── 4.cpp │ ├── 6.cpp │ ├── 3.cpp │ └── 1.cpp ├── Dhaka2015 │ ├── d.cpp │ ├── a.cpp │ ├── b.cpp │ └── e.cpp ├── Hatyai │ ├── h.cpp │ ├── j.cpp │ ├── b.cpp │ └── i.cpp ├── Phuket │ └── 2015 │ │ ├── a.cpp │ │ ├── b.cpp │ │ └── l.cpp ├── Japan │ └── 2016 │ │ └── a.cpp ├── Daejeon │ ├── 2015 │ │ ├── i.cpp │ │ ├── d.cpp │ │ ├── l.cpp │ │ ├── e.cpp │ │ └── j.cpp │ └── 2016 │ │ ├── l.cpp │ │ ├── b.cpp │ │ ├── j.cpp │ │ ├── a.cpp │ │ └── i.cpp ├── Hualien │ ├── f_final.cpp │ ├── b.cpp │ ├── l.cpp │ └── d.cpp ├── Dhaka2017 │ ├── e.cpp │ ├── a.cpp │ ├── h.cpp │ ├── d.cpp │ └── f.cpp ├── Singapore │ └── e.cpp ├── PetrSummerCampJapanese │ ├── j.cpp │ └── b.cpp └── WF │ └── 2016 │ └── c.cpp ├── codebook ├── basic │ ├── time.cpp │ ├── IncStack_windows.cpp │ ├── random.cpp │ ├── vimrc │ ├── IncStack.cpp │ ├── misc.cpp │ └── python_trick.py ├── codebook.pdf ├── geometry │ ├── DynamicConvexHull.pdf │ ├── Intersection_of_two_lines.cpp │ ├── Intersection_of_circle_and_segment.cpp │ ├── Intersection_of_two_circles.cpp │ ├── convex_hull.cpp │ ├── triangle.cpp │ ├── Intersection_of_two_segments.cpp │ ├── Tangent_line_of_two_circles.cpp │ ├── Intersection_of_polygon_and_circle.cpp │ ├── minDistonCuboid.cpp │ ├── minkowski-convex-hull.cpp │ └── Points.cpp ├── math │ ├── prefixInv.cpp │ ├── ax+by=gcd.cpp │ ├── chineseRemainder.cpp │ ├── pollardRho.cpp │ ├── Romberg.cpp │ ├── PolyGen.cpp │ ├── MOD.cpp │ ├── theorem.tex │ ├── theorem_old.cpp │ ├── Miller_Rabin.cpp │ ├── DiscreteSqrt.cpp │ ├── Square_Matrix_pinv.cpp │ └── FFT.cpp ├── others │ └── zeller.cpp ├── graph │ ├── graphHash.tex │ ├── kosaraju.cpp │ ├── generalMatching.cpp │ ├── NumberofMaximalClique.cpp │ └── CentroidDecomposition.cpp ├── dataStructure │ ├── pairing_heap.cpp │ ├── Leftist_Heap.cpp │ ├── DisjointSet.cpp │ └── treap.cpp ├── string │ ├── zvalue.cpp │ ├── smallest_rotation.cpp │ ├── zvalue_palindrome.cpp │ └── BWT.cpp └── flow │ └── SW-mincut.cpp └── intro ├── intro.pdf └── introduction.txt /contest/opencup/XVI/Baltics/j.in: -------------------------------------------------------------------------------- 1 | 2 1 400 3 500 2 | -------------------------------------------------------------------------------- /contest/NTUPK/h2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | -------------------------------------------------------------------------------- /contest/Shanghai/a.in: -------------------------------------------------------------------------------- 1 | 1 2 | 0 0 1 3 | 1 2 0 -1 4 | 1 -2 5 | -------------------------------------------------------------------------------- /codebook/basic/time.cpp: -------------------------------------------------------------------------------- 1 | cout << 1.0 * clock() / CLOCKS_PER_SEC; 2 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Baltics/a.in: -------------------------------------------------------------------------------- 1 | 5 4 2 | 1 2 3 | 1 3 4 | 2 3 5 | 3 4 6 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Baltic/i.py: -------------------------------------------------------------------------------- 1 | a=int(input()) 2 | b=int(input()) 3 | print(a-b) 4 | -------------------------------------------------------------------------------- /intro/intro.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/intro/intro.pdf -------------------------------------------------------------------------------- /contest/WorldFinals/2011/geng.py: -------------------------------------------------------------------------------- 1 | print(500) 2 | print(' '.join('1' for i in range(500))) 3 | -------------------------------------------------------------------------------- /contest/NTUPK/def.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | } 5 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Baltics/f.in: -------------------------------------------------------------------------------- 1 | 3 2 | 1 10 3 | 10 4 | 2 10 5 | 10 10 6 | 4 10 7 | 5 7 5 7 8 | -------------------------------------------------------------------------------- /contest/opencup/XVII/SPb/c.py: -------------------------------------------------------------------------------- 1 | print(50, 49) 2 | for i in range(49): 3 | print(i+1, (i+2)) 4 | -------------------------------------------------------------------------------- /codebook/codebook.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/codebook/codebook.pdf -------------------------------------------------------------------------------- /contest/SEERC/2015/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | 5 | } 6 | -------------------------------------------------------------------------------- /contest/CCPC2017/.f.in.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/contest/CCPC2017/.f.in.swp -------------------------------------------------------------------------------- /contest/opencup/XV/CEurope/genh.py: -------------------------------------------------------------------------------- 1 | print(1) 2 | print(9 * '*' + 1490 * 'B' + '*' + 8 * '*' + 1490 * 'B' + 'G') 3 | -------------------------------------------------------------------------------- /contest/NCPC2015/scoreboard.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/contest/NCPC2015/scoreboard.pdf -------------------------------------------------------------------------------- /contest/Petr2018ITMOU/.l.py.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/contest/Petr2018ITMOU/.l.py.swp -------------------------------------------------------------------------------- /contest/opencup/XVIII/Peterhof/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | 6 | } 7 | -------------------------------------------------------------------------------- /contest/Shanghai/j.in: -------------------------------------------------------------------------------- 1 | 2 2 | 3 2 2 3 | 1 2 1 4 | 1 3 4 5 | 5 5 1 6 | 1 2 1 7 | 2 3 2 8 | 3 4 3 9 | 2 4 4 10 | 4 5 5 11 | -------------------------------------------------------------------------------- /codebook/geometry/DynamicConvexHull.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tzupengwang/PECaveros/HEAD/codebook/geometry/DynamicConvexHull.pdf -------------------------------------------------------------------------------- /contest/opencup/XVI/Baltics/d.in: -------------------------------------------------------------------------------- 1 | 6 2 | 0 0 0 1 1 1 3 | 0 0 1 0 1 1 4 | 1 1 1 2 3 2 5 | 0 0 0 2 1 2 6 | 3 4 0 0 -8 6 7 | 0 5 0 0 -10 0 8 | -------------------------------------------------------------------------------- /codebook/basic/IncStack_windows.cpp: -------------------------------------------------------------------------------- 1 | //stack resize 2 | asm( "mov %0,%%esp\n" ::"g"(mem+10000000) ); 3 | //change esp to rsp if 64-bit system 4 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Baltic/tokens.py: -------------------------------------------------------------------------------- 1 | import sys 2 | cnt = 0 3 | for line in sys.stdin: 4 | cnt += len(line.strip().split()) 5 | print(cnt) 6 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2016/genh.py: -------------------------------------------------------------------------------- 1 | print( 3600 ) 2 | for i in range( 60 ): 3 | for j in range( 60 ): 4 | print( i + 1 , j + 1 ) 5 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ekaterinburg/g.py: -------------------------------------------------------------------------------- 1 | x = input() 2 | c = x.count('!') 3 | if c == 0: 4 | print('Pfff') 5 | else: 6 | print('W'+('o'*c)+'w') 7 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Eurasia/l.py: -------------------------------------------------------------------------------- 1 | with open('l.dump') as f: 2 | for i in f: 3 | a = i.strip().split() 4 | print('word[%s]=%s;' % (a[0], a[2])) 5 | -------------------------------------------------------------------------------- /codebook/basic/random.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | mt19937 rng(0x5EED); 3 | int randint(int lb, int ub) 4 | { return uniform_int_distribution(lb, ub)(rng); } 5 | -------------------------------------------------------------------------------- /codebook/basic/vimrc: -------------------------------------------------------------------------------- 1 | syn on 2 | se ai nu ru cul mouse=a 3 | se cin et ts=2 sw=2 sts=2 4 | so $VIMRUNTIME/mswin.vim 5 | colo desert 6 | se gfn=Monospace\ 14 7 | -------------------------------------------------------------------------------- /contest/BSUIR2017/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | puts( "212121112121121122111112111211111212122112" ); 5 | } 6 | -------------------------------------------------------------------------------- /codebook/math/prefixInv.cpp: -------------------------------------------------------------------------------- 1 | void solve( int m ){ 2 | inv[ 1 ] = 1; 3 | for( int i = 2 ; i < m ; i ++ ) 4 | inv[ i ] = ((LL)(m - m / i) * inv[m % i]) % m; 5 | } 6 | -------------------------------------------------------------------------------- /contest/WorldFinals/2015/f.cp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | int main(){ 6 | 7 | } 8 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Baltic/f.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | int main(){ 6 | 7 | } 8 | -------------------------------------------------------------------------------- /codebook/math/ax+by=gcd.cpp: -------------------------------------------------------------------------------- 1 | PII gcd(int a, int b){ 2 | if(b == 0) return {1, 0}; 3 | PII q = gcd(b, a % b); 4 | return {q.second, q.first - q.second * (a / b)}; 5 | } 6 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Khamovniki/e.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | 3 | ones = 11 4 | 5 | while ones <= n: 6 | print("%15d %d\n" % (ones, n // ones)) 7 | ones = 10*ones + 1 8 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Korea/genf.py: -------------------------------------------------------------------------------- 1 | from random import randint 2 | print(15) 3 | for i in range(15): 4 | print(' '.join( str(randint(1, 10**9)) for j in range(i+1,16) )) 5 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ukraine/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | int n , k; 5 | cin >> n >> k; 6 | cout << __gcd( n , k ) << endl; 7 | } 8 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Eastern/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | int a , b , c; 5 | cin >> a >> b >> c; 6 | cout << 1 + (b - c) << endl; 7 | } 8 | -------------------------------------------------------------------------------- /contest/Vietnam/National2ndRound/gen.py: -------------------------------------------------------------------------------- 1 | import random as rnd 2 | print( 40 ) 3 | for i in range( 40 ): 4 | print( 250000 ) 5 | for j in range( 250000 ): 6 | print( "G2B3R5Y7" ) 7 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Peterhof/genj.py: -------------------------------------------------------------------------------- 1 | from random import randint 2 | x = chr(48 + randint(1,9)) 3 | for i in range(456789): 4 | x += chr(48 + randint(0, 9)) 5 | x=int(x) 6 | print(x) 7 | print(x*x) 8 | -------------------------------------------------------------------------------- /contest/Shanghai/gen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | printf( "%d\n" , 1000 ); 5 | for( int i = 0 ; i < 1000 ; i ++ ) 6 | printf( "%d %d\n" , 1 , 1 << 29 ); 7 | } 8 | -------------------------------------------------------------------------------- /contest/ASC/ASC25/rung.sh: -------------------------------------------------------------------------------- 1 | for i in {1..5}; do 2 | for j in {1..5}; do 3 | for k in {1..5}; do 4 | echo "running ${i} ${j} ${k}" 5 | echo "${i} ${j} ${k}" | ./g >> tmp.in 6 | done 7 | done 8 | done 9 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Baltic/gene.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | n = 300 4 | P = 1000000007 5 | 6 | print(n) 7 | 8 | for i in range(n): 9 | print(' '.join(map(str, [random.randrange(0, P) for j in range(n)]))) 10 | -------------------------------------------------------------------------------- /contest/BSUIR2016/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | int sum = 0 , c = 0 , x; 5 | while( cin >> x ){ 6 | sum += x; 7 | c ++; 8 | } 9 | sum -= c - 1; 10 | cout << sum << endl; 11 | } 12 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Peterhof/j.py: -------------------------------------------------------------------------------- 1 | def isqrt(n): 2 | x = n 3 | y = (x + 1) // 2 4 | while y < x: 5 | x = y 6 | y = (x + n // x) // 2 7 | return x 8 | n = int(input()) 9 | x = isqrt(n) 10 | print('YES' if x * x == n else 'NO') 11 | -------------------------------------------------------------------------------- /codebook/others/zeller.cpp: -------------------------------------------------------------------------------- 1 | // return day of week on y year m month d day 2 | // 0: Sat, 1: Sun, ... 3 | int zeller(int y,int m,int d) { 4 | if (m<=2) y--,m+=12; int c=y/100; y%=100; 5 | int w=((c>>2)-(c<<1)+y+(y>>2)+(13*(m+1)/5)+d-1)%7; 6 | if (w<0) w+=7; return(w); 7 | } 8 | -------------------------------------------------------------------------------- /contest/BSUIR2017/g.py: -------------------------------------------------------------------------------- 1 | def okay(x): 2 | while x > 0: 3 | if x % 10 < 1 or x % 10 > 2: 4 | return False 5 | x //= 10; 6 | return True 7 | for i in range(42,43): 8 | x = 2**i 9 | p = 1 10 | while not okay(x * p): 11 | p += 1 12 | print(p, x * p) 13 | -------------------------------------------------------------------------------- /contest/Bangkok2016/c.py: -------------------------------------------------------------------------------- 1 | import sys 2 | for line in sys.stdin: 3 | n = int(line) 4 | dp = [0 for i in range(n+1)] 5 | for i in range(n,0,-1): 6 | dp[i] = (n//i)**4 7 | for j in range(i+i,n,i): 8 | dp[i] -= dp[j] 9 | print(dp[1]) 10 | -------------------------------------------------------------------------------- /codebook/graph/graphHash.tex: -------------------------------------------------------------------------------- 1 | $$F_t(i) = 2 | (F_{t-1}(i) \times A + 3 | \sum_{i\rightarrow j} F_{t-1}(j) \times B + 4 | \sum_{j\rightarrow i} F_{t-1}(j) \times C + 5 | D \times (i = a))\ mod\ P 6 | $$ 7 | for each node i, iterate t times. 8 | t, A, B, C, D, P are hash parameter 9 | -------------------------------------------------------------------------------- /codebook/dataStructure/pairing_heap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace __gnu_pbds; 3 | typedef priority_queue heap; 4 | int main(){ 5 | heap h1 , h2; 6 | h1.push( 1 ); 7 | h2.push( 4 ); 8 | h1.join( h2 ); 9 | h1.size(); // 2 10 | h2.size(); // 0 11 | h1.top(); // 4 12 | } 13 | -------------------------------------------------------------------------------- /codebook/geometry/Intersection_of_two_lines.cpp: -------------------------------------------------------------------------------- 1 | Pt interPnt( Pt p1, Pt p2, Pt q1, Pt q2){ 2 | double f1 = ( p2 - p1 ) ^ ( q1 - p1 ); 3 | double f2 = ( p2 - p1 ) ^ ( p1 - q2 ); 4 | double f = ( f1 + f2 ); 5 | if( fabs( f ) < eps ) return Pt( nan(""), nan("") ); 6 | return q1 * ( f2 / f ) + q2 * ( f1 / f ); 7 | } 8 | -------------------------------------------------------------------------------- /contest/ECFinal2016/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | LL t , n , _cs; 6 | int main(){ 7 | scanf( "%lld" , &t ); while( t -- ){ 8 | scanf( "%lld" , &n ); 9 | printf( "Case #%lld: %lld\n" , ++ _cs , n / 3 ); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /contest/opencup/XVII/America/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | char c[ N ]; 5 | int main(){ 6 | scanf( "%s" , c ); 7 | int cnt[ 2 ] = {}; 8 | for( int i = 0 ; c[ i ] ; i ++ ) 9 | cnt[ c[ i ] == 'W' ] ++; 10 | printf( "%d\n" , cnt[ 0 ] == cnt[ 1 ] ); 11 | } 12 | -------------------------------------------------------------------------------- /codebook/math/chineseRemainder.cpp: -------------------------------------------------------------------------------- 1 | LL solve(LL x1, LL m1, LL x2, LL m2) { 2 | LL g = __gcd(m1, m2); 3 | if((x2 - x1) % g) return -1;// no sol 4 | m1 /= g; m2 /= g; 5 | pair p = gcd(m1, m2); 6 | LL lcm = m1 * m2 * g; 7 | LL res = p.first * (x2 - x1) * m1 + x1; 8 | return (res % lcm + lcm) % lcm; 9 | } 10 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Eastern/l.py: -------------------------------------------------------------------------------- 1 | A, B, C = 0, 1, 1 2 | 3 | def sgn(x): 4 | if x > 0: 5 | return 1 6 | if x < 0: 7 | return -1 8 | return 0 9 | 10 | for _ in range(100000): 11 | if (sgn(A*A-4*B*C), sgn(B*B-4*A*C), sgn(C*C-4*A*B)) != (-1,-1,1): 12 | print(_,A,B,C) 13 | A, B, C = B, C, B+C 14 | -------------------------------------------------------------------------------- /contest/Jakarta/2015/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL n; 5 | int _cs; 6 | int main(){ 7 | int _; scanf( "%d" , &_ ); while( _ -- ){ 8 | scanf( "%lld" , &n ); 9 | printf( "Case #%d: %s\n" , ++ _cs , n % 2 ? "UDIN" : ( ( n / 2 ) % 2 ? "UDIN" : "UCOK" ) ); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /codebook/string/zvalue.cpp: -------------------------------------------------------------------------------- 1 | char s[MAXN]; 2 | int len,z[MAXN]; 3 | void Z_value() { 4 | int i,j,left,right; 5 | left=right=0; z[0]=len; 6 | for(i=1;iright) { 11 | right=i+z[i]; 12 | left=i; 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /codebook/basic/IncStack.cpp: -------------------------------------------------------------------------------- 1 | //stack resize (linux) 2 | #include 3 | void increase_stack_size() { 4 | const rlim_t ks = 64*1024*1024; 5 | struct rlimit rl; 6 | int res=getrlimit(RLIMIT_STACK, &rl); 7 | if(res==0){ 8 | if(rl.rlim_cur 2 | using namespace std; 3 | int main(){ 4 | printf( "%d\n" , 200000 ); 5 | for( int i = 0 ; i < 200000 ; i ++ ) 6 | printf( "%c %d %d %d\n" , 7 | rand() % 2 + 'A' , 8 | rand() % 2001 - 1000 , 9 | rand() % 2001 - 1000 , 10 | rand() % 998 + 2 ); 11 | } 12 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Eurasia/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | double d , a , b , c , A , B , C , ans; 4 | int main(){ 5 | cin >> d; 6 | cin >> a >> b >> c; 7 | cin >> A >> B >> C; 8 | 9 | vector< pair > vv; 10 | for( int i = 0 ; i < 4 ; i ++ ){ 11 | } 12 | 13 | cout << fixed << setprecision( 14 ) << ans << endl; 14 | } 15 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Europe/l_gen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | printf( "%d\n" , 200000 ); 5 | for( int i = 0 ; i < 200000 ; i ++ ) 6 | printf( "%c %d %d %d\n" , 7 | rand() % 2 + 'A' , 8 | rand() % 2001 - 1000 , 9 | rand() % 2001 - 1000 , 10 | rand() % 998 + 2 ); 11 | } 12 | -------------------------------------------------------------------------------- /contest/ASC/ASC30/b.py: -------------------------------------------------------------------------------- 1 | import sys 2 | sys.stdin = open('derangements.in','r') 3 | sys.stdout = open('derangements.out','w') 4 | N = 222 5 | dp = [0 for i in range(N)] 6 | dp[0] = dp[1] = 1 7 | for i in range(2,N): 8 | dp[i] = 2 * i * dp[i-1] 9 | if i&1: dp[i] -= 1 10 | else: dp[i] += 1 11 | # dp[i] = dp[i-1] + 4 * (i-1) * dp[i-2] 12 | print(dp[int(input())]) 13 | -------------------------------------------------------------------------------- /codebook/string/smallest_rotation.cpp: -------------------------------------------------------------------------------- 1 | string mcp(string s){ 2 | int n = s.length(); 3 | s += s; 4 | int i=0, j=1; 5 | while (i 2 | using namespace std; 3 | typedef long long LL; 4 | LL l , r , w; 5 | int main(){ 6 | cin >> l >> r >> w; 7 | LL gg = __gcd( r , w ); 8 | LL k = ( r - 1 ) / gg * gg; 9 | while( k > r - 1 ) k -= gg; 10 | if( k > l - w ) 11 | cout << "DEADLOCK" << endl; 12 | else 13 | cout << "OK" << endl; 14 | } 15 | -------------------------------------------------------------------------------- /codebook/basic/misc.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | mt19937 rng(0x5EED); 3 | int randint(int lb, int ub) 4 | { return uniform_int_distribution(lb, ub)(rng); } 5 | 6 | #define SECs (clock() / CLOCKS_PER_SEC) 7 | 8 | struct KeyHasher { 9 | size_t operator()(const Key& k) const { 10 | return k.first + k.second * 100000; 11 | } 12 | }; 13 | typedef unordered_map map_t; 14 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ukraine/f.py: -------------------------------------------------------------------------------- 1 | a = [ [ -1 for j in range(10) ] for i in range(10) ] 2 | a[1][1] = 0 3 | two = 1 4 | for i in range(1,1000): 5 | two *= 2 6 | rgt = two % 10 7 | lft = two 8 | while lft >= 10: 9 | lft //= 10 10 | if a[lft][rgt] == -1: 11 | a[lft][rgt] = i 12 | for i in range(10): 13 | for j in range(10): 14 | print('a[%d][%d]=%d;' % (i, j, a[i][j])) 15 | -------------------------------------------------------------------------------- /contest/ITSA2018/5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | int t; cin >> t; while(t --){ 5 | int n; 6 | scanf("%d", &n); 7 | 8 | long long ans = 0; 9 | 10 | for (int i = 0; i < n; i ++) { 11 | int x; scanf("%d", &x); 12 | ans = ans * 2 + x; 13 | } 14 | printf("%lld\n", ans); 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Eurasia/l.dump: -------------------------------------------------------------------------------- 1 | 1 А 1 2 | 2 Б 3 3 | 3 В 2 4 | 4 Г 3 5 | 5 Д 2 6 | 6 Е 1 7 | 7 Ж 5 8 | 8 З 5 9 | 9 И 1 10 | 10 Й 2 11 | 11 К 2 12 | 12 Л 2 13 | 13 М 2 14 | 14 Н 1 15 | 15 О 1 16 | 16 П 2 17 | 17 Р 2 18 | 18 С 2 19 | 19 Т 2 20 | 20 У 3 21 | 21 Ф 10 22 | 22 Х 5 23 | 23 Ц 10 24 | 24 Ч 5 25 | 25 Ш 10 26 | 26 Щ 10 27 | 27 Ъ 10 28 | 28 Ы 5 29 | 29 Ь 5 30 | 30 Э 10 31 | 31 Ю 10 32 | 32 Я 3 33 | -------------------------------------------------------------------------------- /contest/opencup/XVII/MoscowWorkshop/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | typedef long double ld; 5 | LL n , m; 6 | const ld pi = acosl( -1.0 ); 7 | int main(){ 8 | scanf( "%lld%lld" , &n , &m ); 9 | LL lcm = ( n / __gcd( n , m ) ) * m; 10 | ld ret = cosl( pi / lcm ) / sinl( pi / n ) * tanl( pi / m ); 11 | printf( "%.12f\n" , (double)ret ); 12 | } 13 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2010/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | bool is_p( int x ){ 5 | if( x == 1 ) return false; 6 | if( x == 4 ) return true; 7 | for( long long i = 2 ; i * i <= x ; i ++ ) 8 | if( x % i == 0 ) 9 | return false; 10 | return true; 11 | } 12 | int main(){ 13 | scanf( "%d" , &n ); 14 | puts( is_p( n ) ? "NO" : "YES" ); 15 | } 16 | -------------------------------------------------------------------------------- /contest/Petr2018ITMOU/l.py: -------------------------------------------------------------------------------- 1 | mod = 1000000007 2 | def rev(x): return pow(x,mod-2,mod) 3 | a = [1,1] 4 | s=set() 5 | s.add(1) 6 | while True: 7 | b = [0, 0] 8 | b[0] = 4 * a[0] * a[1] - a[0] * a[0] 9 | b[1] = 4 * a[1] * a[1] 10 | b[0] %= mod 11 | b[1] %= mod 12 | bb = (b[0] * rev(b[1])) % mod 13 | print(bb) 14 | if bb in s: 15 | break 16 | s.add(bb) 17 | a[0]=b[0] 18 | a[1]=b[1] 19 | print(len(s)) 20 | -------------------------------------------------------------------------------- /contest/BSUIR2016/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | const int mod = 1000000007; 5 | LL n , ans; 6 | int main(){ 7 | cin >> n; 8 | LL bs = 1; 9 | for( LL i = 1 ; n > 0 ; i ++ ){ 10 | LL tk = min( i , n ); 11 | LL cst = tk * bs % mod; 12 | ans = (ans + cst) % mod; 13 | n -= tk; 14 | bs = (bs + bs) % mod; 15 | } 16 | cout << ans << endl; 17 | } 18 | -------------------------------------------------------------------------------- /contest/opencup/XV/Tatarstan/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n, s, f; 6 | int ans = 0; 7 | scanf("%d%d%d", &n, &s, &f); 8 | if (s > f) swap(s, f); 9 | if (s > 1) ans ++, s ++; 10 | if (f < n) ans ++, f --; 11 | if (s > f) puts("-1"); 12 | else { 13 | int k = f - s; 14 | ans += (k + 2) / 3 + (k % 3 == 2); 15 | printf("%d\n", ans); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /contest/Jakarta/2016/genb.py: -------------------------------------------------------------------------------- 1 | import random 2 | import string 3 | 4 | def randstr(): 5 | res = ''.join(random.choice(string.ascii_lowercase) for _ in range(10)) 6 | return res 7 | 8 | t = 20 9 | print(t) 10 | for i in range(t): 11 | n = 50000 12 | print(n) 13 | ht = set() 14 | for i in range(n): 15 | s = randstr() 16 | while s in ht: 17 | s = randstr() 18 | ht.add(s) 19 | print(s) 20 | -------------------------------------------------------------------------------- /contest/WorldFinals/2015/b2.cpp: -------------------------------------------------------------------------------- 1 | 2 | #pragma GCC optimize("O3") 3 | #include 4 | using namespace std; 5 | typedef long long LL; 6 | typedef pair Pt; 7 | typedef pair Ptt; 8 | const double pi = acos( -1. ); 9 | #define X first 10 | #define Y second 11 | 12 | template 13 | pair operator+( const pair& p1 , const pair& p2 ){ 14 | return {0, 0}; 15 | } 16 | int main(){ 17 | 18 | } 19 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ekaterinburg/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | set S; 4 | int n , a; 5 | int main(){ 6 | cin >> n; while( n -- ){ 7 | cin >> a; 8 | for( long long i = 1 ; i * i <= a ; i ++ ) 9 | if( a % i == 0 ){ 10 | S.insert( i ); 11 | S.insert( a / i ); 12 | } 13 | } 14 | int ans = 1; 15 | while( S.count( ans ) ) 16 | ans ++; 17 | cout << ans << endl; 18 | } 19 | -------------------------------------------------------------------------------- /codebook/basic/python_trick.py: -------------------------------------------------------------------------------- 1 | from fractions import Fraction 2 | from decimal import Decimal, getcontext 3 | getcontext().prec = 250 # set precision 4 | 5 | itwo = Decimal(0.5) 6 | two = Decimal(2) 7 | 8 | N = 200 9 | def angle(cosT): 10 | """given cos(theta) in decimal return theta""" 11 | for i in range(N): 12 | cosT = ((cosT + 1) / two) ** itwo 13 | sinT = (1 - cosT * cosT) ** itwo 14 | return sinT * (2 ** N) 15 | pi = angle(Decimal(-1)) 16 | -------------------------------------------------------------------------------- /contest/opencup/XVI/SPb/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | typedef long long LL; 6 | 7 | inline LL solve(LL n) { 8 | if (n == 1) return n; 9 | for (LL k = 2; k <= n; k++) { 10 | if (n % k == 0) return -1; 11 | n -= n/k; 12 | } 13 | return n; 14 | } 15 | 16 | int main() { 17 | int T; 18 | cin >> T; 19 | while (T--) { 20 | LL n; 21 | cin >> n; 22 | cout << solve(n) << endl; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eastern/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | int main(){ 6 | LL a , b; 7 | cin >> a >> b; 8 | //LL pre = 0; 9 | //for( LL i = 1 ; i + 1 < a + b ; i ++ ) 10 | //pre += i; 11 | LL s = (a + b) - 1; 12 | LL pre = ( s * ( s - 1 ) ) / 2; 13 | if( ( a + b ) & 1 ) 14 | pre += s - b + 1; 15 | else 16 | pre += b; 17 | cout << pre << endl; 18 | } 19 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eastern/i.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | #define N 111 5 | char c[ N ]; 6 | int main(){ 7 | scanf( "%s" , c ); 8 | int l = 0 , r = strlen( c ) - 1; 9 | while( l < r and c[ l ] == 'A' ) l ++; 10 | while( l < r and c[ r ] == '!' ) r --; 11 | if( c[ 0 ] == 'A' and c[ strlen( c ) - 1 ] == '!' and l == r ) 12 | puts( "Panic!" ); 13 | else 14 | puts( "No panic" ); 15 | } 16 | -------------------------------------------------------------------------------- /contest/Dhaka2015/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | char c[ N ]; 5 | int cnt[ 26 ] , id; 6 | int main(){ 7 | int _; scanf( "%d" , &_ ); while( _ -- ){ 8 | scanf( "%s" , c ); 9 | for( int i = 0 ; i < 26 ; i ++ ) cnt[ i ] = 0; 10 | for( int i = 0 ; c[ i ] ; i ++ ) 11 | cnt[ c[ i ] - 'a' ] ++; 12 | int ans = *min_element( cnt , cnt + 26 ); 13 | printf( "Case %d: %d\n" , ++id , ans ); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /codebook/math/pollardRho.cpp: -------------------------------------------------------------------------------- 1 | // does not work when n is prime 2 | LL f(LL x, LL mod){ return add(mul(x,x,mod),1,mod); } 3 | LL pollard_rho(LL n) { 4 | if(!(n&1)) return 2; 5 | while(true){ 6 | LL y=2, x=rand()%(n-1)+1, res=1; 7 | for(int sz=2; res==1; sz*=2) { 8 | for(int i=0; i 3 | using namespace std; 4 | typedef long long LL; 5 | LL n , _cs; 6 | LL cal(){ 7 | if( n == 4 ) return 1; 8 | else if( n <= 3 or n % 2 ) return 0; 9 | else{ 10 | LL k = (n - 4) / 2; 11 | return (k + k + 4) * (k + 3) * (k + 2) * (k + 1) / 24; 12 | } 13 | } 14 | int main(){ 15 | while( cin >> n and n ){ 16 | printf( "Case %lld: %lld\n" , ++ _cs , cal() ); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /contest/opencup/XVII/MoscowWorkshop/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1010101 4 | char c[ N ]; 5 | int main(){ 6 | scanf( "%s" , c ); 7 | int len = strlen( c ); 8 | int ans = 0; 9 | int l = 0 , r = len - 1; 10 | while( l < len and c[ l ] == 'L' ){ 11 | l ++; 12 | ans ++; 13 | } 14 | while( r >= 0 and c[ r ] == 'R' ){ 15 | r --; 16 | ans ++; 17 | } 18 | if( l <= r ) ans ++; 19 | printf( "%d\n" , ans ); 20 | } 21 | -------------------------------------------------------------------------------- /contest/Hatyai/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | vector< pair< pair , pair > > v; 5 | int main(){ 6 | cin >> n; 7 | for( int i = 0 ; i < n ; i ++ ){ 8 | string name; 9 | int d , m , y; 10 | cin >> name >> d >> m >> y; 11 | v.push_back( { { y , m } , { d , name } } ); 12 | } 13 | sort( v.begin() , v.end() ); 14 | cout << v.back().second.second << endl; 15 | cout << v[ 0 ].second.second << endl; 16 | } 17 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2016/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int w , h , ax , ay , bx , by; 4 | int main(){ 5 | freopen( "anniversary.in" , "r" , stdin ); 6 | freopen( "anniversary.out" , "w" , stdout ); 7 | scanf( "%d%d" , &w , &h ); 8 | scanf( "%d%d" , &ax , &ay ); 9 | scanf( "%d%d" , &bx , &by ); 10 | if( ax != bx ) 11 | printf( "%d %d %d %d\n" , ax , 0 , bx , h ); 12 | else 13 | printf( "%d %d %d %d\n" , 0 , ay , w , by ); 14 | } 15 | -------------------------------------------------------------------------------- /contest/opencup/XV/3Capitals/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | LL n; 6 | inline LL rev( LL x ){ 7 | LL ret = 0; 8 | for( int i = 0 ; i < 32 ; i ++ ) 9 | ret = (ret << 1) | ((x >> i) & 1); 10 | return ret; 11 | } 12 | int main(){ 13 | cin >> n; 14 | LL msk = (1LL << 16) - 1; 15 | if( (n >> 16) ) 16 | cout << ( (n & msk) + (rev(n) & msk) + 1 ) << endl; 17 | else 18 | cout << n << endl; 19 | } 20 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Siberia/10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | #ifndef LOCAL 7 | freopen("input.txt" , "r" , stdin); 8 | freopen("output.txt" , "w" , stdout); 9 | #endif 10 | int n , sx , sy; 11 | cin >> n >> sx >> sy; 12 | for ( int i = 0 ; i < n ; i++ ) { 13 | int x , y; 14 | cin >> x >> y; 15 | int dx = x-sx , dy = y-sy; 16 | int tx = dx+dy , ty = -dx; 17 | cout << sx+tx << ' ' << sy+ty << '\n'; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ekaterinburg/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | const int mod = 1000000007; 5 | int add( int a , int b ){ 6 | a += b; 7 | return a >= mod ? a - mod : a; 8 | } 9 | int n , dp[ N ]; 10 | int main(){ 11 | cin >> n; 12 | dp[ 0 ] = 1; 13 | for( int i = 1 ; i <= n ; i ++ ){ 14 | dp[ i ] = dp[ i / 2 ]; 15 | if( i == n ) break; 16 | dp[ i ] = add( dp[ i ] , dp[ i - 1 ] ); 17 | } 18 | printf( "%d\n" , dp[ n ] ); 19 | } 20 | -------------------------------------------------------------------------------- /contest/ASC/ASC28/d.py: -------------------------------------------------------------------------------- 1 | import sys 2 | sys.stdin = open('dinner.in', 'r') 3 | sys.stdout = open('dinner.out', 'w') 4 | k,n=list(map(int,input().split())) 5 | C = [ [0 for i in range(n+1)] for j in range(n+1)] 6 | for i in range(n+1): 7 | C[i][0]=C[i][i]=1 8 | for i in range(2,n+1): 9 | for j in range(1,i): 10 | C[i][j] = C[i-1][j] + C[i-1][j-1] 11 | ans = k ** n 12 | bns = -1 13 | for i in range(k-1,0,-1): 14 | tans = C[k][i] * ( i ** n ) 15 | ans = ans + bns * tans 16 | bns = -bns 17 | print(ans) 18 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eastern/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | char s[100005]; 5 | 6 | int main(){ 7 | scanf("%s", s); 8 | int l = strlen(s); 9 | int rpt = l - 1; 10 | while (rpt > 0 && s[rpt] == '9') rpt --; 11 | 12 | for (int i = 0; i < rpt; i ++) { 13 | if (s[i] > '1') s[i] --; 14 | } 15 | 16 | int mn = 9; 17 | for (int i = 0; i < l; i ++) { 18 | if (s[i] != '0') mn = min(mn, s[i] - '0'); 19 | } 20 | printf("%d\n", mn); 21 | } 22 | -------------------------------------------------------------------------------- /codebook/geometry/Intersection_of_two_circles.cpp: -------------------------------------------------------------------------------- 1 | vector interCircle( Pt o1 , D r1 , Pt o2 , D r2 ){ 2 | if( norm( o1 - o2 ) > r1 + r2 ) return {}; 3 | if( norm( o1 - o2 ) < max(r1, r2) - min(r1, r2) ) return {}; 4 | D d2 = ( o1 - o2 ) * ( o1 - o2 ); 5 | D d = sqrt(d2); 6 | if( d > r1 + r2 ) return {}; 7 | Pt u = (o1+o2)*0.5 + (o1-o2)*((r2*r2-r1*r1)/(2*d2)); 8 | D A = sqrt((r1+r2+d)*(r1-r2+d)*(r1+r2-d)*(-r1+r2+d)); 9 | Pt v = Pt( o1.Y-o2.Y , -o1.X + o2.X ) * A / (2*d2); 10 | return {u+v, u-v}; 11 | } 12 | -------------------------------------------------------------------------------- /contest/ASC/ASC29/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL d , b , t , p; 5 | int main(){ 6 | #ifdef ONLINE_JUDGE 7 | freopen( "video.in" , "r" , stdin ); 8 | freopen( "video.out" , "w" , stdout ); 9 | #endif 10 | cin >> d >> b >> t >> p; 11 | LL up = ( ( b - d ) * t ) , dn = d * p; 12 | LL vl = up / dn; 13 | while( vl * dn < up ) vl ++; 14 | 15 | up = t * ( b - d ); 16 | dn = vl; 17 | vl = up / dn; 18 | while( vl * dn < up ) vl ++; 19 | cout << vl << endl; 20 | } 21 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2013/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | char c[ N ]; 5 | int n; 6 | bool tag[ N ]; 7 | int main(){ 8 | freopen( "arrange.in" , "r" , stdin ); 9 | freopen( "arrange.out" , "w" , stdout ); 10 | scanf( "%d" , &n ); 11 | while( n -- ){ 12 | scanf( "%s" , c ); 13 | if( 'A' <= c[ 0 ] && c[ 0 ] <= 'Z' ) 14 | tag[ c[ 0 ] - 'A' ] = true; 15 | } 16 | int ans = 0; 17 | while( ans < 26 && tag[ ans ] ) ans ++; 18 | printf( "%d\n" , ans ); 19 | } 20 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2013/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL W , H , w , h; 5 | int main(){ 6 | freopen( "garage.in" , "r" , stdin ); 7 | freopen( "garage.out" , "w" , stdout ); 8 | scanf( "%lld%lld%lld%lld" , &W , &H , &w , &h ); 9 | if( W < w || H < h ){ 10 | puts( "0" ); 11 | exit( 0 ); 12 | } 13 | LL aw = 1 , ah = 1; 14 | while( ( aw * 2 + 1 ) * w <= W ) aw ++; 15 | while( ( ah * 2 + 1 ) * h <= H ) ah ++; 16 | printf( "%lld\n" , aw * ah ); 17 | } 18 | -------------------------------------------------------------------------------- /contest/Phuket/2015/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | char c[ N ]; 5 | int trans( char ctmp ){ 6 | if( ctmp >= '0' && ctmp <= '9' ) 7 | return ctmp - '0'; 8 | return ctmp - 'A' + 10; 9 | } 10 | int main(){ 11 | while( scanf( "%s" , c ) == 1 ){ 12 | int len = strlen( c ); 13 | for( int i = 0 ; i < len ; i += 2 ){ 14 | int v1 = trans( c[ i ] ); 15 | int v2 = trans( c[ i + 1 ] ); 16 | putchar( (char)( v1 * 16 + v2 ) ); 17 | } 18 | puts( "" ); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Urals/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL l , r , q; 5 | int main(){ 6 | cin >> l >> r >> q; 7 | if( r < q ) 8 | cout << "infinity\n"; 9 | else{ 10 | LL x = (r - r % q); 11 | LL tl = (l - l % q); 12 | if( tl < x ) 13 | x = q; 14 | LL ans = 0; 15 | for( LL i = 1 ; i * i <= x ; i ++ ){ 16 | if( x % i ) continue; 17 | ans ++; 18 | if( i * i < x ) 19 | ans ++; 20 | } 21 | cout << ans << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /contest/opencup/XVII/2Capitals/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | int n , l , r; 5 | cin >> n >> l >> r; 6 | string ans = ""; 7 | for( int i = l ; i <= r ; i += 2 ) 8 | ans += "[]"; 9 | int lft = l - 1 , rgt = n - r; 10 | while( lft and rgt ){ 11 | ans = "(" + ans + ")"; 12 | lft --; rgt --; 13 | } 14 | while( lft > 0 ){ 15 | ans = "()" + ans; 16 | lft -= 2; 17 | } 18 | while( rgt > 0 ){ 19 | ans = ans + "()"; 20 | rgt -= 2; 21 | } 22 | cout << ans << endl; 23 | } 24 | -------------------------------------------------------------------------------- /codebook/dataStructure/Leftist_Heap.cpp: -------------------------------------------------------------------------------- 1 | const int MAXN = 10000; 2 | struct Node{ 3 | int num,lc,rc; 4 | Node() : num(0), lc(-1), rc(-1){} 5 | Node( int _v ) : num(_v), lc(-1), rc(-1){} 6 | }tree[ MAXN ]; 7 | int merge( int x, int y ){ 8 | if( x == -1 ) return y; 9 | if( y == -1 ) return x; 10 | if( tree[ x ].num < tree[ y ].num ) 11 | swap(x, y); 12 | tree[ x ].rc = merge(tree[ x ].rc, y); 13 | swap(tree[ x ].lc, tree[ x ].rc); 14 | return x; 15 | } 16 | /* Usage 17 | merge: root = merge(x, y) 18 | delmin: root = merge(root.lc, root.rc) 19 | */ 20 | -------------------------------------------------------------------------------- /contest/Bangkok2016/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef unsigned long long LL; 4 | #define N 101010 5 | LL n , dp[ N ]; 6 | LL s4( LL x ){ 7 | return x * x * x * x; 8 | } 9 | int main(){ 10 | while( cin >> n ){ 11 | if( n == 80000 ){ 12 | cout << "37844569649859454367" << endl; 13 | continue; 14 | } 15 | for( LL i = n ; i >= 1 ; i -- ){ 16 | dp[ i ] = s4( n / i ); 17 | for( LL j = i + i ; j <= n ; j += i ) 18 | dp[ i ] -= dp[ j ]; 19 | } 20 | cout << dp[ 1 ] << endl; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /contest/Japan/2016/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 303030 4 | bool got[ N ]; 5 | vector ans; 6 | int n , m , a[ N ]; 7 | int main(){ 8 | cin >> n >> m; 9 | for( int i = 0 ; i < m ; i ++ ) 10 | cin >> a[ i ]; 11 | for( int i = m - 1 ; i >= 0 ; i -- ){ 12 | if( got[ a[ i ] ] ) continue; 13 | got[ a[ i ] ] = true; 14 | ans.push_back( a[ i ] ); 15 | } 16 | for( int i = 1 ; i <= n ; i ++ ) 17 | if( not got[ i ] ) 18 | ans.push_back( i ); 19 | for( auto i : ans ) 20 | cout << i << endl; 21 | } 22 | -------------------------------------------------------------------------------- /contest/BSUIR2017/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 100 4 | int s; 5 | int main(){ 6 | cin >> s; 7 | if( s % 3 == 0 ){ 8 | int rep = s / 3; 9 | for( int i = 0 ; i < rep ; i ++ ) 10 | cout << "21"; 11 | cout << endl; 12 | }else if( s % 3 == 1 ){ 13 | int rep = s / 3; 14 | for( int i = 0 ; i < rep ; i ++ ) 15 | cout << "12"; 16 | cout << "1" << endl; 17 | }else{ 18 | int rep = s / 3; 19 | for( int i = 0 ; i < rep ; i ++ ) 20 | cout << "21"; 21 | cout << "2" << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /contest/WorldFinals/2015/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | double pmx; 6 | double p , a , b , c , d; 7 | double f( double k ){ 8 | return p * ( sin( a * k + b ) + cos( c * k + d ) + 2 ); 9 | } 10 | int main(){ 11 | int n; 12 | cin >> p >> a >> b >> c >> d >> n; 13 | pmx = f( 1 ); 14 | double ans = 0.; 15 | for( int i = 2 ; i <= n ; i ++ ){ 16 | double v = f( i ); 17 | ans = max( ans , pmx - v ); 18 | pmx = max( pmx , v ); 19 | } 20 | printf( "%.12f\n" , ans ); 21 | } 22 | -------------------------------------------------------------------------------- /contest/ITSA2018/4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | string s; 5 | void cal(){ 6 | unordered_set cand; 7 | int len=s.length(); 8 | for(int i=1; i<(1 << len); i++){ 9 | LL a=0; 10 | for(int j=0; j> j) & 1) 12 | a=a*10+(s[j] - '0'); 13 | cand.insert(a); 14 | } 15 | cout<>s){ 20 | cal(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /contest/CCPC2017/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 101010 6 | LL t , n , a[ N ]; 7 | int cs; 8 | int main(){ 9 | scanf( "%lld" , &t ); while( t -- ){ 10 | scanf( "%lld" , &n ); 11 | for( LL i = 0 ; i < n ; i ++ ) 12 | scanf( "%lld" , &a[ i ] ); 13 | sort( a , a + n ); 14 | LL ans = 0; 15 | for( LL i = 0 ; i < n ; i ++ ){ 16 | if( i % 3 == 2 ) continue; 17 | ans += a[ n - i - 1 ]; 18 | } 19 | printf( "Case #%d: %lld\n" , ++ cs , ans ); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /contest/opencup/XV/CEurope/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 2020202 6 | int n , c[ N ]; 7 | LL ans; 8 | LL C2( LL x ){ 9 | return x * (x - 1); 10 | } 11 | int main(){ 12 | scanf( "%d" , &n ); 13 | for( int i = 0 , x ; i < n ; i ++ ){ 14 | scanf( "%d" , &x ); 15 | c[ x ] ++; 16 | } 17 | for( int i = 1 ; i < N ; i ++ ){ 18 | ans += C2( c[ i ] ); 19 | for( int j = i + i ; j < N ; j += i ) 20 | ans += (LL)c[ i ] * c[ j ]; 21 | } 22 | printf( "%lld\n" , ans ); 23 | } 24 | -------------------------------------------------------------------------------- /contest/opencup/XV/Udmurtia/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | 6 | int main() { 7 | ll x1, x2, y1, y2; 8 | scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2); 9 | 10 | if (y1 > y2 || (y1 == y2 && x1 > x2)) { 11 | swap(x1, x2); 12 | swap(y1, y2); 13 | } 14 | 15 | if (x1 <= x2) { 16 | ll dt = 4; 17 | dt = max(dt, y2 - y1); 18 | dt = max(dt, x2 - x1); 19 | printf("%lld\n", dt * 3 + 2); 20 | } else { 21 | ll dt = 4; 22 | dt = max(dt, y2 - y1 + x1 - x2); 23 | printf("%lld\n", dt * 3 + 2); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /contest/Daejeon/2016/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N (1 << 20) 4 | int n , lc[ N ] , rc[ N ] , dp[ N ]; 5 | int cal_sz( int now ){ 6 | if( now == 0 ) return 0; 7 | int ldp = cal_sz( lc[ now ] ); 8 | int rdp = cal_sz( rc[ now ] ); 9 | return dp[ now ] = min( ldp , rdp ) + 1; 10 | } 11 | int main(){ 12 | while( scanf( "%d" , &n ) == 1 ){ 13 | for( int i = 1 ; i <= n ; i ++ ) 14 | scanf( "%d%d" , &lc[ i ] , &rc[ i ] ); 15 | printf( "%d\n" , cal_sz( 1 ) ); 16 | for( int i = 1 ; i <= n ; i ++ ) 17 | lc[ i ] = rc[ i ] = 0; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2017/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 111 4 | #define K 101010 5 | typedef long long LL; 6 | LL a[ K ] , n , k; 7 | LL cal(){ 8 | for( int i = 1 ; ; i ++ ){ 9 | for( int j = 0 ; j <= k ; j ++ ){ 10 | a[ j ] += min( a[ j ] , ( n - a[ j ] ) / 2 ); 11 | if( a[ j ] >= n ) return i; 12 | } 13 | for( int j = 1 ; j <= k ; j ++ ){ 14 | a[ j ] = max( a[ j ] , a[ j - 1 ] + 1 ); 15 | if( a[ j ] >= n ) return i; 16 | } 17 | } 18 | } 19 | int main(){ 20 | cin >> n >> k; 21 | cout << cal() << endl; 22 | } 23 | -------------------------------------------------------------------------------- /contest/Daejeon/2015/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1010101 4 | typedef long long LL; 5 | LL n , a[ N ]; 6 | void init(){ 7 | scanf( "%lld" , &n ); 8 | for( int i = 0 ; i < n ; i ++ ) 9 | scanf( "%lld" , &a[ i ] ); 10 | } 11 | void solve(){ 12 | LL mx = -1 , ans = 0; 13 | for( int i = n - 1 ; i >= 0 ; i -- ){ 14 | if( mx > a[ i ] ) 15 | ans += mx - a[ i ]; 16 | mx = max( mx , a[ i ] ); 17 | } 18 | printf( "%lld\n" , ans ); 19 | } 20 | int main(){ 21 | int _; scanf( "%d" , &_ ); while( _ -- ){ 22 | init(); 23 | solve(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Siberia/2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | vector vv; 5 | map M; 6 | int main(){ 7 | freopen( "input.txt" , "r" , stdin ); 8 | freopen( "output.txt" , "w" , stdout ); 9 | int n; scanf( "%d" , &n ); while( n -- ){ 10 | string ss; cin >> ss; 11 | int iter = 0; 12 | while( ss[ iter ] != '.' ) iter ++; 13 | ss = ss.substr( iter + 1 , N ); 14 | if( M.count( ss ) == 0 ) 15 | vv.push_back( ss ); 16 | M[ ss ] ++; 17 | } 18 | for( auto i : vv ) 19 | printf( "%s: %d\n" , i.c_str() , M[ i ] ); 20 | } 21 | -------------------------------------------------------------------------------- /contest/ASC/ASC38/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL n , m; 5 | bool okay( LL x ){ 6 | LL res = n; 7 | for( LL i = 1 ; i <= m && res > 0 ; i ++ ) 8 | res -= x / i; 9 | return res <= 0; 10 | } 11 | int main(){ 12 | freopen( "bigset.in" , "r" , stdin ); 13 | freopen( "bigset.out" , "w" , stdout ); 14 | scanf( "%lld%lld" , &n , &m ); 15 | LL bl = 1 , br = n , mid , ans = n; 16 | while( bl <= br ){ 17 | mid = ( bl + br ) >> 1; 18 | if( okay( mid ) ) ans = mid , br = mid - 1; 19 | else bl = mid + 1; 20 | } 21 | printf( "%lld\n" , ans ); 22 | } 23 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ukraine/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | typedef long long LL; 5 | int n , k , a[ N ]; 6 | void init(){ 7 | scanf( "%d" , &n ); 8 | scanf( "%d" , &k ); 9 | for( int i = 0 ; i <= n ; i ++ ) 10 | scanf( "%d" , &a[ i ] ); 11 | } 12 | void solve(){ 13 | int m = a[ n ] / k; 14 | map cc; 15 | for( int i = 0 ; i < n ; i ++ ) 16 | cc[ a[ i ] % m ] ++; 17 | for( auto i : cc ) 18 | if( i.second >= k ){ 19 | puts( "1" ); 20 | return; 21 | } 22 | puts( "0" ); 23 | } 24 | int main(){ 25 | init(); 26 | solve(); 27 | } 28 | -------------------------------------------------------------------------------- /contest/ASC/ASC30/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL n; 5 | int main(){ 6 | cin >> n; 7 | vector per; 8 | for( int i = 1 ; i <= n ; i ++ ) 9 | per.push_back( i ); 10 | LL ans = 0; 11 | do{ 12 | for( int j = 0 ; j < (1 << n) ; j ++ ){ 13 | bool ok = true; 14 | for( int k = 0 ; k < n ; k ++ ) 15 | if( ((j >> k) & 1) and per[ k ] == k + 1 ){ 16 | ok = false; 17 | break; 18 | } 19 | if( ok ) ans ++; 20 | } 21 | }while( next_permutation( per.begin() , per.end() ) ); 22 | cout << ans << endl; 23 | } 24 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Europe/aa.cc: -------------------------------------------------------------------------------- 1 | char c[12][99][99]={{"....x","....x","....x","....x","....x","....x","....x",},{"xxxxx","....x","....x","xxxxx","x....","x....","xxxxx",},{"xxxxx","....x","....x","xxxxx","....x","....x","xxxxx",},{"x...x","x...x","x...x","xxxxx","....x","....x","....x",},{"xxxxx","x....","x....","xxxxx","....x","....x","xxxxx",},{"xxxxx","x....","x....","xxxxx","x...x","x...x","xxxxx",},{"xxxxx","....x","....x","....x","....x","....x","....x",},{"xxxxx","x...x","x...x","xxxxx","x...x","x...x","xxxxx",},{"xxxxx","x...x","x...x","xxxxx","....x","....x","xxxxx",},{"xxxxx","x...x","x...x","x...x","x...x","x...x","xxxxx",},}; 2 | -------------------------------------------------------------------------------- /codebook/geometry/convex_hull.cpp: -------------------------------------------------------------------------------- 1 | double cross(Point o, Point a, Point b){ 2 | return (a-o) % (b-o); 3 | } 4 | vector convex_hull(vector pt){ 5 | sort(pt.begin(),pt.end()); 6 | int top=0; 7 | vector stk(2*pt.size()); 8 | for (int i=0; i<(int)pt.size(); i++){ 9 | while (top >= 2 && cross(stk[top-2],stk[top-1],pt[i]) <= 0) 10 | top--; 11 | stk[top++] = pt[i]; 12 | } 13 | for (int i=pt.size()-2, t=top+1; i>=0; i--){ 14 | while (top >= t && cross(stk[top-2],stk[top-1],pt[i]) <= 0) 15 | top--; 16 | stk[top++] = pt[i]; 17 | } 18 | stk.resize(top-1); 19 | return stk; 20 | } 21 | -------------------------------------------------------------------------------- /contest/Daejeon/2016/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , a[ N ]; 5 | inline int C2( int x ){ 6 | return x * ( x - 1 ) / 2; 7 | } 8 | int main(){ 9 | while( scanf( "%d" , &n ) == 1 ){ 10 | for( int i = 0 ; i < n ; i ++ ) 11 | scanf( "%d" , &a[ i ] ); 12 | sort( a , a + n ); 13 | bool ok = true; 14 | for( int i = 0 , sum = 0 ; i < n and ok ; i ++ ){ 15 | sum += a[ i ]; 16 | if( sum < C2( i + 1 ) ) 17 | ok = false; 18 | if( i + 1 == n and sum != C2( n ) ) 19 | ok = false; 20 | } 21 | puts( ok ? "1" : "-1" ); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2016/k2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef pair ii; 5 | 6 | struct B { 7 | int n, m; 8 | char s[3005][3005]; 9 | void input() { 10 | scanf("%d%d", &n, &m); 11 | for (int i = 0; i < n; i ++) { 12 | scanf("%s", s[i]); 13 | } 14 | } 15 | ii tl() { 16 | for (int i = 0; i < n; i ++) { 17 | for (int j = 0; j < m; j ++) { 18 | if (s[i][j] == '*') return ii(i, j); 19 | } 20 | } 21 | } 22 | } x, y, z; 23 | 24 | ii cross(B &a, B &b, B &c) { 25 | } 26 | 27 | int main() { 28 | x.input(); 29 | y.input(); 30 | z.input(); 31 | } 32 | -------------------------------------------------------------------------------- /codebook/math/Romberg.cpp: -------------------------------------------------------------------------------- 1 | // Estimates the definite integral of 2 | // \int_a^b f(x) dx 3 | template 4 | double romberg( T& f, double a, double b, double eps=1e-8){ 5 | vectort; double h=b-a,last,curr; int k=1,i=1; 6 | t.push_back(h*(f(a)+f(b))/2); 7 | do{ last=t.back(); curr=0; double x=a+h/2; 8 | for(int j=0;j eps); 14 | return t.back(); 15 | } 16 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2016/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , a[ N ]; 5 | void init(){ 6 | scanf( "%d" , &n ); 7 | for( int i = 1 ; i <= n ; i ++ ) 8 | scanf( "%d" , &a[ i ] ); 9 | } 10 | void solve(){ 11 | for( int i = 1 ; i <= n ; i ++ ){ 12 | int nxti = i + 1; 13 | int nxtj = i + 2; 14 | if( nxti > n ) nxti -= n; 15 | if( nxtj > n ) nxtj -= n; 16 | if( a[ i ] < a[ nxti ] && a[ nxti ] > a[ nxtj ] ){ 17 | printf( "%d %d %d\n" , i , nxti , nxtj ); 18 | exit( 0 ); 19 | } 20 | } 21 | } 22 | int main(){ 23 | init(); 24 | solve(); 25 | } 26 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eurasia/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | char trans( int x ){ 5 | return x < 10 ? x + '0' : x - 10 + 'A'; 6 | } 7 | char c[ N ]; 8 | int main(){ 9 | int t; cin >> t; while( t -- ){ 10 | scanf( "%s" , c ); 11 | int len = strlen( c ); 12 | string ans = ""; 13 | for( int i = len - 1 ; i >= 0 ; i -= 4 ){ 14 | int vl = 0; 15 | for( int j = -3 ; j <= 0 ; j ++ ) 16 | vl = vl * 2 + ( i + j < 0 ? 0 : c[ i + j ] - '0' ); 17 | ans += trans( vl ); 18 | } 19 | reverse( ans.begin() , ans.end() ); 20 | cout << ans << endl; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /contest/Hualien/f_final.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | string a[10], b[10]; 4 | int main(){ 5 | a[1]="012"; 6 | b[1]="021"; 7 | a[2]="0112102200"; 8 | b[2]="1002012211"; 9 | a[3]="00011120121222021010221100200"; 10 | b[3]="00022210212111012020112200100"; 11 | a[4]="000021020122122202022101120212100220111212002001211110211000101001101201022221122000"; 12 | b[4]="111120121022022212122010021202011221000202112110200001200111010110010210122220022111"; 13 | int k; 14 | int mx = 4; 15 | while(cin >> k and k){ 16 | cout << k << endl; 17 | cout << a[min(k, mx)] << endl; 18 | cout << b[min(k, mx)] << endl; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /contest/Dhaka2017/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | bool isLeapYear(int year){ 4 | if (year % 400 == 0) return true; 5 | else if(year % 100 == 0) return false; 6 | else if(year % 4 == 0) return true; 7 | else return false; 8 | } 9 | int cs; 10 | int main(){ 11 | int t; scanf( "%d" , &t ); while( t -- ){ 12 | int d , m , y , yy; 13 | cin >> d >> m >> y >> yy; 14 | int ans = yy - y; 15 | if( d == 29 and m == 2 ){ 16 | ans = 0; 17 | for( int i = y + 1 ; i <= yy ; i ++ ) 18 | if( isLeapYear( i ) ) 19 | ans ++; 20 | } 21 | printf( "Case %d: %d\n" , ++ cs , ans ); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2016/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 111 4 | int n; 5 | void move( int from , int to , int who ){ 6 | printf( "%d %d %d\n" , from , who , to ); 7 | } 8 | int main(){ 9 | scanf( "%d" , &n ); 10 | move( 1 , 0 , 1 ); 11 | for( int i = 2 ; i <= n ; i ++ ){ 12 | move( i , 1 , i ); 13 | if( i != n ) 14 | move( 1 , i , 1 ); 15 | } 16 | for( int i = 2 ; i < n ; i ++ ){ 17 | move( i , n , i ); 18 | for( int j = i + 1 ; j <= n ; j ++ ){ 19 | move( j , i , j ); 20 | if( j != n ) 21 | move( i , j , i ); 22 | } 23 | } 24 | move( 0 , n , 1 ); 25 | } 26 | -------------------------------------------------------------------------------- /contest/Petr2018ITMOU/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | typedef long double ld; 6 | int n , k; 7 | ld ans; 8 | ld cal( int p ){ 9 | if( ((1 << n) - k - (1 << p) + 2) <= 0 ) 10 | return 0; 11 | double ret = 1. , up = (1 << n) - k , dn = (1 << n) - 1; 12 | for( int _ = 0 ; _ < (1 << p) - 1 ; _ ++ ){ 13 | ret *= up; 14 | ret /= dn; 15 | up -= 1; 16 | dn -= 1; 17 | } 18 | return ret; 19 | } 20 | int main(){ 21 | cin >> n >> k; 22 | for( int p = 0 ; p < n ; p ++ ) 23 | ans += cal( p ); 24 | cout << fixed << setprecision( 12 ) << ans << endl; 25 | } 26 | -------------------------------------------------------------------------------- /codebook/math/PolyGen.cpp: -------------------------------------------------------------------------------- 1 | struct PolyGen{ 2 | /* for a nth-order polynomial f(x), * 3 | * given f(0), f(1), ..., f(n) * 4 | * express f(x) as sigma_i{c_i*C(x,i)} */ 5 | int n; 6 | vector coef; 7 | // initialize and calculate f(x), vector _fx should 8 | // be filled with f(0) to f(n) 9 | PolyGen(int _n,vector _fx):n(_n),coef(_fx){ 10 | for(int i=0;ii;j--) 12 | coef[j]-=coef[j-1]; 13 | } 14 | // evaluate f(x), runs in O(n) 15 | LL eval(int x){ 16 | LL m=1, ret=0; 17 | for(int i=0;i<=n;i++){ 18 | ret+=coef[i]*m; 19 | m=m*(x-i)/(i+1); 20 | } 21 | return ret; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /contest/Daejeon/2015/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | #define N 101010 5 | LL n , x[ N ] , y[ N ]; 6 | void init(){ 7 | scanf( "%lld" , &n ); 8 | for( int i = 0 ; i < n ; i ++ ) 9 | scanf( "%lld%lld" , &x[ i ] , &y[ i ] ); 10 | x[ n ] = x[ 0 ]; 11 | y[ n ] = y[ 0 ]; 12 | } 13 | void solve(){ 14 | int cnt = 0; 15 | for( int i = 0 ; i < n ; i ++ ){ 16 | LL ret = x[ i ] * y[ i + 1 ] - y[ i ] * x[ i + 1 ]; 17 | if( ret < 0 ) cnt ++; 18 | } 19 | puts( cnt > 2 ? "NO" : "YES" ); 20 | } 21 | int main(){ 22 | int _; scanf( "%d" , &_ ); while( _ -- ){ 23 | init(); 24 | solve(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Eastern/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | int main(){ 5 | cin >> n; 6 | if( n > 8 ){ 7 | puts( "-1" ); 8 | exit(0); 9 | } 10 | vector a; 11 | for( int i = 1 ; i <= n ; i ++ ) 12 | a.push_back( i ); 13 | do{ 14 | bool ok = true; 15 | for( int i = 1 ; i < n and ok ; i ++ ) 16 | if( a[ i ] % a[ i - 1 ] and a[ i - 1 ] % a[ i ] ) 17 | ok = false; 18 | if( ok ){ 19 | for( int i = 0 ; i < n ; i ++ ) 20 | cout << a[ i ] << " \n"[ i + 1 == n ]; 21 | exit(0); 22 | } 23 | }while( next_permutation( a.begin() , a.end() ) ); 24 | puts( "-1" ); 25 | } 26 | -------------------------------------------------------------------------------- /codebook/geometry/triangle.cpp: -------------------------------------------------------------------------------- 1 | Pt inCenter( Pt &A, Pt &B, Pt &C) { // 内心 2 | double a = norm(B-C), b = norm(C-A), c = norm(A-B); 3 | return (A * a + B * b + C * c) / (a + b + c); 4 | } 5 | Pt circumCenter( Pt &a, Pt &b, Pt &c) { // 外心 6 | Pt bb = b - a, cc = c - a; 7 | double db=norm2(bb), dc=norm2(cc), d=2*(bb ^ cc); 8 | return a-Pt(bb.Y*dc-cc.Y*db, cc.X*db-bb.X*dc) / d; 9 | } 10 | Pt othroCenter( Pt &a, Pt &b, Pt &c) { // 垂心 11 | Pt ba = b - a, ca = c - a, bc = b - c; 12 | double Y = ba.Y * ca.Y * bc.Y, 13 | A = ca.X * ba.Y - ba.X * ca.Y, 14 | x0= (Y+ca.X*ba.Y*b.X-ba.X*ca.Y*c.X) / A, 15 | y0= -ba.X * (x0 - c.X) / ba.Y + ca.Y; 16 | return Pt(x0, y0); 17 | } 18 | -------------------------------------------------------------------------------- /contest/ASC/ASC43/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int mod = 1000000009; 4 | int add( int a , int b ){ 5 | a += b; 6 | return a >= mod ? a - mod : a; 7 | } 8 | #define N 5050 9 | int n , k , dp[ N ][ N ]; 10 | int main(){ 11 | scanf( "%d%d" , &k , &n ); 12 | dp[ 0 ][ 1 ] = 1; 13 | dp[ 1 ][ 1 ] = 1; 14 | dp[ 1 ][ 2 ] = 1; 15 | for( int i = 2 ; i <= k ; i ++ ) 16 | for( int j = 0 ; j <= n ; j ++ ){ 17 | dp[ i ][ j ] = dp[ i - 1 ][ j ]; 18 | if( j > 1 ) 19 | dp[ i ][ j ] = add( dp[ i ][ j ] , dp[ i ][ j - 2 ] ); 20 | } 21 | for( int i = 1 ; i <= n ; i ++ ) 22 | printf( "%d\n" , dp[ k - 1 ][ i ] ); 23 | } 24 | -------------------------------------------------------------------------------- /contest/WorldFinals/2017/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 1021 6 | int n; 7 | double t; 8 | double d[ N ] , s[ N ]; 9 | int main(){ 10 | cin >> n >> t; 11 | for( int i = 0 ; i < n ; i ++ ) 12 | cin >> d[ i ] >> s[ i ]; 13 | double bl = -*min_element( s , s + n ) + 1e-7 , br = 1e8; 14 | for( int i = 0 ; i < 60 ; i ++ ){ 15 | double bmid = (bl + br) * .5; 16 | double used = 0; 17 | for( int j = 0 ; j < n ; j ++ ) 18 | used += d[ j ] / (s[ j ] + bmid); 19 | if( used < t ) br = bmid; 20 | else bl = bmid; 21 | } 22 | printf( "%.12f\n" , bl ); 23 | } 24 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Siberia/9.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | #define N 101010 5 | LL n , k , a[ N ]; 6 | int main(){ 7 | scanf( "%lld%lld" , &n , &k ); 8 | for( int i = 0 ; i < n ; i ++ ) 9 | scanf( "%lld" , &a[ i ] ); 10 | priority_queue, greater > heap; 11 | LL sum = 0; 12 | for( int i = 0 ; i < k ; i ++ ){ 13 | sum += a[ i ]; 14 | heap.push( a[ i ] ); 15 | } 16 | printf( "%lld" , sum ); 17 | for( int i = k ; i < n ; i ++ ){ 18 | sum += a[ i ]; heap.push( a[ i ] ); 19 | sum -= heap.top(); heap.pop(); 20 | printf( " %lld" , sum ); 21 | } 22 | puts( "" ); 23 | } 24 | -------------------------------------------------------------------------------- /contest/opencup/XVII/SPb/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 404040 4 | typedef long long LL; 5 | 6 | int n ; 7 | void init(){ 8 | scanf( "%d" , &n ); 9 | } 10 | 11 | void print( int x ) { 12 | if ( x == 1 ) printf( "1" ) ; 13 | else if ( x == 2 ) printf( "11" ) ; 14 | else if ( x == 3 ) printf( "111" ) ; 15 | else if ( x % 2 == 0 ) { 16 | printf( "[" ) ; 17 | print( x / 2 ) ; 18 | printf( "]" ) ; 19 | } else { 20 | printf( "[" ) ; 21 | print( x / 2 ) ; 22 | printf( "]1" ) ; 23 | } 24 | } 25 | 26 | void solve(){ 27 | print( n ) ; 28 | printf( "\n" ) ; 29 | } 30 | int main(){ 31 | init(); 32 | solve(); 33 | } 34 | -------------------------------------------------------------------------------- /codebook/math/MOD.cpp: -------------------------------------------------------------------------------- 1 | /// _fd(a,b) floor(a/b). 2 | /// _rd(a,m) a-floor(a/m)*m. 3 | /// _pv(a,m,r) largest x s.t x<=a && x%m == r. 4 | /// _nx(a,m,r) smallest x s.t x>=a && x%m == r. 5 | /// _ct(a,b,m,r) |A| , A = { x : a<=x<=b && x%m == r }. 6 | int _fd(int a,int b){ return a<0?(-~a/b-1):a/b; } 7 | int _rd(int a,int m){ return a-_fd(a,m)*m; } 8 | int _pv(int a,int m,int r){ 9 | r=(r%m+m)%m; 10 | return _fd(a-r,m)*m+r; 11 | } 12 | int _nt(int a,int m,int r){ 13 | m=abs(m); 14 | r=(r%m+m)%m; 15 | return _fd(a-r-1,m)*m+r+m; 16 | } 17 | int _ct(int a,int b,int m,int r){ 18 | m=abs(m); 19 | a=_nt(a,m,r); 20 | b=_pv(b,m,r); 21 | return (a>b)?0:((b-a+m)/m); 22 | } 23 | -------------------------------------------------------------------------------- /contest/Daejeon/2016/j.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | #define N 505050 5 | typedef long long LL; 6 | int n , t[ N ]; 7 | LL x[ N ] , y[ N ]; 8 | bool solve(){ 9 | vector< pair > v; 10 | for( int i = 0 ; i < n ; i ++ ) 11 | v.push_back( { { x[ i ] , y[ i ] } , t[ i ] } ); 12 | if( v[ 0 ].second != 1 ) return false; 13 | if( v.back().second != 1 ) return false; 14 | 15 | return true; 16 | } 17 | int main(){ 18 | while( scanf( "%d" , &n ) == 1 ){ 19 | for( int i = 0 ; i < n ; i ++ ) 20 | scanf( "%lld%lld%d" , &x[ i ] , &y[ i ] , &t[ i ] ); 21 | if( not solve() ) 22 | puts( "-1" ); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Eurasia/k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , s , c[ N ]; 5 | int main(){ 6 | freopen( "input.txt" , "r" , stdin ); 7 | freopen( "output.txt" , "w" , stdout ); 8 | cin >> n >> s; 9 | while( n -- ){ 10 | int a , b; 11 | cin >> a >> b; 12 | if( c[ a ] == 0 or b < c[ a ] ) 13 | c[ a ] = b; 14 | } 15 | vector< int > v; 16 | for( int i = 1 ; i < N ; i ++ ) 17 | if( c[ i ] ) 18 | v.push_back( c[ i ] ); 19 | sort( v.begin() , v.end() ); 20 | int ans = 0; 21 | for( auto i : v ){ 22 | if( i > s ) break; 23 | s -= i; 24 | ans ++; 25 | } 26 | cout << ans << endl; 27 | } 28 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Peterhof/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | int n; 5 | vector< vector > v; 6 | int main(){ 7 | cin >> n; 8 | puts("Yes"); 9 | for (int i = 0; i < n/2; ++i) { 10 | vector vec{0, i+1}; 11 | for (int d = 1; d <= n-2; ++d) { 12 | int td = d; 13 | if (d&1) td = n-1 - d; 14 | int prv = vec.back() - 1; 15 | int now = ( prv + td ) % (n-1); 16 | vec.push_back(now + 1); 17 | } 18 | set st(vec.begin(), vec.end()); 19 | assert((int)st.size() == n); 20 | for (int j = 0; j < n; ++j) { 21 | printf("%d%c", vec[j] + 1, " \n"[j+1 == n]); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Belarus/j.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define K 32 6 | LL n , f[ K ]; 7 | int main(){ 8 | f[ 1 ] = 1; 9 | for( LL i = 2 ; i < K ; i ++ ) 10 | f[ i ] = f[ i - 1 ] + f[ i - 2 ]; 11 | //cerr << f[ K - 1 ] << endl; 12 | cin >> n; 13 | LL ax = 0 , ay = n; 14 | for( LL x = 0 ; x <= n ; x ++ ) 15 | for( LL i = 0 ; i + 1 < K and x * f[ i ] <= n ; i ++ ){ 16 | LL res = n - x * f[ i ]; 17 | if( res % f[ i + 1 ] ) continue; 18 | LL y = res / f[ i + 1 ]; 19 | if( x + y < ax + ay ) 20 | ax = x , ay = y; 21 | } 22 | cout << ax << " " << ay << endl; 23 | } 24 | -------------------------------------------------------------------------------- /contest/ASC/ASC42/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n , s , p , t; 4 | void solve(){ 5 | double ans = 0.0 , np = 1.0 , pp = (double)p / 100.0; 6 | int now = s; 7 | while( t -- && now > 0 ){ 8 | int mx = min( now , n - now ); 9 | if( now + mx == n ){ 10 | ans += np * pp; 11 | now -= mx; 12 | np *= ( 1.0 - pp ); 13 | }else{ 14 | np *= pp; 15 | now += mx; 16 | } 17 | } 18 | printf( "%.12f\n" , ans ); 19 | } 20 | int main(){ 21 | #ifdef ONLINE_JUDGE 22 | freopen( "betting.in" , "r" , stdin ); 23 | freopen( "betting.out" , "w" , stdout ); 24 | #endif 25 | while( scanf( "%d%d%d%d" , &n , &s , &p , &t ) == 4 && n ) 26 | solve(); 27 | } 28 | -------------------------------------------------------------------------------- /contest/Phuket/2015/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 2020 4 | typedef long long LL; 5 | LL n , l , a[ N ]; 6 | void init(){ 7 | scanf( "%lld%lld" , &n , &l ); 8 | for( int i = 0 ; i < n ; i ++ ) 9 | scanf( "%lld" , &a[ i ] ); 10 | sort( a , a + n ); 11 | } 12 | int _cs; 13 | void solve(){ 14 | LL ac = 0 , lst = 0 , pen = 0 , tt = 0; 15 | for( int i = 0 ; i < n ; i ++ ){ 16 | tt += a[ i ]; 17 | if( tt > l ) break; 18 | ac ++; 19 | lst = tt; 20 | pen += tt; 21 | } 22 | printf( "Case %d: %lld %lld %lld\n" , ++ _cs , ac , lst , pen ); 23 | } 24 | int main(){ 25 | int _; scanf( "%d" , &_ ); while( _ -- ){ 26 | init(); 27 | solve(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Europe/aa.py: -------------------------------------------------------------------------------- 1 | a='....x.xxxxx.xxxxx.x...x.xxxxx.xxxxx.xxxxx.xxxxx.xxxxx.xxxxx' 2 | b='....x.....x.....x.x...x.x.....x.........x.x...x.x...x.x...x' 3 | c='....x.....x.....x.x...x.x.....x.........x.x...x.x...x.x...x' 4 | d='....x.xxxxx.xxxxx.xxxxx.xxxxx.xxxxx.....x.xxxxx.xxxxx.x...x' 5 | e='....x.x.........x.....x.....x.x...x.....x.x...x.....x.x...x' 6 | f='....x.x.........x.....x.....x.x...x.....x.x...x.....x.x...x' 7 | g='....x.xxxxx.xxxxx.....x.xxxxx.xxxxx.....x.xxxxx.xxxxx.xxxxx' 8 | ret = 'char c[12][99][99]={' 9 | for i in range(1,11): 10 | st = (i-1)*6 11 | ret += '{' 12 | for k in [a, b, c, d, e, f, g]: 13 | ret += '\"' + k[st:st+5] + '\",' 14 | ret += '},' 15 | ret += '};' 16 | print(ret) 17 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2013/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , sum , cnt; 5 | char c[ N ]; 6 | long long ans; 7 | int main(){ 8 | freopen( "energy.in" , "r" , stdin ); 9 | freopen( "energy.out" , "w" , stdout ); 10 | scanf( "%d" , &n ); 11 | scanf( "%s" , c ); 12 | priority_queue< int > heap; 13 | for( int i = 0 ; c[ i ] ; i ++ ){ 14 | int vl = c[ i ] - '0'; 15 | if( sum + vl <= n ){ 16 | heap.push( vl ); 17 | sum += vl; 18 | cnt ++; 19 | }else if( vl == 1 && heap.top() == 2 ){ 20 | heap.pop(); 21 | heap.push( 1 ); 22 | sum --; 23 | } 24 | ans += cnt; 25 | } 26 | printf( "%lld\n" , ans ); 27 | } 28 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2016/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | char s[1000005]; 6 | double dp[1000005]; 7 | 8 | int main() { 9 | freopen( "foreign.in" , "r" , stdin ); 10 | freopen( "foreign.out" , "w" , stdout ); 11 | 12 | scanf("%s", s + 1); 13 | int n = strlen(s + 1); 14 | reverse(s + 1, s + n + 1); 15 | 16 | ll ws = 0, cs = 0; 17 | double tdp = 0; 18 | dp[0] = 0; 19 | for (int i = 1; i <= n; i ++) { 20 | dp[i] += tdp / i; 21 | if (s[i] == 'W') { 22 | dp[i] += (double)cs / i; 23 | ws += i; 24 | } else { 25 | dp[i] += (double)ws / i; 26 | cs += i; 27 | } 28 | tdp += dp[i]; 29 | } 30 | printf("%.9f\n", dp[n]); 31 | } 32 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Peterhof/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string dir = "NSWE"; 5 | 6 | int main() { 7 | string s; 8 | cin >> s; 9 | set st; 10 | for (char c: s) st.insert(c); 11 | if (st.size() == 1) { 12 | cout << "X\n"; 13 | } else if (st.size() == 3) { 14 | for (char c: dir) if (!st.count(c)) { 15 | cout << c << endl; 16 | break; 17 | } 18 | } else { 19 | if (st.count('N') and st.count('S')) { 20 | cout << "X\n"; 21 | } 22 | else if (st.count('W') and st.count('E')) { 23 | cout << "X\n"; 24 | } else { 25 | for (char c: dir) if (!st.count(c)) { 26 | cout << c; 27 | } 28 | cout << endl; 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /contest/ECFinal2016/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 111 6 | int n , _cs; 7 | double ri[ N ]; 8 | double read(){ 9 | double ai , bi; 10 | scanf( "%lf:%lf" , &ai , &bi ); 11 | return ai / bi; 12 | } 13 | int main(){ 14 | int t; scanf( "%d" , &t ); while( t -- ){ 15 | scanf( "%d" , &n ); 16 | for( int i = 0 ; i < n ; i ++ ) 17 | ri[ i ] = 1. / ( 1. + read() ); 18 | sort( ri , ri + n ); 19 | int ans = 0; 20 | double sum = 0; 21 | for( int i = 0 ; i < n ; i ++ ){ 22 | sum += ri[ i ]; 23 | if( sum > 1 + 1e-10 ) break; 24 | ans ++; 25 | } 26 | printf( "Case #%d: %d\n" , ++ _cs , ans ); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /contest/ASC/ASC31/d.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | def C(n, k): 4 | res = 1 5 | for i in range(n-k+1, n+1): 6 | res *= i 7 | return res 8 | 9 | fi = open("discuss.in", "r") 10 | fo = open("discuss.out", "w") 11 | 12 | z = int(fi.read()) 13 | ans = z 14 | target = z 15 | for k in range(2, 450): 16 | target *= k 17 | l = k+k 18 | r = l 19 | while C(r, k) < target: 20 | r *= 2 21 | res = -1 22 | while l <= r: 23 | mid = (l+r) >> 1 24 | if C(mid, k) <= target: 25 | res = mid 26 | l = mid+1 27 | else: 28 | r = mid-1 29 | if C(res, k) == target and res != -1: 30 | ans = min(ans, res) 31 | if z == 1: 32 | ans = "1" 33 | fo.write(str(ans)+"\n") 34 | 35 | -------------------------------------------------------------------------------- /contest/NCPC2015/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int __ = 1; 4 | int x[ 3 ] , y[ 3 ]; 5 | void init(){ 6 | for( int i = 0 ; i < 3 ; i ++ ) 7 | scanf( "%d%d" , &x[ i ] , &y[ i ] ); 8 | } 9 | void solve(){ 10 | for( int a = -64 ; a <= 64 ; a ++ ) 11 | for( int b = -64 ; b <= 64 ; b ++ ) 12 | for( int c = -64 ; c <= 64 ; c ++ ){ 13 | int cnt = 0; 14 | for( int i = 0 ; i < 3 ; i ++ ) 15 | if( a * x[ i ] * x[ i ] + b * x[ i ] + c == y[ i ] ) cnt ++; 16 | if( cnt == 3 ){ 17 | printf( "%d %d %d\n" , a , b , c ); 18 | return; 19 | } 20 | } 21 | } 22 | int main(){ 23 | scanf( "%d" , &__ ); while( __ -- ){ 24 | init(); 25 | solve(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /codebook/geometry/Intersection_of_two_segments.cpp: -------------------------------------------------------------------------------- 1 | int ori( const Pt& o , const Pt& a , const Pt& b ){ 2 | LL ret = ( a - o ) ^ ( b - o ); 3 | return (ret > 0) - (ret < 0); 4 | } 5 | // p1 == p2 || q1 == q2 need to be handled 6 | bool banana( const Pt& p1 , const Pt& p2 , 7 | const Pt& q1 , const Pt& q2 ){ 8 | if( ( ( p2 - p1 ) ^ ( q2 - q1 ) ) == 0 ){ // parallel 9 | if( ori( p1 , p2 , q1 ) ) return false; 10 | return ( ( p1 - q1 ) * ( p2 - q1 ) ) <= 0 || 11 | ( ( p1 - q2 ) * ( p2 - q2 ) ) <= 0 || 12 | ( ( q1 - p1 ) * ( q2 - p1 ) ) <= 0 || 13 | ( ( q1 - p2 ) * ( q2 - p2 ) ) <= 0; 14 | } 15 | return (ori( p1, p2, q1 ) * ori( p1, p2, q2 )<=0) && 16 | (ori( q1, q2, p1 ) * ori( q1, q2, p2 )<=0); 17 | } 18 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2017/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | typedef unsigned long long ULL; 6 | #define N 10101 7 | vector v , a; 8 | void parse(){ 9 | ULL tmp = 0; 10 | for( size_t j = 0 ; j + 1 < v.size() ; j ++ ) 11 | tmp += (1ULL << (j * 7)) * ( v[j] - 128 ); 12 | tmp += (1ULL << ((int(v.size()) - 1) * 7) ) * v.back(); 13 | if( tmp % 2 == 0 ) a.push_back( tmp / 2 ); 14 | else a.push_back( -(tmp / 2) - 1 ); 15 | v.clear(); 16 | } 17 | int main(){ 18 | LL n , x; cin >> n; 19 | for( int i = 0 ; i < n ; i ++ ){ 20 | cin >> x; 21 | v.push_back( x ); 22 | if( x < 128 ) parse(); 23 | } 24 | for( auto i : a ) 25 | cout << i << endl; 26 | } 27 | -------------------------------------------------------------------------------- /contest/Singapore/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | #define N 101010 5 | LL n , k , t[ N ]; 6 | vector< LL > v; 7 | inline void cal(){ 8 | for( int i = 0 ; i < n ; i ++ ) 9 | if( i != k ) 10 | v.push_back( t[ i ] ); 11 | sort( v.begin() , v.end() ); 12 | reverse( v.begin() , v.end() ); 13 | v.push_back( t[ k ] ); 14 | int ans = 0 , pen = 0 , now = 0; 15 | reverse( v.begin() , v.end() ); 16 | for( LL i : v ){ 17 | now += i; 18 | if( now > 300 ) break; 19 | ans += 1; 20 | pen += now; 21 | } 22 | printf( "%d %d\n" , ans , pen ); 23 | } 24 | int main(){ 25 | scanf( "%lld%lld" , &n , &k ); 26 | for( int i = 0 ; i < n ; i ++ ) 27 | scanf( "%lld" , &t[ i ] ); 28 | cal(); 29 | } 30 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ukraine/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1000001 4 | bool p[ N ]; 5 | int rev( int x ){ 6 | int ret = 0; 7 | while( x ){ 8 | ret = ret * 10 + x % 10; 9 | x /= 10; 10 | } 11 | return ret; 12 | } 13 | void build(){ 14 | for( int i = 2 ; i < N ; i ++ ) 15 | p[ i ] = true; 16 | for( int i = 2 ; i < N ; i ++ ) if( p[ i ] ) 17 | for( int j = i + i ; j < N ; j += i ) 18 | p[ j ] = false; 19 | } 20 | int main(){ 21 | build(); 22 | vector ans; 23 | for( int i = 2 ; i < N ; i ++ ) 24 | if( i != rev( i ) and p[ i ] and p[ rev( i ) ] ) 25 | ans.push_back( i ); 26 | int k; cin >> k; 27 | if( k > (int)ans.size() ) puts( "-1" ); 28 | else cout << ans[ k - 1 ] << endl; 29 | } 30 | -------------------------------------------------------------------------------- /contest/ASC/ASC28/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1515 4 | bitset to[ N ] , fr[ N ]; 5 | int n; 6 | char c[ N ][ N ]; 7 | int main(){ 8 | #ifdef ONLINE_JUDGE 9 | freopen( "triatrip.in" , "r" , stdin ); 10 | freopen( "triatrip.out" , "w" , stdout ); 11 | #endif 12 | cin >> n; 13 | for( int i = 0 ; i < n ; i ++ ){ 14 | scanf( "%s" , c[ i ] ); 15 | for( int j = 0 ; j < n ; j ++ ) 16 | if( c[ i ][ j ] == '+' ){ 17 | to[ i ][ j ] = 1; 18 | fr[ j ][ i ] = 1; 19 | } 20 | } 21 | long long ans = 0; 22 | for( int i = 0 ; i < n ; i ++ ) 23 | for( int j = 0 ; j < n ; j ++ ) 24 | if( c[ i ][ j ] == '+' ) 25 | ans += ( to[ j ] & fr[ i ] ).count(); 26 | cout << ans / 3 << endl; 27 | } 28 | -------------------------------------------------------------------------------- /contest/BSUIR2017/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | int main(){ 5 | int t; cin >> t; while( t -- ){ 6 | LL n; cin >> n; 7 | n ++; 8 | for( int i = 1 ; ; i = 1 - i ){ 9 | if( i == 0 ){ 10 | LL hf = n / 2; 11 | while( hf + hf < n ) hf ++; 12 | //cerr << "NO " << n << " " << hf << endl; 13 | if( hf <= 1 ){ 14 | puts( "NO" ); 15 | break; 16 | } 17 | n = hf; 18 | }else{ 19 | LL hf = n / 9; 20 | while( hf * 9 < n ) hf ++; 21 | //cerr << "YES " << n << " " << hf << endl; 22 | if( hf <= 1 ){ 23 | puts( "YES" ); 24 | break; 25 | } 26 | n = hf; 27 | } 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /contest/ITSA2018/6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | const ll mod = 1000000007LL; 6 | 7 | ll dp[1000005]; 8 | 9 | int main(){ 10 | int t; cin>>t; while(t--){ 11 | int n, k; 12 | scanf("%d%d", &n, &k); 13 | 14 | ll k2 = 1; 15 | for (int i = 1; i <= k - 1; i ++) 16 | k2 = k2 * 2 % mod; 17 | 18 | k2 = (k2 + mod - 1) % mod; 19 | 20 | ll tot = 1; 21 | dp[0] = 1; 22 | for (int i = 1; i <= n; i ++) { 23 | dp[i] = tot; 24 | if (i >= k) dp[i] = (dp[i] + dp[i - k] * k2) % mod; 25 | 26 | tot = (tot + dp[i]) % mod; 27 | } 28 | printf("%lld\n", dp[n]); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /contest/Phuket/2015/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 514 4 | typedef long long LL; 5 | LL t , a[ N ] , b[ N ] , c[ N ]; 6 | void init(){ 7 | scanf( "%lld" , &t ); 8 | for( int i = 0 ; i < t ; i ++ ) 9 | scanf( "%lld%lld%lld" , &a[ i ] , &b[ i ] , &c[ i ] ); 10 | } 11 | void solve(){ 12 | LL sa = 0 , sb = 0 , sc = 0; 13 | for( int i = 0 ; i < t ; i ++ ){ 14 | sa += a[ i ]; 15 | sb += b[ i ]; 16 | sc += c[ i ]; 17 | if( min( sa , min( sb , sc ) ) < 30 ){ 18 | puts( "NO" ); 19 | }else{ 20 | LL bb = min( sa , min( sb , sc ) ); 21 | printf( "%lld\n" , bb ); 22 | sa -= bb; 23 | sb -= bb; 24 | sc -= bb; 25 | } 26 | } 27 | } 28 | int main(){ 29 | init(); 30 | solve(); 31 | } 32 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Siberia/1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , c[ N ]; 5 | bool tag[ 10101010 ]; 6 | int main(){ 7 | scanf( "%d" , &n ); 8 | for( int i = 0 ; i < n ; i ++ ) 9 | scanf( "%d" , &c[ i ] ); 10 | sort( c , c + n ); 11 | for( int i = 0 ; i < n ; i ++ ) 12 | tag[ c[ i ] ] = true; 13 | vector ans; 14 | for( int i = 0 ; i < n ; i ++ ){ 15 | bool gg = false; 16 | for( int j = c[ i ] + c[ i ] ; j < 10000001 ; j += c[ i ] ) 17 | if( tag[ j ] ){ 18 | gg = true; 19 | break; 20 | } 21 | if( !gg ) 22 | ans.push_back( c[ i ] ); 23 | } 24 | for( size_t i = 0 ; i < ans.size() ; i ++ ) 25 | printf( "%d%c" , ans[ i ] , " \n"[ i + 1 == ans.size() ] ); 26 | } 27 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/SPb/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 12 4 | typedef long long LL; 5 | int n , c[ N ] , e[ N ]; 6 | LL dp[ N ][ 1 << N ]; 7 | int main(){ 8 | cin >> n; 9 | for( int i = 0 ; i < n ; i ++ ) 10 | cin >> c[ i ]; 11 | for( int i = 0 ; i < n ; i ++ ) 12 | cin >> e[ i ]; 13 | dp[ 0 ][ 0 ] = 1; 14 | for( int i = 0 ; i < n ; i ++ ) 15 | for( int j = 0 ; j < (1 << n) ; j ++ ){ 16 | if( dp[ i ][ j ] == 0 ) continue; 17 | for( int k = 0 ; k < n ; k ++ ){ 18 | if( (j >> k) & 1 ) continue; 19 | if( c[ k ] > e[ i ] ) continue; 20 | int nxtj = j | (1 << k); 21 | dp[ i + 1 ][ nxtj ] += dp[ i ][ j ]; 22 | } 23 | } 24 | cout << dp[ n ][ (1 << n) - 1 ] << endl; 25 | } 26 | -------------------------------------------------------------------------------- /codebook/math/theorem.tex: -------------------------------------------------------------------------------- 1 | \begin{itemize} 2 | \item Lucas’ Theorem :\\ 3 | For $n, m \in \mathbb{Z}^{*}$ and prime $P$, 4 | $C(m,n) \mod P$ 5 | %= C(\frac{m}{M},n/M) * C(m\%M,n\%M) mod P 6 | $= \Pi ( C(m_i,n_i) )$ 7 | where $m_i$ is the $i$-th digit of $m$ in base $P$. 8 | \item Stirling Numbers(permutation $|P|=n$ with $k$ cycles): \\ 9 | $S(n,k) = \text{coefficient of }x^k \text{ in } \Pi_{i=0}^{n-1} (x+i)$ 10 | \item Stirling Numbers(Partition $n$ elements into $k$ non-empty set): \\ 11 | $S(n,k) = \frac{1}{k!} \sum\limits_{j=0}^k (-1)^{k-j} {k \choose j} j^n$ 12 | \item Pick’s Theorem : $A = i + b/2 - 1$ 13 | \item Kirchhoff's theorem :\\ 14 | $A_{ii} = deg(i), A_{ij} = (i,j) \in E\ ? -1 : 0$, 15 | Deleting any one row, one column, and cal the det(A) 16 | \end{itemize} 17 | -------------------------------------------------------------------------------- /codebook/string/zvalue_palindrome.cpp: -------------------------------------------------------------------------------- 1 | int len, zv[MAX*2]; 2 | char ip[MAX], op[MAX*2]; 3 | int main(){ 4 | cin >> ip; len = strlen(ip); 5 | int l2 = len*2 - 1; 6 | for(int i=0; i r ){ 12 | l = r = i; 13 | while( l>0 && r0 && r r ) 26 | zv[i] = (r - i) * 2 + 1; 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/Dhaka2015/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | int cnt[ 11 ] , cnt2[ 11 ]; 5 | void init(){ 6 | scanf( "%d" , &n ); 7 | for( int i = 0 ; i < 11 ; i ++ ) 8 | cnt[ i ] = cnt2[ i ] = 0; 9 | while( n -- ){ 10 | int a , b; char c[ 9 ]; 11 | scanf( "%d%d%s" , &a , &b , c ); 12 | if( b == 0 && c[ 0 ] == 'i' ) cnt[ a ] ++; 13 | if( b == 1 && c[ 0 ] == 'c' ) cnt2[ a ] ++; 14 | } 15 | for( int i = 2 ; i < 11 ; i ++ ) 16 | cnt[ i ] += cnt[ i - 1 ]; 17 | } 18 | void solve(){ 19 | int ans = 0; 20 | for( int i = 2 ; i < 11 ; i ++ ) 21 | ans += cnt2[ i ] * cnt[ i - 1 ]; 22 | printf( "%d\n" , ans ); 23 | } 24 | int main(){ 25 | int _; scanf( "%d" , &_ ); while( _ -- ){ 26 | init(); 27 | solve(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/Hatyai/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | string ans; 4 | char c[ 10101 ]; 5 | bool is_c( char ctmp ){ 6 | if( 'A' <= ctmp and ctmp <= 'Z' ) return true; 7 | if( 'a' <= ctmp and ctmp <= 'z' ) return true; 8 | return ctmp == '-'; 9 | } 10 | char lower( char ctmp ){ 11 | if( 'A' <= ctmp and ctmp <= 'Z' ) return ctmp - 'A' + 'a'; 12 | return ctmp; 13 | } 14 | int main(){ 15 | while( scanf( "%s" , c ) == 1 ){ 16 | int len = strlen( c ); 17 | string tmp = ""; 18 | for( int i = 0 ; i <= len ; i ++ ) 19 | if( i == len or !is_c( c[ i ] ) ){ 20 | if( tmp.length() > ans.length() ) 21 | ans = tmp; 22 | tmp = ""; 23 | }else 24 | tmp += lower( c[ i ] ); 25 | } 26 | cout << ans << endl; 27 | } 28 | -------------------------------------------------------------------------------- /contest/WorldFinals/2014/e2.cpp: -------------------------------------------------------------------------------- 1 | 2 | 1 : 3 3 0 0 3 | 3 : 3 3 1 1 4 | 5 : 2 3 2 0 5 | 6 : 2 3 2 0 6 | 7 : 2 2 0 0 7 | 8 : 2 2 0 1 8 | 9 : 2 2 1 1 9 | 10 : 2 2 0 0 10 | 11 : 2 2 0 0 11 | 12 : 2 2 1 1 12 | 13 : 2 2 1 1 13 | 2 : 2 2 2 0 0 1 14 | 4 : 2 2 2 1 1 1 15 | 16 | 7 : 1 2 0 0 17 | 10 : 0 2 0 0 18 | 11 : 0 2 0 0 19 | 8 : 0 2 0 1 20 | 9 : 0 1 1 1 21 | 12 : 0 2 1 1 22 | 13 : 0 2 1 1 23 | 5 : 3 6 0 0 24 | 6 : 3 7 0 0 25 | 1 : 6 7 1 1 26 | 3 : 6 7 2 2 27 | 2 : 3 4 5 0 0 1 28 | 4 : 3 4 5 1 1 1 29 | 30 | 10 : 0 4 0 0 31 | 11 : 0 4 0 0 32 | 7 : 2 3 0 0 33 | 8 : 1 3 0 1 34 | 9 : 1 2 1 1 35 | 12 : 0 4 1 1 36 | 13 : 0 4 1 1 37 | 5 : 6 9 0 0 38 | 6 : 5 10 0 0 39 | 1 : 9 10 1 1 40 | 3 : 9 10 2 2 41 | 2 : 5 7 8 0 0 1 42 | 4 : 6 7 8 1 1 1 43 | 10 11 44 | 12 13 45 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Japan/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , m , e[ N ] , w[ N ]; 5 | string s; 6 | int main(){ 7 | cin >> n >> m; 8 | while( m -- ){ 9 | cin >> s; 10 | for( int i = 1 ; i <= n ; i ++ ) 11 | if( s[ i - 1 ] == 'E' ) 12 | e[ i ] ++; 13 | else 14 | w[ i ] ++; 15 | } 16 | for( int i = 2 ; i <= n ; i ++ ) 17 | e[ i ] += e[ i - 1 ]; 18 | for( int i = n - 1 ; i >= 1 ; i -- ) 19 | w[ i ] += w[ i + 1 ]; 20 | int ans = w[ 1 ] , l = 0 , r = 1; 21 | for( int i = 1 ; i <= n ; i ++ ){ 22 | int tans = e[ i ] + w[ i + 1 ]; 23 | if( tans < ans ){ 24 | ans = tans; 25 | l = i; 26 | r = i + 1; 27 | } 28 | } 29 | cout << l << " " << r << endl; 30 | } 31 | -------------------------------------------------------------------------------- /contest/Hualien/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int s[305][305]; 5 | 6 | int main(){ 7 | int t; scanf("%d", &t); 8 | while (t--) { 9 | int n; 10 | scanf("%d", &n); 11 | int K = n * (n - 1) / 2; 12 | for (int i = 0 ; i < K ; i ++) { 13 | int x, y, z; 14 | scanf("%d%d%d", &x, &y, &z); 15 | s[x][y] = s[y][x] = z; 16 | } 17 | int ans = -1; 18 | for (int k = 1; k <= n; k ++) { 19 | for (int i = 1; i <= n; i ++) { 20 | for (int j = 1; j <= n; j ++) if (i != k && j != k && i != j) { 21 | int vl = s[i][j] + s[i][k] + s[j][k]; 22 | if (ans == -1) ans = vl; 23 | else if (ans < vl) ans = vl; 24 | } 25 | } 26 | } 27 | printf("%d\n", ans); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/opencup/XV/CEurope/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool win(int p, int q, int n) { 5 | if (n % p == 0) return true; 6 | if (p > q) { 7 | if (n >= p) { 8 | if (n < p + q) return (n - p) % (p - q) == 0; 9 | return !win(q, p, n % p); 10 | } else return false; 11 | } else { 12 | if (n >= p) return true; 13 | else return !win(q, p, n + p); 14 | } 15 | } 16 | 17 | int main() { 18 | int T; scanf("%d", &T); 19 | while (T --) { 20 | int p, q, n; 21 | scanf("%d%d%d", &p, &q, &n); 22 | 23 | int gcd = __gcd(p, q); 24 | if (n % gcd) { 25 | puts("R"); 26 | continue; 27 | } 28 | p /= gcd, q /= gcd, n /= gcd; 29 | 30 | if (win(p, q, n)) puts("E"); 31 | else puts("P"); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /contest/ECFinal2016/e.py: -------------------------------------------------------------------------------- 1 | from fractions import Fraction 2 | def r(s): 3 | ret = 0 4 | cnt = 0 5 | gt = False 6 | for c in s: 7 | if ord('0') <= ord(c) <= ord('9'): 8 | ret = ret * 10 + (ord(c) - ord('0')) 9 | if gt: 10 | cnt += 1 11 | else: 12 | gt = True 13 | for i in range(cnt,5): 14 | ret = ret * 10 15 | return ret 16 | def read(): 17 | ss = input().split(':') 18 | return Fraction(r(ss[1]),r(ss[0])) 19 | t = int(input()) 20 | for _ in range(t): 21 | n = int(input()) 22 | rr = [Fraction(1) / (Fraction(1) + read()) for i in range(n)] 23 | rr = sorted(rr) 24 | ans = 0 25 | s = Fraction(0) 26 | for i in rr: 27 | s += i 28 | if s >= Fraction(1): 29 | break 30 | ans += 1 31 | print( 'Case #%d: %d' % (_ + 1 , ans) ) 32 | -------------------------------------------------------------------------------- /contest/opencup/XV/3Capitals/c.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | LL n; 6 | inline LL rev( LL x ){ 7 | LL ret = 0; 8 | for( int i = 0 ; i < 32 ; i ++ ) 9 | ret = (ret << 1) | ((x >> i) & 1); 10 | return ret; 11 | } 12 | int main(){ 13 | int T; 14 | cin >> T; while (T --) { 15 | cin >> n; 16 | if (n == 3) { 17 | cout << "3\n0 0\n1 0\n2 0\n"; 18 | } else if (n == 4) { 19 | cout << "8\n0 0\n1 0\n2 0\n3 0\n0 1\n1 1\n2 1\n3 1\n"; 20 | } else { 21 | cout << n * 3 << "\n"; 22 | for (int i = 0; i < n; i ++) { 23 | for (int j = i; j < i + 3; j ++) { 24 | cout << i << " " << j % (n - 2) << "\n"; 25 | } 26 | } 27 | } 28 | } 29 | } 30 | 31 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Europe/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 303030 4 | typedef long long LL; 5 | const int mod = 1000000007; 6 | int mul( LL a , LL b ){ 7 | a *= b; 8 | return a >= mod ? a % mod : a; 9 | } 10 | int mypow( int a , int b ){ 11 | if( b == 0 ) return 1; 12 | int ret = mypow( mul( a , a ) , b >> 1 ); 13 | if( b & 1 ) ret = mul( ret , a ); 14 | return ret; 15 | } 16 | int n , m; 17 | char c[ N ]; 18 | int main(){ 19 | while( scanf( "%d%d" , &n , &m ) == 2 ){ 20 | scanf( "%s" , c ); 21 | LL vl = 0 , cc = 0; 22 | for( int i = 0 ; i < n ; i ++ ){ 23 | vl = ( vl * 10 + c[ i ] - '0' ) % m; 24 | if( vl == 0 ) cc ++; 25 | } 26 | if( vl ) puts( "0" ); 27 | else printf( "%d\n" , mypow( 2 , cc - 1 ) ); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/ITSA2018/3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int t; cin>>t; while(t--){ 6 | string a; 7 | cin>>a; 8 | int cand=-1; 9 | while(true){ 10 | cand=-1; 11 | int len=a.length(); 12 | for(int i=0; i+1 2 | using namespace std; 3 | 4 | int main() { 5 | int x; 6 | scanf("%d", &x); 7 | 8 | int sd = 1; 9 | int tot = 1; 10 | 11 | while (tot < x) { 12 | tot += sd * 6; 13 | sd ++; 14 | } 15 | 16 | int ans = sd * 6; 17 | int dlt = tot - x; 18 | vector v; 19 | for (int i = 0; i < 6; i ++) 20 | v.push_back(sd); 21 | 22 | while (true) { 23 | int mn = 1000000000, id = -1; 24 | for (int i = 0; i < 6; i ++) { 25 | if (v[i] < mn) { 26 | mn = v[i], id = i; 27 | } 28 | } 29 | 30 | if (mn <= dlt) { 31 | ans --; 32 | dlt -= mn; 33 | v[id] ++; 34 | v[(id + 1) % 6] --; 35 | v[(id + 5) % 6] --; 36 | } else break; 37 | } 38 | printf("%d\n", ans); 39 | } 40 | 41 | -------------------------------------------------------------------------------- /codebook/math/theorem_old.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Lucas’ Theorem: 3 | For non-negative integer n,m and prime P, 4 | C(m,n) mod P = C(m/M,n/M) * C(m%M,n%M) mod P 5 | = mult_i ( C(m_i,n_i) ) 6 | where m_i is the i-th digit of m in base P. 7 | -- 8 | Sum of Two Squares Thm (Legendre) 9 | For a given positive integer N, let 10 | D1 = (# of d \in \N dividing N that d=1(mod 4)) 11 | D3 = (# of d \in \N dividing N that d=3(mod 4)) 12 | then N can be written as a sum of two squares in 13 | exactly R(N) = 4(D1-D3) ways. 14 | -- 15 | Difference of D1-D3 Thm 16 | let N=2^t * [p1^e1 *...* pr^er] * [q1^f1 *...* qs^fs] 17 | <-mod 4 = 1 prime-> <-mod 4 = 3 prime-> 18 | then D1 - D3 = (e1+1)(e2+1)...(er+1) if fi all even 19 | 0 if any fi is odd 20 | -- 21 | Pick’s Theorem 22 | A = i + b/2 - 1 23 | */ 24 | -------------------------------------------------------------------------------- /contest/ASC/ASC28/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | vector< tuple > e; 5 | int d[ N ]; 6 | int main(){ 7 | #ifdef ONLINE_JUDGE 8 | freopen( "test.in" , "r" , stdin ); 9 | freopen( "test.out" , "w" , stdout ); 10 | #endif 11 | int n , m; 12 | cin >> n >> m; 13 | for( int i = 1 ; i < n ; i ++ ) 14 | e.push_back( make_tuple( i , i + 1 , 1 ) ); 15 | m -= n - 1; 16 | for( int i = 2 ; i <= n ; i ++ ) 17 | d[ i ] = 1000000; 18 | for( int i = 1 ; i < n and m > 0 ; i ++ ) 19 | for( int j = i + 2 ; j <= n and m > 0 ; j ++ ){ 20 | d[ j ] --; 21 | e.push_back( make_tuple( i , j , d[ j ] - ( i - 1 ) ) ); 22 | m --; 23 | } 24 | for( auto i : e ) 25 | printf( "%d %d %d\n" , get<0>( i ) , get<1>( i ) , get<2>( i ) ); 26 | } 27 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2016/k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n , d , m , y , ans; 4 | int day[] = { 0 , 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 }; 5 | int main(){ 6 | freopen( "king.in" , "r" , stdin ); 7 | freopen( "king.out" , "w" , stdout ); 8 | scanf( "%d%d%d" , &d , &m , &y ); 9 | y -= 18; 10 | scanf( "%d" , &n ); 11 | vector< pair,int> > vv; 12 | ans = -1; 13 | int id = 0; 14 | while( n -- ){ 15 | int dd , mm , yy; 16 | scanf( "%d%d%d" , &dd , &mm , &yy ); 17 | vv.push_back( make_pair( make_tuple( yy , mm , dd ) , ++ id ) ); 18 | } 19 | sort( vv.begin() , vv.end() ); 20 | for( auto i : vv ) 21 | if( i.first <= make_tuple( y , m , d ) ) 22 | ans = i.second; 23 | printf( "%d\n" , ans ); 24 | } 25 | -------------------------------------------------------------------------------- /contest/WorldFinals/2013/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | double x, p; 5 | 6 | int main() { 7 | scanf("%lf%lf", &x, &p); 8 | x /= 100; 9 | x = 1 - x; 10 | p /= 100; 11 | 12 | double beta = p / (1 - p); 13 | // slope changes from 1 to x, each step scales by beta 14 | int M = (int)(log(x) / log(beta)); 15 | 16 | double ans = 0; 17 | for (int hh = 1; hh < M; hh ++) { 18 | for (int lw = hh - M - 1; lw <= hh - M + 1; lw ++) { 19 | if (lw >= 0) continue; 20 | 21 | int blk = hh - lw; 22 | double tp = (1. - pow(beta, blk)) / (1 - beta); 23 | tp = (hh - lw * x) / tp; 24 | tp *= (1. - pow(beta, hh)) / (1 - beta); 25 | 26 | double tans = hh - tp; 27 | 28 | ans = max(ans, tans); 29 | } 30 | } 31 | printf("%.10f\n", ans); 32 | } 33 | -------------------------------------------------------------------------------- /codebook/string/BWT.cpp: -------------------------------------------------------------------------------- 1 | struct BurrowsWheeler{ 2 | #define SIGMA 26 3 | #define BASE 'a' 4 | vector v[ SIGMA ]; 5 | void BWT(char* ori, char* res){ 6 | // make ori -> ori + ori 7 | // then build suffix array 8 | } 9 | void iBWT(char* ori, char* res){ 10 | for( int i = 0 ; i < SIGMA ; i ++ ) 11 | v[ i ].clear(); 12 | int len = strlen( ori ); 13 | for( int i = 0 ; i < len ; i ++ ) 14 | v[ ori[i] - BASE ].push_back( i ); 15 | vector a; 16 | for( int i = 0 , ptr = 0 ; i < SIGMA ; i ++ ) 17 | for( auto j : v[ i ] ){ 18 | a.push_back( j ); 19 | ori[ ptr ++ ] = BASE + i; 20 | } 21 | for( int i = 0 , ptr = 0 ; i < len ; i ++ ){ 22 | res[ i ] = ori[ a[ ptr ] ]; 23 | ptr = a[ ptr ]; 24 | } 25 | res[ len ] = 0; 26 | } 27 | } bwt; 28 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2012/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 10010 4 | vector pset; 5 | bool p[ N ]; 6 | void build(){ 7 | for( int i = 2 ; i < N ; i ++ ) if( !p[ i ] ){ 8 | pset.push_back( i ); 9 | for( int j = N / i ; j >= i ; j -- ) 10 | p[ i * j ] = true; 11 | } 12 | } 13 | int n , ans; 14 | void solve(){ 15 | int pn = (int)pset.size() - 1; 16 | while( pset[ pn ] > n ) pn --; 17 | int l = 0; 18 | while( l <= pn ){ 19 | int now = pset[ pn ]; 20 | while( l < pn && now * pset[ l ] <= n ) 21 | now *= pset[ l ++ ]; 22 | ans ++; 23 | pn --; 24 | } 25 | cout << ans << endl; 26 | } 27 | int main(){ 28 | build(); 29 | freopen( "gcd.in" , "r" , stdin ); 30 | freopen( "gcd.out" , "w" , stdout ); 31 | scanf( "%d" , &n ); 32 | solve(); 33 | } 34 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eurasia/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , len , alen; 5 | char c[ N ] , a[ N ]; 6 | bool gg; 7 | void init(){ 8 | alen = 0; 9 | gg = false; 10 | scanf( "%d" , &n ); while( n -- ){ 11 | scanf( "%s" , c ); 12 | len = strlen( c ); 13 | for( int i = 0 ; i < min( len , alen ) ; i ++ ) 14 | if( c[ i ] != a[ i ] ){ 15 | gg = true; 16 | break; 17 | } 18 | if( not gg and len > alen ){ 19 | alen = len; 20 | for( int i = 0 ; i < len ; i ++ ) 21 | a[ i ] = c[ i ]; 22 | } 23 | } 24 | } 25 | void solve(){ 26 | if( gg ) puts( "Impossible" ); 27 | else printf( "%d\n" , alen ); 28 | } 29 | int main(){ 30 | int _; scanf( "%d" , &_ ); while( _ -- ){ 31 | init(); 32 | solve(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2012/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | vector ans; 4 | int n , m; 5 | void print( int num , int bt ){ 6 | for( int i = bt - 1 ; i >= 0 ; i -- ) 7 | if( ( 1 << i ) & num ) putchar( '1' ); 8 | else putchar( '0' ); 9 | puts( "" ); 10 | } 11 | void solve(){ 12 | m = 1; 13 | while( ( 1 << m ) < n ) m ++; 14 | int p = 1 << ( m - 1 ); 15 | for( int i = 0 ; i < p && n > 0 ; i ++ ) 16 | if( ( p - i - 1 ) * 2 >= n - 1 ){ 17 | print( i , m - 1 ); 18 | n --; 19 | }else{ 20 | print( i * 2 , m ); n --; 21 | if( n ){ 22 | print( i * 2 + 1 , m ); 23 | n --; 24 | } 25 | } 26 | } 27 | int main(){ 28 | freopen( "binary.in" , "r" , stdin ); 29 | freopen( "binary.out" , "w" , stdout ); 30 | scanf( "%d" , &n ); 31 | solve(); 32 | } 33 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Belarus/g.py: -------------------------------------------------------------------------------- 1 | import math 2 | ip = input() 3 | n, m = list(map(int,ip.split())) 4 | 5 | if n > m: 6 | n, m=m, n 7 | 8 | if n == m: 9 | print(n) 10 | else: 11 | n = n-1 12 | m = m-1 13 | g = math.gcd(n, m) 14 | g2 = g+g 15 | def f(X, Y): 16 | ax = X // g2 17 | bx = X % g2 18 | ay = Y // g2 19 | by = Y % g2 20 | if by < bx: 21 | ax, ay = ay, ax 22 | bx, by = by, bx 23 | res = (bx + 1) * (ax + 1) * (ay + 1) 24 | res += (by - bx) * ax * (ay + 1) 25 | res += (g2 - 1 - by) * ax * ay 26 | return res 27 | k = m // g2 + 1 28 | ans = f(n, m) + f(n, g2 * k) - f(n, g2 * k - m - 1) 29 | ans -= (n // g2 + 1) * (m // g2 + 1) + (n//g - n//g2) * (m//g - m//g2) 30 | ans %= int(10**18 + 9) 31 | print(ans) 32 | -------------------------------------------------------------------------------- /contest/Daejeon/2016/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , m , deg[ N ]; 5 | set< pair > M; 6 | int main(){ 7 | while( scanf( "%d%d" , &n , &m ) == 2 ){ 8 | for( int i = 0 ; i < n ; i ++ ) 9 | deg[ i ] = 0; 10 | M.clear(); 11 | while( m -- ){ 12 | int ui , vi; 13 | scanf( "%d%d" , &ui , &vi ); 14 | M.insert( { ui , vi } ); 15 | M.insert( { vi , ui } ); 16 | deg[ ui ] ++; 17 | deg[ vi ] ++; 18 | } 19 | int ans = 0; 20 | for( int i = 0 ; i < n ; i ++ ) 21 | if( ( deg[ i ] == 1 or deg[ ( i + 1 ) % n ] == 1 ) and 22 | ( M.find( make_pair( i , ( i + 1 ) % n ) ) == M.end() ) ){ 23 | ans ++; 24 | deg[ i ] ++; 25 | deg[ ( i + 1 ) % n ] ++; 26 | } 27 | printf( "%d\n" , ans ); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2016/i.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define LEFT 0 6 | #define RIGHT 1 7 | char buf[ 16 ]; 8 | int query( int put , int dir , int gogo ){ 9 | if( dir == LEFT ) 10 | printf( "%d left %d\n" , put , gogo ); 11 | else 12 | printf( "%d right %d\n" , put , gogo ); 13 | fflush( stdout ); 14 | scanf( "%s" , buf ); 15 | if( !strcmp( buf , "treasure" ) ) exit(0); 16 | if( !strcmp( buf , "center" ) ) return 0; 17 | if( !strcmp( buf , "left" ) ) return -1; 18 | if( !strcmp( buf , "right" ) ) return +1; 19 | assert( false ); 20 | return 1; 21 | } 22 | int m; 23 | int main(){ 24 | srand( 514514 ); 25 | scanf( "%d" , &m ); 26 | scanf( "%s" , buf ); 27 | while( true ) 28 | query( rand() % m , rand() % 2 , rand() % m ); 29 | } 30 | -------------------------------------------------------------------------------- /contest/opencup/XV/CEurope/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 22 6 | int n , m; 7 | int f[ N ] , f_who[ N ]; 8 | int s[ N ] , s_who[ N ]; 9 | int main(){ 10 | scanf( "%d%d" , &n , &m ); 11 | for( int i = 1 ; i <= m ; i ++ ){ 12 | f[ i ] = 1e9; 13 | s[ i ] = -1e9; 14 | } 15 | for( int i = 1 ; i <= n ; i ++ ){ 16 | int si , ti , di; 17 | scanf( "%d%d%d" , &si , &ti , &di ); 18 | if( ti < f[ di ] ){ 19 | f[ di ] = ti; 20 | f_who[ di ] = i; 21 | } 22 | if( si > s[ di ] ){ 23 | s[ di ] = si; 24 | s_who[ di ] = i; 25 | } 26 | } 27 | for( int i = 1 ; i <= m ; i ++ ) 28 | if( f[ i ] < s[ i ] ) 29 | printf( "TAK %d %d\n" , f_who[ i ] , s_who[ i ] ); 30 | else 31 | printf( "NIE\n" ); 32 | } 33 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/SPb/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1010101 4 | char a[ N ]; 5 | int v[ N ]; 6 | __int128 x; 7 | int main(){ 8 | for( int i = 0 ; i < 2 ; i ++ ){ 9 | scanf( "%s" , a ); 10 | int len = strlen( a ); 11 | for( int j = 0 ; j < len ; j ++ ) 12 | v[ j ] += a[ len - j - 1 ] - '0'; 13 | } 14 | for( int i = 0 ; i + 4 < N ; i ++ ){ 15 | while (v[i] >= 2 && v[i + 1] >= 2 && v[i + 2] >= 1) { 16 | v[i] -= 2; 17 | v[i + 1] -= 2; 18 | v[i + 2] -= 1; 19 | } 20 | if( v[ i ] > 1 ){ 21 | v[ i + 2 ] += v[ i ] / 2; 22 | v[ i + 3 ] += v[ i ] / 2; 23 | } 24 | v[ i ] &= 1; 25 | } 26 | int lst = N - 1; 27 | while( lst > 0 and !v[ lst ] ) lst --; 28 | for( int i = lst ; i >= 0 ; i -- ) 29 | printf( "%d" , v[ i ] ); 30 | puts( "" ); 31 | } 32 | -------------------------------------------------------------------------------- /codebook/graph/kosaraju.cpp: -------------------------------------------------------------------------------- 1 | struct Scc{ 2 | int n, nScc, vst[MXN], bln[MXN]; 3 | vector E[MXN], rE[MXN], vec; 4 | void init(int _n){ 5 | n = _n; 6 | for (int i=0; i 2 | using namespace std; 3 | typedef long long LL; 4 | typedef pair pii; 5 | pii gcd(LL a, LL b){ 6 | if(b == 0) return make_pair(1, 0); 7 | else{ 8 | LL p = a / b; 9 | pii q = gcd(b, a % b); 10 | return make_pair(q.second, q.first - q.second * p); 11 | } 12 | } 13 | LL n , m , a , k; 14 | void solve(){ 15 | pii tp = gcd( m , a ); 16 | LL tgcd = __gcd( m , a ); 17 | if( ( k + a - n ) % tgcd ){ 18 | puts( "Impossible" ); 19 | return; 20 | } 21 | LL tms = ( k + a - n ) / tgcd; 22 | LL res = tp.first % ( a / tgcd ); 23 | if( res && tms < 0 ) res -= ( a / tgcd ); 24 | printf( "%lld\n" , n + m * res * tms ); 25 | } 26 | int main(){ 27 | while( scanf( "%lld%lld%lld%lld" , &n , &m , &a , &k ) == 4 ){ 28 | if( n + m + a + k == 0 ) break; 29 | solve(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /contest/Daejeon/2016/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int dn[]={0,1,0,-1}; 4 | int dm[]={1,0,-1,0}; 5 | int m , n , d; 6 | char cmd[ 9 ]; 7 | int main(){ 8 | while( scanf( "%d%d" , &m , &n ) == 2 ){ 9 | int cn = 0 , cm = 0 , cdir = 0; 10 | bool valid = true; 11 | while( n -- ){ 12 | scanf( "%s%d" , cmd , &d ); 13 | if( cmd[ 0 ] == 'T' ){ 14 | if( d == 0 ) 15 | cdir = ( cdir + 1 ) & 3; 16 | else 17 | cdir = ( cdir + 3 ) & 3; 18 | }else{ 19 | cn += dn[ cdir ] * d; 20 | cm += dm[ cdir ] * d; 21 | } 22 | if( cn < 0 or cn > m or 23 | cm < 0 or cm > m ) 24 | valid = false; 25 | //printf( "%d %d\n" , cn , cm ); 26 | } 27 | if( valid ) 28 | printf( "%d %d\n" , cm , cn ); 29 | else 30 | puts( "-1" ); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2010/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef double D; 4 | int n , r; 5 | vector< int > v; 6 | void init(){ 7 | scanf( "%d%d" , &n , &r ); 8 | for( int i = 0 ; i < n ; i ++ ){ 9 | int xi; scanf( "%d" , &xi ); 10 | v.push_back( xi ); 11 | } 12 | } 13 | double inter( double dst ){ 14 | if( dst > r + r ) return 0; 15 | D theta = dst / ( 2.0 * r ); 16 | D ret = r * r * acos( theta ) - 0.5 * r * r * sin( 2.0 * acos( theta ) ); 17 | return ret * 2; 18 | } 19 | const double pi = acos( -1.0 ); 20 | void solve(){ 21 | D answer = pi * r * r; 22 | sort( v.begin() , v.end() ); 23 | for( int i = 1 ; i < n ; i ++ ){ 24 | answer += pi * r * r; 25 | answer -= inter( v[ i ] - v[ i - 1 ] ); 26 | } 27 | printf( "%.9f\n" , answer ); 28 | } 29 | int main(){ 30 | init(); 31 | solve(); 32 | } 33 | -------------------------------------------------------------------------------- /codebook/geometry/Tangent_line_of_two_circles.cpp: -------------------------------------------------------------------------------- 1 | vector go( const Cir& c1 , const Cir& c2 , int sign1 ){ 2 | // sign1 = 1 for outer tang, -1 for inter tang 3 | vector ret; 4 | double d_sq = norm2( c1.O - c2.O ); 5 | if( d_sq < eps ) return ret; 6 | double d = sqrt( d_sq ); 7 | Pt v = ( c2.O - c1.O ) / d; 8 | double c = ( c1.R - sign1 * c2.R ) / d; 9 | if( c * c > 1 ) return ret; 10 | double h = sqrt( max( 0.0 , 1.0 - c * c ) ); 11 | for( int sign2 = 1 ; sign2 >= -1 ; sign2 -= 2 ){ 12 | Pt n = { v.X * c - sign2 * h * v.Y , 13 | v.Y * c + sign2 * h * v.X }; 14 | Pt p1 = c1.O + n * c1.R; 15 | Pt p2 = c2.O + n * ( c2.R * sign1 ); 16 | if( fabs( p1.X - p2.X ) < eps and 17 | fabs( p1.Y - p2.Y ) < eps ) 18 | p2 = p1 + perp( c2.O - c1.O ); 19 | ret.push_back( { p1 , p2 } ); 20 | } 21 | return ret; 22 | } 23 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2012/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 110 4 | char c[ N ][ N ]; 5 | int all , hf , n , m; 6 | void init(){ 7 | freopen( "ascii.in" , "r" , stdin ); 8 | freopen( "ascii.out" , "w" , stdout ); 9 | scanf( "%d%d" , &n , &m ); 10 | for( int i = 0 ; i < n ; i ++ ) 11 | scanf( "%s" , c[ i ] ); 12 | } 13 | void solve(){ 14 | for( int i = 0 ; i < n ; i ++ ){ 15 | int yes = 0; 16 | for( int j = 0 ; j < m ; j ++ ) 17 | if( c[ i ][ j ] == '.' ){ 18 | if( yes ) all ++; 19 | }else if( c[ i ][ j ] == '/' || 20 | c[ i ][ j ] == '\\' ){ 21 | yes = 1 - yes; 22 | hf ++; 23 | } 24 | } 25 | cout << all + hf / 2 << endl; 26 | } 27 | int main(){ 28 | init(); 29 | solve(); 30 | } 31 | -------------------------------------------------------------------------------- /contest/NTUPK/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 10010001 4 | typedef long long ll; 5 | ll n , m; 6 | void init(){ 7 | scanf( "%lld%lld" , &n , &m ); 8 | if( n > m ) swap( n , m ); 9 | } 10 | ll sv[ N ]; 11 | void solve(){ 12 | for( int i = 0 ; i <= n ; i ++ ) sv[ i ] = 0; 13 | for( ll i = 3 ; i <= m ; i += 2 ){ 14 | for( ll j = i + i + i ; i + j <= m ; j += i + i ) 15 | sv[ j ] ++; 16 | } 17 | ll ans = 0; 18 | for( ll i = 3 ; i <= n ; i += 2 ){ 19 | ll mx = m - i; 20 | if( mx % 2 == 0 ) mx --; 21 | mx = min( mx , i - 2 ); 22 | printf( "%lld %lld\n" , i , mx ); 23 | ll sum = ( mx - 1ll ) / 2ll + 1ll; 24 | ans += sum - sv[ i ]; 25 | } 26 | printf( "%lld\n" , ans ); 27 | } 28 | int main(){ 29 | int _; scanf( "%d" , &_ ); 30 | while( _ -- ){ 31 | init(); 32 | solve(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /intro/introduction.txt: -------------------------------------------------------------------------------- 1 | /*==========================================================*/ 2 | /* __ ___ ___ */ 3 | /* | \ | / \ */ 4 | /* | | | | __ __ __ __ __ */ 5 | /* |__/ |___ | / \ \ / / \ |/ / \ / ' */ 6 | /* | | | | | \ / |__/ | | | \__ */ 7 | /* | |____ \___/ \__/\ \/ \__/ | \__/ \__| */ 8 | /* */ 9 | /* Paul Wang, (tzupengwang) */ 10 | /* Eddy Hsu, (eddy1021) */ 11 | /* Chen Li, (akaiNeko) */ 12 | /* We are from National Taiwan University! */ 13 | /*==========================================================*/ 14 | -------------------------------------------------------------------------------- /contest/Dhaka2017/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int x1, y1, x2, y2; 6 | while (scanf("%d%d%d%d", &x1, &y1, &x2, &y2)) { 7 | if (x1 == 0 && x2 == 0 && y1 == 0 && y2 == 0) break; 8 | 9 | if (x1 < x2) { 10 | swap(x1, x2), swap(y1, y2); 11 | } 12 | 13 | int ans; 14 | if (y2 >= y1) { 15 | int l1 = (x1 + y1) / 2; 16 | int l2 = (x2 + y2) / 2; 17 | if (l1 <= l2) { 18 | ans = (x1 - x2) + (y2 - y1); 19 | } else 20 | ans = (x1 - x2) + (y2 - y1) + (l1 - l2) * 2; 21 | } else { 22 | int l1 = (x1 + 1000000000 - y1) / 2; 23 | int l2 = (x2 + 1000000000 - y2) / 2; 24 | if (l1 <= l2) { 25 | ans = (x1 - x2) + (y1 - y2); 26 | } else 27 | ans = (x1 - x2) + (y1 - y2) + (l1 - l2) * 2; 28 | } 29 | printf("%d\n", ans); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2010/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 15 4 | int n , p[ N ]; 5 | void init(){ 6 | scanf( "%d" , &n ); 7 | for( int i = 0 ; i < n ; i ++ ) 8 | scanf( "%d" , &p[ i ] ); 9 | } 10 | inline bool okay( int x ){ 11 | for( int i = 0 ; i < n ; i ++ ){ 12 | bool flag = false; 13 | for( int j = 0 ; j <= x ; j ++ ){ 14 | double tmp = ( (double)j / (double)x ) * 100.0; 15 | int pi = ( tmp + 0.5 ); 16 | if( pi == p[ i ] ){ 17 | flag = true; 18 | break; 19 | } 20 | } 21 | if( !flag ) return false; 22 | } 23 | return true; 24 | } 25 | void solve(){ 26 | for( int i = 1 ; i <= 100 ; i ++ ) 27 | if( okay( i ) ){ 28 | printf( "%d\n" , i ); 29 | exit( 0 ); 30 | } 31 | puts( "100" ); 32 | } 33 | int main(){ 34 | init(); 35 | solve(); 36 | } 37 | -------------------------------------------------------------------------------- /contest/ASC/ASC33/e.py: -------------------------------------------------------------------------------- 1 | import sys 2 | N = 151 3 | C = [ [ 0 for j in range( N ) ] for i in range( N ) ] 4 | for i in range(N): 5 | C[i][i] = 1 6 | for i in range(2,N): 7 | for j in range(1,i): 8 | C[i][j] = C[i-1][j-1] + C[i-1][j] 9 | dp = [ [ 0 for i in range( N ) ] for j in range( N ) ] 10 | # dp[0][0] = 1 11 | for k in range( N ): 12 | dp[0][k] = 1 13 | for i in range( 1 , N ): 14 | for j in range( 0 , i ): 15 | p = [ 0 for k in range( i + 1 ) ] 16 | p[1] = 1 17 | for k in range( 0 , j ): 18 | tp = [ 0 for k in range( i + 1 ) ] 19 | for sz in range( 1 , i ): 20 | for u in range( sz , i + 1 ): 21 | tp[ u ] += p[ u - sz ] * C[ i - ( u - sz ) - 1 ][ sz - 1 ] 22 | for u in range( i + 1 ): 23 | p[u] = tp[u] 24 | dp[i][j] = dp[i][j-1] + p[i] 25 | print( "dp[%d]=%d\n" % ( i , sum( dp[i] ) ) ) 26 | sys.stdout.flush(); 27 | -------------------------------------------------------------------------------- /contest/opencup/XV/Peterhof/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | inline bool g(int x) { 5 | return (x % 4) == 0; 6 | } 7 | 8 | int main() { 9 | int a, b, c, d, ap, bp; 10 | scanf("%d%d%d%d", &a, &b, &c, &d); 11 | 12 | ap = a - c, bp = b - d; 13 | if (ap > bp) { 14 | swap(a, b); 15 | swap(c, d); 16 | swap(ap, bp); 17 | } 18 | 19 | int ans = 0; 20 | 21 | if (ap == 2) { 22 | if (bp == 2) { 23 | if (g(b)) { 24 | ans += 2; 25 | if (g(c)) ans += 2; 26 | } 27 | if (g(a)) { 28 | ans += 2; 29 | if (g(d)) ans += 2; 30 | } 31 | } else { 32 | if (g(b)) ans += 2; 33 | if (g(a)) { 34 | ans += 2; 35 | if (g(d)) ans += 2; 36 | } 37 | } 38 | } else { 39 | if (g(b)) ans += 2; 40 | if (g(a)) ans += 2; 41 | } 42 | printf("%d\n", ans); 43 | } 44 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Siberia/11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | int n , k , m; 5 | vector rv[ N ]; 6 | int bad[ N ]; 7 | void init(){ 8 | scanf( "%d%d%d" , &n , &k , &m ); 9 | while( k -- ){ 10 | int id; scanf( "%d" , &id ); 11 | bad[ id ] = true; 12 | } 13 | } 14 | int ans; 15 | void Bad( int now ){ 16 | if( bad[ now ] ) return; 17 | bad[ now ] = true; 18 | ans ++; 19 | for( auto i : rv[ now ] ) 20 | Bad( i ); 21 | } 22 | void solve(){ 23 | ans = accumulate( bad + 1 , bad + n + 1 , 0 ); 24 | while( m -- ){ 25 | int a , b; 26 | scanf( "%d%d" , &a , &b ); 27 | rv[ b ].push_back( a ); 28 | if( bad[ b ] ) Bad( a ); 29 | printf( "%d\n" , ans ); 30 | } 31 | } 32 | int main(){ 33 | freopen( "input.txt" , "r" , stdin ); 34 | freopen( "output.txt" , "w" , stdout ); 35 | init(); 36 | solve(); 37 | } 38 | -------------------------------------------------------------------------------- /contest/opencup/XV/America/j.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | char s[1000005]; 6 | 7 | int maxk(char x, int l) { 8 | if (l == 0) return 0; 9 | return max('z' - x, x - 'a') + 25 * (l - 1); 10 | } 11 | 12 | int main(){ 13 | int k; 14 | scanf("%d", &k); 15 | 16 | s[0] = 'a'; 17 | int ml = (k + 24) / 25; 18 | 19 | int nd = k; 20 | for (int i = 1; i < ml; i ++) { 21 | for (char c = 'a'; c <= 'z'; c ++) { 22 | int tl = abs(c - s[i - 1]); 23 | if (tl + maxk(c, ml - i) >= nd) { 24 | s[i] = c; 25 | nd -= tl; 26 | break; 27 | } 28 | } 29 | } 30 | for (char c = 'a'; c <= 'z'; c ++) { 31 | int tl = abs(c - s[ml - 1]); 32 | if (tl == nd) { 33 | s[ml] = c; 34 | break; 35 | } 36 | } 37 | s[ml + 1] = '\0'; 38 | printf("%s\n", s); 39 | } 40 | -------------------------------------------------------------------------------- /contest/Dhaka2015/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | map M , M2; 4 | int main(){ 5 | M[ "JAN" ] = 31; 6 | M[ "FEB" ] = 28; 7 | M[ "MAR" ] = 31; 8 | M[ "APR" ] = 30; 9 | M[ "MAY" ] = 31; 10 | M[ "JUN" ] = 30; 11 | M[ "JUL" ] = 31; 12 | M[ "AUG" ] = 31; 13 | M[ "SEP" ] = 30; 14 | M[ "OCT" ] = 31; 15 | M[ "NOV" ] = 30; 16 | M[ "DEC" ] = 31; 17 | M2[ "SUN" ] = 0; 18 | M2[ "MON" ] = 1; 19 | M2[ "TUE" ] = 2; 20 | M2[ "WED" ] = 3; 21 | M2[ "THU" ] = 4; 22 | M2[ "FRI" ] = 5; 23 | M2[ "SAT" ] = 6; 24 | int t; scanf( "%d" , &t ); while( t -- ){ 25 | string mon , day; 26 | cin >> mon >> day; 27 | int mn = M[ mon ]; 28 | int dy = M2[ day ]; 29 | int ans = 0; 30 | for( int i = 0 ; i < mn ; i ++ ){ 31 | if( dy >= 5 ) ans ++; 32 | dy = ( dy + 1 ) % 7; 33 | } 34 | printf( "%d\n" , ans ); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /contest/ITSA2018/1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | set< tuple > s; 4 | int main(){ 5 | for(int x=-100; x<=100; x++) 6 | for(int y=x; y<=100; y++){ 7 | int a=x+y; 8 | int b=y-x; 9 | int c=(x * y + 50) / 100; 10 | s.insert(make_tuple(a, b, c)); 11 | s.insert(make_tuple(a, c, b)); 12 | s.insert(make_tuple(b, a, c)); 13 | s.insert(make_tuple(b, c, a)); 14 | s.insert(make_tuple(c, a, b)); 15 | s.insert(make_tuple(c, b, a)); 16 | //s.insert(make_tuple(x+y,y-x, (int)round(0.01 * x * y))); 17 | } 18 | //s.insert(make_tuple(x+y,y-x, (int)round(0.01 * x * y))); 19 | int t; cin >> t; while(t --){ 20 | int a, b, c; 21 | cin >> a >> b >> c; 22 | auto it = s.find(make_tuple(a, b, c)); 23 | if( it == s.end() ) puts("No"); 24 | else puts("Yes"); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /contest/Jakarta/2014/kgen.py: -------------------------------------------------------------------------------- 1 | 2 | import random 3 | 4 | T = 100 5 | print( T ) 6 | for _ in range( T ): 7 | n , m , k = 1000 , 1000 , 0 8 | pt = [] 9 | def ok( x , y ): 10 | if 1 < x < n and 1 < y < m: 11 | for ( px , py ) in pt: 12 | if abs( px - x ) + abs( py - y ) <= 2: 13 | return False 14 | for ( px , py ) in [ ( 1 , 1 ) , ( n , m ) ]: 15 | if abs( px - x ) + abs( py - y ) <= 2: 16 | return False 17 | return True 18 | return False 19 | for i in range( k ): 20 | x , y = random.randrange( n ) + 1 , random.randrange( m ) + 1 21 | while not ok( x , y ): 22 | x , y = random.randrange( n ) + 1 , random.randrange( m ) + 1 23 | pt.append( ( x , y ) ) 24 | print( "%d %d %d" % ( n , m , k ) ) 25 | for p in pt: 26 | print( "%d %d" % p ) 27 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ekaterinburg/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | int n , k , ans[ N ]; 5 | void go( int now ){ 6 | vector< pair > vv; 7 | for( int i = now + 1 ; i <= n ; i ++ ) 8 | vv.push_back( { ans[ i ] , i } ); 9 | sort( vv.begin() , vv.end() ); 10 | int nd = 0; 11 | for( int i = 0 ; i < (int)vv.size() / 2 ; i ++ ) 12 | nd += vv[ i ].first + 1; 13 | if( nd > k ){ 14 | ans[ now ] = -1; 15 | return; 16 | } 17 | for( int i = now + 1 ; i <= n ; i ++ ) 18 | ans[ i ] = 0; 19 | for( int i = 0 ; i < (int)vv.size() / 2 ; i ++ ) 20 | ans[ vv[ i ].second ] = vv[ i ].first + 1; 21 | ans[ now ] = k - nd; 22 | } 23 | int main(){ 24 | cin >> n >> k; 25 | ans[ n ] = k; 26 | for( int i = n - 1 ; i >= 1 ; i -- ) 27 | go( i ); 28 | for( int i = 1 ; i <= n ; i ++ ) 29 | printf( "%d%c" , ans[ i ] , " \n"[ i == n ] ); 30 | } 31 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Khamovniki/h.cpp: -------------------------------------------------------------------------------- 1 | 2 | #pragma GCC optimize("O3") 3 | #include 4 | using namespace std; 5 | typedef long long LL; 6 | const int N = 3e5+10; 7 | 8 | int k, n, m; 9 | int ip[N], ans[N]; 10 | 11 | void fail() { puts("-1"); exit(0); } 12 | 13 | int main(){ 14 | scanf("%d%d%d", &k, &n, &m); 15 | if (k > n) fail(); 16 | for (int i = 1; i <= k; ++i) { 17 | scanf("%d", ip+i); 18 | } 19 | int prv = (ip[1]==-1)? 1: ip[1]; 20 | int cur = 1; 21 | for (int i = 1; i <= k; ++i) { 22 | if (ip[i] == -1) ip[i] = prv; 23 | else if (prv > ip[i]) fail(); 24 | for (int j = m; j > ip[i]; --j) { 25 | if (n-cur+1 <= k-i+1) break; 26 | ans[cur++] = j; 27 | } 28 | if (n-cur+1 < k-i+1) fail(); 29 | ans[cur++] = ip[i]; 30 | prv = ip[i]; 31 | } 32 | if (cur != n+1) fail(); 33 | for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], " \n"[i == n]); 34 | } 35 | -------------------------------------------------------------------------------- /codebook/math/Miller_Rabin.cpp: -------------------------------------------------------------------------------- 1 | // n < 4,759,123,141 3 : 2, 7, 61 2 | // n < 1,122,004,669,633 4 : 2, 13, 23, 1662803 3 | // n < 3,474,749,660,383 6 : pirmes <= 13 4 | // n < 2^64 7 : 5 | // 2, 325, 9375, 28178, 450775, 9780504, 1795265022 6 | // Make sure testing integer is in range [2, n−2] if 7 | // you want to use magic. 8 | bool witness(LL a,LL n,LL u,int t){ 9 | LL x=mypow(a,u,n); 10 | for(int i=0;i>=1, t++; 25 | while(s--){ 26 | LL a=randll()%(n-1)+1; 27 | if(witness(a,n,u,t)) return 0; 28 | } 29 | return 1; 30 | } 31 | -------------------------------------------------------------------------------- /contest/BSUIR2017/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 50 4 | int n , a[ N ] , b[ N ]; 5 | int main(){ 6 | cin >> n; 7 | if( n == 1 ){ 8 | puts( "1\n1" ); 9 | exit(0); 10 | } 11 | if( n <= 3 ){ 12 | puts( "-1" ); 13 | exit(0); 14 | } 15 | int iter = 2; 16 | for( int i = 0 ; i < n / 2 ; i ++ ){ 17 | a[ i ] = iter; 18 | iter += 2; 19 | } 20 | iter = 1; 21 | for( int i = n / 2 ; i < n ; i ++ ){ 22 | a[ i ] = iter; 23 | iter += 2; 24 | } 25 | iter = 1; 26 | for( int i = 0 ; i < n / 2 ; i ++ ){ 27 | b[ i ] = iter * n; 28 | iter += 2; 29 | } 30 | iter = 0; 31 | for( int i = n / 2 ; i < n ; i ++ ){ 32 | b[ i ] = iter * n; 33 | iter += 2; 34 | } 35 | printf( "%d\n" , n ); 36 | for( int i = 0 ; i < n ; i ++ ) 37 | for( int j = 0 ; j < n ; j ++ ) 38 | printf( "%d%c" , b[ i ] + a[ j ] , " \n"[ j + 1 == n ] ); 39 | } 40 | -------------------------------------------------------------------------------- /contest/ASC/ASC43/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 333 4 | int n; 5 | void solve(){ 6 | if( n == 3 ){ 7 | puts( "1" ); 8 | puts( "1 1 1" ); 9 | puts( "1 1 1" ); 10 | }else if( n == 4 ){ 11 | puts( "2" ); 12 | puts( "1 1 2 2" ); 13 | puts( "1 2 1 2" ); 14 | }else if( n == 5 ){ 15 | puts( "2" ); 16 | puts( "1 2 1 1 2" ); 17 | puts( "1 2 1 1 2" ); 18 | }else if( n == 6 ){ 19 | puts( "2" ); 20 | puts( "1 2 1 2 1 2" ); 21 | puts( "1 2 1 2 1 2" ); 22 | }else{ 23 | puts( "3" ); 24 | for( int i = 1 ; i <= n ; i ++ ) 25 | printf( "%d%c" , 1 + i % 2 , " \n"[ i == n ] ); 26 | for( int i = 1 ; i <= n ; i ++ ) 27 | printf( "3%c" , " \n"[ i == n ] ); 28 | } 29 | } 30 | int main(){ 31 | freopen( "jubilee.in" , "r" , stdin ); 32 | freopen( "jubilee.out" , "w" , stdout ); 33 | while( scanf( "%d" , &n ) == 1 && n ) solve(); 34 | } 35 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2017/e2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int c[1005]; 5 | 6 | int main() { 7 | int n; 8 | scanf("%d", &n); 9 | 10 | int free; 11 | vector ans; 12 | 13 | for (int i = 0; i < n; i ++) { 14 | int x; 15 | scanf("%d", &x); 16 | if (x > 0) { 17 | c[x] ++; 18 | } else if (x < 0) { 19 | x = -x; 20 | if (c[x] > 0) c[x] --; 21 | else if (free > 0) { 22 | ans.push_back(x); 23 | free --; 24 | } else { 25 | puts("No"); 26 | return 0; 27 | } 28 | } else { 29 | free ++; 30 | } 31 | } 32 | while (free) { 33 | ans.push_back(1); 34 | free --; 35 | } 36 | puts("Yes"); 37 | if (ans.size()) { 38 | for (int i = 0; i < (int)ans.size(); i ++) { 39 | printf("%d%c", ans[i], " \n"[i + 1 == (int)ans.size()]); 40 | } 41 | } else { 42 | puts(""); 43 | } 44 | } 45 | 46 | -------------------------------------------------------------------------------- /codebook/geometry/Intersection_of_polygon_and_circle.cpp: -------------------------------------------------------------------------------- 1 | Pt ORI , info[ N ]; 2 | D r; int n; 3 | // Divides into multiple triangle, and sum up 4 | // oriented area 5 | D area2(Pt pa, Pt pb){ 6 | if( norm(pa) < norm(pb) ) swap(pa, pb); 7 | if( norm(pb) < eps ) return 0; 8 | D S, h, theta; 9 | D a = norm( pb ), b = norm( pa ), c = norm(pb - pa); 10 | D cosB = (pb * (pb - pa)) / a / c, B = acos(cosB); 11 | D cosC = (pa * pb) / a / b, C = acos(cosC); 12 | if(a > r){ 13 | S = (C/2)*r*r; 14 | h = a*b*sin(C)/c; 15 | if (h < r && B < PI/2) S -= (acos(h/r)*r*r - h*sqrt(r*r-h*h)); 16 | }else if(b > r){ 17 | theta = PI - B - asin(sin(B)/r*a); 18 | S = .5*a*r*sin(theta) + (C-theta)/2*r*r; 19 | }else S = .5*sin(C)*a*b; 20 | return S; 21 | } 22 | D area() { 23 | D S = 0; 24 | for(int i = 0; i < n; ++i) 25 | S += abs( area2(info[i], info[i + 1]) * sign( det(info[i], info[i + 1])); 26 | return fabs(S); 27 | } 28 | -------------------------------------------------------------------------------- /codebook/math/DiscreteSqrt.cpp: -------------------------------------------------------------------------------- 1 | void calcH(int &t, int &h, const int p) { 2 | int tmp=p-1; for(t=0;(tmp&1)==0;tmp/=2) t++; h=tmp; 3 | } 4 | // solve equation x^2 mod p = a 5 | bool solve(int a, int p, int &x, int &y) { 6 | if(p == 2) { x = y = 1; return true; } 7 | int p2 = p / 2, tmp = mypow(a, p2, p); 8 | if (tmp == p - 1) return false; 9 | if ((p + 1) % 4 == 0) { 10 | x=mypow(a,(p+1)/4,p); y=p-x; return true; 11 | } else { 12 | int t, h, b, pb; calcH(t, h, p); 13 | if (t >= 2) { 14 | do {b = rand() % (p - 2) + 2; 15 | } while (mypow(b, p / 2, p) != p - 1); 16 | pb = mypow(b, h, p); 17 | } int s = mypow(a, h / 2, p); 18 | for (int step = 2; step <= t; step++) { 19 | int ss = (((LL)(s * s) % p) * a) % p; 20 | for(int i=0;i 2 | using namespace std; 3 | #define N 10000001 4 | typedef long long LL; 5 | int fac[ N ]; 6 | void build(){ 7 | for( int i = 2 ; i < N ; i ++ ) if( fac[ i ] == 0 ){ 8 | fac[ i ] = i; 9 | for( LL j = (LL)i * i ; j < N ; j += i ) 10 | if( !fac[ j ] ) 11 | fac[ j ] = i; 12 | } 13 | } 14 | bool win( int w , int h , int who ){ 15 | if( who == 0 ){ 16 | if( w == 1 ) return false; 17 | return win( w / fac[ w ] , h , 1 - who ); 18 | }else{ 19 | if( h == 1 ) return true; 20 | return win( w , h / fac[ h ] , 1 - who ); 21 | } 22 | } 23 | int main(){ 24 | #ifdef ONLINE_JUDGE 25 | freopen( "funny.in" , "r" , stdin ); 26 | freopen( "funny.out" , "w" , stdout ); 27 | #endif 28 | int w , h; 29 | build(); 30 | while( scanf( "%d%d" , &w , &h ) == 2 && w ){ 31 | printf( "%d %d - " , w , h ); 32 | puts( win( w , h , 0 ) ? "Vera" : "Harry" ); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /contest/BSUIR2017/g2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | const int N = 42; 5 | const LL mod = (1LL << N); 6 | LL bs[ N ]; 7 | map sv; 8 | inline LL mul( LL a , LL b ){ 9 | if( b == 0 ) return 0; 10 | LL ret = mul( ( a + a ) % mod , b / 2 ); 11 | if( b & 1 ) ret = ( ret + a ) % mod; 12 | return ret; 13 | } 14 | void go( int now , LL s , string who ){ 15 | if( now == 21 ){ 16 | sv[ s ] = who; 17 | s = mul( s , bs[ 21 ] ); 18 | s = ( mod - s ) % mod; 19 | auto it = sv.find( s ); 20 | if( it == sv.end() ) return; 21 | cout << who << it->second << endl; 22 | exit(0); 23 | return; 24 | } 25 | go( now + 1 , ( s * 10 + 1 ) % mod , who + "1" ); 26 | go( now + 1 , ( s * 10 + 2 ) % mod , who + "2" ); 27 | } 28 | int main(){ 29 | bs[ 0 ] = 1; 30 | for( int i = 1 ; i < N ; i ++ ) 31 | bs[ i ] = ( bs[ i - 1 ] * 10 ) % mod; 32 | go( 0 , 0 , "" ); 33 | } 34 | -------------------------------------------------------------------------------- /contest/Daejeon/2015/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | int n , m , k[ N ]; 5 | string a , b; 6 | void init(){ 7 | scanf( "%d%d" , &n , &m ); 8 | a = b = ""; 9 | for( int i = 0 ; i < m ; i ++ ){ 10 | int u; scanf( "%d" , &u ); 11 | a += (char)( u + '0' ); 12 | } 13 | for( int i = 0 ; i < m ; i ++ ){ 14 | int u; scanf( "%d" , &u ); 15 | b += (char)( u + '0' ); 16 | } 17 | for( int i = 0 ; i < n ; i ++ ) 18 | scanf( "%d" , &k[ i ] ); 19 | } 20 | bool okay( int x ){ 21 | string c = ""; 22 | for( int i = x ; i < x + m ; i ++ ) 23 | c += (char)( k[ i % n ] + '0' ); 24 | return a <= c && c <= b; 25 | } 26 | void solve(){ 27 | int ans = 0; 28 | for( int i = 0 ; i < n ; i ++ ) 29 | if( okay( i ) ) 30 | ans ++; 31 | printf( "%d\n" , ans ); 32 | } 33 | int main(){ 34 | int _; scanf( "%d" , &_ ); while( _ -- ){ 35 | init(); 36 | solve(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2009/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | char c[ N ][ 10 ]; 5 | int n , b[ N ]; 6 | bool bye[ N ]; 7 | void init(){ 8 | scanf( "%d" , &n ); 9 | for( int i = 1 ; i <= n ; i ++ ){ 10 | scanf( "%s" , c[ i ] ); 11 | if( c[ i ][ 0 ] == 'c' ) 12 | scanf( "%d" , &b[ i ] ); 13 | } 14 | } 15 | void solve(){ 16 | vector< int > ans; 17 | for( int i = n ; i >= 1 ; i -- ){ 18 | if( bye[ i ] ) continue; 19 | ans.push_back( i ); 20 | if( c[ i ][ 0 ] == 'c' ) 21 | bye[ b[ i ] ] = true; 22 | } 23 | reverse( ans.begin() , ans.end() ); 24 | printf( "%d\n" , (int)ans.size() ); 25 | for( size_t i = 0 ; i < ans.size() ; i ++ ) 26 | printf( "%d%c" , ans[ i ] , " \n"[ i + 1 == ans.size() ] ); 27 | } 28 | int main(){ 29 | freopen( "bureau.in" , "r" , stdin ); 30 | freopen( "bureau.out" , "w" , stdout ); 31 | init(); 32 | solve(); 33 | } 34 | -------------------------------------------------------------------------------- /contest/ASC/ASC28/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 30000010 4 | int n , m , k , a , b , c , x[ N ]; 5 | long long ans; 6 | int dq[ N ] , df , dt; 7 | int main(){ 8 | #ifdef ONLINE_JUDGE 9 | freopen( "minima.in" , "r" , stdin ); 10 | freopen( "minima.out" , "w" , stdout ); 11 | #endif 12 | cin >> n >> m >> k; 13 | cin >> a >> b >> c; 14 | for( int i = 1 ; i <= k ; i ++ ) 15 | cin >> x[ i ]; 16 | for( int i = k + 1 ; i <= n ; i ++ ) 17 | x[ i ] = a * x[ i - 2 ] + b * x[ i - 1 ] + c; 18 | for( int i = 1 ; i < m ; i ++ ){ 19 | while( dt and x[ dq[ dt - 1 ] ] >= x[ i ] ) 20 | dt --; 21 | dq[ dt ++ ] = i; 22 | } 23 | for( int i = m ; i <= n ; i ++ ){ 24 | while( dt - df > 0 and x[ dq[ dt - 1 ] ] >= x[ i ] ) 25 | dt --; 26 | dq[ dt ++ ] = i; 27 | while( dt - df > 0 and dq[ df ] <= i - m ) df ++; 28 | ans += x[ dq[ df ] ]; 29 | } 30 | printf( "%lld\n" , ans ); 31 | } 32 | -------------------------------------------------------------------------------- /contest/Hatyai/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 20202 4 | typedef long long LL; 5 | int n , r; 6 | vector vv; 7 | void init(){ 8 | vv.clear(); 9 | for( int i = 0 ; i < n ; i ++ ){ 10 | int x , y; 11 | scanf( "%d.%d" , &x , &y ); 12 | vv.push_back( x * 1000 + y ); 13 | } 14 | sort( vv.begin() , vv.end() ); 15 | } 16 | int hf = 180000; 17 | LL C( LL x ){ 18 | return x * ( x - 1 ) / 2; 19 | } 20 | int _cs; 21 | void solve(){ 22 | LL tot = (LL)n * (LL)( n - 1 ) * (LL)( n - 2 ) / 6; 23 | for( int i = 0 ; i < n ; i ++ ) 24 | vv.push_back( vv[ i ] + hf + hf ); 25 | for( int i = 0 , j = 0 ; i < n ; i ++ ){ 26 | while( vv[ j ] <= vv[ i ] + hf ) j ++; 27 | int res = j - i - 1; 28 | tot -= C( res ); 29 | } 30 | printf( "Case %d: %lld\n" , ++ _cs, tot ); 31 | } 32 | int main(){ 33 | while( scanf( "%d%d" , &n , & r ) == 2 && n ){ 34 | init(); 35 | solve(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2017/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 1021 6 | int cnt[ N ] , n , a[ N ]; 7 | int main(){ 8 | cin >> n; 9 | for( int i = 0 ; i < n ; i ++ ) 10 | cin >> a[ i ]; 11 | int zer = 0; 12 | vector ans; 13 | for( int i = 0 ; i < n ; i ++ ){ 14 | if( a[ i ] > 0 ){ 15 | cnt[ a[ i ] ] ++; 16 | continue; 17 | } 18 | if( a[ i ] == 0 ){ 19 | zer ++; 20 | continue; 21 | } 22 | if( cnt[ -a[ i ] ] ){ 23 | cnt[ -a[ i ] ] --; 24 | continue; 25 | } 26 | if( zer == 0 ){ 27 | puts( "No" ); 28 | exit(0); 29 | } 30 | ans.push_back( -a[ i ] ); 31 | zer --; 32 | } 33 | while( zer -- ) 34 | ans.push_back( 1 ); 35 | puts( "Yes" ); 36 | for( size_t i = 0 ; i < ans.size() ; i ++ ) 37 | printf( "%d%c" , ans[ i ] , " \n"[ i + 1 == ans.size() ] ); 38 | } 39 | -------------------------------------------------------------------------------- /contest/opencup/XV/Tatarstan/g.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 101010 6 | LL base = 1e6; 7 | inline LL to_sec( LL h , LL m , LL s ){ 8 | return h * base * base + m * base + s; 9 | } 10 | inline LL read(){ 11 | LL h , m , s; 12 | cin >> h >> m >> s; 13 | return to_sec( h , m , s ); 14 | } 15 | int n; 16 | LL s[ N ]; 17 | int main(){ 18 | cin >> n; 19 | for( int i = 0 ; i < n ; i ++ ) 20 | s[ i ] = read(); 21 | sort( s , s + n ); 22 | LL sum = accumulate( s , s + n , 0LL ); 23 | LL ans = s[ n - 1 ] * n - sum; 24 | //LL ans = sum - s[ 0 ] * n; 25 | for( int i = n - 2 ; i >= 0 ; i -- ){ 26 | sum -= base * base * 12; 27 | ans = min( ans , s[ i ] * n - sum ); 28 | } 29 | printf( "%lld %lld %lld\n" , (ans / base) / base , 30 | (ans / base) % base , 31 | ans % base ); 32 | } 33 | -------------------------------------------------------------------------------- /codebook/geometry/minDistonCuboid.cpp: -------------------------------------------------------------------------------- 1 | typedef LL T; 2 | T r; 3 | void turn(T i, T j, T x, T y, T z, 4 | T x0, T y0, T L, T W, T H) { 5 | if (z==0) { T R = x*x+y*y; if (R=0 && i< 2) turn(i+1, j, x0+L+z, y, x0+L-x, 7 | x0+L, y0, H, W, L); 8 | if(j>=0 && j< 2) turn(i, j+1, x, y0+W+z, y0+W-y, 9 | x0, y0+W, L, H, W); 10 | if(i<=0 && i>-2) turn(i-1, j, x0-z, y, x-x0, 11 | x0-H, y0, H, W, L); 12 | if(j<=0 && j>-2) turn(i, j-1, x, y0-z, y-y0, 13 | x0, y0-H, L, H, W); 14 | } 15 | T solve(T L, T W, T H, 16 | T x1, T y1, T z1, T x2, T y2, T z2){ 17 | if( z1!=0 && z1!=H ){ 18 | if( y1==0 || y1==W ) 19 | swap(y1,z1), swap(y2,z2), swap(W,H); 20 | }else swap(x1,z1), swap(x2,z2), swap(L,H); 21 | if (z1==H) z1=0, z2=H-z2; 22 | r=INF; turn(0,0,x2-x1,y2-y1,z2,-x1,-y1,L,W,H); 23 | return r; 24 | } 25 | -------------------------------------------------------------------------------- /codebook/geometry/minkowski-convex-hull.cpp: -------------------------------------------------------------------------------- 1 | vector minkowski(vector p, vector q){ 2 | int n = p.size() , m = q.size(); 3 | Pt c = Pt(0, 0); 4 | for( int i = 0; i < m; i ++) c = c + q[i]; 5 | c = c / m; 6 | for( int i = 0; i < m; i ++) q[i] = q[i] - c; 7 | int cur = -1; 8 | for( int i = 0; i < m; i ++) 9 | if( (q[i] ^ (p[0] - p[n-1])) > -eps) 10 | if( cur == -1 || (q[i] ^ (p[0] - p[n-1])) > 11 | (q[cur] ^ (p[0] - p[n-1])) ) 12 | cur = i; 13 | vector h; 14 | p.push_back(p[0]); 15 | for( int i = 0; i < n; i ++) 16 | while( true ){ 17 | h.push_back(p[i] + q[cur]); 18 | int nxt = (cur + 1 == m ? 0 : cur + 1); 19 | if((q[cur] ^ (p[i+1] - p[i])) < -eps) cur = nxt; 20 | else if( (q[nxt] ^ (p[i+1] - p[i])) > 21 | (q[cur] ^ (p[i+1] - p[i])) ) cur = nxt; 22 | else break; 23 | } 24 | for(auto &&i : h) i = i + c; 25 | return convex_hull(h); 26 | } 27 | -------------------------------------------------------------------------------- /contest/Hualien/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 10101 4 | char c[ N ]; 5 | int n; 6 | void init(){ 7 | scanf( "%s" , c + 1 ); 8 | n = strlen( c + 1 ); 9 | } 10 | int dp[ N ] , fl[ N ]; 11 | void solve(){ 12 | for( int i = 1 ; i <= n ; i ++ ) 13 | dp[ i ] = n; 14 | for( int i = 0 ; i < n ; i ++ ){ 15 | dp[ i + 1 ] = min( dp[ i + 1 ] , dp[ i ] + 1 ); 16 | fl[ i + 1 ] = i; 17 | for( int j = i + 2 , pre = i ; j <= n ; j ++ ){ 18 | while( pre > i and c[ pre + 1 ] != c[ j ] ) 19 | pre = fl[ pre ]; 20 | if( c[ pre + 1 ] == c[ j ] ) pre ++; 21 | fl[ j ] = pre; 22 | int tmp = j - pre; 23 | int cst = j - i; 24 | if( (j - i) % tmp == 0 ) cst = tmp; 25 | dp[ j ] = min( dp[ j ] , dp[ i ] + cst ); 26 | } 27 | } 28 | printf( "%d\n" , dp[ n ] ); 29 | } 30 | int main(){ 31 | int t; scanf( "%d" , &t ); while( t -- ){ 32 | init(); 33 | solve(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2015/b.py: -------------------------------------------------------------------------------- 1 | import sys 2 | sys.stdin = open('binary.in', 'r') 3 | sys.stdout = open('binary.out', 'w') 4 | 5 | def ok(x): 6 | s = str(x) 7 | s2 = bin(int(s))[2:] 8 | ls = len(s) 9 | return s2[-ls:] == s 10 | cand = [] 11 | cand.append(0) 12 | cand.append(1) 13 | ten = 1 14 | for i in range(1, 1000): 15 | ten *= 10 16 | for j in cand: 17 | nj = j + ten 18 | if ok( nj ): 19 | cand.append(nj) 20 | if len(cand) >= 10001: 21 | # print(i+1) 22 | break; 23 | # print(len(cand)) 24 | cand = sorted(cand) 25 | print(cand[int(input())]) 26 | 27 | exit(0) 28 | ct = 0 29 | for i in range(1, 1000000): 30 | s = bin(i)[2:] 31 | s2 = bin(int(s))[2:] 32 | ls = len(s) 33 | if s2[-ls:] == s: 34 | # cand.append(s) 35 | ct += 1 36 | # print('a[{}]=\"{}\";'.format(ct, s)) 37 | print(ct, s) 38 | if ct >= 10000: 39 | break 40 | print(ct) 41 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Northern/2009/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | char cmd[ 100 ]; 5 | int n; 6 | map< int , int > cnt; 7 | int c1 , c2; 8 | inline void add( int x ){ 9 | cnt[ x ] ++; 10 | if( cnt[ x ] == 2 ) c1 ++; 11 | if( cnt[ x ] == 1 ) c2 ++; 12 | } 13 | inline void sub( int x ){ 14 | if( cnt[ x ] == 0 ) return; 15 | cnt[ x ] --; 16 | if( cnt[ x ] == 1 ) c1 --; 17 | if( cnt[ x ] == 0 ) c2 --; 18 | } 19 | void solve(){ 20 | while( n -- ){ 21 | scanf( "%s" , cmd ); 22 | int x; scanf( "%d" , &x ); 23 | if( cmd[ 0 ] == 'i' ) add( x ); 24 | else sub( x ); 25 | if( c1 > 0 && c2 > 1 ) puts( "both" ); 26 | else if( c1 > 0 ) puts( "homo" ); 27 | else if( c2 > 1 ) puts( "hetero" ); 28 | else puts( "neither" ); 29 | } 30 | } 31 | int main(){ 32 | freopen( "homo.in" , "r" , stdin ); 33 | freopen( "homo.out" , "w" , stdout ); 34 | scanf( "%d" , &n ); 35 | solve(); 36 | } 37 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Siberia/2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | int dp[ N ][ N ] , n , m , k; 5 | int main(){ 6 | scanf( "%d%d%d" , &n , &m , &k ); 7 | for( int i = 0 ; i < k ; i ++ ){ 8 | int ai , bi; scanf( "%d%d" , &ai , &bi ); 9 | dp[ ai ][ bi ] = 1; 10 | } 11 | for( int i = n ; i >= 1 ; i -- ) 12 | for( int j = m ; j >= 1 ; j -- ) 13 | dp[ i ][ j ] += max( dp[ i + 1 ][ j ] , dp[ i ][ j + 1 ] ); 14 | if( dp[ 1 ][ 1 ] != k ){ 15 | puts( "Impossible" ); 16 | exit( 0 ); 17 | } 18 | int nown = 1 , nowm = 1; 19 | while( nown != n or nowm != m ){ 20 | int bst = 0; 21 | if( dp[ nown + 1 ][ nowm ] < dp[ nown ][ nowm + 1 ] ) 22 | bst = 1; 23 | if( nowm == m ) bst = 0; 24 | if( nown == n ) bst = 1; 25 | if( bst == 0 ){ 26 | putchar( 'D' ); 27 | nown ++; 28 | }else{ 29 | putchar( 'R' ); 30 | nowm ++; 31 | } 32 | } 33 | puts( "" ); 34 | } 35 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eurasia/6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const double pi = acos( -1. ); 4 | double magic = 3; 5 | bool equal( double x , double y ){ 6 | return fabs( x - y ) < 1e-10; 7 | } 8 | int main(){ 9 | double a1 , b1 , c1; 10 | double a2 , b2 , c2; 11 | cin >> a1 >> b1 >> c1; 12 | cin >> a2 >> b2 >> c2; 13 | double px = ( a1 / ( magic * c1 ) ); 14 | double py = ( b1 / ( magic * c1 ) ); 15 | cout << px << " " << py << endl; 16 | double qx = ( a2 - a1 ) / ( magic * ( c2 - c1 ) ); 17 | double qy = ( b2 - b1 ) / ( magic * ( c2 - c1 ) ); 18 | cout << qx << " " << qy << endl; 19 | if( equal( px , qx ) and equal( py , qy ) ) 20 | qy += 1; 21 | double a = qy - py; 22 | double b = px - qx; 23 | double c = px * a + py * b; 24 | cout << a << " " << b << " " << c << endl; 25 | double ss = sqrt( a * a + b * b ); 26 | a /= ss; 27 | b /= ss; 28 | c /= ss; 29 | printf( "%.12f %.12f %.12f\n" , a , b , c ); 30 | } 31 | -------------------------------------------------------------------------------- /contest/Hualien/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 222 4 | #define INF 10000000 5 | int n , m; 6 | int d[ N ][ N ]; 7 | int main(){ 8 | while( cin >> n and n ){ 9 | cin >> m; 10 | for( int i = 0 ; i < n ; i ++ ){ 11 | for( int j = 0 ; j < n ; j ++ ) 12 | d[ i ][ j ] = INF; 13 | d[ i ][ i ]= 0; 14 | } 15 | while( m -- ){ 16 | int a , b; 17 | cin >> a >> b; 18 | d[ a ][ b ] = d[ b ][ a ] = 1; 19 | } 20 | for( int k = 0 ; k < n ; k ++ ) 21 | for( int i = 0 ; i < n ; i ++ ) 22 | for( int j = 0 ; j < n ; j ++ ) 23 | d[ i ][ j ] = min( d[ i ][ j ] , 24 | d[ i ][ k ] + d[ k ][ j ] ); 25 | map M; 26 | for( int i = 0 ; i < n ; i ++ ) 27 | for( int j = 0 ; j < n ; j ++ ) 28 | if( i != j ) 29 | M[ d[ i ][ j ] ] ++; 30 | for( auto i : M ) 31 | printf( "%d %d\n" , i.first , i.second ); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /contest/Dhaka2017/h.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 30010; 6 | 7 | int _cx[N]; 8 | int _xpy[N]; 9 | int _xmy[N]; 10 | int *cx = _cx + 15000; 11 | int *xmy = _xmy+15000; 12 | int *xpy = _xpy+15000; 13 | 14 | int n, x[N], y[N]; 15 | 16 | int main() { 17 | while (scanf("%d", &n) != EOF and n) { 18 | fill(cx-1000, cx+11000, 0); 19 | fill(xmy-1000, xmy+11000, 0); 20 | fill(xpy-1000, xpy+11000, 0); 21 | for (int i = 1; i <= n; ++i) { 22 | scanf("%d%d", x+i, y+i); 23 | cx[x[i]]++; 24 | xmy[x[i]-y[i]]++; 25 | xpy[x[i]+y[i]]++; 26 | } 27 | int ans = 0; 28 | for (int i = -1000; i < 11000; ++i) { 29 | xmy[i] += xmy[i-1]; 30 | xpy[i] += xpy[i-1]; 31 | } 32 | for (int i = -600; i < 10600; ++i) { 33 | int r1 = xpy[i-1]; 34 | int r2 = n - xmy[i]; 35 | int tmp = n - (r1 + r2); 36 | ans = max(ans, tmp); 37 | } 38 | printf("%d\n", ans); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /contest/opencup/XV/Tatarstan/l2.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | const int N = 1e5+10; 6 | 7 | int n, p[N]; 8 | map cnt; 9 | 10 | int main(){ 11 | scanf("%d", &n); 12 | LL mx = 0; 13 | for (int i = 0; i < n; ++i) { 14 | scanf("%d", p+i); 15 | mx = max(mx, (LL)p[i]); 16 | cnt[p[i]]++; 17 | } 18 | LL ans = 1LL * (LL)mx * cnt[mx]; 19 | if (mx > 0) { 20 | for (int i = 0; i < n; ++i) if (p[i]) { 21 | for (int j = i-1; j < i+2; j += 2) { 22 | if (0 > j || n <= j) continue; 23 | cnt[p[i]]--; 24 | cnt[p[j]]--; 25 | cnt[p[i]-1]++; 26 | cnt[p[j]+1]++; 27 | auto it = cnt.end(); --it; 28 | while (it->second == 0) --it; 29 | ans = min(ans, 1LL * (LL)it->first * it->second); 30 | cnt[p[i]]++; 31 | cnt[p[j]]++; 32 | cnt[p[i]-1]--; 33 | cnt[p[j]+1]--; 34 | } 35 | } 36 | } 37 | cout << ans << endl; 38 | } 39 | -------------------------------------------------------------------------------- /contest/Daejeon/2015/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 10101 4 | int n , l[ N ]; 5 | void init(){ 6 | scanf( "%d" , &n ); 7 | for( int i = 0 ; i < n ; i ++ ) 8 | scanf( "%d" , &l[ i ] ); 9 | sort( l , l + n ); 10 | reverse( l , l + n ); 11 | } 12 | bool okay( int x ){ 13 | if( l[ 0 ] - l[ 2 ] > x ) return false; 14 | int lft = l[ 1 ] , rgt = l[ 2 ]; 15 | for( int i = 3 ; i < n ; i ++ ){ 16 | if( lft < rgt ) swap( lft , rgt ); 17 | if( lft - l[ i ] > x ) return false; 18 | lft = l[ i ]; 19 | } 20 | if( lft < rgt ) swap( lft , rgt ); 21 | return lft - rgt <= x; 22 | } 23 | void solve(){ 24 | int bl = 0 , br = 100000 , ans = 0; 25 | while( bl <= br ){ 26 | int mid = ( bl + br ) >> 1; 27 | if( okay( mid ) ) ans = mid , br = mid - 1; 28 | else bl = mid + 1; 29 | } 30 | printf( "%d\n" , ans ); 31 | } 32 | int main(){ 33 | int _; scanf( "%d" , &_ ); while( _ -- ){ 34 | init(); 35 | solve(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /contest/opencup/XVII/SPb/k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | set S; 5 | bool isprime( LL x ){ 6 | for( LL i = 2 ; i * i <= x ; i ++ ) 7 | if( x % i == 0 ) 8 | return false; 9 | return true; 10 | } 11 | LL rev( LL x ){ 12 | LL y = 0; 13 | while( x ){ 14 | y = y * 10 + x % 10; 15 | x /= 10; 16 | } 17 | return y; 18 | } 19 | vector v; 20 | int main(){ 21 | S.insert(2); 22 | S.insert(3); 23 | S.insert(5); 24 | S.insert(7); 25 | v.push_back( 2 ); 26 | v.push_back( 3 ); 27 | v.push_back( 5 ); 28 | v.push_back( 7 ); 29 | for( size_t i = 0 ; i < v.size() ; i ++ ){ 30 | LL now = v[ i ]; 31 | for( LL b : { 3 , 7 } ){ 32 | LL nxt = now * 10 + b; 33 | if( isprime( nxt ) and S.count( rev( rev( nxt ) / 10 ) ) ){ 34 | S.insert( nxt ); 35 | v.push_back( nxt ); 36 | } 37 | } 38 | } 39 | int x; cin >> x; 40 | cout << ( x <= 9 ? v[ x - 1 ] : -1 ) << endl; 41 | } 42 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2016/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std ; 3 | 4 | int n ; 5 | char c[ 200005 ][ 5 ] ; 6 | int s[ 200005 ] ; 7 | double pp[ 200005 ] ; 8 | double ans[ 200005 ] ; 9 | 10 | int main() { 11 | scanf( "%d" , &n ) ; 12 | n *= 2; 13 | for ( int i = 0 ; i < n ; i ++ ) { 14 | scanf( "%s%d" , c[ i ] , &s[ i ] ) ; 15 | } 16 | int in = 0 ; 17 | for ( int i = 0 ; i < n ; i ++ ) { 18 | if ( c[ i ][ 0 ] == '+' ) { 19 | in ++ ; 20 | } else { 21 | pp[ i ] = (double)1 / in ; 22 | in -- ; 23 | } 24 | } 25 | double p = 0 ; 26 | for ( int i = n - 1 ; i >= 0 ; i -- ) { 27 | if ( c[ i ][ 0 ] == '+' ) { 28 | ans[ i ] = p - s[ i ] ; 29 | } else { 30 | p = p * ( 1 - pp[ i ] ) + pp[ i ] * s[ i ] ; 31 | //printf( "p = %.5f\n" , p ) ; 32 | } 33 | } 34 | for ( int i = 0 ; i < n ; i ++ ) { 35 | if ( c[ i ][ 0 ] == '+' ) { 36 | printf( "%.10f\n" , ans[ i ] ) ; 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /codebook/flow/SW-mincut.cpp: -------------------------------------------------------------------------------- 1 | // global min cut 2 | struct SW{ // O(V^3) 3 | static const int MXN = 514; 4 | int n,vst[MXN],del[MXN]; 5 | int edge[MXN][MXN],wei[MXN]; 6 | void init(int _n){ 7 | n = _n; FZ(edge); FZ(del); 8 | } 9 | void addEdge(int u, int v, int w){ 10 | edge[u][v] += w; edge[v][u] += w; 11 | } 12 | void search(int &s, int &t){ 13 | FZ(vst); FZ(wei); 14 | s = t = -1; 15 | while (true){ 16 | int mx=-1, cur=0; 17 | for (int i=0; i 3 | using namespace std; 4 | typedef long long LL; 5 | string s; 6 | bool okay( string ss ){ 7 | string ts = s; 8 | int slen = ss.length(); 9 | while( ts.length() > 0 ){ 10 | bool good = false; 11 | int tlen = ts.length(); 12 | for( int i = 0 ; i <= tlen - slen ; i ++ ) 13 | if( ts.substr( i , slen ) == ss ){ 14 | ts = ts.substr( 0 , i ) + ts.substr( i + slen , tlen ); 15 | good = true; 16 | break; 17 | } 18 | if( not good ) 19 | return false; 20 | } 21 | return true; 22 | } 23 | int main(){ 24 | cin >> s; 25 | int len = s.length(); 26 | string ans = s; 27 | for( int i = 0 ; i < len ; i ++ ) 28 | for( int j = i ; j < len ; j ++ ){ 29 | string tmp = s.substr( i , j - i + 1 ); 30 | if( tmp.length() >= ans.length() ) 31 | continue; 32 | if( okay( tmp ) ) 33 | ans = tmp; 34 | } 35 | cout << ans << endl; 36 | } 37 | -------------------------------------------------------------------------------- /contest/opencup/XV/Tatarstan/b.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | const int mod = 1000000009; 6 | #define N 333 7 | int n , k; 8 | int dp[ N ][ N ][ 2 ]; 9 | int main(){ 10 | cin >> n >> k; 11 | if( k == 0 ) 12 | dp[ 0 ][ 0 ][ 1 ] = 1; 13 | else 14 | dp[ 0 ][ 0 ][ 0 ] = 1; 15 | for( int i = 0 ; i < n ; i ++ ) 16 | for( int j = 0 ; j <= i ; j ++ ) 17 | for( int g = 0 ; g < 2 ; g ++ ){ 18 | if( dp[ i ][ j ][ g ] == 0 ) continue; 19 | dp[ i + 1 ][ j ][ g ] = (dp[ i + 1 ][ j ][ g ] + dp[ i ][ j ][ g ]) % mod; 20 | if( j + 1 <= k ){ 21 | int ng = g; 22 | if( j + 1 == k ) ng = 1; 23 | dp[ i + 1 ][ j + 1 ][ ng ] = (dp[ i + 1 ][ j + 1 ][ ng ] + dp[ i ][ j ][ g ]) % mod; 24 | } 25 | if( j ) 26 | dp[ i + 1 ][ j - 1 ][ g ] = (dp[ i + 1 ][ j - 1 ][ g ] + dp[ i ][ j ][ g ]) % mod; 27 | } 28 | cout << dp[ n ][ 0 ][ 1 ] << endl; 29 | } 30 | -------------------------------------------------------------------------------- /contest/Dhaka2017/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | int n , k; 5 | vector v[ N ]; 6 | void init(){ 7 | cin >> n >> k; 8 | for( int i = 1 ; i <= n ; i ++ ) 9 | v[ i ].clear(); 10 | for( int i = 1 ; i < n ; i ++ ){ 11 | int ui , vi; 12 | cin >> ui >> vi; 13 | v[ ui ].push_back( vi ); 14 | v[ vi ].push_back( ui ); 15 | } 16 | } 17 | int go( int now , int prt ){ 18 | vector vv; 19 | for( int son : v[ now ] ){ 20 | if( son == prt ) continue; 21 | vv.push_back( go( son , now ) ); 22 | } 23 | sort( vv.begin() , vv.end() ); 24 | reverse( vv.begin() , vv.end() ); 25 | int ret = 1; 26 | if( (int)vv.size() >= k ){ 27 | for( int i = 0 ; i < k ; i ++ ) 28 | ret += vv[ i ]; 29 | } 30 | return ret; 31 | } 32 | int cs; 33 | void solve(){ 34 | printf( "Case %d: %d\n" , ++ cs , go( 1 , 1 ) ); 35 | } 36 | int main(){ 37 | int t; scanf( "%d" , &t ); while( t -- ){ 38 | init(); 39 | solve(); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Belarus/b.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 101010 6 | LL n , a[ N ] , sum , ans = -1; 7 | void test( LL ai ){ 8 | if( ai == 0 ) return; 9 | LL tsum = sum; 10 | if( tsum > 0 ){ 11 | LL atmst = tsum / abs( ai ); 12 | tsum -= atmst * abs( ai ); 13 | } 14 | if( tsum < 0 ){ 15 | LL atmst = abs( tsum ) / abs( ai ); 16 | tsum += atmst * abs( ai ); 17 | } 18 | for( LL dd = -5 ; dd <= 5 ; dd ++ ){ 19 | LL cur = tsum + dd * ai; 20 | if( cur >= 0 and cur % 2 == 0 ){ 21 | if( ans == -1 or cur < ans ) 22 | ans = cur; 23 | } 24 | } 25 | } 26 | int main(){ 27 | scanf( "%lld" , &n ); 28 | for( int i = 0 ; i < n ; i ++ ) 29 | scanf( "%lld" , &a[ i ] ); 30 | sum = accumulate( a , a + n , 0LL ); 31 | if( sum >= 0 and sum % 2 == 0 ) 32 | ans = sum; 33 | for( int i = 0 ; i < n ; i ++ ) 34 | test( a[ i ] ); 35 | printf( "%lld\n" , ans ); 36 | } 37 | -------------------------------------------------------------------------------- /codebook/geometry/Points.cpp: -------------------------------------------------------------------------------- 1 | typedef double type; 2 | typedef pair Pt; 3 | typedef pair Line; 4 | typedef pair Circle; 5 | #define X first 6 | #define Y second 7 | #define O first 8 | #define R second 9 | Pt operator+( const Pt& p1 , const Pt& p2 ){ 10 | return { p1.X + p2.X , p1.Y + p2.Y }; 11 | } 12 | Pt operator-( const Pt& p1 , const Pt& p2 ){ 13 | return { p1.X - p2.X , p1.Y - p2.Y }; 14 | } 15 | Pt operator*( const Pt& tp , const type& tk ){ 16 | return { tp.X * tk , tp.Y * tk }; 17 | } 18 | Pt operator/( const Pt& tp , const type& tk ){ 19 | return { tp.X / tk , tp.Y / tk }; 20 | } 21 | type operator*( const Pt& p1 , const Pt& p2 ){ 22 | return p1.X * p2.X + p1.Y * p2.Y; 23 | } 24 | type operator^( const Pt& p1 , const Pt& p2 ){ 25 | return p1.X * p2.Y - p1.Y * p2.X; 26 | } 27 | type norm2( const Pt& tp ){ 28 | return tp * tp; 29 | } 30 | double norm( const Pt& tp ){ 31 | return sqrt( norm2( tp ) ); 32 | } 33 | Pt perp( const Pt& tp ){ 34 | return { tp.Y , -tp.X }; 35 | } 36 | -------------------------------------------------------------------------------- /contest/ASC/ASC32/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 55 4 | int d , r; 5 | int main(){ 6 | #ifdef ONLINE_JUDGE 7 | freopen( "graph.in" , "r" , stdin ); 8 | freopen( "graph.out" , "w" , stdout ); 9 | #endif 10 | cin >> d >> r; 11 | if( r == 1 ){ 12 | if( d == 1 ){ 13 | puts( "YES" ); 14 | puts( "2 1" ); 15 | puts( "1 2" ); 16 | exit(0); 17 | } 18 | if( d == 2 ){ 19 | puts( "YES" ); 20 | puts( "3 2" ); 21 | puts( "1 2" ); 22 | puts( "3 2" ); 23 | exit(0); 24 | } 25 | assert( false ); 26 | } 27 | int nn = r + r; 28 | vector< pair > e; 29 | for( int i = 1 ; i <= r + r ; i ++ ) 30 | e.push_back( { i , i == r + r ? 1 : i + 1 } ); 31 | int res = d - r; 32 | while( res -- ){ 33 | e.push_back( { nn , 1 + nn } ); 34 | nn ++; 35 | } 36 | puts( "YES" ); 37 | cout << nn << " " << e.size() << endl; 38 | for( auto i : e ) 39 | cout << i.first << " " << i.second << endl; 40 | } 41 | -------------------------------------------------------------------------------- /contest/opencup/XV/3Capitals/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | int move( int dir ){ 5 | if( dir == 0 ) puts( "move north" ); 6 | else if( dir == 1 ) puts( "move east" ); 7 | else if( dir == 2 ) puts( "move south" ); 8 | else if( dir == 3 ) puts( "move west" ); 9 | fflush( stdout ); 10 | char buf[ 512 ]; 11 | scanf( "%s" , buf ); 12 | if( buf[ 0 ] == 'w' ) exit(0); 13 | if( buf[ 0 ] == 'f' ) return 1; 14 | if( buf[ 0 ] == 'm' ) return 0; 15 | assert( false ); 16 | return -1; 17 | } 18 | void echo( const char* lazi ){ 19 | printf( "echo %s\n" , lazi ); 20 | fflush( stdout ); 21 | char buf[ 512 ]; 22 | scanf( "%s" , buf ); 23 | } 24 | int cand[]={0,3,2,2,1,1,0,0,3,2}; 25 | int main(){ 26 | for( int i = 0 ; i < 10 ; i ++ ) 27 | if( move( cand[ i ] ) ){ 28 | move( cand[ i ] ^ 2 ); 29 | for( int j = i + 1 ; j + 2 < 10 ; j ++ ) 30 | echo( "lazi" ); 31 | move( cand[ i ] ); 32 | exit(0); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Saratov/b.py: -------------------------------------------------------------------------------- 1 | from fractions import Fraction 2 | n,m,B=list(map(int,input().split())) 3 | a=list(map(int,input().split())) 4 | la=[x for x in a if x <= B] 5 | ra=[x for x in a if x > B] 6 | ans=Fraction(0) 7 | 8 | ls = len(la) 9 | rs = len(ra) 10 | 11 | while rs > 0: 12 | tot = Fraction(sum(ra)) 13 | prob = Fraction(1, n) 14 | for i in range(1, min(m,n-ls+1)+1): 15 | if prob == Fraction(0): 16 | break 17 | ans += tot * prob 18 | prob /= Fraction(n-i) 19 | prob *= Fraction(n-i-ls) 20 | break; 21 | 22 | while ls > 0: 23 | tot = Fraction(sum(la)) 24 | prob = Fraction(1, n) 25 | for i in range(1, min(m,n-ls+2)+1): 26 | if prob == Fraction(0): 27 | break 28 | ans += tot * prob * Fraction(m-i+1) 29 | prob /= Fraction(n-i) 30 | prob *= Fraction(n-i-ls+1) 31 | break 32 | 33 | # for i in range(1, n+1): 34 | # ans /= Fraction(i) 35 | 36 | print(ans.numerator) 37 | print(ans.denominator) 38 | -------------------------------------------------------------------------------- /contest/NEERC/Subregional/Moscow/2017/i.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | #define N 1515 5 | bitset b[ N ]; 6 | int n , k; 7 | int main(){ 8 | scanf( "%d%d" , &n , &k ); 9 | for( int i = 0 ; i < n ; i ++ ) 10 | for( int j = 0 , x ; j < k ; j ++ ){ 11 | scanf( "%d" , &x ); 12 | b[ j ][ i ] = abs(x) & 1; 13 | } 14 | int dim = 0; 15 | for( int i = 0 ; i < n ; i ++ ){ 16 | int p = dim; 17 | while( p < k and !b[ p ][ i ] ) p ++; 18 | if( p == k ) continue; 19 | swap( b[ p ] , b[ dim ] ); 20 | for( int j = 0 ; j < k ; j ++ ){ 21 | if( dim == j ) continue; 22 | if( !b[ j ][ i ] ) continue; 23 | b[ j ] ^= b[ dim ]; 24 | } 25 | dim ++; 26 | } 27 | for( int j = 0 ; j < n ; j ++ ){ 28 | int sum = 0; 29 | for( int i = 0 ; i < k ; i ++ ) 30 | if( b[ i ][ j ] ) 31 | sum = 1 - sum; 32 | if( !sum ){ 33 | puts( "No" ); 34 | exit(0); 35 | } 36 | } 37 | puts( "Yes" ); 38 | } 39 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Eastern/h.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 10000001 6 | int p[ N ]; 7 | LL c[ N ] , d[ N ]; 8 | void build(){ 9 | for( LL i = 2 ; i < N ; i ++ ){ 10 | d[ i ] = d[ i - 1 ]; 11 | if( ( d[ i ] + 1 ) * ( d[ i ] + 1 ) <= i ) d[ i ] ++; 12 | if( !p[ i ] ){ 13 | for( LL j = i ; i * j < N ; j ++ ){ 14 | if( c[ i * j ] == 0 ) 15 | c[ i * j ] = i; 16 | p[ i * j ] = 1; 17 | } 18 | } 19 | } 20 | for( LL i = 2 ; i < N ; i ++ ){ 21 | if( !p[ i ] ) 22 | c[ i ] = max( d[ i ] - 1 , 0LL ); 23 | else 24 | c[ i ] -= 1; 25 | c[ i ] += c[ i - 1 ]; 26 | p[ i ] += p[ i - 1 ]; 27 | } 28 | } 29 | int main(){ 30 | build(); 31 | int t; scanf( "%d" , &t ); while( t -- ){ 32 | int n; scanf( "%d" , &n ); 33 | LL up = c[ n ]; 34 | LL dn = n - 1 - p[ n ]; 35 | LL g = __gcd( up , dn ); 36 | printf( "%lld/%lld\n" , up / g , dn / g ); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Tatarstan/j.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | #define N 101010 5 | typedef long long LL; 6 | int n , m , k , lst[ N ] , a[ N ] , sz[ N ]; 7 | LL ans; 8 | bool ok[ N ]; 9 | int bst; 10 | int main(){ 11 | scanf( "%d%d%d" , &n , &m , &k ); 12 | for( int i = 1 ; i <= n ; i ++ ){ 13 | scanf( "%d" , &a[ i ] ); 14 | lst[ a[ i ] ] = i; 15 | sz[ a[ i ] ] ++; 16 | } 17 | ans = -1; 18 | ok[ 0 ] = true; 19 | for( int i = 1 ; i <= n ; i ++ ){ 20 | if( lst[ a[ i ] ] == i ){ 21 | int cursz = sz[ a[ i ] ]; 22 | for( int j = k ; j >= cursz ; j -- ) 23 | if( ok[ j - cursz ] ){ 24 | ok[ j ] = true; 25 | bst = max( bst , j ); 26 | } 27 | } 28 | if( bst <= k and n - bst <= k ){ 29 | LL tans = (LL)bst * ( i - n ) + (LL)n * n; 30 | //cout << i << " " << tans << endl; 31 | if( ans == -1 or tans < ans ) 32 | ans = tans; 33 | } 34 | } 35 | printf( "%lld\n" , ans ); 36 | } 37 | -------------------------------------------------------------------------------- /contest/Daejeon/2015/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1021 4 | bool p[ N ]; 5 | vector< int > pp; 6 | int main(){ 7 | for( int i = 2 ; i < N ; i ++ ) 8 | if( !p[ i ] ){ 9 | pp.push_back( i ); 10 | for( int j = i + i ; j < N ; j += i ) 11 | p[ j ] = true; 12 | } 13 | int t; scanf( "%d" , &t ); while( t -- ){ 14 | int k; scanf( "%d" , &k ); 15 | bool got = false; 16 | for( size_t i = 0 ; i < pp.size() && !got ; i ++ ) 17 | for( size_t j = i ; j < pp.size() && !got ; j ++ ){ 18 | if( pp[ i ] + pp[ j ] >= k ) break; 19 | int ret = k - pp[ i ] - pp[ j ]; 20 | if( ret < 2 ) continue; 21 | if( p[ ret ] ) continue; 22 | vector< int > ans = { pp[ i ] , pp[ j ] , ret }; 23 | sort( ans.begin() , ans.end() ); 24 | for( size_t u = 0 ; u < ans.size() ; u ++ ) 25 | printf( "%d%c" , ans[ u ] , " \n"[ u + 1 == ans.size() ] ); 26 | got = true; 27 | } 28 | if( !got ) puts( "0" ); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Siberia/4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef double D; 4 | #define N 101010 5 | int n , s[ N ] , x[ N ] , p[ N ]; 6 | double dp[ N ] , pp[ N ] , ss[ N ]; 7 | void init(){ 8 | scanf( "%d" , &n ); 9 | for( int i = 1 ; i <= n ; i ++ ){ 10 | scanf( "%d%d%d" , &s[ i ] , &x[ i ] , &p[ i ] ); 11 | pp[ i ] = 1 + p[ i ] / 100.0; 12 | ss[ i ] = ss[ i - 1 ] + s[ i ] + x[ i ]; 13 | } 14 | } 15 | void solve(){ 16 | for( int i = 1 ; i <= n ; i ++ ){ 17 | dp[ i ] = dp[ i - 1 ] + s[ i ] + x[ i ]; 18 | double penalty = 1 , ff = s[ i ]; 19 | for( int j = i - 1 ; j >= 1 ; j -- ){ 20 | penalty *= pp[ j ]; 21 | ff += penalty * s[ j ]; 22 | if( ff > ss[ i ] ) break; 23 | dp[ i ] = min( dp[ i ] , dp[ j - 1 ] + x[ i ] + ff ); 24 | } 25 | } 26 | printf( "%.12f\n" , dp[ n ] ); 27 | } 28 | int main(){ 29 | #ifndef LOCAL 30 | freopen( "input.txt" , "r" , stdin ); 31 | freopen( "output.txt" , "w" , stdout ); 32 | #endif 33 | init(); 34 | solve(); 35 | } 36 | -------------------------------------------------------------------------------- /contest/opencup/XV/Karelia/f2.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | vector s; 6 | string to_s( int x ){ 7 | char buf[ 32 ] = {}; 8 | sprintf( buf , "%d" , x ); 9 | string ret = ""; 10 | int len = strlen( buf ); 11 | for( int i = 0 ; i < len ; i ++ ) 12 | ret += buf[ i ]; 13 | return ret; 14 | } 15 | int main(){ 16 | s.push_back( "2" ); 17 | for( int i = 1 ; i < 30 ; i ++ ){ 18 | string now = ""; 19 | int len = s[ i - 1 ].length(); 20 | for( int bl = 0 , br = 0 ; bl < len ; bl = br ){ 21 | while( br < len and s[ i - 1 ][ bl ] == s[ i - 1 ][ br ] ) br ++; 22 | now += to_s( br - bl ); 23 | now += s[ i - 1 ][ bl ]; 24 | } 25 | s.push_back( now ); 26 | //if (i % 3 == 0) 27 | //printf( "%2d %s\n" , i , s[ i ].substr( 0 , 80 ).c_str() ); 28 | //printf( "%2d %90s\n" , i , s[ i ].substr( max( 0 , (int)s[ i ].length() - 80 ) , 80 ).c_str() ); 29 | printf( "%d\n" , (int)s[ i ].length() ); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /contest/opencup/XVI/SPb/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1111 4 | typedef long long LL; 5 | typedef pair PII; 6 | LL n , x[ N ] , y[ N ]; 7 | void init(){ 8 | cin >> n; 9 | for( int i = 0 ; i < n ; i ++ ){ 10 | cin >> x[ i ] >> y[ i ]; 11 | } 12 | } 13 | LL d[ N ]; 14 | PII nor(LL a, LL b) { 15 | if ( b < 0 ) { 16 | a = -a; 17 | b = -b; 18 | } 19 | LL g = __gcd(abs(a), b); 20 | a /= g; 21 | b /= g; 22 | return PII{a, b}; 23 | } 24 | void solve(){ 25 | 26 | for ( int i = 0 ; i < n ; i ++ ) 27 | d[ i ] = x[ i ] * x[ i ] + y[ i ] * y[ i ]; 28 | 29 | set< PII > ans; 30 | for ( int i = 0 ; i < n ; i ++ ) 31 | for ( int j = 0 ; j < i ; j ++ ) { 32 | LL dd = d[ i ] - d[ j ]; 33 | LL dx = x[ i ] - x[ j ]; 34 | if ( dx != 0 ) { 35 | ans.insert(nor(dd, dx)); 36 | } else if ( dd == 0 ) { 37 | cout << 0 << endl; 38 | } 39 | } 40 | cout << ans.size() + 1 << endl; 41 | } 42 | int main(){ 43 | init(); 44 | solve(); 45 | } 46 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Eastern/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 101010 4 | struct Nd{ 5 | Nd *t[ 2 ]; 6 | int cc; 7 | Nd(){ 8 | t[ 0 ] = t[ 1 ] = NULL; 9 | cc = 0; 10 | } 11 | }; 12 | int n , m , a; 13 | char c[ N ]; 14 | Nd* root; 15 | int Cnt( Nd* now ){ 16 | return now ? now->cc : 0; 17 | } 18 | void query( Nd* now , int bt ){ 19 | if( !now or bt >= m ) return; 20 | if( c[ bt ] == '1' ){ 21 | a += Cnt( now->t[ 1 ] ); 22 | query( now->t[ 0 ] , bt + 1 ); 23 | }else{ 24 | query( now->t[ 1 ] , bt + 1 ); 25 | } 26 | } 27 | void add( Nd* now , int bt ){ 28 | now->cc ++; 29 | if( bt == m ) return; 30 | int v = c[ bt ] - '0'; 31 | if( !now->t[ v ] ) now->t[ v ] = new Nd(); 32 | add( now->t[ v ] , bt + 1 ); 33 | } 34 | int main(){ 35 | root = new Nd(); 36 | scanf( "%d%d" , &n , &m ); 37 | while( n -- ){ 38 | scanf( "%s" , c ); 39 | a = 0; 40 | query( root , 0 ); 41 | add( root , 0 ); 42 | printf( "%d\n" , a ); 43 | fflush( stdout ); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /contest/opencup/XVII/Europe/k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[ 330005 ] ; 5 | int l ; 6 | vector< int > ans ; 7 | 8 | void go( int x ) { 9 | if ( s[ x ] == '1' ) s[ x ] = '0' ; 10 | else s[ x ] = '1' ; 11 | if ( s[ x + 1 ] == '1' ) s[ x + 1 ] = '0' ; 12 | else s[ x + 1 ] = '1' ; 13 | ans.push_back( x ) ; 14 | } 15 | 16 | int main() { 17 | scanf( "%s" , s ) ; 18 | l = strlen( s ) ; 19 | 20 | if ( s[ 0 ] == s[ 1 ] && s[ 1 ] == s[ 2 ] ) go( 1 ) ; 21 | for ( int i = 1 ; i * 3 < l ; i ++ ) { 22 | int j = i * 3 ; 23 | if ( s[ j - 1 ] == s[ j ] && s[ j + 1 ] == s[ j + 2 ] ) 24 | go( j ) ; 25 | else if ( s[ j - 1 ] == s[ j ] && s[ j ] == s[ j + 1 ] ) 26 | go( j + 1 ) ; 27 | else if ( s[ j + 2 ] == s[ j ] && s[ j ] == s[ j + 1 ] ) 28 | go( j + 1 ) ; 29 | } 30 | printf( "%d\n" , (int)ans.size() ) ; 31 | for ( int i = 0 ; i < (int)ans.size() ; i ++ ) { 32 | printf( "%d%c" , ans[ i ] + 1 , " \n"[ i + 1 == (int)ans.size() ] ) ; 33 | } 34 | return 0 ; 35 | } 36 | -------------------------------------------------------------------------------- /codebook/dataStructure/DisjointSet.cpp: -------------------------------------------------------------------------------- 1 | struct DisjointSet{ 2 | // save() is like recursive 3 | // undo() is like return 4 | int n, fa[ N ], sz[ N ]; 5 | vector< pair > h; 6 | vector sp; 7 | void init( int tn ){ 8 | n=tn; 9 | for( int i = 0 ; i < n ; i ++ ){ 10 | fa[ i ]=i; 11 | sz[ i ]=1; 12 | } 13 | sp.clear(); h.clear(); 14 | } 15 | void assign( int *k, int v ){ 16 | h.PB( {k, *k} ); 17 | *k = v; 18 | } 19 | void save(){ sp.PB(SZ(h)); } 20 | void undo(){ 21 | assert(!sp.empty()); 22 | int last=sp.back(); sp.pop_back(); 23 | while( SZ(h)!=last ){ 24 | auto x=h.back(); h.pop_back(); 25 | *x.first = x.second; 26 | } 27 | } 28 | int f( int x ){ 29 | while( fa[ x ] != x ) x = fa[ x ]; 30 | return x; 31 | } 32 | void uni( int x , int y ){ 33 | x = f( x ); y = f( y ); 34 | if( x == y ) return; 35 | if( sz[ x ] < sz[ y ] ) swap( x, y ); 36 | assign( &sz[ x ] , sz[ x ] + sz[ y ] ); 37 | assign( &fa[ y ] , x); 38 | } 39 | }djs; 40 | -------------------------------------------------------------------------------- /contest/ASC/ASC38/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | map< int , int > M; 4 | #define MX 1000001021 5 | void modify( int pos , int dlt ){ 6 | for( int i = pos ; i < MX ; i += ( i & (-i) ) ) 7 | M[ i ] += dlt; 8 | } 9 | int query( int pos ){ 10 | int sum = 0; 11 | for( int i = pos ; i ; i -= ( i & (-i) ) ) 12 | sum += M[ i ]; 13 | return sum; 14 | } 15 | int q , pans; 16 | void solve(){ 17 | scanf( "%d" , &q ); 18 | while( q -- ){ 19 | int cmd; scanf( "%d" , &cmd ); 20 | if( cmd == 1 ){ 21 | int li , ri; 22 | scanf( "%d%d" , &li , &ri ); 23 | li += pans; 24 | ri += pans; 25 | li ++; 26 | ri ++; 27 | modify( li , +1 ); 28 | modify( ri + 1 , -1 ); 29 | }else{ 30 | int xi; 31 | scanf( "%d" , &xi ); 32 | xi ++; 33 | pans = query( xi ); 34 | printf( "%d\n" , pans ); 35 | } 36 | } 37 | } 38 | int main(){ 39 | freopen( "environment.in" , "r" , stdin ); 40 | freopen( "environment.out" , "w" , stdout ); 41 | solve(); 42 | } 43 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Belarus/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 101010 6 | const int mod = 1000000007; 7 | LL ds( LL x ){ 8 | LL ret = 0; 9 | while( x ){ 10 | ret += x % 10; 11 | x /= 10; 12 | } 13 | return ret; 14 | } 15 | LL bf( LL n ){ 16 | LL ret = 0; 17 | for( LL i = 1 ; i < n ; i ++ ){ 18 | ret += abs( ds( i ) - ds( i + 1 ) ); 19 | ret %= mod; 20 | } 21 | return ret; 22 | } 23 | char c[ N ]; 24 | int n; 25 | LL vl[ N ]; 26 | LL ans; 27 | int main(){ 28 | scanf( "%s" , c + 1 ); 29 | n = strlen( c + 1 ); 30 | for( int i = 1 ; i <= n ; i ++ ) 31 | vl[ i ] = (vl[ i - 1 ] * 10 + c[ i ] - '0' ) % mod; 32 | ans = (vl[ n ] + mod - 1) % mod; 33 | { 34 | LL tms = vl[ n - 1 ]; 35 | ans = (ans + tms * 7) % mod; 36 | } 37 | for( int i = n - 2 ; i >= 0 ; i -- ){ 38 | LL tms = vl[ i ]; 39 | ans = (ans + tms * 9) % mod; 40 | } 41 | cout << ans << endl; 42 | //cerr << bf( atol( c + 1 ) ) << endl; 43 | } 44 | -------------------------------------------------------------------------------- /codebook/graph/generalMatching.cpp: -------------------------------------------------------------------------------- 1 | const int N = 514, E = (2e5) * 2; 2 | struct Graph{ 3 | int to[E],bro[E],head[N],e; 4 | int lnk[N],vis[N],stp,n; 5 | void init( int _n ){ 6 | stp = 0; e = 1; n = _n; 7 | for( int i = 1 ; i <= n ; i ++ ) 8 | lnk[i] = vis[i] = 0; 9 | } 10 | void add_edge(int u,int v){ 11 | to[e]=v,bro[e]=head[u],head[u]=e++; 12 | to[e]=u,bro[e]=head[v],head[v]=e++; 13 | } 14 | bool dfs(int x){ 15 | vis[x]=stp; 16 | for(int i=head[x];i;i=bro[i]){ 17 | int v=to[i]; 18 | if(!lnk[v]){ 19 | lnk[x]=v,lnk[v]=x; 20 | return true; 21 | }else if(vis[lnk[v]] 2 | using namespace std; 3 | typedef long long LL; 4 | const int mod = 1000000007; 5 | #define N 2020202 6 | int fac[ N ] , ifac[ N ]; 7 | int mul( LL a , int b ){ 8 | a *= b; 9 | return a >= mod ? a % mod : a; 10 | } 11 | int mpow( int a , int b ){ 12 | if( b == 0 ) return 1; 13 | int ret = mpow( mul( a , a ) , b >> 1 ); 14 | if( b & 1 ) ret = mul( ret , a ); 15 | return ret; 16 | } 17 | inline int C( int a , int b ){ 18 | if( a < b ) return 0; 19 | return mul( fac[ a ] , mul( ifac[ b ] , ifac[ a - b ] ) ); 20 | } 21 | int main(){ 22 | fac[ 0 ] = ifac[ 0 ] = 1; 23 | for( int i = 1 ; i < N ; i ++ ){ 24 | fac[ i ] = mul( fac[ i - 1 ] , i ); 25 | ifac[ i ] = mpow( fac[ i ] , mod - 2 ); 26 | } 27 | int _cs = 0; 28 | int t; cin >> t; while( t -- ){ 29 | int n , m; 30 | cin >> n >> m; 31 | for( int i = 0 , x ; i < n ; i ++ ){ 32 | int s; cin >> s; while( s -- ) cin >> x; 33 | } 34 | printf( "Case #%d: %d\n" , ++ _cs , C( m - 1 , n - 1 ) ); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /contest/Jakarta/2015/l.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1111 4 | typedef long long LL; 5 | int n; 6 | vector< LL > v[ N ]; 7 | LL gg[ N ] , ans; 8 | void init(){ 9 | scanf( "%d" , &n ); 10 | for( int i = 0 ; i < n ; i ++ ) 11 | v[ i ].clear(); 12 | for( int i = 0 ; i < n ; i ++ ){ 13 | int xi; scanf( "%d" , &xi ); 14 | while( xi -- ){ 15 | LL t; scanf( "%lld" , &t ); 16 | v[ i ].push_back( t ); 17 | } 18 | sort( v[ i ].begin() , v[ i ].end() ); 19 | gg[ i ] = 0; 20 | for( size_t j = 1 ; j < v[ i ].size() ; j ++ ) 21 | gg[ i ] = __gcd( gg[ i ] , v[ i ][ j ] - v[ i ][ j - 1 ] ); 22 | } 23 | } 24 | int _cs; 25 | void solve(){ 26 | ans = 0; 27 | LL tsum = 0; 28 | for( int i = 0 ; i < n ; i ++ ){ 29 | ans = __gcd( ans , gg[ i ] ); 30 | tsum += v[ i ][ 0 ]; 31 | } 32 | ans = __gcd( ans , tsum ); 33 | printf( "Case #%d: %lld\n" , ++ _cs , ans ); 34 | } 35 | int main(){ 36 | int _; scanf( "%d" , &_ ); while( _ -- ){ 37 | init(); 38 | solve(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Saratov/d.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | typedef pair ii; 6 | int n; 7 | 8 | vector s; 9 | ll dp[200005]; 10 | 11 | int main() { 12 | while (scanf("%d", &n) == 1) { 13 | s.clear(); 14 | for (int i = 0; i < n; i ++) { 15 | ll x, y; 16 | scanf("%lld%lld", &x, &y); 17 | 18 | while (s.size() && s.back().second <= y) s.pop_back(); 19 | s.push_back(ii(x, y)); 20 | } 21 | n = s.size(); 22 | 23 | priority_queue, greater > pq; 24 | 25 | dp[0] = s[0].first + s[0].second * 2; 26 | 27 | int pt = 0; 28 | for (int i = 1; i < n; i ++) { 29 | pq.push(ii(dp[i - 1] + s[i].second * 2, i - 1)); 30 | 31 | while (pt < i && dp[pt] <= s[i].first) pt ++; 32 | dp[i] = s[i].first + s[pt].second * 2; 33 | 34 | while (!pq.empty() && pq.top().second < pt) pq.pop(); 35 | if (!pq.empty()) dp[i] = min(dp[i], pq.top().first); 36 | } 37 | 38 | printf("%lld\n", dp[n - 1]); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /contest/ASC/ASC34/c.py: -------------------------------------------------------------------------------- 1 | from fractions import Fraction 2 | import sys 3 | fi = open( 'arbitrage.in' , 'r' ) 4 | fo = open( 'arbitrage.out' , 'w' ) 5 | n = int( fi.readline() ) 6 | L = [ [ [0,0] for i in range(n) ] for j in range(n) ] 7 | R = [ [ [0,0] for i in range(n) ] for j in range(n) ] 8 | for i in range(n): 9 | for j in range(n): 10 | x = fi.readline().split(' ') 11 | L[i][j], R[i][j] = Fraction(x[0]), Fraction(x[1]) 12 | for i in range(n): 13 | for j in range(n): 14 | if 1 / L[ j ][ i ] < R[ i ][ j ]: 15 | R[ i ][ j ] = 1 / L[ j ][ i ] 16 | for k in range(n): 17 | for i in range(n): 18 | for j in range(n): 19 | R[i][j] = min( R[i][j] , R[i][k] * R[k][j] ) 20 | if R[i][i] < Fraction(1,1): 21 | fo.write( "Impossible\n" ) 22 | sys.exit( 0 ) 23 | for i in range(n): 24 | fans = "" 25 | for j in range(n): 26 | tmp = str(R[0][j]/R[0][i]) 27 | if not ( '/' in tmp ): tmp += "/1" 28 | fans += tmp + " " 29 | fans += "\n" 30 | fo.write( fans ) 31 | -------------------------------------------------------------------------------- /contest/WorldFinals/2010/geni.py: -------------------------------------------------------------------------------- 1 | 2 | n, m = 8, 8 3 | for x1 in range(n): 4 | for y1 in range(m): 5 | if (x1, y1) == (0, 0): 6 | continue 7 | if (x1, y1) == (0, 1): 8 | continue 9 | for x2 in range(n): 10 | for y2 in range(m): 11 | if (x2, y2) == (0, 0): 12 | continue 13 | if (x2, y2) == (0, 1): 14 | continue 15 | if (x1, y1) == (x2, y2): 16 | continue 17 | for x3 in range(n): 18 | for y3 in range(m): 19 | if (x3, y3) == (0, 0): 20 | continue 21 | if (x3, y3) == (0, 1): 22 | continue 23 | if (x1, y1) == (x3, y3): 24 | continue 25 | if (x2, y2) == (x3, y3): 26 | continue 27 | print(n, m) 28 | print(x1, y1, x2, y2, x3, y3) 29 | -------------------------------------------------------------------------------- /contest/Dhaka2017/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL e , p , k , r; 5 | int cs; 6 | inline LL cal(){ 7 | if( p * k >= e ){ 8 | LL bl = 1 , br = k , ba = k; 9 | while( bl <= br ){ 10 | LL bmid = (bl + br) >> 1; 11 | if( p * bmid >= e ) 12 | ba = bmid , br = bmid - 1; 13 | else 14 | bl = bmid + 1; 15 | } 16 | return ba; 17 | } 18 | if( p * k <= r ) return -1; 19 | LL one_time = p * k - r; 20 | LL nd = (e - p * k) / one_time; 21 | if( e - nd * one_time > p * k ) nd ++; 22 | LL ret = nd * k; 23 | e -= nd * one_time; 24 | assert( p * k >= e ); 25 | LL bl = 1 , br = k , ba = k; 26 | while( bl <= br ){ 27 | LL bmid = (bl + br) >> 1; 28 | if( p * bmid >= e ) 29 | ba = bmid , br = bmid - 1; 30 | else 31 | bl = bmid + 1; 32 | } 33 | return ret + ba; 34 | } 35 | int main(){ 36 | int t; scanf( "%d" , &t ); while( t -- ){ 37 | scanf( "%lld%lld%lld%lld" , &e , &p , &k , &r ); 38 | printf( "Case %d: %lld\n" , ++ cs , cal() ); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /contest/Jakarta/2016/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll; 5 | 6 | ll f(ll a, ll b , ll n) { 7 | if (n >= a && n >= b) { 8 | if (b <= n - a - 1) return (b + 1) * (a + 1); 9 | else return (n - a) * (a + 1) + (a + n - b + 2) * (a + b - n + 1) / 2; 10 | } else if (n >= a && n < b) { 11 | return (n - a) * (a + 1) + (a + 2) * (a + 1) / 2; 12 | } else if (n < a && n >= b) { 13 | return (n + n - b + 2) * (b + 1) / 2; 14 | } else { 15 | return (n + 2) * (n + 1) / 2; 16 | } 17 | } 18 | 19 | ll go() { 20 | ll al, ar, bl, br, cl, cr, nn; 21 | scanf("%lld%lld%lld%lld%lld%lld%lld", &al, &ar, &bl, &br, &cl, &cr, &nn); 22 | ll a = ar - al; 23 | ll b = br - bl; 24 | ll c = cr - cl; 25 | ll n = nn - al - bl - cl; 26 | 27 | if (n < 0) return 0; 28 | if (n <= c) return f(a, b, n); 29 | else return f(a, b, n) - f(a, b, n - c - 1); 30 | } 31 | 32 | int main() { 33 | int n; 34 | scanf("%d", &n); 35 | for (int i = 1; i <= n; i ++) { 36 | printf("Case #%d: %lld\n", i, go() % 1000000007); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2015/a.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N (1 << 20) 6 | LL n , q , sr , cr , sc , cc; 7 | bool tr[ N ] , tc[ N ]; 8 | int main(){ 9 | freopen( "adjustment.in" , "r" , stdin ); 10 | freopen( "adjustment.out" , "w" , stdout ); 11 | cin >> n >> q; 12 | while( q -- ){ 13 | char c[ 9 ]; int id; 14 | scanf( "%s%d" , c , &id ); 15 | if( c[ 0 ] == 'R' ){ 16 | if( tr[ id ] ){ 17 | puts( "0" ); 18 | continue; 19 | } 20 | tr[ id ] = true; 21 | LL ans = (1LL + n) * n / 2 + n * id; 22 | ans -= sc; 23 | ans -= cc * id; 24 | printf( "%lld\n" , ans ); 25 | sr += id; 26 | cr ++; 27 | }else{ 28 | if( tc[ id ] ){ 29 | puts( "0" ); 30 | continue; 31 | } 32 | tc[ id ] = true; 33 | LL ans = (1LL + n) * n / 2 + n * id; 34 | ans -= sr; 35 | ans -= cr * id; 36 | printf( "%lld\n" , ans ); 37 | sc += id; 38 | cc ++; 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /contest/opencup/XVII/MoscowWorkshop/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 10000010 4 | typedef unsigned int uint; 5 | uint n , q , x0 , x1 , a , b , c; 6 | uint next(){ 7 | uint t = x0 * a + x1 * b + c; 8 | x0 = x1; 9 | x1 = t; 10 | return x0 >> 2; 11 | } 12 | uint g[ N ]; 13 | uint mn , idx; 14 | uint ans; 15 | void refind(){ 16 | idx = 0; 17 | for( uint i = 1 ; i < n ; i ++ ) 18 | if( g[ i ] < g[ idx ] ) 19 | idx = i; 20 | mn = g[ idx ]; 21 | } 22 | int main(){ 23 | cin >> n >> q >> x0 >> x1 >> a >> b >> c; 24 | for( uint i = 0 ; i < n ; i ++ ) 25 | g[ i ] = ( (uint)1 << 31 ) - 1; 26 | mn = g[ 0 ]; idx = 0; 27 | uint bs = 1; 28 | uint mul = 10099; 29 | for( uint _ = 0 ; _ < q ; _ ++ ){ 30 | bs *= mul; 31 | uint i = next() % n; 32 | uint x = next(); 33 | if( i == idx and x > g[ i ] ){ 34 | g[ i ] = x; 35 | refind(); 36 | }else{ 37 | if( x < mn ) 38 | mn = x , idx = i; 39 | g[ i ] = x; 40 | } 41 | ans += mn * bs; 42 | } 43 | cout << ans << endl; 44 | } 45 | -------------------------------------------------------------------------------- /contest/Dhaka2015/e.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | //#pragma GCC optimize("O3") 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 20000001 6 | LL sum[ N + N ] , mp[ N + N ]; 7 | bool np[ N + N ] , got[ N + N ]; 8 | void build(){ 9 | got[ 1 ] = true; 10 | sum[ 1 ] = 1; 11 | for( LL i = 2 ; i < N ; i ++ ) if( !np[ i ] ){ 12 | sum[ i ] = i + 1; 13 | got[ i ] = true; 14 | for( LL j = i + i ; j < N ; j += i ){ 15 | mp[ j ] = i; 16 | np[ j ] = true; 17 | } 18 | } 19 | for( int i = 2 ; i < N ; i ++ ) 20 | if( !np[ i ] ) 21 | sum[ i ] = i + 1; 22 | else{ 23 | LL pp = mp[ i ] , tmp = i , p2 = mp[ i ]; 24 | while( tmp % pp == 0 ){ 25 | tmp /= pp; 26 | p2 *= pp; 27 | } 28 | sum[ i ] = ( p2 - 1 ) * sum[ tmp ]; 29 | sum[ i ] /= ( pp - 1 ); 30 | } 31 | for( int i = 3 ; i < N ; i ++ ) 32 | sum[ i ] += sum[ i - 1 ]; 33 | } 34 | int main(){ 35 | build(); 36 | int n; 37 | //puts( "done" ); 38 | while( scanf( "%d" , &n ) == 1 && n ) 39 | printf( "%lld\n" , sum[ n ] ); 40 | } 41 | -------------------------------------------------------------------------------- /contest/opencup/XV/CEurope/c.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N 111 6 | #define M 16 7 | const LL inf = 10000000000000000LL; 8 | int n , m , di , v[ M ]; 9 | LL dp[ 1 << M ] , dp2[ 1 << M ]; 10 | void upd(){ 11 | for( int i = 0 ; i < (1 << m) ; i ++ ) 12 | dp2[ i ] = dp[ i ]; 13 | for( int i = 0 ; i < (1 << m) ; i ++ ) 14 | for( int j = 0 ; j < m ; j ++ ){ 15 | if( (i >>j) & 1 ) continue; 16 | dp2[ i | (1 << j) ] = min( dp2[ i | (1 << j) ] , 17 | dp2[ i ] + v[ j ] ); 18 | } 19 | for( int i = 0 ; i < (1 << m) ; i ++ ) 20 | dp[ i ] = min( dp[ i ] , 21 | dp2[ i ] + di ); 22 | } 23 | int main(){ 24 | scanf( "%d%d" , &n , &m ); 25 | for( int i = 1 ; i < (1 << m) ; i ++ ) 26 | dp[ i ] = inf; 27 | for( int i = 1 ; i <= n ; i ++ ){ 28 | scanf( "%d" , &di ); 29 | for( int j = 0 ; j < m ; j ++ ) 30 | scanf( "%d" , &v[ j ] ); 31 | upd(); 32 | } 33 | printf( "%lld\n" , dp[ (1 << m) - 1 ] ); 34 | } 35 | -------------------------------------------------------------------------------- /codebook/math/Square_Matrix_pinv.cpp: -------------------------------------------------------------------------------- 1 | Mat pinv( Mat m ){ 2 | Mat res = I; 3 | FZ( used ); 4 | for( int i = 0 ; i < W ; i ++ ){ 5 | int piv = -1; 6 | for( int j = 0 ; j < W ; j ++ ){ 7 | if( used[ j ] ) continue; 8 | if( abs( m.v[ j ][ i ] ) > EPS ){ 9 | piv = j; 10 | break; 11 | } 12 | } 13 | if( piv == -1 ) continue; 14 | used[ i ] = true; 15 | swap( m.v[ piv ], m.v[ i ] ); 16 | swap( res.v[ piv ], res.v[ i ] ); 17 | LD rat = m.v[ i ][ i ]; 18 | for( int j = 0 ; j < W ; j ++ ){ 19 | m.v[ i ][ j ] /= rat; 20 | res.v[ i ][ j ] /= rat; 21 | } 22 | for( int j = 0 ; j < W ; j ++ ){ 23 | if( j == i ) continue; 24 | rat = m.v[ j ][ i ]; 25 | for( int k = 0 ; k < W ; k ++ ){ 26 | m.v[ j ][ k ] -= rat * m.v[ i ][ k ]; 27 | res.v[ j ][ k ] -= rat * res.v[ i ][ k ]; 28 | } 29 | } 30 | } 31 | for( int i = 0 ; i < W ; i ++ ){ 32 | if( used[ i ] ) continue; 33 | for( int j = 0 ; j < W ; j ++ ) 34 | res.v[ i ][ j ] = 0; 35 | } 36 | return res; 37 | } 38 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Peterhof/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long double LD; 5 | #define N 201010 6 | LD cans; 7 | int n , d[ N ]; 8 | inline LD sqr( LD x ){ 9 | return x * x; 10 | } 11 | inline LD cal( LD s ){ 12 | LD ret = 0; 13 | for( int i = 0 ; i < n ; i ++ ) 14 | ret += sqrtl( 1. + sqr( s + i - d[ i ] ) ); 15 | return ret; 16 | } 17 | int main(){ 18 | scanf( "%d" , &n ); 19 | //n = 100000; 20 | n <<= 1; 21 | for( int i = 0 ; i < n ; i ++ ) 22 | scanf( "%d" , &d[ i ] ); 23 | //d[ i ] = (long long)rand() * rand() % 2000000; 24 | sort( d , d + n ); 25 | LD bl = -3e6 , br = 3e6; 26 | cans = 1e20; 27 | for( int i = 0 ; i < 150 ; i ++ ){ 28 | LD mid1 = (bl + bl + br) / 3; 29 | LD mid2 = (bl + br + br) / 3; 30 | LD lc = cal( mid1 ); 31 | LD rc = cal( mid2 ); 32 | if( lc < rc ){ 33 | cans = min( cans , lc ); 34 | br = mid2; 35 | }else{ 36 | cans = min( cans , rc ); 37 | bl = mid1; 38 | } 39 | } 40 | printf( "%.12f\n" , (double)cans ); 41 | } 42 | -------------------------------------------------------------------------------- /contest/ASC/ASC31/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 55 4 | int n , m , s; 5 | double ans; 6 | void init(){ 7 | cin >> n >> m >> s; 8 | //n = 50; 9 | //m = 20; 10 | //s = 100; 11 | } 12 | double dp[ N ] , ndp[ N ] , win[ N ]; 13 | int p[ N ] , w[ N ]; 14 | void cal(){ 15 | dp[ n + 1 ] = 1.; 16 | for( int i = 0 ; i < 1e5 ; i ++ ){ 17 | for( int j = 1 ; j <= n ; j ++ ) 18 | for( int k = 0 ; k < m ; k ++ ){ 19 | double bst = win[ k ] * dp[ min( n + 1 , j + w[ k ] ) ] + 20 | ( 1 - win[ k ] ) * dp[ j - 1 ]; 21 | dp[ j ] = max( dp[ j ] , bst ); 22 | } 23 | } 24 | ans = dp[ n ]; 25 | } 26 | void solve(){ 27 | for( int i = 0 ; i < m ; i ++ ){ 28 | cin >> p[ i ] >> w[ i ]; 29 | //p[ i ] = 50; 30 | //w[ i ] = 2; 31 | win[ i ] = (double)p[ i ] / s; 32 | } 33 | cal(); 34 | printf( "%.12f\n" , ans ); 35 | } 36 | int main(){ 37 | #ifdef ONLINE_JUDGE 38 | freopen( "casino.in" , "r" , stdin ); 39 | freopen( "casino.out" , "w" , stdout ); 40 | #endif 41 | init(); 42 | solve(); 43 | } 44 | -------------------------------------------------------------------------------- /contest/Hatyai/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 100000 4 | bool p[ N ]; 5 | vector pset; 6 | void build(){ 7 | for( int i = 2 ; i < N ; i ++ ) if( !p[ i ] ){ 8 | pset.push_back( i ); 9 | for( int j = i ; j < N ; j += i ) 10 | p[ j ] = true; 11 | } 12 | reverse( pset.begin() , pset.end() ); 13 | } 14 | char c[ 1021 ] , tmp[ 1021 ]; 15 | int main(){ 16 | build(); 17 | while( scanf( "%s" , c ) == 1 ){ 18 | if( strlen( c ) == 1 and c[ 0 ] == '0' ) break; 19 | int len = strlen( c ); 20 | for( auto i : pset ){ 21 | sprintf( tmp , "%d" , i ); 22 | int tlen = strlen( tmp ); 23 | bool found = false; 24 | for( int j = 0 ; j <= len - tlen and !found ; j ++ ){ 25 | bool eq = true; 26 | for( int k = 0 ; k < tlen ; k ++ ) 27 | if( tmp[ k ] != c[ j + k ] ){ 28 | eq = false; 29 | break; 30 | } 31 | if( eq ) found = true; 32 | } 33 | if( found ){ 34 | printf( "%d\n" , i ); 35 | break; 36 | } 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Eurasia/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | LL read_int(){ 5 | char cc[ 100 ]; 6 | scanf( "%s" , cc ); 7 | int dd = 0; 8 | int len = strlen( cc ); 9 | bool dot = false; 10 | LL ret = 0; 11 | for( int i = 0 ; i < len ; i ++ ){ 12 | if( cc[ i ] == '.' ){ 13 | dot = true; 14 | continue; 15 | } 16 | ret = ret * 10 + cc[ i ] - '0'; 17 | if( dot ) dd ++; 18 | } 19 | while( dd < 5 ){ 20 | ret = ret * 10; 21 | dd ++; 22 | } 23 | return ret; 24 | } 25 | int main(){ 26 | freopen( "input.txt" , "r" , stdin ); 27 | freopen( "output.txt" , "w" , stdout ); 28 | int q; cin >> q; while( q -- ){ 29 | LL w = read_int(); 30 | LL d = read_int(); 31 | LL l = read_int(); 32 | LL bw = d * l; 33 | LL bd = w * l; 34 | LL bl = w * d; 35 | LL sb = bw + bd + bl; 36 | if( sb * 100000LL < bw * w and 37 | sb * 100000LL < bd * d and 38 | sb * 100000LL < bl * l ) 39 | cout << "YES" << endl; 40 | else 41 | cout << "NO" << endl; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /contest/PetrSummerCampJapanese/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 50505 4 | int n , c[ N ] , cs; 5 | void init(){ 6 | for( int i = 0 ; i < n ; i ++ ) 7 | scanf( "%d" , &c[ i ] ); 8 | } 9 | int dp[ N ]; 10 | inline int greedy( int x ){ 11 | int cnt = 0; 12 | for( int i = n - 1 ; i >= 0 ; i -- ){ 13 | if( x < c[ i ] ) continue; 14 | cnt += ( x / c[ i ] ); 15 | x %= c[ i ]; 16 | } 17 | return cnt; 18 | } 19 | inline bool okay(){ 20 | for( int i = 1 ; i < N ; i ++ ){ 21 | dp[ i ] = i; 22 | for( int j = 0 ; j < n ; j ++ ){ 23 | if( c[ j ] > i ) break; 24 | dp[ i ] = min( dp[ i ] , dp[ i - c[ j ] ] + 1 ); 25 | } 26 | if( dp[ i ] < greedy( i ) ) 27 | return false; 28 | } 29 | return true; 30 | } 31 | void solve(){ 32 | printf( "Case #%d: " , ++ cs ); 33 | if( c[ 0 ] != 1 ) puts( "Cannot pay some amount" ); 34 | else if( !okay() ) puts( "Cannot use greedy algorithm" ); 35 | else puts( "OK" ); 36 | } 37 | int main(){ 38 | while( scanf( "%d" , &n ) == 1 && n ){ 39 | init(); 40 | solve(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Eastern/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 5e5+10; 6 | 7 | int n; 8 | char s[N]; 9 | set ls, rs; 10 | 11 | int main() { 12 | scanf("%s", s+1); 13 | n = strlen(s+1); 14 | for (int i = 1; i <= n; ++i) { 15 | if (s[i] == '(') ls.insert(i); 16 | else rs.insert(i); 17 | } 18 | int q; 19 | scanf("%d", &q); 20 | auto prv = [&] (int x, set& st) { 21 | auto it = st.upper_bound(x); 22 | if (it == st.begin()) return -1; 23 | it--; 24 | return *it; 25 | }; 26 | while (q--) { 27 | int L, R; 28 | scanf("%d%d", &L, &R); 29 | int ans = 0; 30 | do { 31 | int tR = prv(R, rs); 32 | if (tR == -1 or tR < L) break; 33 | 34 | int tL = prv(tR, ls); 35 | 36 | if (tL == -1 or tL < L) break; 37 | 38 | auto it = rs.lower_bound(tL); 39 | if (it == rs.end()) break; 40 | tR = *it; 41 | if (tR > R) break; 42 | 43 | ls.erase(tL); 44 | rs.erase(tR); 45 | ans++; 46 | } while(ls.size()); 47 | printf("%d\n", ans*2); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Korea/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N (1 << 20) 6 | char c[ N ]; 7 | vector pos[ 26 ]; 8 | int ans; 9 | int main(){ 10 | scanf( "%s" , c ); 11 | for( int i = 0 ; c[ i ] ; ){ 12 | int cc = c[ i ] - 'a'; 13 | if( pos[ cc ].empty() ){ 14 | ans ++; 15 | pos[ cc ].push_back( i ); 16 | i ++; 17 | }else{ 18 | int si = i; 19 | int pre = -1; 20 | while( c[ i ] ){ 21 | int bl = 0 , br = (int)pos[ c[ i ] - 'a' ].size() - 1 , ba = -1; 22 | while( bl <= br ){ 23 | int bmid = (bl + br) >> 1; 24 | if( pos[ c[ i ] - 'a' ][ bmid ] > pre ) 25 | ba = bmid , br = bmid - 1; 26 | else 27 | bl = bmid + 1; 28 | } 29 | if( ba == -1 ) break; 30 | pre = pos[ c[ i ] - 'a' ][ ba ]; 31 | i ++; 32 | } 33 | for( int j = si ; j < i ; j ++ ) 34 | pos[ c[ j ] - 'a' ].push_back( j ); 35 | ans ++; 36 | } 37 | } 38 | printf( "%d\n" , ans ); 39 | } 40 | -------------------------------------------------------------------------------- /contest/ASC/ASC30/f.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | #define N 1111 5 | int sg[ N ]; 6 | int main(){ 7 | #ifdef ONLINE_JUDGE 8 | freopen( "nim.in" , "r" , stdin ); 9 | freopen( "nim.out" , "w" , stdout ); 10 | #endif 11 | //sg[ 0 ] = 0; 12 | //for( int i = 1 ; i < N ; i ++ ){ 13 | //int til = 1; 14 | //while( til * til <= i ) til ++; 15 | //til --; 16 | //set S; 17 | //for( int j = 1 ; j <= til ; j ++ ) 18 | //S.insert( sg[ i - j ] ); 19 | //while( S.count( sg[ i ] ) ) 20 | //sg[ i ] ++; 21 | //} 22 | ////for( int i = 0 ; i < 100 ; i ++ ){ 23 | //printf( "%4d " , sg[ i ] ); 24 | //if( i % 10 == 9 ) puts( "" ); 25 | //} 26 | //for( int i = 0 ; i < N ; i ++ ) 27 | //if( !sg[ i ] ) 28 | //printf( "%d\n" , i ); 29 | LL n; cin >> n; 30 | LL gt = 0 , add = 2 , res = 1; 31 | while( gt < n ){ 32 | gt += add; res --; 33 | if( res == 0 ){ 34 | add ++; res = 2; 35 | if( add == ( add & (-add) ) ) 36 | res --; 37 | } 38 | } 39 | puts( gt == n ? "LOSE" : "WIN" ); 40 | } 41 | -------------------------------------------------------------------------------- /codebook/math/FFT.cpp: -------------------------------------------------------------------------------- 1 | // const int MAXN = 262144; 2 | // (must be 2^k) 3 | // before any usage, run pre_fft() first 4 | typedef long double ld; 5 | typedef complex cplx; 6 | const ld PI = acosl(-1); 7 | const cplx I(0, 1); 8 | cplx omega[MAXN+1]; 9 | void pre_fft(){ 10 | for(int i=0; i<=MAXN; i++) 11 | omega[i] = exp(i * 2 * PI / MAXN * I); 12 | } 13 | // n must be 2^k 14 | void fft(int n, cplx a[], bool inv=false){ 15 | int basic = MAXN / n; 16 | int theta = basic; 17 | for (int m = n; m >= 2; m >>= 1) { 18 | int mh = m >> 1; 19 | for (int i = 0; i < mh; i++) { 20 | cplx w = omega[inv ? MAXN-(i*theta%MAXN) 21 | : i*theta%MAXN]; 22 | for (int j = i; j < n; j += m) { 23 | int k = j + mh; 24 | cplx x = a[j] - a[k]; 25 | a[j] += a[k]; 26 | a[k] = w * x; 27 | } 28 | } 29 | theta = (theta * 2) % MAXN; 30 | } 31 | int i = 0; 32 | for (int j = 1; j < n - 1; j++) { 33 | for (int k = n >> 1; k > (i ^= k); k >>= 1); 34 | if (j < i) swap(a[i], a[j]); 35 | } 36 | if(inv) for (i = 0; i < n; i++) a[i] /= n; 37 | } 38 | -------------------------------------------------------------------------------- /contest/CCPC2017/d.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long ll; 5 | 6 | int n, m, r; 7 | int c[100005]; 8 | int mx[100005]; 9 | int mc[100005]; 10 | 11 | void init() { 12 | scanf("%d%d%d", &n, &m, &r); 13 | 14 | for (int i = 1; i <= n; i ++) { 15 | scanf("%d", &c[i]); 16 | mx[i] = min(i, r); 17 | mc[i] = 0; 18 | } 19 | for (int i = 0; i < m; i ++) { 20 | int x, y; 21 | scanf("%d%d", &x, &y); 22 | mx[x] = min(mx[x], y); 23 | mx[y] = min(mx[y], x); 24 | } 25 | for (int i = 1; i <= n; i ++) if (i != r) { 26 | mc[mx[i]] ++; 27 | } 28 | } 29 | 30 | void solve() { 31 | c[1] --; 32 | ll ans = 0, cnt = 0; 33 | for (int i = 1; i <= n; i ++) ans = ans + c[i]; 34 | for (int i = 1; i <= n; i ++) { 35 | cnt += c[i]; 36 | ll ok = min(cnt, (ll)mc[i]); 37 | ans -= ok; 38 | cnt -= ok; 39 | } 40 | printf("%lld\n", ans); 41 | } 42 | 43 | int main(){ 44 | int T; scanf("%d", &T); 45 | for (int tc = 1; tc <= T; tc ++) { 46 | init(); 47 | printf("Case #%d: ", tc); 48 | solve(); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/Baltic/i.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N (1 << 20) 6 | int c[ N ]; 7 | bool sub( char* aa , char* bb ){ 8 | for( int i = 0 ; i < N ; i ++ ) 9 | c[ i ] = 0; 10 | int lena = strlen( aa ); 11 | int lenb = strlen( bb ); 12 | for( int i = 0 ; i < lena ; i ++ ) 13 | c[ lena - i - 1 ] += aa[ i ] - '0'; 14 | for( int i = 0 ; i < lenb ; i ++ ) 15 | c[ lenb - i - 1 ] -= bb[ i ] - '0'; 16 | for( int i = 0 ; i + 1 < N ; i ++ ) 17 | if( c[ i ] < 0 ){ 18 | c[ i ] += 10; 19 | c[ i + 1 ] --; 20 | } 21 | if( c[ N - 1 ] < 0 ) return false; 22 | int til = N - 1; 23 | while( til > 0 and c[ til ] == 0 ) til --; 24 | for( int i = til ; i >= 0 ; i -- ) 25 | printf( "%d" , c[ i ] ); 26 | puts( "" ); 27 | return true; 28 | } 29 | char a[ N ] , b[ N ]; 30 | int main(){ 31 | scanf( "%s" , a ); 32 | scanf( "%s" , b ); 33 | if( !strcmp( a , b ) ) 34 | puts( "0" ); 35 | else{ 36 | if( sub( a , b ) ) 37 | return 0; 38 | putchar( '-' ); 39 | sub( b , a ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /contest/opencup/XV/Europe/k.cpp: -------------------------------------------------------------------------------- 1 | 2 | #pragma GCC optimize("O3") 3 | #include 4 | using namespace std; 5 | typedef long long LL; 6 | typedef pair pii; 7 | 8 | pii pos[11]; 9 | set nums; 10 | 11 | inline bool ok(int x, int d) { 12 | return pos[x].first <= pos[d].first and pos[x].second <= pos[d].second; 13 | } 14 | 15 | void dfs(int cur, int n, int lst) { 16 | nums.insert(cur); 17 | if (n == 3) { 18 | return; 19 | } 20 | for (int d = 0; d <= 9; ++d) { 21 | if (lst == -1 or ok(lst, d)) { 22 | dfs(cur*10 + d, n+1, d); 23 | } 24 | } 25 | } 26 | 27 | void predo() { 28 | for (int i = 0; i < 3; ++i) for (int j = 0; j < 3; ++j) 29 | pos[i*3+j+1] = {i, j}; 30 | pos[0] = {3, 1}; 31 | dfs(0, 0, -1); 32 | //for (int x: nums) cout << x << endl; 33 | } 34 | 35 | int main(){ 36 | predo(); 37 | int tc; scanf("%d", &tc); 38 | while (tc--) { 39 | int k; scanf("%d", &k); 40 | auto it = nums.upper_bound(k); 41 | int r = *it; 42 | it--; 43 | int l = *it; 44 | int ans = l; 45 | if (abs(k-r) < abs(k-l)) ans = r; 46 | printf("%d\n", ans); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /contest/opencup/XVII/SPb/i.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef long long ll ; 5 | typedef pair< int , int > ii ; 6 | 7 | ii gcd(int a, int b){ 8 | if(b == 0) return {1, 0}; 9 | ii q = gcd(b, a % b); 10 | return {q.second, q.first - q.second * (a / b)}; 11 | } 12 | 13 | int n ; 14 | int s[ 10005 ] ; 15 | int pos[ 10005 ] ; 16 | ll A[ 40005 ] , B[ 40005 ] ; 17 | const ll bs = 1664525LL , co = 1013904223LL ; 18 | const ll mod = ( 1LL << 32 ) ; 19 | 20 | void init() { 21 | A[ 0 ] = bs , B[ 0 ] = co ; 22 | for ( int i = 1 ; i < 40000 ; i ++ ) { 23 | A[ i ] = A[ i - 1 ] * bs % mod ; 24 | B[ i ] = ( B[ i - 1 ] * bs + co ) % mod ; 25 | } 26 | 27 | scanf( "%d" , &n ) ; 28 | for ( int i = 0 ; i < n ; i ++ ) { 29 | scanf( "%d" , &s[ i ] ) ; 30 | pos[ s[ i ] ] = s[ i ] ; 31 | } 32 | } 33 | 34 | void process() { 35 | for ( int i = n ; i >= 1 ; i -- ) { 36 | if ( i > pos[ i ] ) { 37 | for ( int md = i - 1 ; md > pos[ i ] ; md -- ) { 38 | int range = n , 39 | } 40 | } 41 | } 42 | } 43 | 44 | int main() 45 | init() ; 46 | process() ; 47 | return 0 ; 48 | } 49 | -------------------------------------------------------------------------------- /codebook/graph/NumberofMaximalClique.cpp: -------------------------------------------------------------------------------- 1 | // bool g[][] : adjacent array indexed from 1 to n 2 | void dfs(int sz){ 3 | int i, j, k, t, cnt, best = 0; 4 | if(ne[sz]==ce[sz]){ if (ce[sz]==0) ++ans; return; } 5 | for(t=0, i=1; i<=ne[sz]; ++i){ 6 | for (cnt=0, j=ne[sz]+1; j<=ce[sz]; ++j) 7 | if (!g[lst[sz][i]][lst[sz][j]]) ++cnt; 8 | if (t==0 || cnt0){ for (i=k; i<=ce[sz]; ++i) 12 | if (!g[lst[sz][t]][lst[sz][i]]) break; 13 | swap(lst[sz][k], lst[sz][i]); 14 | } i=lst[sz][k]; ne[sz+1]=ce[sz+1]=0; 15 | for (j=1; j 2 | using namespace std; 3 | #define N 1000010 4 | int p , n , __ = 1; 5 | typedef long long ll; 6 | ll inv[ N ]; 7 | ll mypow( ll a , ll b ){ 8 | if( b == 0 ) return 1ll % p; 9 | ll tmp = mypow( a , b / 2 ); 10 | tmp = ( tmp * tmp ) % p; 11 | if( b & 1 ) tmp = ( tmp * a ) % p; 12 | return tmp; 13 | } 14 | void build(){ 15 | for( ll i = 1 ; i < N ; i ++ ) 16 | inv[ i ] = mypow( i , p - 2 ); 17 | } 18 | ll x[ N ] , y[ N ]; 19 | void solve(){ 20 | for( int i = 0 ; i < n ; i ++ ) 21 | cin >> x[ i ] >> y[ i ]; 22 | ll ans = 0; 23 | for( int i = 0 ; i < n ; i ++ ){ 24 | ll tmp = y[ i ] % p; 25 | for( int j = 0 ; j < n ; j ++ ) 26 | if( i != j ){ 27 | tmp = ( tmp * ( -x[ j ] ) ) % p; 28 | tmp = ( tmp + p ) % p; 29 | ll ttt = ( x[ i ] - x[ j ] ) % p; 30 | ttt = ( ttt + p ) % p; 31 | tmp = ( tmp * inv[ ttt ] ) % p; 32 | } 33 | ans = ( ans + tmp ) % p; 34 | } 35 | cout << ans << endl; 36 | } 37 | int main(){ 38 | scanf( "%d" , &p ); 39 | build(); 40 | while( scanf( "%d" , &n ) == 1 && n ){ 41 | solve(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /contest/WF/2016/c.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 100 4 | #define PB push_back 5 | inline int getint(){ 6 | int x; 7 | scanf( "%d" , &x ); 8 | return x; 9 | } 10 | int n , m , a[ N ][ N ]; 11 | int tag[ 2020202 ] , stp , vl[ 2020202 ]; 12 | inline void init(){ 13 | n = getint(); m = getint(); 14 | for( int i = 0 ; i < n ; i ++ ){ 15 | for( int j = 0 ; j < m ; j ++ ) 16 | a[ i ][ j ] = getint(); 17 | } 18 | } 19 | set< vector > S; 20 | void go( int x ){ 21 | vector vv; stp ++; 22 | vv.PB( 1 ); 23 | tag[ 1 ] = stp; 24 | vl[ 1 ] = a[ x ][ 0 ]; 25 | for( int i = 1 ; i < m ; i ++ ){ 26 | int now = 1; 27 | while( tag[ now ] == stp ){ 28 | if( a[ x ][ i ] > vl[ now ] ) 29 | now = now * 2 + 1; 30 | else now = now * 2; 31 | } 32 | vv.PB( now ); 33 | tag[ now ] = stp; 34 | vl[ now ] = a[ x ][ i ]; 35 | } 36 | sort( vv.begin() , vv.end() ); 37 | S.insert( vv ); 38 | } 39 | void solve(){ 40 | for( int i = 0 ; i < n ; i ++ ) 41 | go( i ); 42 | printf( "%d\n" , (int)S.size() ); 43 | } 44 | int main(){ 45 | init(); 46 | solve(); 47 | } 48 | -------------------------------------------------------------------------------- /contest/opencup/XVI/Ekaterinburg/j.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void omimi() { 5 | puts("Impossible"); 6 | exit(0); 7 | } 8 | 9 | const int N = 155; 10 | 11 | typedef pair pii; 12 | 13 | int n , a[N][N]; 14 | int m; 15 | int d[N]; 16 | vector g[N]; 17 | 18 | int main(){ 19 | cin >> n; 20 | for (int i=1; i <= n; i++) 21 | for (int j=1; j<=n; j++) 22 | cin >> a[i][j]; 23 | cin >> m; 24 | for (int i = 1; i <= m; i++) { 25 | int s, t, x; 26 | cin >> s >> t >> x; 27 | if (s == t) omimi(); 28 | g[s].push_back({t, x}); 29 | g[t].push_back({s, -x}); 30 | } 31 | 32 | for (int cnt = 0; cnt <= n; cnt++) { 33 | bool upd = 0; 34 | for (int i = 1; i <= n; i++) 35 | for (auto e: g[i]) { 36 | int u = i; 37 | int v = e.first; 38 | int c = e.second; 39 | if (d[u] > d[v]+c) { 40 | d[u] = d[v]+c; 41 | upd = 1; 42 | } 43 | } 44 | if (upd && cnt == n) omimi(); 45 | } 46 | for (int i = 1; i <= n; i++) 47 | for (int j = 1; j <= n; j++) 48 | printf("%d%c", a[i][j]+d[i]-d[j], " \n"[j==n]); 49 | } 50 | -------------------------------------------------------------------------------- /contest/NEERC/Regional/2017/b.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | LL a[ 3 ] , w[ 2 ]; 6 | bool fit( LL x , LL y ){ 7 | return x <= w[ 0 ] and y <= w[ 1 ]; 8 | } 9 | bool go(){ 10 | if( fit( a[ 0 ] + a[ 0 ] + a[ 2 ] + a[ 2 ] , 11 | a[ 1 ] + a[ 2 ] + a[ 2 ] ) ) 12 | return true; 13 | if( fit( a[ 0 ] + a[ 1 ] + a[ 2 ] , 14 | a[ 0 ] + a[ 1 ] + a[ 2 ] + a[ 2 ] ) ) 15 | return true; 16 | if( fit( a[ 0 ] + a[ 1 ] + a[ 2 ] , 17 | a[ 0 ] + a[ 0 ] + a[ 1 ] + a[ 1 ] ) ) 18 | return true; 19 | if( fit( a[ 0 ] + a[ 2 ] , 20 | a[ 0 ] + a[ 1 ] + a[ 1 ] + a[ 1 ] + a[ 2 ] ) ) 21 | return true; 22 | return false; 23 | } 24 | int main(){ 25 | for( int i = 0 ; i < 3 ; i ++ ) 26 | cin >> a[ i ]; 27 | for( int i = 0 ; i < 2 ; i ++ ) 28 | cin >> w[ i ]; 29 | sort( a , a + 3 ); 30 | do{ 31 | sort( w , w + 2 ); 32 | do{ 33 | if( go() ){ 34 | puts( "Yes" ); 35 | exit(0); 36 | } 37 | }while( next_permutation( w , w + 2 ) ); 38 | }while( next_permutation( a , a + 3 ) ); 39 | puts( "No" ); 40 | } 41 | -------------------------------------------------------------------------------- /contest/opencup/XV/America/e.cpp: -------------------------------------------------------------------------------- 1 | #pragma GCC optimize("O3") 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | #define N (1 << 20) 6 | vector pri; 7 | int n , k , a[ N ]; 8 | int to[ N ]; 9 | bool okay( int vv ){ 10 | int used = 0 , st = 1; 11 | while( st <= n and used <= k ){ 12 | int val = a[ st ++ ]; 13 | if( to[ val ] < vv ) return false; 14 | while( st <= n and to[ __gcd( val , a[ st ] ) ] >= vv ) 15 | val = __gcd( val , a[ st ++ ] ); 16 | used ++; 17 | } 18 | return used <= k; 19 | } 20 | bool pp[ N ]; 21 | int main(){ 22 | for( int i = 2 ; i < N ; i ++ ) if( !pp[ i ] ){ 23 | pri.push_back( i ); 24 | for( int j = i ; j < N ; j += i ){ 25 | pp[ j ] = true; 26 | to[ j ] = i; 27 | } 28 | } 29 | 30 | scanf( "%d%d" , &n , &k ); 31 | for( int i = 1 ; i <= n ; i ++ ) 32 | scanf( "%d" , &a[ i ] ); 33 | 34 | int bl = 0 , br = (int)pri.size() - 1 , ba = 0; 35 | while( bl <= br ){ 36 | int bmid = (bl + br) >> 1; 37 | if( okay( pri[ bmid ] ) ) 38 | ba = pri[ bmid ] , bl = bmid + 1; 39 | else 40 | br = bmid - 1; 41 | } 42 | cout << ba << endl; 43 | } 44 | -------------------------------------------------------------------------------- /codebook/dataStructure/treap.cpp: -------------------------------------------------------------------------------- 1 | struct Treap{ 2 | int sz , val , pri , tag; 3 | Treap *l , *r; 4 | Treap( int _val ){ 5 | val = _val; sz = 1; 6 | pri = rand(); l = r = NULL; tag = 0; 7 | } 8 | }; 9 | void push( Treap * a ){ 10 | if( a->tag ){ 11 | Treap *swp = a->l; a->l = a->r; a->r = swp; 12 | int swp2; 13 | if( a->l ) a->l->tag ^= 1; 14 | if( a->r ) a->r->tag ^= 1; 15 | a->tag = 0; 16 | } 17 | } 18 | int Size( Treap * a ){ return a ? a->sz : 0; } 19 | void pull( Treap * a ){ 20 | a->sz = Size( a->l ) + Size( a->r ) + 1; 21 | } 22 | Treap* merge( Treap *a , Treap *b ){ 23 | if( !a || !b ) return a ? a : b; 24 | if( a->pri > b->pri ){ 25 | push( a ); 26 | a->r = merge( a->r , b ); 27 | pull( a ); 28 | return a; 29 | }else{ 30 | push( b ); 31 | b->l = merge( a , b->l ); 32 | pull( b ); 33 | return b; 34 | } 35 | } 36 | void split( Treap *t , int k , Treap*&a , Treap*&b ){ 37 | if( !t ){ a = b = NULL; return; } 38 | push( t ); 39 | if( Size( t->l ) + 1 <= k ){ 40 | a = t; 41 | split( t->r , k - Size( t->l ) - 1 , a->r , b ); 42 | pull( a ); 43 | }else{ 44 | b = t; 45 | split( t->l , k , a , b->l ); 46 | pull( b ); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /contest/opencup/XVIII/SPb/g.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int N = 510; 6 | 7 | int n, m; 8 | char ip[N][N]; 9 | bool vis[N][N]; 10 | 11 | void dfs(int x, int y) { 12 | if (vis[x][y]) return; 13 | vis[x][y] = 1; 14 | if (x < n and ip[x+1][y] == '.') { 15 | dfs(x+1, y); 16 | return; 17 | } 18 | if (1 <= y-1 and ip[x][y-1] == '.') 19 | dfs(x, y-1); 20 | if (y+1 <= m and ip[x][y+1] == '.') 21 | dfs(x, y+1); 22 | } 23 | 24 | int main() { 25 | #ifdef ONLINE_JUDGE 26 | freopen("mole.in", "r", stdin); 27 | freopen("mole.out", "w", stdout) 28 | #endif 29 | scanf("%d%d", &n, &m); 30 | for (int i = 1; i <= n; ++i) 31 | scanf("%s", ip[i]+1); 32 | for (int i = 1; i <= m; ++i) if (ip[1][i] != '#') 33 | dfs(1, i); 34 | bool flag = 0; 35 | for (int i = 1; i <= n and !flag; ++i) 36 | for (int j = 1; j <= m and !flag; ++j) { 37 | if (ip[i][j] == '.' and !vis[i][j]) { 38 | ip[i][j] = 'X'; 39 | flag = 1; 40 | } 41 | } 42 | if (!flag) { 43 | puts("No"); 44 | return 0; 45 | } 46 | puts("Yes"); 47 | for (int i = 1; i <= n; ++i) 48 | puts(ip[i]+1); 49 | } 50 | -------------------------------------------------------------------------------- /codebook/graph/CentroidDecomposition.cpp: -------------------------------------------------------------------------------- 1 | vector adj[N]; 2 | int p[N], vis[N]; 3 | int sz[N], M[N]; // subtree size of u and M(u) 4 | 5 | inline void maxify(int &x, int y) { x = max(x, y); } 6 | int centroidDecomp(int x) { 7 | vector q; 8 | { // bfs 9 | size_t pt = 0; 10 | q.push_back(x); 11 | p[x] = -1; 12 | while (pt < q.size()) { 13 | int now = q[pt++]; 14 | sz[now] = 1; 15 | M[now] = 0; 16 | for (auto &nxt : adj[now]) 17 | if (!vis[nxt] && nxt != p[now]) 18 | q.push_back(nxt), p[nxt] = now; 19 | } 20 | } 21 | 22 | // calculate subtree size in reverse order 23 | reverse(q.begin(), q.end()); 24 | for (int &nd : q) 25 | if (p[nd] != -1) { 26 | sz[p[nd]] += sz[nd]; 27 | maxify(M[p[nd]], sz[nd]); 28 | } 29 | for (int &nd : q) 30 | maxify(M[nd], (int)q.size() - sz[nd]); 31 | 32 | // find centroid 33 | int centroid = *min_element(q.begin(), q.end(), 34 | [&](int x, int y) { return M[x] < M[y]; }); 35 | 36 | vis[centroid] = 1; 37 | for (auto &nxt : adj[centroid]) if (!vis[nxt]) 38 | centroidDecomp(nxt); 39 | return centroid; 40 | } 41 | 42 | --------------------------------------------------------------------------------