├── 15894.py ├── 12107.py ├── README.md ├── 15226.py ├── 9660.py ├── 9661.py ├── 11025.py ├── 13316.txt ├── 15927.py ├── 2163.cpp ├── 3046.cpp ├── 12796.cpp ├── 1138.py ├── 11947.py ├── 1287.py ├── 13116.py ├── 1789.cpp ├── 2010.cpp ├── 10220.cpp ├── 11726.cpp ├── 11727.cpp ├── 2553.py ├── 10162.cpp ├── 1179.py ├── 4781.py ├── 1543.cpp ├── 11653.cpp ├── 1100.cpp ├── 2442.cpp ├── 2443.cpp ├── 2012.cpp ├── 9625.cpp ├── 1085.cpp ├── 2193.cpp ├── 11931.cpp ├── 9095.cpp ├── 2436.cpp ├── 9536.py ├── 1072.cpp ├── 1720.py ├── 2133.cpp ├── 2217.cpp ├── 7868.py ├── 1037.cpp ├── 1305.cpp ├── 16464.cpp ├── 1920.cpp ├── 11689.cpp ├── 15632.py ├── 10815.cpp ├── 11052.cpp ├── 5557.cpp ├── 1629.cpp ├── 11729.cpp ├── 1152.cpp ├── 10773.cpp ├── 2444.cpp ├── 10610.cpp ├── 3986.cpp ├── 1377.cpp ├── 1456.py ├── 2230.cpp ├── 15329.cpp ├── 9658.cpp ├── 1026.cpp ├── 1309.cpp ├── 1015.cpp ├── 11057.cpp ├── 11003.cpp ├── 1124.cpp ├── 3110.cpp ├── 3078.cpp ├── 1009.cpp ├── 2231.cpp ├── 1701.cpp ├── 1010.cpp ├── 4889.cpp ├── 11053.cpp ├── 2447.cpp ├── 1032.cpp ├── 16409.cpp ├── 11049.cpp ├── 1205.cpp ├── 2841.cpp ├── 11055.cpp ├── 2022.cpp ├── 2003.cpp ├── 2631.cpp ├── 13560.cpp ├── 2135.py ├── 15824.cpp ├── 11387.py ├── 2294.cpp ├── 4354.cpp ├── 3613.py ├── 17947.cpp ├── 2957.cpp ├── 5582.cpp ├── 10163.cpp ├── 11060.cpp ├── 11728.cpp ├── 1016.cpp ├── 1038.cpp ├── 2302.cpp ├── 6236.cpp ├── 1004.cpp ├── 1300.cpp ├── 1931.cpp ├── 1946.cpp ├── 2004.cpp ├── 14889.cpp ├── 1699.cpp ├── 1620.cpp ├── autosubmit.py ├── 10942.cpp ├── 1890.cpp ├── 1806.cpp ├── 2531.cpp ├── 10835.cpp ├── 13711.cpp ├── 2167.cpp ├── 2089.cpp ├── 6988.cpp ├── 6986.cpp ├── 14931.cpp ├── 14930.cpp ├── 1654.cpp ├── 5052.cpp ├── 5397.cpp ├── 1764.cpp ├── 10974.cpp ├── 6549.cpp ├── 8291.cpp ├── 2805.cpp ├── 9465.cpp ├── 2512.cpp ├── 1239.cpp ├── 1697.cpp ├── 11723.cpp ├── 14003.cpp ├── 1561.cpp ├── 13023.cpp ├── 15588.cpp ├── 1495.cpp ├── 14501.cpp ├── 2253.cpp ├── 14488.py ├── 1786.cpp ├── 1987.cpp ├── 8986.cpp ├── 1915.cpp ├── 1182.cpp ├── 1036.py ├── 11690.cpp ├── 5639.cpp ├── 1762.cpp ├── 14888.cpp ├── 15511.cpp ├── 2306.cpp ├── 2515.cpp ├── 2042.cpp ├── 1034.cpp ├── 11504.cpp ├── 2110.cpp ├── 1644.cpp ├── 1766.cpp ├── 9663.cpp ├── 11585.cpp ├── 1717.cpp ├── 11403.cpp ├── 1253.cpp ├── 9009.cpp ├── 11724.cpp ├── 14791.cpp ├── 1504.cpp ├── 15509.cpp ├── 1068.cpp ├── 1325.cpp ├── 1562.cpp ├── 11778.cpp ├── 1025.cpp ├── 2263.cpp ├── 3307.cpp ├── 1958.cpp ├── 1509.cpp ├── 3080.cpp ├── 1406.cpp ├── 2084.cpp ├── 1711.cpp ├── 11404.cpp ├── 1933.cpp ├── 1992.cpp ├── 1019.cpp ├── 1991.cpp ├── 1517.cpp ├── 10216.cpp ├── 2240.cpp ├── 12921.cpp ├── 1007.cpp ├── 2300.cpp ├── 7453.cpp ├── 1023.cpp ├── 1030.cpp ├── 1565.py ├── 1167.cpp ├── 1520.cpp ├── 11659.cpp ├── 14444.cpp ├── 1943.cpp ├── 1027.cpp ├── 1937.cpp ├── 2467.cpp ├── 1168.cpp ├── 1516.cpp ├── 1941.cpp ├── 9935.cpp ├── 1063.py ├── 1040.py ├── 17261.cpp ├── 1389.cpp ├── 1849.cpp ├── 1081.cpp ├── 3665.cpp ├── 10816.cpp ├── 6324.py ├── 1033.cpp ├── 1753.cpp ├── 1967.cpp ├── 6101.cpp ├── 10711.cpp ├── 11657.cpp ├── 2336.cpp ├── 2938.cpp ├── 1029.cpp ├── 1707.cpp ├── 1983.cpp ├── 1693.cpp ├── 1196.cpp ├── 1865.cpp ├── 1289.cpp ├── 2261.cpp ├── 1922.cpp ├── 2250.cpp ├── 7562.cpp └── 14891.cpp /15894.py: -------------------------------------------------------------------------------- 1 | print(int(input())*4) 2 | -------------------------------------------------------------------------------- /12107.py: -------------------------------------------------------------------------------- 1 | if input() == '1': print("B") 2 | else: print("A") 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 여기 올라와있는 모든 코드에 대한 상세한 설명은 https://blog.encrypted.gg 에서 확인할 수 있습니다. 2 | -------------------------------------------------------------------------------- /15226.py: -------------------------------------------------------------------------------- 1 | h = int(input()) 2 | while h % 8 != 0 and h % 8 != 5: h+=1 3 | print(h) 4 | -------------------------------------------------------------------------------- /9660.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | if N % 7 == 0 or N % 7 == 2: 3 | print("CY") 4 | else: 5 | print("SK") 6 | -------------------------------------------------------------------------------- /9661.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | if N % 5 == 0 or N % 5 == 2: 3 | print("CY") 4 | else: 5 | print("SK") 6 | -------------------------------------------------------------------------------- /11025.py: -------------------------------------------------------------------------------- 1 | N,M=map(int,input().split()) 2 | R=0 3 | for i in range(1,N+1): 4 | R=(R+M)%i 5 | print(R+1) 6 | -------------------------------------------------------------------------------- /13316.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 1 1 3 | 0 0 4 | 2 1 5 | 3 11 6 | 0 0 7 | 4 1 8 | 5 1 9 | 6 1 10 | 6 7 11 | 4 6 12 | -------------------------------------------------------------------------------- /15927.py: -------------------------------------------------------------------------------- 1 | S = input() 2 | if S == S[0]*len(S): print(-1) 3 | elif S != S[::-1]: print(len(S)) 4 | else: print(len(S)-1) 5 | -------------------------------------------------------------------------------- /2163.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int N, M; 4 | scanf("%d %d", &N, &M); 5 | printf("%d", N*M-1); 6 | } 7 | -------------------------------------------------------------------------------- /3046.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int a, b; 4 | scanf("%d %d", &a, &b); 5 | printf("%d", 2 * b - a); 6 | } 7 | -------------------------------------------------------------------------------- /12796.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int K; 4 | scanf("%d", &K); 5 | printf("%d\n%d %d %d %d", 3, 1, 1, 1, K + 1); 6 | } 7 | -------------------------------------------------------------------------------- /1138.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | H = list(map(int,input().split())) 3 | L = [] 4 | for i in range(N-1,-1,-1): 5 | L.insert(H[i],i+1) 6 | for elem in L: 7 | print(elem,end=' ') 8 | -------------------------------------------------------------------------------- /11947.py: -------------------------------------------------------------------------------- 1 | T = int(input()) 2 | for _ in range(T): 3 | N = input() 4 | l = len(N) 5 | N = int(N) 6 | if N >= 10**l // 2: 7 | N = 10**l // 2 8 | print(N*(10**(l)-1-N)) 9 | -------------------------------------------------------------------------------- /1287.py: -------------------------------------------------------------------------------- 1 | S=input() 2 | try: 3 | eval(S.replace("+","&").replace("-","&").replace("/","&").replace("*","&")) 4 | print(int(eval(S.replace("/","//")))) 5 | except:print("ROCK") 6 | -------------------------------------------------------------------------------- /13116.py: -------------------------------------------------------------------------------- 1 | T = int(input()) 2 | for _ in range(T): 3 | A,B = map(int, input().split()) 4 | while A != B: 5 | if A > B: 6 | A //= 2 7 | else: 8 | B //= 2 9 | print(10*A) 10 | -------------------------------------------------------------------------------- /1789.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(void){ 4 | long long int S; 5 | scanf("%lld", &S); 6 | int N = sqrt(2.0*S); 7 | while( 1LL * N * (N+1) / 2 <= S) 8 | N++; 9 | printf("%d", N-1); 10 | } 11 | -------------------------------------------------------------------------------- /2010.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int N; 4 | scanf("%d", &N); 5 | int cnt = 1; 6 | while (N--) { 7 | int t; 8 | scanf("%d", &t); 9 | cnt += t - 1; 10 | } 11 | printf("%d", cnt); 12 | } 13 | -------------------------------------------------------------------------------- /10220.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int T; 4 | scanf("%d", &T); 5 | while (T--) { 6 | int a; 7 | scanf("%d", &a); 8 | if (6 % a == 0) 9 | printf("0\n"); 10 | else if (a == 4) 11 | printf("2\n"); 12 | else 13 | printf("1\n"); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /11726.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 10007 3 | int main(void) { 4 | int D[1003]; 5 | D[1] = 1; 6 | D[2] = 2; 7 | for (int i = 3; i <= 1000; i++) 8 | D[i] = (D[i - 1] + D[i - 2]) % MOD; 9 | int n; 10 | scanf("%d", &n); 11 | printf("%d", D[n]); 12 | } 13 | -------------------------------------------------------------------------------- /11727.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 10007 3 | int main(void) { 4 | int D[1003]; 5 | D[1] = 1; 6 | D[2] = 3; 7 | for (int i = 3; i <= 1000; i++) 8 | D[i] = (D[i - 1] + 2*D[i - 2]) % MOD; 9 | int n; 10 | scanf("%d", &n); 11 | printf("%d", D[n]); 12 | } 13 | -------------------------------------------------------------------------------- /2553.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | num = 0 3 | tn = n 4 | while tn: 5 | num += tn//5 6 | tn //= 5 7 | 8 | ret = 1 9 | for i in range(1,n+1): 10 | ti = i 11 | while ti % 5 == 0: 12 | ti //= 5 13 | if num and ti % 2 == 0: 14 | num -= 1 15 | ti //= 2 16 | ret = (ret*ti)%10 17 | print(ret) 18 | -------------------------------------------------------------------------------- /10162.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int T; 4 | scanf("%d", &T); 5 | if (T % 10 != 0) { 6 | printf("-1"); 7 | return 0; 8 | } 9 | int A = T / 300; 10 | T -= A * 300; 11 | int B = T / 60; 12 | T -= B * 60; 13 | printf("%d %d %d", A, B, T / 10); 14 | } 15 | -------------------------------------------------------------------------------- /1179.py: -------------------------------------------------------------------------------- 1 | import sys 2 | def solve(N,M): 3 | if M == 1: return N-1 4 | if N == 1: return 0 5 | if 1 < N <= M: 6 | return (solve(N-1,M)+M)%N 7 | NN = N-N//M 8 | tmp = (solve(NN,M)-N%M) % NN 9 | return M*tmp // (M-1) 10 | sys.setrecursionlimit(0x100000) 11 | N,M = map(int,input().split()) 12 | print(solve(N,M)+1) 13 | -------------------------------------------------------------------------------- /4781.py: -------------------------------------------------------------------------------- 1 | def parse(): 2 | S = input().split() 3 | return int(S[0]), int(''.join(S[1].split('.'))) 4 | 5 | while True: 6 | n,m = parse() 7 | D = [0]*(m+1) 8 | if n == 0: break 9 | for _ in range(n): 10 | c,p = parse() 11 | for i in range(p,m+1): 12 | D[i] = max(D[i],D[i-p]+c) 13 | print(D[m]) 14 | 15 | 16 | -------------------------------------------------------------------------------- /1543.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int main(void) { 6 | string T, P; 7 | getline(cin, T); 8 | getline(cin, P); 9 | auto f = T.find(P); 10 | int cnt = 0; 11 | while (f != string::npos) { 12 | cnt++; 13 | f = T.find(P, f + P.size()); 14 | } 15 | printf("%d", cnt); 16 | } 17 | -------------------------------------------------------------------------------- /11653.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int N; 4 | scanf("%d", &N); 5 | int p = 2; 6 | while (p*p <= N) { 7 | if (N % p == 0) { 8 | printf("%d\n", p); 9 | N /= p; 10 | } 11 | else 12 | p++; 13 | } 14 | if (N != 1) 15 | printf("%d\n", N); 16 | } 17 | -------------------------------------------------------------------------------- /1100.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | char board[10][10]; 4 | for (int i = 0; i < 8; i++) 5 | scanf("%s", board[i]); 6 | int cnt = 0; 7 | for (int i = 0; i < 8; i++) { 8 | for (int j = 0; j < 8; j ++) 9 | cnt += (board[i][j] == 'F' && (i+j) % 2 == 0); 10 | } 11 | printf("%d", cnt); 12 | } 13 | -------------------------------------------------------------------------------- /2442.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | void blank(int n) { 3 | while (n--) printf(" "); 4 | } 5 | void star(int n) { 6 | while (n--) printf("*"); 7 | } 8 | int main(void) { 9 | int N; 10 | scanf("%d", &N); 11 | for (int h = 1; h <= N; h++) { 12 | blank(N - h); 13 | star(2 * h - 1); 14 | printf("\n"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /2443.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | void blank(int n) { 3 | while (n--) printf(" "); 4 | } 5 | void star(int n) { 6 | while (n--) printf("*"); 7 | } 8 | int main(void) { 9 | int N; 10 | scanf("%d", &N); 11 | for (int h = N; h >= 1; h--) { 12 | blank(N - h); 13 | star(2 * h - 1); 14 | printf("\n"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /2012.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N; 5 | int rk[500003]; 6 | int main(void) { 7 | scanf("%d", &N); 8 | for (int i = 0; i < N; i++) 9 | scanf("%d", &rk[i]); 10 | sort(rk, rk + N); 11 | long long tot = 0; 12 | for (int i = 0; i < N; i++) 13 | tot += abs(rk[i] - i - 1); 14 | printf("%lld", tot); 15 | } 16 | -------------------------------------------------------------------------------- /9625.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int numa[100]; 4 | int numb[100]; 5 | numa[0] = 1; 6 | numb[0] = 0; 7 | for (int i = 1; i <= 50; i++) { 8 | numa[i] = numb[i - 1]; 9 | numb[i] = numa[i - 1] + numb[i - 1]; 10 | } 11 | int K; 12 | scanf("%d", &K); 13 | printf("%d %d", numa[K], numb[K]); 14 | } 15 | -------------------------------------------------------------------------------- /1085.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int min4(int a, int b, int c, int d) { 3 | int min = a; 4 | min = min < b ? min : b; 5 | min = min < c ? min : c; 6 | min = min < d ? min : d; 7 | return min; 8 | } 9 | int main(void) { 10 | int x, y, w, h; 11 | scanf("%d %d %d %d", &x, &y, &w, &h); 12 | printf("%d", min4(x, w - x, y, h - y)); 13 | } 14 | -------------------------------------------------------------------------------- /2193.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | long long D[100][2]; // D[i][j] : i자리 수, 맨 앞에 j가 옴 4 | int N; 5 | scanf("%d", &N); 6 | D[1][0] = 1; 7 | D[1][1] = 1; 8 | for (int i = 2; i <= N; i++) { 9 | D[i][0] = D[i - 1][0] + D[i - 1][1]; 10 | D[i][1] = D[i - 1][0]; 11 | } 12 | printf("%lld", D[N][1]); 13 | } 14 | -------------------------------------------------------------------------------- /11931.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int N; 3 | int num[2000003]; 4 | int main(void) { 5 | scanf("%d", &N); 6 | for (int i = 0; i < N; i++) { 7 | int t; 8 | scanf("%d", &t); 9 | num[t + 1000000] = 1; 10 | } 11 | for (int i = 2000000; i >= 0; i--) { 12 | if (num[i] == 1) 13 | printf("%d\n", i - 1000000); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /9095.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | int T; 4 | scanf("%d", &T); 5 | int D[12]; 6 | D[1] = 1; 7 | D[2] = 2; 8 | D[3] = 4; 9 | for (int i = 4; i <= 11; i++) 10 | D[i] = D[i - 1] + D[i - 2] + D[i - 3]; 11 | while (T--) { 12 | int t; 13 | scanf("%d", &t); 14 | printf("%d\n", D[t]); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /2436.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int gcd(int a, int b) { 3 | if (a == 0) 4 | return b; 5 | return gcd(b%a, a); 6 | } 7 | int main(void) { 8 | int g, l; 9 | scanf("%d %d", &g, &l); 10 | int val = 1; 11 | int f = l / g; 12 | for (int i = 2; i*i <= f; i++) { 13 | if (f%i == 0 && gcd(i, f / i) == 1) 14 | val = i; 15 | } 16 | printf("%d %d", g*val, g*(f / val)); 17 | } 18 | -------------------------------------------------------------------------------- /9536.py: -------------------------------------------------------------------------------- 1 | T = int(input()) 2 | for _ in range(T): 3 | FoxSound = input().split() 4 | AnimalSound = [] 5 | while True: 6 | S = input() 7 | if S[:5] == "what ": break 8 | AnimalSound.append(S.split()[2]) 9 | for word in FoxSound: 10 | if word in AnimalSound: 11 | continue 12 | print(word, end = ' ') 13 | print() 14 | -------------------------------------------------------------------------------- /1072.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long ll; 3 | int main(void) { 4 | ll X, Y, Z; 5 | while (scanf("%lld %lld", &X, &Y) != EOF) { 6 | Z = 100 * Y / X; 7 | if (Z >= 99) 8 | printf("-1\n"); 9 | else { 10 | ll a = X*Z + X - 100 * Y; 11 | ll b = 99 - Z; 12 | ll k = a / b; 13 | if (k * b < a) 14 | k++; 15 | printf("%lld\n", k); 16 | } 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /1720.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | D = [0]*40 # 좌우 대칭과 무관하게 채우는 갯수 3 | symmetric = [0]*40 # 좌우 대칭인 형태의 갯수 4 | D[1] = 1 5 | D[2] = 3 6 | symmetric[1] = 1 7 | symmetric[2] = 3 8 | symmetric[3] = 1 9 | symmetric[4] = 5 10 | for i in range(3,N+1): 11 | D[i] = 2*D[i-2]+D[i-1] 12 | for i in range(5,N+1): 13 | symmetric[i] = symmetric[i-2]+2*symmetric[i-4] 14 | print((D[N]-symmetric[N])//2 + symmetric[N]) 15 | -------------------------------------------------------------------------------- /2133.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void){ 3 | int D1[40] = {0, }; 4 | int D2[40] = {0, }; 5 | D1[0] = 1; 6 | D1[2] = 3; 7 | D2[1] = 1; 8 | for(int i = 1; i <= 15; i++){ 9 | D1[2*i] = 2*D2[2*i-1] + D1[2*i-2]; 10 | D2[2*i+1] = D1[2*i] + D2[2*i-1]; 11 | } 12 | D1[0] = 0; 13 | int n; 14 | scanf("%d", &n); 15 | printf("%d", D1[n]); 16 | } 17 | -------------------------------------------------------------------------------- /2217.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N; 6 | int lope[100004]; 7 | int main(void) { 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d", &lope[i]); 11 | sort(lope, lope + N, greater()); 12 | int mx = 0; 13 | for(int k = 1; k <= N; k++) 14 | mx = max(mx, lope[k - 1] * k); 15 | printf("%d", mx); 16 | } 17 | -------------------------------------------------------------------------------- /7868.py: -------------------------------------------------------------------------------- 1 | p1,p2,p3,x = map(int, input().split()) 2 | seq = [] 3 | pow1 = p1 4 | INF = 10**18 5 | for i in range(0,60): 6 | if p1**i > INF: break 7 | for j in range(0,60): 8 | if p1**i * p2**j > INF: break 9 | for k in range(0,60): 10 | if i+j+k == 0: continue 11 | if p1**i * p2**j * p3**k > INF: break 12 | seq.append(p1**i * p2**j * p3**k) 13 | seq.sort() 14 | print(seq[x-1]) 15 | -------------------------------------------------------------------------------- /1037.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | int n; 6 | scanf("%d", &n); 7 | int mindiv = 0x7fffffff; 8 | int maxdiv = -1; 9 | while (n--) { 10 | int t; 11 | scanf("%d", &t); 12 | mindiv = min(mindiv, t); 13 | maxdiv = max(maxdiv, t); 14 | } 15 | printf("%lld", 1LL * mindiv * maxdiv); 16 | } 17 | -------------------------------------------------------------------------------- /1305.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int L; 3 | char a[1000003]; 4 | int f[1000003]; 5 | int main(void) { 6 | scanf("%d", &L); 7 | scanf("%s", a); 8 | f[0] = -1; 9 | for (int i = 1; i < L; i++) { 10 | int j = f[i - 1]; 11 | while (a[i] != a[j + 1] && j >= 0) 12 | j = f[j]; 13 | if (a[i] == a[j+1]) 14 | f[i] = j + 1; 15 | else 16 | f[i] = -1; 17 | } 18 | printf("%d", L - 1 - f[L - 1]); 19 | } 20 | -------------------------------------------------------------------------------- /16464.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | 8 | int main(void){ 9 | ios::sync_with_stdio(0); 10 | cin.tie(0); 11 | int n; 12 | cin >> n; 13 | while(n--){ 14 | int k; 15 | cin>>k; 16 | if(__builtin_popcount(k) == 1) cout << "GoHanGang\n"; 17 | else cout << "Gazua\n"; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /1920.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int A[100000]; 5 | int N, M; 6 | int main(void) { 7 | scanf("%d", &N); 8 | for (int i = 0; i < N; i++) 9 | scanf("%d", &A[i]); 10 | sort(A, A + N); 11 | scanf("%d", &M); 12 | while (M--) { 13 | int num; 14 | scanf("%d", &num); 15 | printf("%d\n", binary_search(A, A + N, num)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /11689.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void) { 3 | long long n; 4 | scanf("%lld", &n); 5 | long long pi = n; 6 | long long prime = 2; 7 | while (prime * prime <= n) { 8 | if (n % prime == 0) 9 | pi = pi / prime * (prime - 1); 10 | while (n % prime == 0) // n에 prime 소인수를 전부 제거 11 | n = n / prime; 12 | prime++; 13 | } 14 | if (n != 1) { // 소인수가 남아있다면 15 | pi = pi / n * (n - 1); 16 | } 17 | printf("%lld", pi); 18 | } 19 | -------------------------------------------------------------------------------- /15632.py: -------------------------------------------------------------------------------- 1 | x0,y0,r0=map(int,input().split()) 2 | x1,y1,r1=map(int,input().split()) 3 | x2,y2,r2=map(int,input().split()) 4 | N = 230 5 | area = 0 6 | for i in range(1,100*N+1): 7 | for j in range(1,100*N+1): 8 | if (i/N-x0-0.5/N)**2+(j/N-y0-0.5/N)**2 <= r0*r0: area += 1 9 | elif (i/N-x1-0.5/N)**2+(j/N-y1-0.5/N)**2 <= r1*r1: area += 1 10 | elif (i/N-x2-0.5/N)**2+(j/N-y2-0.5/N)**2 <= r2*r2: area += 1 11 | 12 | print(area/N/N) 13 | -------------------------------------------------------------------------------- /10815.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, M; 5 | int card[500001]; 6 | int main(void) { 7 | scanf("%d", &N); 8 | for (int i = 0; i < N; i++) 9 | scanf("%d", &card[i]); 10 | sort(card, card + N); 11 | scanf("%d", &M); 12 | while (M--) { 13 | int num; 14 | scanf("%d", &num); 15 | printf("%d ", binary_search(card, card + N, num)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /11052.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void){ 5 | int N; 6 | int P[1001]; 7 | int D[1001]; 8 | scanf("%d", &N); 9 | for(int i = 1; i <= N; i++) 10 | scanf("%d", &P[i]); 11 | D[1] = P[1]; 12 | for(int i = 2; i <= N; i++){ 13 | D[i] = P[i]; 14 | for(int j = 1; j <= i-1; j++) 15 | D[i] = max(D[i], D[j]+D[i-j]); 16 | } 17 | printf("%d", D[N]); 18 | } 19 | -------------------------------------------------------------------------------- /5557.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int N; 3 | int num[103]; 4 | long long D[100][21]; 5 | int main(void) { 6 | scanf("%d", &N); 7 | for (int i = 0; i < N; i++) 8 | scanf("%d", &num[i]); 9 | D[0][num[0]] = 1; 10 | for (int i = 1; i < N-1; i++) { 11 | for (int j = 0; j <= 20 - num[i]; j++) 12 | D[i][j] += D[i-1][j + num[i]]; 13 | for (int j = num[i]; j <= 20; j++) 14 | D[i][j] += D[i-1][j - num[i]]; 15 | } 16 | printf("%lld", D[N - 2][num[N - 1]]); 17 | } 18 | -------------------------------------------------------------------------------- /1629.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long LL; 3 | LL power(LL A, LL B, LL C) { 4 | if (B == 0) 5 | return 1; 6 | if (B == 1) 7 | return A % C; 8 | LL tmp = power(A, B / 2, C); 9 | if (B % 2 == 0) 10 | return (tmp*tmp) % C; 11 | else 12 | return (((tmp*tmp) % C) * A) % C; 13 | } 14 | int main(void) { 15 | LL A, B, C; 16 | scanf("%lld %lld %lld", &A, &B, &C); 17 | printf("%lld", power(A, B, C)); 18 | } 19 | -------------------------------------------------------------------------------- /11729.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | void print_state(int st, int en) { 3 | printf("%d %d\n", st, en); 4 | } 5 | void hanoi(int st, int en, int N) { 6 | if (N == 1) { 7 | print_state(st, en); 8 | return; 9 | } 10 | hanoi(st, 6 - st - en, N-1); 11 | print_state(st, en); 12 | hanoi(6 - st - en, en, N - 1); 13 | } 14 | int main(void) { 15 | int K; 16 | scanf("%d", &K); 17 | printf("%d\n", (1 << K) - 1); 18 | hanoi(1, 3, K); 19 | } 20 | -------------------------------------------------------------------------------- /1152.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(void) { 4 | int cnt = 0; 5 | bool isword = false; 6 | while(true){ 7 | char c; 8 | if (scanf("%c", &c) == EOF) 9 | break; 10 | if (c == '\n') 11 | break; 12 | if (c == ' ') 13 | isword = false; 14 | else { 15 | if (!isword) cnt++; 16 | isword = true; 17 | } 18 | } 19 | printf("%d", cnt); 20 | } 21 | -------------------------------------------------------------------------------- /10773.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | int K; 6 | scanf("%d", &K); 7 | stack S; 8 | while (K--) { 9 | int t; 10 | scanf("%d", &t); 11 | if (t > 0) 12 | S.push(t); 13 | else 14 | S.pop(); 15 | } 16 | long long sum = 0; 17 | while (!S.empty()) { 18 | sum += S.top(); 19 | S.pop(); 20 | } 21 | printf("%lld", sum); 22 | } 23 | -------------------------------------------------------------------------------- /2444.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | void blank(int n) { 3 | while (n--) printf(" "); 4 | } 5 | void star(int n) { 6 | while (n--) printf("*"); 7 | } 8 | int main(void) { 9 | int N; 10 | scanf("%d", &N); 11 | for (int h = 1; h <= N; h++) { 12 | blank(N - h); 13 | star(2 * h - 1); 14 | printf("\n"); 15 | } 16 | for (int h = N - 1; h >= 1; h--) { 17 | blank(N - h); 18 | star(2 * h - 1); 19 | printf("\n"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /10610.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | int main(void){ 7 | char num[100005]; 8 | scanf("%s", num); 9 | int len = strlen(num); 10 | sort(num, num + len, greater()); 11 | int cnt = 0; 12 | for (int i = 0; i < len; i++) 13 | cnt += (num[i] - '0'); 14 | if (cnt % 3 == 0 && num[len - 1] == '0') 15 | printf("%s", num); 16 | else 17 | printf("-1"); 18 | } 19 | -------------------------------------------------------------------------------- /3986.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int main(void) { 6 | int N; 7 | int cnt = 0; 8 | scanf("%d", &N); 9 | while (N--) { 10 | char word[100005]; 11 | scanf("%s", word); 12 | int len = strlen(word); 13 | stack S; 14 | for (int i = 0; i < len; i++) { 15 | if (S.empty() || S.top() != word[i]) 16 | S.push(word[i]); 17 | else 18 | S.pop(); 19 | } 20 | cnt += S.empty(); 21 | } 22 | printf("%d", cnt); 23 | } 24 | -------------------------------------------------------------------------------- /1377.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair PAIR; 5 | #define X first 6 | #define Y second 7 | PAIR num[500004]; 8 | int N; 9 | int main(void) { 10 | scanf("%d", &N); 11 | for (int i = 0; i < N; i++) { 12 | scanf("%d", &num[i].X); 13 | num[i].Y = i; 14 | } 15 | sort(num, num + N); 16 | int cnt = 0; 17 | for (int i = 0; i < N; i++) 18 | cnt = max(num[i].Y - i, cnt); 19 | printf("%d", cnt+1); 20 | } 21 | -------------------------------------------------------------------------------- /1456.py: -------------------------------------------------------------------------------- 1 | N = 10**7+5 2 | sieve = [True]*(N+100) 3 | sieve[0] = False 4 | sieve[1] = False 5 | sieve[2] = True 6 | prime = 2 7 | while prime*prime <= N: 8 | if not sieve[prime]: 9 | prime += 1 10 | continue 11 | for t in range(2*prime, N+3, prime): sieve[t] = False 12 | prime += 1 13 | 14 | 15 | A,B=map(int, input().split()) 16 | cnt = 0 17 | for p in range(2,N): 18 | if not sieve[p]: continue 19 | mul = p*p 20 | while mul <= B: 21 | cnt += (A <= mul) 22 | mul *= p 23 | print(cnt) 24 | -------------------------------------------------------------------------------- /2230.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N, M; 6 | int A[100003]; 7 | int main(void) { 8 | scanf("%d %d", &N, &M); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d", &A[i]); 11 | sort(A, A + N); 12 | int j = 0; 13 | int diff = 0x7f7f7f7f; 14 | for (int i = 0; i < N; i++) { 15 | while (j < N && A[j] - A[i] < M) 16 | j++; 17 | if (j == N) 18 | break; 19 | diff = min(diff, A[j] - A[i]); 20 | } 21 | printf("%d", diff); 22 | } 23 | -------------------------------------------------------------------------------- /15329.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | 8 | int l,k; 9 | ll D[103]; 10 | 11 | int main(void){ 12 | ios::sync_with_stdio(0); 13 | cin.tie(0); 14 | cin >> l >> k; 15 | D[1] = D[k] = 1; 16 | for(int i = 2; i <= l; i++){ 17 | D[i] += D[i-2]; 18 | if(i >= k+1) D[i] += D[i-k-1]; 19 | } 20 | ll tot = 0; 21 | for(int i = 1; i <= l; i++) tot += D[i]; 22 | cout << tot; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /9658.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int D[1003]; // D[i] = 1 : 돌이 i개 있을 때 선수가 이김 3 | int main(void) { 4 | D[0] = 1; 5 | D[1] = 0; 6 | D[2] = 1; 7 | D[3] = 0; 8 | 9 | for (int i = 4; i <= 1000; i++) { 10 | if (D[i - 1] == 1 && D[i - 3] == 1 && D[i - 4] == 1) 11 | D[i] = 0; 12 | else 13 | D[i] = 1; 14 | } 15 | int N; 16 | scanf("%d", &N); 17 | if (D[N] == 1) 18 | printf("SK"); 19 | else 20 | printf("CY"); 21 | 22 | } 23 | -------------------------------------------------------------------------------- /1026.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int main(void) { 6 | int N; 7 | int A[52]; 8 | int B[52]; 9 | scanf("%d", &N); 10 | for (int i = 0; i < N; i++) 11 | scanf("%d", &A[i]); 12 | for (int i = 0; i < N; i++) 13 | scanf("%d", &B[i]); 14 | sort(A, A + N, greater() ); 15 | sort(B, B + N); 16 | int sum = 0; 17 | for (int i = 0; i < N; i++) sum += A[i] * B[i]; 18 | printf("%d", sum); 19 | } 20 | -------------------------------------------------------------------------------- /1309.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 9901 3 | int D[100001]; 4 | int main(void) { 5 | int N; 6 | D[0] = 1; 7 | D[1] = 3; 8 | 9 | D[2] = D[1] + 2 * (D[0]) + 2; 10 | D[3] = D[2] + 2 * (D[1] + D[0]) + 2; 11 | D[4] = D[3] + 2 * (D[2] + D[1] + D[0]) + 2; 12 | int sum = D[0]+D[1]; 13 | for (int i = 3; i <= 100000; i++) { 14 | D[i] = (D[i - 1] + 2 * sum + 2) % MOD; 15 | sum = (sum + D[i - 1]) % MOD; 16 | } 17 | scanf("%d", &N); 18 | printf("%d", D[N]); 19 | } 20 | -------------------------------------------------------------------------------- /1015.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair PAIR; 5 | PAIR num[60]; 6 | int main(void) { 7 | int N; 8 | int P[60]; 9 | scanf("%d", &N); 10 | for (int i = 0; i < N; i++) { 11 | scanf("%d", &num[i].first); 12 | num[i].second = i; 13 | } // (2, 0), (3, 1), (1, 2) 14 | sort(num, num + N); 15 | for (int i = 0; i < N; i++) 16 | P[num[i].second] = i;; 17 | for (int i = 0; i < N; i++) 18 | printf("%d ", P[i]); 19 | } 20 | -------------------------------------------------------------------------------- /11057.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 10007 3 | int D[1006][10]; 4 | int main(void){ 5 | int N; 6 | scanf("%d", &N); 7 | for(int i = 0; i < 10; i++) 8 | D[1][i] = 1; 9 | for(int i = 2; i <= N; i++){ 10 | for(int j = 0; j < 10; j++){ 11 | for(int k = 0; k <= j; k++) 12 | D[i][j] = (D[i][j] + D[i-1][k]) % MOD; 13 | } 14 | } 15 | int ans = 0; 16 | for(int i = 0; i < 10; i++) 17 | ans = (ans + D[N][i]) % MOD; 18 | printf("%d", ans); 19 | } 20 | -------------------------------------------------------------------------------- /11003.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | #define X first 6 | #define Y second 7 | typedef pair pii; 8 | int main(void) { 9 | int N, L; 10 | scanf("%d %d", &N, &L); 11 | deque DQ; 12 | for (int i = 0; i < N; i++) { 13 | int t; 14 | scanf("%d", &t); 15 | while (!DQ.empty() && DQ.back().X > t) 16 | DQ.pop_back(); 17 | DQ.push_back({ t,i }); 18 | while (i - DQ.front().Y >= L) 19 | DQ.pop_front(); 20 | printf("%d ", DQ.front().X); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /1124.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int D[100003]; 3 | bool isPrime[100003]; 4 | int main(void) { 5 | D[1] = false; 6 | for (int i = 2; i <= 100003; i++) { 7 | isPrime[i] = true; 8 | for (int d = 2; d*d <= i; d++) { 9 | if (i % d == 0) { 10 | D[i] = D[i / d] + 1; 11 | isPrime[i] = false; 12 | break; 13 | } 14 | } 15 | if (isPrime[i]) 16 | D[i] = 1; 17 | } 18 | int A, B; 19 | scanf("%d %d", &A, &B); 20 | int sum = 0; 21 | for (int i = A; i <= B; i++) 22 | sum += isPrime[D[i]]; 23 | printf("%d", sum); 24 | } 25 | -------------------------------------------------------------------------------- /3110.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int cmp(int a1, int a2, int b1, int b2) { // 음수면 a1/a2 < b1/b2 3 | return a1 * b2 - a2 * b1; 4 | } 5 | 6 | int main(void) { 7 | int B, C, D, A1, A2, E1, E2; 8 | scanf("%d %d %d %d %d %d %d", &B, &C, &D, &A1, &A2, &E1, &E2); 9 | long long cnt = 0; 10 | for (int C1 = 1; C1 <= 1000000; C1++) { 11 | if (cmp(A1, A2, C1, C) >= 0) 12 | continue; 13 | if (cmp(C1, C, E1, E2) >= 0) 14 | break; 15 | cnt += ((E1*D - 1) / E2 - (C1*D) / C) * ((B*C1 - 1) / C - (A1*B) / A2); 16 | } 17 | printf("%lld", cnt); 18 | } 19 | -------------------------------------------------------------------------------- /3078.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | using ll = long long; 4 | int n,k; 5 | vector occur[25]; 6 | int main(){ 7 | ios::sync_with_stdio(0); 8 | cin.tie(0); 9 | cin >> n >> k; 10 | string s; 11 | ll tot = 0; 12 | for(int i = 0; i < n; i++){ 13 | cin >> s; 14 | occur[s.size()].push_back(i); 15 | } 16 | for(int i = 2; i <= 20; i++){ 17 | for(int j = 0; j < occur[i].size(); j++) 18 | tot += occur[i].begin() + j -lower_bound(occur[i].begin(),occur[i].end(),occur[i][j]-k); 19 | } 20 | cout << tot; 21 | } 22 | -------------------------------------------------------------------------------- /1009.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int conv(int n) { 3 | if (n == 0) 4 | return 10; 5 | return n; 6 | } 7 | int pow(int a, int b) { 8 | if (b == 1) 9 | return conv(a % 10); 10 | int tmp = pow(a, b / 2); 11 | if (b % 2 == 0) 12 | return conv(tmp*tmp % 10); 13 | if (b % 2 != 0) 14 | return conv(tmp*tmp * a % 10); 15 | } 16 | int main(void) { 17 | int T; 18 | scanf("%d", &T); 19 | while (T--) { 20 | int a, b; 21 | scanf("%d %d", &a, &b); 22 | printf("%d\n", pow(a, b)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /2231.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int dec_sum[1000001]; 3 | int main(void) { 4 | for (int i = 1; i <= 1000000; i++) { 5 | int tmp = i; 6 | int sum = tmp; 7 | while (tmp > 0) { 8 | sum += tmp % 10; 9 | tmp /= 10; 10 | } 11 | dec_sum[i] = sum; 12 | } 13 | int N; 14 | scanf("%d", &N); 15 | for (int i = 1; i <= 1000000; i++) { 16 | if (dec_sum[i] == N) { 17 | printf("%d", i); 18 | return 0; 19 | } 20 | } 21 | printf("0"); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /1701.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char T[5003]; 6 | int pi[5003]; 7 | int main(void) { 8 | scanf("%s", T); 9 | int len = strlen(T); 10 | int mx = 0; 11 | for (int i = 0; i < len; i++) { // T[i:]의 pi함수를 계산할 예정 12 | int k = 0; 13 | for (int j = 1; j < len - i; j++) { 14 | while (k > 0 && T[i + j] != T[i + k]) 15 | k = pi[k - 1]; 16 | if (T[i + j] == T[i + k]) 17 | pi[j] = ++k; 18 | else 19 | pi[j] = 0; 20 | mx = max(pi[j], mx); 21 | } 22 | } 23 | printf("%d", mx); 24 | } 25 | -------------------------------------------------------------------------------- /1010.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int comb[31][31]; 3 | void comb_table(int n) { 4 | for (int i = 1; i <= n; i++) { 5 | comb[i][0] = 1; comb[i][i] = 1; 6 | } 7 | for (int i = 2; i <= n; i++) { 8 | for (int j = 1; j <= i-1; j++) { 9 | comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1]; 10 | } 11 | } 12 | } 13 | int main(void) { 14 | comb_table(30); 15 | int T; 16 | scanf("%d", &T); 17 | while (T--) { 18 | int N, M; 19 | scanf("%d %d", &N, &M); 20 | printf("%d\n", comb[M][N]); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /4889.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | ios::sync_with_stdio(0); 6 | cin.tie(0); 7 | int ord = 0; 8 | while(true){ 9 | ord++; 10 | string a; 11 | getline(cin, a); 12 | if(a[0]=='-')break; 13 | int cnt = 0; 14 | int ans = 0; 15 | for(auto c : a){ 16 | if(c=='{') cnt++; 17 | else{ 18 | cnt--; 19 | if(cnt == -1){ 20 | cnt=1; 21 | ans++; 22 | } 23 | } 24 | } 25 | ans += cnt/2; 26 | cout << ord << ". " << ans << '\n'; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /11053.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | int A[1001]; 6 | int LIS[1001]; 7 | int N; 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d", &A[i]); 11 | LIS[0] = A[0]; 12 | int len = 1; 13 | for (int i = 0; i < N; i++) { 14 | if (A[i] > LIS[len - 1]) { 15 | LIS[len++] = A[i]; 16 | continue; 17 | } 18 | int idx = lower_bound(LIS, LIS + len, A[i])-LIS; 19 | LIS[idx] = A[i]; 20 | } 21 | printf("%d", len); 22 | } 23 | -------------------------------------------------------------------------------- /2447.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | char map[2300][2300]; 3 | void solve(int N, int x, int y) { 4 | if (N == 1) { 5 | map[x][y] = '*'; 6 | return; 7 | } 8 | for (int i = 0; i < 3; i++) { 9 | for (int j = 0; j < 3; j++) { 10 | if (i == 1 && j == 1) 11 | continue; 12 | solve(N / 3, x + N / 3 * i, y + N / 3 * j); 13 | } 14 | } 15 | } 16 | int main(void) { 17 | int N; 18 | scanf("%d", &N); 19 | for (int i = 0; i < N; i++) 20 | for (int j = 0; j < N; j++) 21 | map[i][j] = ' '; 22 | solve(N, 0, 0); 23 | for (int i = 0; i < N; i++) 24 | printf("%s\n", map[i]); 25 | } 26 | -------------------------------------------------------------------------------- /1032.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(void) { 4 | int N; 5 | scanf("%d", &N); 6 | char name[53][53]; 7 | for (int i = 0; i < N; i++) 8 | scanf("%s", name[i]); 9 | int len = strlen(name[0]); 10 | int cnt = 0; 11 | char ans[53] = { 0, }; 12 | for (int i = 0; i < len; i++) { 13 | ans[i] = name[0][i]; 14 | for (int j = 1; j < N; j++) { 15 | if (name[0][i] != name[j][i]) { 16 | ans[i] = '?'; 17 | break; 18 | } 19 | } 20 | } 21 | printf("%s", ans); 22 | } 23 | -------------------------------------------------------------------------------- /16409.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | using ll = long long; 5 | 6 | // d1[i] : gcd(x,y)가 i의 배수인 횟수 7 | // d2[i] : gcd(x,y)가 i인 횟수 8 | ll d1[10000005],d2[10000005]; 9 | ll a,b,c,d; 10 | int main(void) { 11 | ios::sync_with_stdio(0); 12 | cin.tie(0); 13 | cin >> a >> b >> c >> d; a--; c--; 14 | for(int i = 1; i <= 10000000; i++){ 15 | d1[i] = (b/i-a/i) * (d/i-c/i); 16 | } 17 | 18 | for(int i = 10000000; i >= 1; i--){ 19 | d2[i] = d1[i]; 20 | for(int j = 2*i; j <= 10000000; j += i) 21 | d2[i] -= d2[j]; 22 | } 23 | cout << d2[1]; 24 | } 25 | -------------------------------------------------------------------------------- /11049.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N; 5 | int D[501][501]; 6 | int arr[501][2]; 7 | int main(void) { 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d%d", &arr[i][0], &arr[i][1]); 11 | for (int len = 2; len <= N; len++) { 12 | for (int st = 0; st <= N - len; st++) { 13 | D[st][st + len] = 0x7fffffff; 14 | for(int sep = st+1; sep < st+len; sep++) 15 | D[st][st + len] = min(D[st][st+len], D[st][sep] + D[sep][st + len] + arr[st][0] * arr[sep][0] * arr[st + len - 1][1]); 16 | } 17 | } 18 | printf("%d", D[0][N]); 19 | } 20 | -------------------------------------------------------------------------------- /1205.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define X first 4 | #define Y second 5 | typedef long long ll; 6 | int N, score, P; 7 | int main() 8 | { 9 | ios::sync_with_stdio(false); 10 | cin.tie(0); 11 | cin >> N >> score >> P; 12 | vector L(N); 13 | for (int i = 0; i < N; i++) { 14 | cin >> L[i]; 15 | L[i] = -L[i]; 16 | } 17 | if (N == 0) { 18 | cout << 1; 19 | return 0; 20 | } 21 | int num = lower_bound(L.begin(), L.end(), -score)-L.begin(); 22 | if (-score == L.back() && N == P) 23 | cout << -1; 24 | else 25 | cout << (num + 1 > P ? -1 : num + 1); 26 | } 27 | -------------------------------------------------------------------------------- /2841.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | int N, P; 6 | scanf("%d %d", &N, &P); 7 | vector string[6]; // increasing order로 누르고있는 flat의 정보가 저장되어있음 8 | int cnt = 0; 9 | while (N--) { 10 | int a, b; 11 | scanf("%d %d", &a, &b); 12 | while (!string[a - 1].empty() && string[a - 1].back() > b) { 13 | string[a - 1].pop_back(); // 손을 뗌 14 | cnt++; 15 | } 16 | if (!string[a - 1].empty() && string[a - 1].back() == b) 17 | continue; 18 | string[a - 1].push_back(b); // 손을 붙임 19 | cnt++; 20 | } 21 | printf("%d", cnt); 22 | } 23 | -------------------------------------------------------------------------------- /11055.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[1003]; 5 | int main(void) { 6 | int A[1003]; 7 | int N; 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d", &A[i]); 11 | 12 | D[0] = A[0]; 13 | int mx = D[0]; 14 | for (int i = 1; i < N; i++) { 15 | D[i] = A[i]; 16 | for (int j = 0; j < i; j++) { 17 | if (A[j] >= A[i]) 18 | continue; 19 | D[i] = max(D[i], D[j] + A[i]); 20 | } 21 | mx = max(mx, D[i]); 22 | } 23 | printf("%d", mx); 24 | } 25 | -------------------------------------------------------------------------------- /2022.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | double f(double x, double y, double d) { 6 | double sqrt1 = sqrt(x*x - d * d); 7 | double sqrt2 = sqrt(y*y - d * d); 8 | return sqrt1 * sqrt2 / (sqrt1 + sqrt2); 9 | } 10 | int main(void) { 11 | double x, y, c; 12 | while ((scanf("%lf %lf %lf", &x, &y, &c)) != EOF) { 13 | double st = 0; 14 | double en = min(x, y); 15 | while (en - st > 1e-6) { 16 | double mid = (st + en) / 2; 17 | if (f(x, y, mid) > c) 18 | st = mid; 19 | else 20 | en = mid; 21 | } 22 | printf("%.3f\n", st); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /2003.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef long long LL; 5 | int A[10001]; 6 | int N, M; 7 | LL D[10001]; // D[i] = A[0] + A[1] + A[2] + .. + A[i-1] 8 | int main(void) { 9 | int N; 10 | LL M; 11 | scanf("%d %lld", &N, &M); 12 | for (int i = 0; i < N; i++) 13 | scanf("%d", &A[i]); 14 | for (int i = 1; i <= N; i++) { 15 | D[i] = D[i - 1] + A[i-1]; 16 | } 17 | int cnt = 0; 18 | for (int i = 1; i <= N; i++) // D[i]에 대해서 D[j] = D[i]-M를 만족하는 j가 있는지 탐색할 것임 19 | cnt += binary_search(D, D + i, D[i]-M); 20 | printf("%d", cnt); 21 | } 22 | -------------------------------------------------------------------------------- /2631.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int LIS[201]; // LIS를 저장할 array 5 | int main(void) { 6 | int N; 7 | int num[201]; 8 | int idx = 0; // LIS에서 사용할 index 9 | scanf("%d", &N); 10 | for (int i = 0; i < N; i++) 11 | scanf("%d", &num[i]); 12 | LIS[0] = num[0]; 13 | idx++; 14 | for (int i = 0; i < N; i++) { 15 | if (LIS[idx - 1] < num[i]) { 16 | LIS[idx] = num[i]; 17 | idx++; 18 | } 19 | else 20 | *lower_bound(LIS, LIS + idx, num[i]) = num[i]; 21 | } 22 | printf("%d", N - idx); 23 | } 24 | -------------------------------------------------------------------------------- /13560.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define X first 4 | #define Y second 5 | #define pb push_back 6 | typedef long long ll; 7 | 8 | int main(void){ 9 | ios::sync_with_stdio(0); 10 | cin.tie(0); 11 | int n; 12 | cin>> n; 13 | vector a(n); 14 | for(int i = 0; i < n;i++) cin >> a[i]; 15 | sort(a.begin(),a.end()); 16 | int tot = 0; 17 | for(int i = 0; i < n ; i++){ 18 | tot += a[i]; 19 | if(tot < i*(i+1)/2){ 20 | cout << -1; 21 | return 0; 22 | } 23 | } 24 | if(tot != n*(n-1)/2){ 25 | cout << -1; 26 | return 0; 27 | } 28 | cout << 1; 29 | 30 | } 31 | -------------------------------------------------------------------------------- /2135.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | n = len(s) 3 | d = [[0]*(n+1) for i in range(n+1)] 4 | 5 | for i in range(n): 6 | d[i][i+1] = 1 7 | 8 | for sz in range(2,n+1): 9 | divs = [] 10 | for i in range(1,sz): 11 | if sz%i == 0: divs.append(i) 12 | for st in range(n-sz+1): 13 | val = sz 14 | for div in divs: 15 | if all(s[st:st+div] == s[k:k+div] for k in range(st, st+sz, div)): 16 | val = min(val, 2 + d[st][st+div] + len(str((sz//div)))) 17 | 18 | 19 | for sep in range(st+1, st+sz): 20 | val = min(val, d[st][sep] + d[sep][st+sz]) 21 | 22 | d[st][st+sz] = val 23 | 24 | print(d[0][n]) 25 | 26 | -------------------------------------------------------------------------------- /15824.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll MOD = 1e9 + 7; 5 | ll ppow2[300003]; 6 | int main(void) { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | int N; 10 | cin >> N; 11 | vector val(N + 1); 12 | for(int i = 1; i <= N; i++) { 13 | cin >> val[i]; 14 | } 15 | sort(val.begin()+1,val.end()); 16 | ppow2[0] = 1; 17 | for(int i = 1; i <= N; i++) { 18 | ppow2[i] = (ppow2[i - 1] * 2) % MOD; 19 | } 20 | ll ans = 0; 21 | for(int i = 1; i <= N; i++) 22 | ans = (ans+ (ppow2[i - 1] - ppow2[N-i]) * val[i])%MOD; 23 | if (ans < 0) ans += MOD; 24 | cout << ans; 25 | } 26 | -------------------------------------------------------------------------------- /11387.py: -------------------------------------------------------------------------------- 1 | def power(h,w): 2 | return (h[0]+w[0]) * (100+h[1]+w[1]) * ( 100*(100-min(h[2]+w[2],100)) + min(h[2]+w[2],100) * (h[3]+w[3])) * (100+h[4]+w[4]) 3 | h1=list(map(int, input().split())) 4 | h2=list(map(int, input().split())) 5 | w1=list(map(int, input().split())) 6 | w2=list(map(int, input().split())) 7 | for i in range(5): 8 | h1[i] -= w1[i] 9 | h2[i] -= w2[i] 10 | 11 | diff1 = power(h1,w2) - power(h1,w1) 12 | diff2 = power(h2,w1) - power(h2,w2) 13 | 14 | if diff1 > 0: print('+') 15 | elif diff1 == 0: print('0') 16 | else: print('-') 17 | 18 | if diff2 > 0: print('+') 19 | elif diff2 == 0: print('0') 20 | else: print('-') 21 | 22 | -------------------------------------------------------------------------------- /2294.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int coin[101]; 4 | int D[10001]; 5 | using namespace std; 6 | int main(void) { 7 | int n, k; 8 | scanf("%d %d", &n, &k); 9 | for (int i = 0; i <= k; i++) 10 | D[i] = 0x7ffffff; 11 | for (int i = 0; i < n; i++) 12 | scanf("%d", &coin[i]); 13 | for (int i = 0; i < n; i++) { 14 | if (coin[i] > k) 15 | continue; 16 | D[coin[i]] = 1; 17 | for (int j = coin[i] + 1; j <= k; j++) 18 | D[j] = min(D[j], D[j - coin[i]] + 1); 19 | } 20 | if (D[k] == 0x7ffffff) 21 | D[k] = -1; 22 | printf("%d", D[k]); 23 | } 24 | -------------------------------------------------------------------------------- /4354.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | char S[1000004]; 5 | int f[1000004]; 6 | int main(void) { 7 | while (true) { 8 | scanf("%s", S); 9 | int len = strlen(S); 10 | if (len == 1 && S[0] == '.') 11 | break; 12 | int j = 0; 13 | for (int i = 1; i < len; i++) { 14 | while (j > 0 && S[i] != S[j]) 15 | j = f[j - 1]; 16 | if (S[i] == S[j]) 17 | f[i] = ++j; 18 | else 19 | f[i] = 0; 20 | } 21 | if (f[len - 1] == 0) { 22 | printf("1\n"); 23 | continue; 24 | } 25 | int k = len - f[len - 1]; 26 | if (len % k == 0) 27 | printf("%d\n", len / k); 28 | else 29 | printf("1\n"); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /3613.py: -------------------------------------------------------------------------------- 1 | def solve(): 2 | T = input() 3 | if T.find('__') != -1: 4 | print("Error!") 5 | return None 6 | if T[-1] == '_' or T[0] == '_': 7 | print("Error!") 8 | return None 9 | if T.find('_') != -1: 10 | if T != T.lower(): 11 | print("Error!") 12 | return None 13 | S = T.split('_') 14 | print(S[0],end='') 15 | for w in S[1:]: 16 | print(w[0].upper()+w[1:],end='') 17 | else: 18 | if T[0] != T[0].lower(): 19 | print("Error!") 20 | return None 21 | for c in T: 22 | if c == c.lower(): 23 | print(c,end='') 24 | else: 25 | print('_'+c.lower(),end='') 26 | solve() 27 | -------------------------------------------------------------------------------- /17947.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int cnt[400005]; 5 | 6 | int main(){ 7 | ios::sync_with_stdio(0); 8 | cin.tie(0); 9 | int n,m,k; 10 | cin >> n >> m >> k; 11 | for(int i = 1; i <= 4*n; i++) cnt[i%k]++; 12 | for(int i = 0; i < 2*m; i++){ 13 | int t; 14 | cin >> t; 15 | cnt[t%k]--; 16 | } 17 | int a,b; 18 | cin >> a >> b; 19 | int diff = abs(a%k - b%k); 20 | cnt[a%k]--; cnt[b%k]--; 21 | int ans = 0; 22 | int val = 0; 23 | for(int i = diff+1; i < k; i++){ 24 | val += cnt[i-diff-1]; 25 | ans += min(val, cnt[i]); 26 | val -= min(val, cnt[i]); 27 | } 28 | cout << min(ans, m-1); 29 | } 30 | -------------------------------------------------------------------------------- /2957.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N; 6 | long long cnt = 0; 7 | int main(void) { 8 | scanf("%d", &N); 9 | map M; 10 | int val; 11 | scanf("%d", &val); 12 | M[val] = 0; 13 | printf("0\n"); 14 | for (int i = 1; i < N; i++) { 15 | int val; 16 | scanf("%d", &val); 17 | auto it = M.lower_bound(val); 18 | int cmp1 = 0; 19 | int cmp2 = 0; 20 | if (it != M.end()) 21 | cmp1 = it->second; 22 | if (it != M.begin()) { 23 | it--; 24 | cmp2 = it->second; 25 | } 26 | M[val] = max(cmp1, cmp2)+1; 27 | cnt += max(cmp1, cmp2)+1; 28 | printf("%lld\n", cnt); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /5582.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char s1[4005]; 6 | char s2[4005]; 7 | int D[4005][4005]; // D[i][j] : s1[0~i-1], s2[0~j-1]에서 s1[i-1], s2[j-1]을 포함하는 가장 긴 공통 부분 문자열의 길이 8 | int len1, len2; 9 | int main(void){ 10 | scanf("%s", s1); 11 | scanf("%s", s2); 12 | len1 = strlen(s1); 13 | len2 = strlen(s2); 14 | int mx = 0; 15 | for (int i = 1; i <= len1; i++) { 16 | for (int j = 1; j <= len2; j++) { 17 | D[i][j] = (s1[i - 1] == s2[j - 1]) * (1 + D[i - 1][j - 1]); 18 | mx = max(mx, D[i][j]); 19 | } 20 | } 21 | printf("%d", mx); 22 | } 23 | -------------------------------------------------------------------------------- /10163.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int map[103][103]; // map[i][j] : (i, j)칸에 보이는 색종이의 종류 3 | int cnt[103]; 4 | int main(void) { 5 | int N; 6 | scanf("%d", &N); 7 | for (int i = 1; i <= N; i++) { 8 | int x, y, width, height; 9 | scanf("%d %d %d %d", &x, &y, &width, &height); 10 | for (int a = x; a < x + width; a++) { 11 | for (int b = y; b < y + height; b++) 12 | map[a][b] = i; 13 | } 14 | } 15 | 16 | for (int i = 0; i <= 100; i++) 17 | for (int j = 0; j <= 100; j++) 18 | cnt[map[i][j]]++; 19 | for (int i = 1; i <= N; i++) 20 | printf("%d\n", cnt[i]); 21 | } 22 | -------------------------------------------------------------------------------- /11060.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[1004]; // D[i] : i번째 칸에 도달하기 위한 최소 점프 횟수 5 | int A[1004]; 6 | int main(void) { 7 | int N; 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) { 10 | scanf("%d", &A[i]); 11 | D[i] = 0x7ffff; 12 | } 13 | D[0] = 0; 14 | for (int i = 0; i < N; i++) { 15 | for (int j = i; j <= i + A[i]; j++) { 16 | if (j >= N) 17 | break; 18 | D[j] = min(D[j], D[i] + 1); 19 | } 20 | } 21 | if (D[N - 1] >= 0x7ffff) 22 | printf("-1"); 23 | else 24 | printf("%d", D[N - 1]); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /11728.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int N, M; 3 | int A[1000001]; 4 | int B[1000001]; 5 | int idx1, idx2; 6 | int main(void) { 7 | scanf("%d %d", &N, &M); 8 | for (int i = 0; i < N; i++) 9 | scanf("%d", &A[i]); 10 | for (int i = 0; i < M; i++) 11 | scanf("%d", &B[i]); 12 | while (idx1 + idx2 < N + M) { 13 | if (idx1 == N) 14 | printf("%d ", B[idx2++]); 15 | else if (idx2 == M) 16 | printf("%d ", A[idx1++]); 17 | else { 18 | if (A[idx1] > B[idx2]) 19 | printf("%d ", B[idx2++]); 20 | else 21 | printf("%d ", A[idx1++]); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /1016.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long LL; 3 | int isSqFree[1000001]; 4 | int main(void) { 5 | LL a, b; 6 | scanf("%lld %lld", &a, &b); 7 | for (int i = 0; i < b - a + 1; i++) 8 | isSqFree[i] = true; 9 | for (LL sq = 2; sq <= 1000000; sq++) { 10 | if (b < sq*sq) // b보다 sq*sq가 크다면 11 | break; // 앞으로는 sq*sq의 배수가 있는지 확인할 필요가 없음 12 | for (LL i = a / (sq*sq); i*sq*sq <= b; i++) { 13 | if (sq*sq*i >= a) // sq*sq의 배수가 a~b사이에 있는거면 14 | isSqFree[sq*sq*i - a] = false; 15 | } 16 | } 17 | int cnt = 0; 18 | for (int i = 0; i < b - a + 1; i++) 19 | cnt += isSqFree[i]; 20 | printf("%d", cnt); 21 | } 22 | -------------------------------------------------------------------------------- /1038.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int main(void) { 6 | vector dec_num; 7 | for (int i = 1; i <= 1023; i++) { // {0, 1, 2, 3, .. , 9}의 공집합이 아닌 부분집합을 뽑아내기 위해서. 8 | long long num = 0; // i에 대응되는 감소하는 수 9 | int tmp_i = i; 10 | for (int idx = 9; idx >= 0; idx--) { 11 | if (tmp_i % 2 == 1) 12 | num = 10 * num + idx; // idx를 1의 자리에 넣음 13 | tmp_i /= 2; 14 | } 15 | dec_num.push_back(num); // i에 대응되는 감소하는 수를 list에 넣음 16 | } 17 | sort(dec_num.begin(), dec_num.end()); 18 | int N; 19 | scanf("%d", &N); 20 | if (N > 1022) 21 | printf("-1"); 22 | else 23 | printf("%lld", dec_num[N]); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /2302.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long LL; 3 | int main(void) { 4 | LL D[42]; // D[i] : VIP석이 없는 경우 i명을 배치할 수 있는 경우의 수 5 | D[0] = 1; 6 | D[1] = 1; 7 | D[2] = 2; 8 | for (int i = 3; i <= 40; i++) 9 | D[i] = D[i - 1] + D[i - 2]; 10 | int N, M; 11 | scanf("%d %d", &N, &M); 12 | int fix[42]; 13 | for (int i = 0; i < M; i++) 14 | scanf("%d", &fix[i]); 15 | if (M == 0) { 16 | printf("%lld", D[N]); 17 | return 0; 18 | } 19 | LL val = 1; 20 | val *= D[fix[0] - 1]; 21 | for (int i = 1; i < M; i++) 22 | val *= D[fix[i] - fix[i - 1] - 1]; 23 | val *= D[N - fix[M - 1]]; 24 | printf("%lld", val); 25 | } 26 | -------------------------------------------------------------------------------- /6236.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int m[100003]; 5 | int N, M; 6 | int calc(int limit) { 7 | int ans = 1; 8 | int now = 0; 9 | for (int i = 0; i < N; i++) { 10 | if (now + m[i] > limit) { 11 | ans++; 12 | now = m[i]; 13 | } 14 | else 15 | now += m[i]; 16 | } 17 | return ans; 18 | } 19 | int main(void) { 20 | scanf("%d %d", &N, &M); 21 | int st = 1; 22 | int en = 1000000000; 23 | for (int i = 0; i < N; i++) { 24 | scanf("%d", &m[i]); 25 | st = max(st, m[i]); 26 | } 27 | while (st < en) { 28 | int mid = (st + en) / 2; 29 | if (calc(mid) > M) 30 | st = mid + 1; 31 | else 32 | en = mid; 33 | } 34 | printf("%d", st); 35 | } 36 | -------------------------------------------------------------------------------- /1004.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | bool isInner(int cx, int cy, int r, int x, int y) { 3 | return r*r > (cx - x)*(cx - x) + (cy - y)*(cy - y); 4 | } 5 | int main(void) { 6 | int T; 7 | scanf("%d", &T); 8 | while (T--) { 9 | int x1, y1, x2, y2; 10 | scanf("%d %d %d %d", &x1, &y1, &x2, &y2); 11 | int n; 12 | scanf("%d", &n); 13 | int cnt = 0; 14 | for (int i = 0; i < n; i++) { 15 | int cx, cy, r; 16 | scanf("%d %d %d", &cx, &cy, &r); 17 | cnt += isInner(cx, cy, r, x1, y1) ^ isInner(cx, cy, r, x2, y2); // 하나는 안에, 하나는 밖에 있을 경우 cnt 1 증가 18 | } 19 | printf("%d\n", cnt); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /1300.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef long long ll; 5 | ll N, K; 6 | ll order(ll val) { // val와 같거나 작은 수가 몇 개가 있는지 7 | ll sum = 0; 8 | for (int i = 1; i <= N; i++) { 9 | sum += min(N, val / i); 10 | if (i > val) 11 | break; 12 | } 13 | return sum; 14 | } 15 | int main(void) { 16 | 17 | scanf("%lld %lld", &N, &K); 18 | // order(i) < K을 만족하는 가장 큰 i를 찾고 i+1을 출력하면 된다. 19 | ll left = 0; 20 | ll right = N*N; 21 | // i는 left~right에 존재 22 | while (right != left) { 23 | ll mid = (left + right) / 2 + 1; 24 | if (order(mid) >= K) { 25 | right = mid - 1; 26 | } 27 | else { 28 | left = mid; 29 | } 30 | } 31 | printf("%lld", left+1); 32 | } 33 | -------------------------------------------------------------------------------- /1931.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define X first 4 | #define Y second 5 | using namespace std; 6 | typedef pair PAIR; // 끝나는 시간, 시작 시간 7 | 8 | int n; 9 | PAIR schedule[100002]; 10 | int main(void) { 11 | scanf("%d", &n); 12 | for (int i = 0; i < n; i++) 13 | scanf("%d %d", &schedule[i].Y, &schedule[i].X); 14 | sort(schedule, schedule + n); 15 | int last_time = schedule[0].X; // 지금 정해진 스케쥴이 끝나는 시간이 기록 16 | int cnt = 1; // 지금까지 열린 회의의 수가 저장 17 | for (int i = 1; i < n; i++) { 18 | if (schedule[i].Y >= last_time) { 19 | cnt++; 20 | last_time = schedule[i].X; 21 | } 22 | } 23 | printf("%d", cnt); 24 | } 25 | -------------------------------------------------------------------------------- /1946.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int grade[100004]; // grade[i] : 서류심사 성적이 i등인 사람의 면접 성적 등수 3 | int N; 4 | int main(void) { 5 | int T; 6 | scanf("%d", &T); 7 | while (T--) { 8 | scanf("%d", &N); 9 | for (int i = 0; i < N; i++) { 10 | int a, b; 11 | scanf("%d %d", &a, &b); 12 | grade[a] = b; 13 | } 14 | int cnt = 0; 15 | int tmpMinGrade = 100005; 16 | for (int i = 1; i <= N; i++) { 17 | if (tmpMinGrade > grade[i]) { // 나보다 서류심사 등수가 좋은 사람들의 면접 등수 최솟값보다 내 면접 성적이 더 좋을 경우 18 | cnt++; 19 | tmpMinGrade = grade[i]; 20 | } 21 | } 22 | printf("%d\n", cnt); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /2004.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | // nCm = n! / m!*(n-m)! 5 | int amount2(int a) { // a!의 2의 갯수 6 | int val = a; 7 | int cnt = 0; 8 | while (val > 0) { 9 | val /= 2; 10 | cnt += val; 11 | } 12 | return cnt; 13 | } 14 | int amount5(int a) { // a!의 5의 갯수 15 | int val = a; 16 | int cnt = 0; 17 | while (val > 0) { 18 | val /= 5; 19 | cnt += val; 20 | } 21 | return cnt; 22 | } 23 | int main(void) { 24 | int n, m; 25 | scanf("%d %d", &n, &m); 26 | int num2 = amount2(n) - amount2(m) - amount2(n - m); 27 | int num5 = amount5(n) - amount5(m) - amount5(n - m); 28 | printf("%d", min(num2, num5)); 29 | } 30 | -------------------------------------------------------------------------------- /14889.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | int N; 7 | int S[22][22]; 8 | int main(void) { 9 | scanf("%d", &N); 10 | for (int i = 1; i <= N; i++) 11 | for (int j = 1; j <= N; j++) 12 | scanf("%d", &S[i][j]); 13 | vector team(N, -1); 14 | fill(team.begin() + N / 2, team.end(), 1); 15 | int mn = 0x7ffffff; 16 | do { 17 | int cnt = 0; 18 | for (int i = 1; i <= N; i++) { 19 | for (int j = i+1; j <= N; j++) { 20 | if (team[i-1] == team[j-1]) 21 | cnt += team[i-1] * (S[i][j] + S[j][i]); 22 | } 23 | } 24 | mn = min(mn, abs(cnt)); 25 | } while (next_permutation(team.begin(), team.end())); 26 | printf("%d", mn); 27 | } 28 | -------------------------------------------------------------------------------- /1699.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int isSquare[100001]; 4 | int isTwoSquare[100001]; 5 | int main(void) { 6 | for (int i = 1; i*i < 100001; i++) 7 | isSquare[i*i] = 1; 8 | for (int i = 1; i*i < 100001; i++) { 9 | for (int j = i; j*j + i*i < 100001; j++) 10 | isTwoSquare[i*i + j*j] = 1; 11 | } 12 | int N; 13 | scanf("%d", &N); 14 | if (isSquare[N]) 15 | printf("1"); 16 | else if (isTwoSquare[N]) 17 | printf("2"); 18 | else { 19 | for (int i = 1; i*i <= N; i++) { 20 | if (isTwoSquare[N - i*i]) { 21 | printf("3"); 22 | return 0; 23 | } 24 | } 25 | printf("4"); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /1620.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | string Num2Str[100001]; 8 | int main(void) { 9 | map Str2Num; 10 | int N, M; 11 | scanf("%d %d", &N, &M); 12 | for (int i = 1; i <= N; i++) { 13 | char tmp[1000]; 14 | scanf("%s", tmp); 15 | Num2Str[i] = tmp; 16 | Str2Num[tmp] = i; 17 | } 18 | while (M--) { 19 | char tmp[1000]; 20 | scanf("%s", tmp); 21 | string s = tmp; 22 | if (s[0] >= '0' && s[0] <= '9') 23 | cout << Num2Str[stoi(s)] << '\n'; 24 | else 25 | cout << Str2Num[s] << '\n'; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /autosubmit.py: -------------------------------------------------------------------------------- 1 | from selenium import webdriver 2 | browser = webdriver.Chrome(executable_path=r"C:\Users\win10\AppData\Local\Programs\Python\chromedriver.exe") 3 | browser.get('https://www.acmicpc.net/login/?next=%2F') 4 | ID = "**************" 5 | PW = "**************" 6 | elem_login = browser.find_element_by_name("login_user_id") 7 | elem_login.send_keys(ID) 8 | elem_login = browser.find_element_by_name("login_password") 9 | elem_login.send_keys(PW) 10 | browser.find_element_by_xpath('/html/body/div[3]/div[3]/div/div/form/div[4]/div[2]/button').click() 11 | while True: 12 | browser.get('https://www.acmicpc.net/submit/10944/9280398') # 이전에 제출한 곳의 주소 13 | browser.find_element_by_xpath('//*[@id="submit_form"]/div[4]/div/button').click() 14 | -------------------------------------------------------------------------------- /10942.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | bool isPalindrome[2002][2002]; 3 | int num[2002]; 4 | int main(void) { 5 | int N, M; 6 | scanf("%d", &N); 7 | for (int i = 1; i <= N; i++) 8 | scanf("%d", &num[i]); 9 | scanf("%d", &M); 10 | for (int i = 1; i <= N; i++) { 11 | isPalindrome[i][i] = true; 12 | isPalindrome[i][i+1] = num[i] == num[i+1]; 13 | } 14 | for (int sz = 3; sz <= N; sz++) { 15 | for (int i = 1; i <= N - sz + 1; i++) 16 | isPalindrome[i][i + sz - 1] = ((isPalindrome[i + 1][i + sz - 2]) && (num[i] == num[i + sz - 1])); 17 | } 18 | while (M--) { 19 | int S, E; 20 | scanf("%d %d", &S, &E); 21 | printf("%d\n", isPalindrome[S][E]); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /1890.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long LL; 3 | int board[103][103]; 4 | int N; 5 | LL D[103][103]; // D[i][j] : (i, j)칸까지 도달하는 경우의 수 6 | int main(void) { 7 | scanf("%d", &N); 8 | for (int i = 0; i < N; i++) 9 | for (int j = 0; j < N; j++) 10 | scanf("%lld", &board[i][j]); 11 | D[0][0] = 1; 12 | for (int i = 0; i < N; i++) { 13 | for (int j = 0; j < N; j++) { 14 | if (board[i][j] == 0) 15 | continue; 16 | if (i + board[i][j] < N) 17 | D[i + board[i][j]][j] += D[i][j]; 18 | if (j + board[i][j] < N) 19 | D[i][j + board[i][j]] += D[i][j]; 20 | } 21 | } 22 | printf("%lld", D[N - 1][N - 1]); 23 | } 24 | -------------------------------------------------------------------------------- /1806.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, S; 5 | int num[100003]; 6 | int D[100003]; // D[i] : num[1]+num[2]...+num[i] 7 | int main(void) { 8 | scanf("%d %d", &N, &S); 9 | for (int i = 1; i <= N; i++) { 10 | scanf("%d", &num[i]); 11 | D[i] = D[i - 1] + num[i]; 12 | } 13 | int min_len = 100001; 14 | for (int st_idx = 1; st_idx <= N; st_idx++) { // D[i] - D[st_idx-1] >= S인 최소의 i를 찾을 예정 15 | int i = distance(D, lower_bound(D, D + N + 1, S + D[st_idx - 1])); 16 | if (i > N) 17 | continue; 18 | min_len = min(min_len, i - st_idx + 1); 19 | } 20 | if (min_len == 100001) 21 | min_len = 0; 22 | printf("%d", min_len); 23 | } 24 | -------------------------------------------------------------------------------- /2531.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, d, k, c; 5 | int arr[30005]; 6 | int kind[3005]; 7 | int main(void) { 8 | scanf("%d %d %d %d", &N, &d, &k, &c); 9 | for (int i = 0; i < N; i++) 10 | scanf("%d", &arr[i]); 11 | int tot = 0; 12 | for (int i = N - k; i < N; i++) { 13 | if (kind[arr[i]] == 0) 14 | tot++; 15 | kind[arr[i]]++; 16 | } 17 | int mx = 0; 18 | for (int i = 0; i < N; i++) { 19 | if (kind[arr[i]] == 0) 20 | tot++; 21 | kind[arr[i]]++; 22 | int del_dish = i - k; 23 | if (del_dish < 0) 24 | del_dish += N; 25 | if (kind[arr[del_dish]] == 1) 26 | tot--; 27 | kind[arr[del_dish]]--; 28 | mx = max(mx, tot + (kind[c] == 0)); 29 | } 30 | printf("%d", mx); 31 | } 32 | -------------------------------------------------------------------------------- /10835.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N; 5 | int A[2005]; 6 | int B[2005]; 7 | int D[2005][2005]; 8 | int main(void) { 9 | scanf("%d", &N); 10 | for (int i = 0; i < N; i++) 11 | scanf("%d", &A[i]); 12 | for (int i = 0; i < N; i++) 13 | scanf("%d", &B[i]); 14 | for (int i = N-1; i >= 0; i--) { 15 | for (int j = N-1; j >= 0; j--) { 16 | if (i != N-1) 17 | D[i][j] = max(D[i][j], D[i + 1][j]); 18 | if (i != N-1 && j != N-1) 19 | D[i][j] = max(D[i][j], D[i + 1][j + 1]); 20 | if (A[i] > B[j]) { 21 | if (j != N-1) 22 | D[i][j] = max(D[i][j], D[i][j + 1] + B[j]); 23 | else 24 | D[i][j] = max(D[i][j], B[j]); 25 | } 26 | } 27 | } 28 | printf("%d", D[0][0]); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /13711.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | 8 | int n; 9 | int a[100005],binv[100005],c[100005]; 10 | vector d; 11 | int main(void){ 12 | ios::sync_with_stdio(0); 13 | cin.tie(0); 14 | cin >> n; 15 | for(int i = 0; i < n; i++) cin >> a[i]; 16 | for(int i = 0; i < n; i++){ 17 | int t; 18 | cin >> t; 19 | binv[t] = i; 20 | } 21 | for(int i = 0; i < n; i++){ 22 | c[i] = binv[a[i]]; 23 | } 24 | d.pb(c[0]); 25 | for(int i = 1; i < n; i++){ 26 | if(d.back() < c[i]){ 27 | d.pb(c[i]); 28 | } 29 | else{ 30 | *lower_bound(d.begin(),d.end(), c[i]) = c[i]; 31 | } 32 | } 33 | cout << d.size(); 34 | } 35 | -------------------------------------------------------------------------------- /2167.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int arr[301][301]; 3 | int D[301][301]; // D[i][j] : (1,1)부터 (i, j)까지의 합 4 | int main(void) { 5 | int N, M; 6 | scanf("%d %d", &N, &M); 7 | for (int i = 1; i <= N; i++) { 8 | for (int j = 1; j <= M; j++) 9 | scanf("%d", &arr[i][j]); 10 | } 11 | for (int i = 1; i <= N; i++) { 12 | D[i][1] = D[i - 1][1] + arr[i][1]; 13 | for (int j = 2; j <= M; j++) { 14 | D[i][j] = D[i][j - 1] + D[i-1][j] + arr[i][j] - D[i-1][j-1]; 15 | } 16 | } 17 | int K; 18 | scanf("%d", &K); 19 | while (K--) { 20 | int i, j, x, y; 21 | scanf("%d %d %d %d", &i, &j, &x, &y); 22 | printf("%d\n", D[x][y] - D[x][j - 1] - D[i - 1][y] + D[i - 1][j - 1]); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /2089.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | void solve(int N, bool isNegative) { 3 | if (N == 0) 4 | return; 5 | if (N == 1 && !isNegative) { 6 | printf("1"); 7 | return; 8 | } 9 | if (N == 1 && isNegative) { 10 | printf("11"); 11 | return; 12 | } 13 | if (N % 2 == 0) { 14 | solve(N / 2, !isNegative); 15 | printf("0"); 16 | } 17 | else { 18 | if (!isNegative) // 다음 digit은 negative 19 | solve((N - 1) / 2, !isNegative); 20 | else 21 | solve((N + 1) / 2, !isNegative); 22 | printf("1"); 23 | } 24 | 25 | } 26 | int main(void) { 27 | int N; 28 | scanf("%d", &N); 29 | if (N == 0) 30 | printf("0"); 31 | else 32 | solve(N, 0); 33 | } 34 | -------------------------------------------------------------------------------- /6988.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | int n; 5 | int a[3005]; 6 | int pos[1000005]; 7 | ll d[3005][3005]; 8 | int main(void) { 9 | ios::sync_with_stdio(0); 10 | cin.tie(0); 11 | cin >> n; 12 | fill(pos,pos+1000001,-1); 13 | for(int i = 0; i < n; i++){ 14 | cin >> a[i]; 15 | pos[a[i]]=i; 16 | } 17 | ll ans = 0; 18 | for(int i = 0; i < n; i++){ 19 | for(int j = i+1; j < n; j++){ 20 | int bb = -1; 21 | if(2*a[i]-a[j] >= 0) bb = pos[2*a[i]-a[j]]; 22 | if(bb == -1) d[i][j] = a[i]+a[j]; 23 | else{ 24 | // cout << bb << ' ' << i << ' ' << j << '\n'; 25 | d[i][j] = d[bb][i] + a[j]; 26 | ans = max(ans,d[i][j]); 27 | } 28 | } 29 | } 30 | cout << ans; 31 | } 32 | -------------------------------------------------------------------------------- /6986.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, K; 5 | long long a[100004]; 6 | int main(void) { 7 | scanf("%d %d", &N, &K); 8 | for (int i = 0; i < N; i++) { 9 | char s[10]; 10 | scanf("%s", &s); 11 | if (s[3] == 0) 12 | a[i] = (s[0] - '0') * 1000 + (s[2] - '0')*100; 13 | else 14 | a[i] = 10000; 15 | } 16 | sort(a, a + N); 17 | long long sum1 = 0; 18 | long long sum2 = 0; 19 | sum2 += a[K]*K + a[N-K-1]*K; 20 | for (int i = K; i < N - K; i++) { 21 | sum1 += a[i]; 22 | sum2 += a[i]; 23 | } 24 | long long avg1 = sum1 / (N - 2 * K); 25 | long long avg2 = sum2 / N; 26 | avg1 += 5; 27 | avg2 += 5; 28 | avg1 /= 10; 29 | avg2 /= 10; 30 | printf("%lld.%02lld\n%lld.%02lld", avg1 / 100, avg1 % 100, avg2 / 100, avg2 % 100); 31 | } 32 | -------------------------------------------------------------------------------- /14931.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | typedef long long ll; 9 | typedef pair pii; 10 | int dx[4] = { 1,-1,0,0 }; 11 | int dy[4] = { 0,0,1,-1 }; 12 | #define X first 13 | #define Y second 14 | int L; 15 | int pt[1000003]; 16 | ll val[1000003]; 17 | int main(void) { 18 | scanf("%d", &L); 19 | for (int i = 1; i <= L; i++) 20 | scanf("%d", &pt[i]); 21 | for (int d = 1; d <= L; d++) 22 | for (int i = d; i <= L; i += d) 23 | val[d] += pt[i]; 24 | ll mx = 1; 25 | for (int d = 1; d <= L; d++) 26 | if (val[mx] < val[d]) 27 | mx = d; 28 | if (val[mx] <= 0) { 29 | printf("0 0"); 30 | return 0; 31 | } 32 | printf("%lld %lld", mx, val[mx]); 33 | } 34 | -------------------------------------------------------------------------------- /14930.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | typedef long long ll; 9 | typedef pair pii; 10 | int dx[4] = { 1,-1,0,0 }; 11 | int dy[4] = { 0,0,1,-1 }; 12 | #define X first 13 | #define Y second 14 | ll N, t; 15 | ll x[100001]; 16 | ll v[100001]; 17 | int main(void) { 18 | scanf("%lld %lld", &N, &t); 19 | int order = 0; // 빨간 구슬이 몇 번째에 위치해있는가. 20 | vector fin; 21 | scanf("%lld %lld", &x[0], &v[0]); 22 | fin.push_back(x[0] + v[0] * t); 23 | for (int i = 1; i < N; i++) { 24 | scanf("%lld %lld", &x[i], &v[i]); 25 | order += (x[i] < x[0]); 26 | fin.push_back(x[i] + v[i] * t); 27 | } 28 | sort(fin.begin(), fin.end()); 29 | printf("%lld", fin[order]); 30 | } 31 | -------------------------------------------------------------------------------- /1654.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long LL; 3 | LL K, N; 4 | LL lan[10000]; 5 | LL amount(LL len) { 6 | LL sum = 0; 7 | for (int i = 0; i < K; i++) 8 | sum += lan[i] / len; 9 | return sum; 10 | } 11 | int main(void) { 12 | scanf("%d %d", &K, &N); 13 | for (int i = 0; i < K; i++) 14 | scanf("%d", &lan[i]); 15 | LL st = 1; 16 | LL en = 0x80000000LL; // 답이 st~en-1 안에 있는 상태를 유지할 것임 17 | while (en - st > 1LL) { 18 | LL mid = (st + en) / 2; 19 | LL chunk = amount(mid); 20 | if (chunk >= N) // 크기가 mid인 조각이 N개 이상이면(답이 mid일 수도 있으므로 st = mid로 두어 범위를 mid~en-1로 축소) 21 | st = mid; 22 | else // 크기가 mid인 조각이 N개 미만이라면(답이 mid일 수가 없으므로 en = mid로 두어 범위를 st~mid-1로 축소) 23 | en = mid; 24 | } 25 | printf("%lld", st); 26 | } 27 | -------------------------------------------------------------------------------- /5052.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | string arr[10005]; 6 | bool isPrefix(string a, string b) { 7 | if (a.size() >= b.size()) 8 | return false; 9 | for (int i = 0; i < a.size(); i++) 10 | if (a[i] != b[i]) 11 | return false; 12 | return true; 13 | } 14 | int main(void) { 15 | ios::sync_with_stdio(false); 16 | int T; 17 | cin >> T; 18 | while (T--) { 19 | int n; 20 | cin >> n; 21 | for(int i = 0; i < n; i++) 22 | cin >> arr[i]; 23 | sort(arr, arr + n); 24 | bool isConsistent = true; 25 | for (int i = 0; i < n - 1; i++) { 26 | if (isPrefix(arr[i], arr[i + 1])) { 27 | isConsistent = false; 28 | break; 29 | } 30 | } 31 | if (isConsistent) 32 | cout << "YES\n"; 33 | else 34 | cout << "NO\n"; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /5397.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | int T; 6 | scanf("%d", &T); 7 | while (T--) { 8 | char s[1000004]; 9 | scanf("%s", s); 10 | int i = 0; 11 | list L; 12 | auto it = L.begin(); // 현재 커서의 위치(=다음에 삽입될 원소의 위치) 13 | while (s[i]) { 14 | if (s[i] == '<') { 15 | if (it != L.begin()) 16 | it--; 17 | } 18 | else if (s[i] == '>') { 19 | if (it != L.end()) 20 | it++; 21 | } 22 | else if (s[i] == '-') { 23 | if (it != L.begin()) { 24 | it--; 25 | it = L.erase(it); 26 | } 27 | 28 | } 29 | else { 30 | L.insert(it, s[i]); 31 | } 32 | i++; 33 | } 34 | it = L.begin(); 35 | while (it != L.end()) { 36 | printf("%c", *it); 37 | it++; 38 | } 39 | printf("\n"); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /1764.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N, M; 6 | string a[500001]; 7 | string b[500001]; 8 | string c[500001]; 9 | int main(void) { 10 | cin >> N >> M; 11 | for (int i = 0; i < N; i++) 12 | cin >> a[i]; 13 | for (int i = 0; i < M; i++) 14 | cin >> b[i]; 15 | sort(a, a + N); 16 | sort(b, b + M); 17 | int aidx = 0, bidx = 0, idx = 0; 18 | while (aidx < N && bidx < M) { 19 | if (a[aidx] < b[bidx]) 20 | aidx++; 21 | else if (a[aidx] > b[bidx]) 22 | bidx++; 23 | else { 24 | c[idx++] = a[aidx++]; 25 | bidx++; 26 | } 27 | } 28 | cout << idx << "\n"; 29 | for (int i = 0; i < idx; i++) 30 | cout << c[i] << "\n"; 31 | 32 | } 33 | -------------------------------------------------------------------------------- /10974.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N; 6 | void print_permutation(string prefix, int* isused, int left) { 7 | if (left == 1) { 8 | for (int i = 1; i <= N; i++) { 9 | if (!isused[i]) { 10 | cout << prefix + to_string(i) + " " + "\n"; 11 | return; 12 | } 13 | } 14 | } 15 | for (int i = 1; i <= N; i++) { 16 | if (!isused[i]) { 17 | isused[i] = true; 18 | print_permutation(prefix + to_string(i) + " ", isused, left - 1); 19 | isused[i] = false; 20 | } 21 | } 22 | } 23 | int main(void) { 24 | scanf("%d", &N); 25 | int isused[9] = { false, }; 26 | string prefix = ""; 27 | print_permutation(prefix, isused, N); 28 | } 29 | -------------------------------------------------------------------------------- /6549.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define X first 5 | #define Y second 6 | using namespace std; 7 | typedef pair PAIR; // height, index 8 | int n; 9 | int h[100004]; 10 | int main(void) { 11 | while (true) { 12 | scanf("%d", &n); 13 | if (n == 0) 14 | break; 15 | for (int i = 0; i < n; i++) 16 | scanf("%d", &h[i]); 17 | stack S; 18 | long long ans = 0; 19 | for (int i = 0; i < n; i++) { 20 | int idx = i; 21 | while (!S.empty() && S.top().X >= h[i]) { 22 | ans = max(ans, 1LL * (i - S.top().Y) * S.top().X); 23 | idx = S.top().Y; 24 | S.pop(); 25 | } 26 | S.push({ h[i], idx }); 27 | } 28 | while (!S.empty()) { 29 | ans = max(ans, 1LL * (n - S.top().Y) * S.top().X); 30 | S.pop(); 31 | } 32 | printf("%lld\n", ans); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /8291.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | using ll = long long; 5 | 6 | int n; 7 | // d1[i] : 수 i의 등장 횟수 8 | // d2[i] : i 배수의 등장 횟수 9 | // d3[i] : gcd(x,y)가 i의 배수인 횟수 10 | // d4[i] : gcd(x,y)가 i인 횟수 11 | ll d1[3000005],d2[3000005],d3[3000005],d4[3000005]; 12 | int main(void) { 13 | ios::sync_with_stdio(0); 14 | cin.tie(0); 15 | cin >> n; 16 | ll t; 17 | for(int i = 0; i < n; i++){ 18 | cin >> t; 19 | d1[t]++; 20 | } 21 | 22 | for(int i = 3000000; i >= 1; i--){ 23 | for(int j = i; j <= 3000000; j += i) 24 | d2[i] += d1[j]; 25 | } 26 | 27 | for(int i = 1; i <= 3000000; i++) 28 | d3[i] = (d2[i]-1)*d2[i]/2; 29 | 30 | for(int i = 3000000; i >= 1; i--){ 31 | d4[i] = d3[i]; 32 | for(int j = 2*i; j <= 3000000; j += i) 33 | d4[i] -= d4[j]; 34 | } 35 | cout << d4[1]; 36 | } 37 | -------------------------------------------------------------------------------- /2805.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, M; 5 | int tree[1000001]; 6 | int divi(int a, int b) { 7 | return (a / b + (a%b != 0)); 8 | } 9 | int main(void) { 10 | scanf("%d %d", &N, &M); 11 | for (int i = 0; i < N; i++) 12 | scanf("%d", &tree[i]); 13 | sort(tree, tree + N); 14 | int treeidx = N - 1; // 잘려나가는 tree중에 가장 작은 tree의 index 15 | while (true) { 16 | //printf("%d %d\n", M, treeidx); 17 | if (treeidx == 0 || divi(M, N - treeidx) <= tree[treeidx] - tree[treeidx-1]) { // treeidx-1 나무를 자르지 않고도 해결이 가능한 상황이면 18 | printf("%d", tree[treeidx] - divi(M, N - treeidx)); 19 | return 0; 20 | } 21 | else { 22 | M -= (N - treeidx)*(tree[treeidx] - tree[treeidx - 1]); 23 | treeidx--; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /9465.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[100000][2]; // D[i][0] : 0~i-1열 전체 + i열 0행에 대해 최댓값, D[i][1] : 0~i-1열 전체 + i열 1행에 대해 최댓값 5 | int sticker[100000][2]; 6 | int main(void) { 7 | int T; 8 | scanf("%d", &T); 9 | while (T--) { 10 | int N; 11 | scanf("%d", &N); 12 | for (int i = 0; i < N; i++) 13 | scanf("%d", &sticker[i][0]); 14 | for (int i = 0; i < N; i++) 15 | scanf("%d", &sticker[i][1]); 16 | D[0][0] = sticker[0][0]; 17 | D[0][1] = sticker[0][1]; 18 | for (int i = 1; i < N; i++) { 19 | D[i][0] = max(sticker[i][0] + D[i - 1][1], D[i - 1][0]); 20 | D[i][1] = max(sticker[i][1] + D[i - 1][0], D[i - 1][1]); 21 | } 22 | printf("%d\n", max(D[N - 1][0], D[N - 1][1])); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /2512.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | typedef long long LL; 6 | LL N; 7 | LL budget[100000]; 8 | LL M; 9 | LL D[100001]; // D[i] = budget[0] + budget[1] + ... + budget[i-1] 10 | int main(void) { 11 | scanf("%lld", &N); 12 | for (int i = 0; i < N; i++) 13 | scanf("%lld", &budget[i]); 14 | scanf("%lld", &M); 15 | sort(budget, budget + N); 16 | D[0] = 0; 17 | for (int i = 1; i <= N; i++) 18 | D[i] = D[i - 1] + budget[i-1]; 19 | for (int i = 1; i <= N; i++) { 20 | if (D[i] + (N - i) * budget[i - 1] > M) { // i-1번쨰까진 예산을 전부 집행하고 그 이후로는 budget[i-1]로 한정된 예산을 집행했을 떄도 M을 초과할 경우 21 | printf("%lld", (M - D[i - 1]) / (N - i + 1)); 22 | return 0; 23 | } 24 | } // 모두 다 퍼줘도 예산이 넉넉하면 for문이 정상적으로 종료됨 25 | printf("%lld", budget[N - 1]); 26 | } 27 | -------------------------------------------------------------------------------- /1239.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int calc(vector chart) { 6 | int len = chart.size(); 7 | int cnt = 0; 8 | for (int st = 0; st < len; st++) { 9 | int sum = 0; 10 | int tmp_idx = st; 11 | while (sum < 50) { 12 | sum += chart[tmp_idx]; 13 | tmp_idx = (tmp_idx + 1) % len; 14 | } 15 | cnt += (sum == 50); 16 | } 17 | return cnt; 18 | } 19 | int main(void) { 20 | int N; 21 | scanf("%d", &N); 22 | vector chart(N); 23 | for (int i = 0; i < N; i++) 24 | scanf("%d", &chart[i]); 25 | sort(chart.begin(), chart.end()); 26 | int mx = 0; 27 | do { 28 | mx = max(mx, calc(chart)); 29 | } while (next_permutation(chart.begin(), chart.end())); 30 | printf("%d", mx / 2); 31 | } 32 | -------------------------------------------------------------------------------- /1697.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int level[100001]; 5 | int main(void) { 6 | int N, K; 7 | scanf("%d %d", &N, &K); 8 | queue Q; 9 | Q.push(N); 10 | level[N] = 1; 11 | if (N == K) { 12 | printf("0"); 13 | return 0; 14 | } 15 | while (true) { 16 | int cur = Q.front(); Q.pop(); 17 | int arr[3] = { cur + 1, cur - 1, cur * 2 }; 18 | for (int i = 0; i < 3; i++) { 19 | if (arr[i] < 0 || arr[i] > 100000) 20 | continue; 21 | if (level[arr[i]] != 0) 22 | continue; 23 | if (arr[i] == K) { 24 | printf("%d", level[cur]); 25 | return 0; 26 | } 27 | level[arr[i]] = level[cur] + 1; 28 | Q.push(arr[i]); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /11723.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | bool exists[21]; 5 | void add(int x) { 6 | exists[x] = true; 7 | } 8 | void remove(int x) { 9 | exists[x] = false; 10 | } 11 | int check(int x) { 12 | return exists[x]; 13 | } 14 | void toggle(int x) { 15 | exists[x] ^= 1; 16 | } 17 | void all(void) { 18 | fill(exists + 1, exists + 21, true); 19 | } 20 | void empty(void) { 21 | fill(exists + 1, exists + 21, false); 22 | } 23 | int main(void) { 24 | int M; 25 | scanf("%d", &M); 26 | while (M--) { 27 | char q[100]; 28 | int x; 29 | scanf("%s %d", &q, &x); 30 | 31 | if (q[0] == 'a' && q[1] == 'd') add(x); 32 | else if (q[0] == 'c') printf("%d\n", check(x)); 33 | else if (q[0] == 'r') remove(x); 34 | else if (q[0] == 't') toggle(x); 35 | else if (q[0] == 'a' && q[1] == 'l') all(); 36 | else empty(); 37 | 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /14003.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int A[1000001]; 6 | int LIS[1000001]; 7 | int N; 8 | int myLIS[1000001]; 9 | int main(void) { 10 | scanf("%d", &N); 11 | for (int i = 0; i < N; i++) 12 | scanf("%d", &A[i]); 13 | LIS[0] = A[0]; 14 | myLIS[0] = 1; 15 | int len = 1; 16 | for (int i = 0; i < N; i++) { 17 | if (A[i] > LIS[len - 1]) { 18 | LIS[len++] = A[i]; 19 | myLIS[i] = len; 20 | continue; 21 | } 22 | int idx = lower_bound(LIS, LIS + len, A[i]) - LIS; 23 | LIS[idx] = A[i]; 24 | myLIS[i] = idx + 1; 25 | } 26 | printf("%d\n", len); 27 | 28 | vector V; 29 | for (int i = N - 1; i >= 0; i--) { 30 | if (myLIS[i] == len) { 31 | V.push_back(A[i]); 32 | len--; 33 | } 34 | } 35 | reverse(V.begin(), V.end()); 36 | for (auto v : V) 37 | printf("%d ", v); 38 | 39 | } 40 | -------------------------------------------------------------------------------- /1561.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int N, M; 3 | int t[10004]; 4 | long long capacity(long long T) { 5 | long long val = 0; 6 | for (int i = 0; i < M; i++) 7 | val += T / t[i] + 1; 8 | return val; 9 | } 10 | int main(void) { 11 | scanf("%d %d", &N, &M); 12 | for (int i = 0; i < M; i++) 13 | scanf("%d", &t[i]); 14 | if (N <= M) { 15 | printf("%d", N); 16 | return 0; 17 | } 18 | long long st = 0; 19 | long long en = N * 30L + 10; 20 | while (en - st > 40) { 21 | long long mid = (st + en) / 2; 22 | if (capacity(mid) >= N) 23 | en = mid; 24 | else 25 | st = mid; 26 | } 27 | long long cur = capacity(st); 28 | st++; 29 | while (true) { 30 | for (int i = 0; i < M; i++) { 31 | if (st % t[i] == 0) { 32 | cur++; 33 | if (cur == N) { 34 | printf("%d", i + 1); 35 | return 0; 36 | } 37 | } 38 | } 39 | st++; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /13023.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | int n; 8 | vector adj[2004]; 9 | vector depth; 10 | void dfs(int cur){ 11 | if(depth[cur] == 5){ 12 | cout << 1; 13 | exit(0); 14 | } 15 | for(auto nxt : adj[cur]){ 16 | if(depth[nxt] != -1) continue; 17 | depth[nxt] = depth[cur]+1; 18 | dfs(nxt); 19 | depth[nxt] = -1; 20 | } 21 | } 22 | int main(void){ 23 | ios::sync_with_stdio(0); 24 | cin.tie(0); 25 | cin >> n; 26 | int m; 27 | cin >> m; 28 | while(m--){ 29 | int a,b; 30 | cin>>a>>b; 31 | adj[a].pb(b); 32 | adj[b].pb(a); 33 | } 34 | for(int r = 0; r < n; r++){ 35 | depth.resize(n); 36 | fill(depth.begin(),depth.end(),-1); 37 | depth[r] = 1; 38 | dfs(r); 39 | 40 | } 41 | cout << 0; 42 | } 43 | -------------------------------------------------------------------------------- /15588.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | ll POW(ll a, ll b, ll m){ 8 | ll ret = 1; 9 | for (; b; b >>= 1, a = (a * a) % m) 10 | if (b & 1) ret = (ret * a) % m; 11 | return ret; 12 | } 13 | int mod = 1e9+7; 14 | ll d[1000005]; 15 | int n,m,k; 16 | int main(void){ 17 | ios::sync_with_stdio(0); 18 | cin.tie(0); 19 | cin>>n>>m>>k; 20 | if(k==1){ 21 | cout << POW(m,n,mod); 22 | return 0; 23 | } 24 | ll tot = d[1] = m; 25 | for(int i = 2; i <= k-1; i++){ 26 | d[i] = d[i-1]*m%mod; 27 | tot = (tot+d[i])%mod; 28 | } 29 | for(int i = k; i <= n; i++){ 30 | d[i] = tot*(m-1)%mod; 31 | tot = (mod+tot-d[i-k+1]+d[i])%mod; 32 | } 33 | //for(int i = 1; i <= n; i++) cout << d[i] << ' '; 34 | cout << (mod+POW(m,n,mod)-d[n])%mod; 35 | } 36 | -------------------------------------------------------------------------------- /1495.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | bool isPossible[1003][2]; 3 | int volume[102]; 4 | int main(void) { 5 | int N, S, M; 6 | scanf("%d %d %d", &N, &S, &M); 7 | for (int i = 0; i < N; i++) 8 | scanf("%d", &volume[i]); 9 | isPossible[S][0] = true; 10 | for (int i = 1; i <= N; i++) { 11 | for (int j = 0; j <= M; j++) { 12 | isPossible[j][i % 2] = false; 13 | if (j - volume[i-1] >= 0 && isPossible[j - volume[i-1]][1 - i % 2]) 14 | isPossible[j][i % 2] = true; 15 | if (j + volume[i-1] <= M && isPossible[j + volume[i-1]][1 - i % 2]) 16 | isPossible[j][i % 2] = true; 17 | } 18 | } 19 | int mx = -1; 20 | for (int i = M; i >= 0; i--) { 21 | if (isPossible[i][N % 2]) { 22 | mx = i; 23 | break; 24 | } 25 | } 26 | printf("%d", mx); 27 | } 28 | -------------------------------------------------------------------------------- /14501.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N; 6 | int T[17]; 7 | int P[17]; 8 | 9 | int main(void) { 10 | scanf("%d", &N); 11 | for (int i = 0; i < N; i++) { 12 | scanf("%d %d", &T[i], &P[i]); 13 | T[i]--; 14 | } 15 | int mx = 0; 16 | for (int day = 1; day <= N; day++) { 17 | vector V(N); 18 | fill(V.begin() + (N - day), V.end(), true); 19 | do { 20 | int val = 0; 21 | int last_day = -1; 22 | for (int i = 0; i < N; i++) { 23 | if (V[i]) { 24 | if (last_day >= i) { 25 | val = -8888; 26 | break; 27 | } 28 | if (T[i] + i >= N) { 29 | val = -8888; 30 | break; 31 | } 32 | val += P[i]; 33 | last_day = T[i] + i; 34 | } 35 | } 36 | mx = max(mx, val); 37 | } while (next_permutation(V.begin(),V.end())); 38 | } 39 | printf("%d", mx); 40 | } 41 | -------------------------------------------------------------------------------- /2253.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[10003][203]; 5 | int N, M; 6 | int block[10003]; 7 | int main(void) { 8 | scanf("%d %d", &N, &M); 9 | while (M--) { 10 | int t; 11 | scanf("%d", &t); 12 | block[t] = 1; 13 | } 14 | for (int i = 0; i <= 10000; i++) 15 | for (int j = 0; j <= 200; j++) 16 | D[i][j] = 0x7f7f7f; 17 | D[1][0] = 0; 18 | for (int i = 1; i <= N; i++) { 19 | for (int j = 0; j <= 200; j++) { 20 | if (D[i][j] == 0x7f7f7f) 21 | continue; 22 | for (int jmp = j - 1; jmp <= j + 1; jmp++) { 23 | if (jmp <= 0 || i + jmp > N || block[i+jmp]) 24 | continue; 25 | D[i + jmp][jmp] = min(0x7f7f7f, D[i][j] + 1); 26 | } 27 | } 28 | } 29 | int ans = 0x7f7f7f; 30 | for (int j = 0; j <= 200; j++) 31 | ans = min(ans, D[N][j]); 32 | if (ans == 0x7f7f7f) 33 | ans = -1; 34 | printf("%d", ans); 35 | } 36 | -------------------------------------------------------------------------------- /14488.py: -------------------------------------------------------------------------------- 1 | def left_reach(x, v): 2 | return x-v*T 3 | def right_reach(x,v): 4 | return x+v*T 5 | def main(): 6 | bound = [0,0] # 학생이 T초간 도달할 수 있는 범위 7 | bound[0] = left_reach(x[0],v[0]) 8 | bound[1] = right_reach(x[0],v[0]) 9 | for i in range(1,N): 10 | left = left_reach(x[i],v[i]) 11 | right = right_reach(x[i],v[i]) 12 | if bound[1] < left or bound[0] > right: 13 | print("0") 14 | return None 15 | if bound[0] <= left: 16 | bound[0] = left 17 | if bound[1] >= right: 18 | bound[1] = right 19 | print("1") 20 | 21 | S = input() 22 | N = int(S.split()[0]) 23 | T = 0 24 | if S.find('.') == -1: 25 | T = int(S.split()[1]) 26 | else: 27 | T = int(S.split()[1].split('.')[0]+S.split()[1].split('.')[1].ljust(4, '0')) 28 | x = list(map(int, input().split())) 29 | v = list(map(int, input().split())) 30 | x = list(map(lambda a : a*10000, x)) 31 | main() 32 | -------------------------------------------------------------------------------- /1786.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int fail[1000004]; 8 | string T; 9 | string P; 10 | int lenT, lenP; 11 | int main(void) { 12 | getline(cin, T); 13 | getline(cin, P); 14 | lenT = T.size(); 15 | lenP = P.size(); 16 | int cmp = 0; 17 | for (int i = 1; i < lenP; i++) { 18 | while (cmp > 0 && P[i] != P[cmp]) 19 | cmp = fail[cmp-1]; 20 | if (P[i] == P[cmp]) 21 | fail[i] = ++cmp; 22 | } 23 | vector ans; 24 | cmp = 0; 25 | for (int i = 0; i < lenT; i++) { 26 | while (cmp > 0 && T[i] != P[cmp]) 27 | cmp = fail[cmp - 1]; 28 | if (T[i] == P[cmp]) { 29 | if (cmp == lenP - 1) { 30 | ans.push_back(i - cmp + 1); 31 | cmp = fail[cmp]; 32 | } 33 | else 34 | cmp++; 35 | } 36 | } 37 | printf("%d\n", ans.size()); 38 | for (auto i : ans) 39 | printf("%d ", i); 40 | } 41 | -------------------------------------------------------------------------------- /1987.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int R, C; 5 | char board[21][21]; 6 | int isvisited[26]; 7 | int maxdepth = 0; 8 | int dx[4] = { 0,0,1,-1 }; 9 | int dy[4] = { 1, -1, 0,0 }; 10 | void dfs(int r, int c, int depth) { 11 | maxdepth = max(maxdepth, depth); 12 | isvisited[board[r][c] - 'A'] = true; 13 | for (int dir = 0; dir < 4; dir++) { 14 | if (r + dx[dir] < 0 || r + dx[dir] >= R || c+dy[dir] < 0 || c+dy[dir] >= C) 15 | continue; 16 | if (isvisited[board[r + dx[dir]][c + dy[dir]] - 'A']) 17 | continue; 18 | dfs(r + dx[dir], c + dy[dir], depth + 1); 19 | } 20 | isvisited[board[r][c] - 'A'] = false; 21 | } 22 | int main(void) { 23 | scanf("%d %d", &R, &C); 24 | for (int i = 0; i < R; i++) 25 | scanf("%s", board[i]); 26 | dfs(0, 0, 1); 27 | printf("%d", maxdepth); 28 | } 29 | -------------------------------------------------------------------------------- /8986.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N; 5 | int x[100004]; 6 | long long dist(long long d) { 7 | long long val = 0; 8 | for (int i = 0; i < N; i++) 9 | val += abs(d*i - x[i]); 10 | return val; 11 | } 12 | int main(void) { 13 | scanf("%d", &N); 14 | for (int i = 0; i < N; i++) 15 | scanf("%d", &x[i]); 16 | long long st = 1; 17 | long long en = 1000000000; 18 | while (en - st > 10) { 19 | long long mid1 = (st * 2 + en) / 3; 20 | long long mid2 = (st + en * 2) / 3; 21 | long long dist1 = dist(mid1); 22 | long long dist2 = dist(mid2); 23 | if (dist1 == dist2) { 24 | st = mid1; 25 | en = mid2; 26 | } 27 | else if (dist1 > dist2) 28 | st = mid1; 29 | else 30 | en = mid2; 31 | } 32 | long long mn = 0x7f7f7f7f7f7f7f7f; 33 | for (long long i = st; i <= en; i++) 34 | mn = min(mn, dist(i)); 35 | printf("%lld", mn); 36 | } 37 | -------------------------------------------------------------------------------- /1915.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | char map[1001][1001]; 5 | int D[1001][1001]; // D[i][j] : (i, j)를 오른쪽 하단으로 두는 1로 된 가장 큰 직사각형의 변의 길이 6 | int n, m; 7 | 8 | int min3(int a, int b, int c) { 9 | return min(min(a, b), c); 10 | } 11 | int main(void) { 12 | scanf("%d %d", &n, &m); 13 | for (int i = 0; i < n; i++) 14 | scanf("%s", map[i]); 15 | int mx = 0; 16 | for (int i = 0; i < m; i++) 17 | D[0][i] = map[0][i] - '0'; // 첫 row만 처리 18 | 19 | for(int i = 1; i < n; i++){ 20 | D[i][0] = map[i][0] - '0'; 21 | for (int j = 1; j < m; j++) 22 | D[i][j] = (map[i][j] - '0') * (min3(D[i][j - 1], D[i - 1][j], D[i - 1][j - 1]) + 1); 23 | } 24 | for (int i = 0; i < n; i++) { 25 | for (int j = 0; j < m; j++) 26 | mx = max(mx, D[i][j]); 27 | } 28 | printf("%d", mx*mx); 29 | } 30 | -------------------------------------------------------------------------------- /1182.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int pow2(int n){ 3 | int val = 1; 4 | while(n--) 5 | val *= 2; 6 | return val; 7 | } 8 | void next_brute(int* num, int N){ 9 | num[N-1]++; 10 | for(int i = N-1; i >= 0; i--){ 11 | if(num[i] == 2){ 12 | num[i] = 0; 13 | num[i-1]++; 14 | } 15 | else 16 | return ; 17 | } 18 | } 19 | int main(void){ 20 | int N, S; 21 | int num[20]; 22 | int brute[20] = {0, }; 23 | int cnt = 0; 24 | scanf("%d %d", &N, &S); 25 | for(int i = 0; i < N; i++) 26 | scanf("%d", &num[i]); 27 | brute[N-1] = 1; 28 | int brutelen = pow2(N)-1; 29 | while(brutelen--){ 30 | int sum = 0; 31 | for(int i = 0; i < N; i++) 32 | sum += num[i] * brute[i]; 33 | cnt += sum == S; 34 | next_brute(brute, N); 35 | } 36 | printf("%d", cnt); 37 | } 38 | -------------------------------------------------------------------------------- /1036.py: -------------------------------------------------------------------------------- 1 | def d(c): 2 | if ord('0') <= ord(c) <= ord('9'): 3 | return ord(c)-ord('0') 4 | return ord(c)-ord('A')+10 5 | def to36(n): 6 | if n == 0: 7 | return "0" 8 | S = "" 9 | d = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] 10 | while n > 0: 11 | S += d[n%36] 12 | n = n // 36 13 | return S[::-1] 14 | N = int(input()) 15 | val = [0]*36 16 | for _ in range(N): 17 | S = input() 18 | for i in range(len(S)): 19 | val[d(S[i])] += 36**(len(S)-i-1) 20 | K = int(input()) 21 | arr = [[0]*2 for i in range(36)] 22 | for i in range(36): 23 | arr[i][0] = val[i]*(35-i) 24 | arr[i][1] = i 25 | arr.sort() 26 | ans = 0 27 | for i in range(36-K): 28 | ans += val[arr[i][1]]*arr[i][1] 29 | for i in range(36-K, 36): 30 | ans += val[arr[i][1]]*35 31 | print(to36(ans)) 32 | -------------------------------------------------------------------------------- /11690.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | vector< bool > sieve; 8 | int calc(int p, int n){ 9 | int cnt = 1; 10 | ll pp = p; 11 | while(pp <= n){ 12 | pp *= p; 13 | cnt++; 14 | } 15 | return pp/p; 16 | } 17 | int main(void){ 18 | ios::sync_with_stdio(0); 19 | cin.tie(0); 20 | int n; 21 | cin >> n; 22 | if(n==1){ 23 | cout << 1; 24 | return 0; 25 | } 26 | sieve.resize(n+1,1); 27 | sieve[1]=0; 28 | unsigned int lcm = 1; 29 | for(int i = 2; i*i <= n; i++){ 30 | if(!sieve[i]) continue; 31 | for(int j = i*i; j <= n; j+=i){ 32 | sieve[j] = 0; 33 | } 34 | } 35 | int p = 2; 36 | for(;p*p <= n; p++){ 37 | if(sieve[p]) lcm *= calc(p,n); 38 | } 39 | for(; p <= n; p++){ 40 | if(sieve[p]) lcm *= p; 41 | } 42 | cout << lcm; 43 | 44 | 45 | } 46 | -------------------------------------------------------------------------------- /5639.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair pii; 5 | #define L first 6 | #define R second 7 | pii sibling[1000005]; 8 | void print_recursion(int cur) { 9 | if (sibling[cur].L != 0) 10 | print_recursion(sibling[cur].L); 11 | if (sibling[cur].R != 0) 12 | print_recursion(sibling[cur].R); 13 | printf("%d\n", cur); 14 | } 15 | int main(void) { 16 | int root; 17 | scanf("%d", &root); 18 | int t; 19 | while (scanf("%d", &t) != EOF) { 20 | int st = root; 21 | while (true) { 22 | if (t < st) { 23 | if (sibling[st].L == 0) { 24 | sibling[st].L = t; 25 | break; 26 | } 27 | else 28 | st = sibling[st].L; 29 | } 30 | if (t > st) { 31 | if (sibling[st].R == 0) { 32 | sibling[st].R = t; 33 | break; 34 | } 35 | else 36 | st = sibling[st].R; 37 | } 38 | } 39 | } 40 | print_recursion(root); 41 | } 42 | -------------------------------------------------------------------------------- /1762.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | int n; 8 | vector adj[100005]; 9 | int main(void){ 10 | ios::sync_with_stdio(0); 11 | cin.tie(0); 12 | int m; 13 | cin >> n >> m; 14 | while(m--){ 15 | int a,b; 16 | cin >> a >> b; 17 | adj[a].pb(b); 18 | adj[b].pb(a); 19 | } 20 | for(int i = 1; i <= n; i++){ 21 | sort(adj[i].begin(),adj[i].end()); 22 | } 23 | int cnt = 0; 24 | for(int i = 1; i <= n; i++){ 25 | for(auto nxt : adj[i]){ 26 | if(nxt < i) continue; 27 | int v1 = nxt; 28 | int v2 = i; 29 | if(adj[v1].size() > adj[v2].size()) swap(v1,v2); 30 | for(auto k : adj[v1]) 31 | cnt += binary_search(adj[v2].begin(),adj[v2].end(),k); 32 | } 33 | } 34 | // cout << cnt << endl; 35 | //assert(cnt%3==0); 36 | cout << cnt/3; 37 | } 38 | -------------------------------------------------------------------------------- /14888.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int main(void) { 6 | int N; 7 | int A[13]; 8 | int op[4]; // + - * / 9 | scanf("%d", &N); 10 | for(int i = 0; i < N; i++) 11 | scanf("%d", &A[i]); 12 | scanf("%d %d %d %d", &op[0], &op[1], &op[2], &op[3]); 13 | vector op_brute; 14 | for (int i = 0; i < 4; i++) 15 | while(op[i]--) 16 | op_brute.push_back(i); 17 | int mn = 0x7fffffff; 18 | int mx = 0x80000000; 19 | do { 20 | int mid = A[0]; 21 | for (int i = 0; i < N - 1; i++) { 22 | if (op_brute[i] == 0) 23 | mid += A[i + 1]; 24 | if (op_brute[i] == 1) 25 | mid -= A[i + 1]; 26 | if (op_brute[i] == 2) 27 | mid *= A[i + 1]; 28 | if (op_brute[i] == 3) 29 | mid /= A[i + 1]; 30 | } 31 | mx = max(mx, mid); 32 | mn = min(mn, mid); 33 | } while (next_permutation(op_brute.begin(), op_brute.end())); 34 | printf("%d\n%d", mx, mn); 35 | } 36 | -------------------------------------------------------------------------------- /15511.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | int n, m; 7 | typedef pair PAIR; 8 | #define X first 9 | #define Y second 10 | vector adj[1000005]; 11 | int p[1000005]; 12 | int main(void) { 13 | scanf("%d %d", &n, &m); 14 | while (m--) { 15 | int a, b; 16 | scanf("%d %d", &a, &b); 17 | adj[a].push_back(b); 18 | adj[b].push_back(a); 19 | } 20 | for (int st = 1; st <= n; st++) { 21 | if (p[st] == 0) 22 | p[st] = 1; 23 | queue Q; 24 | Q.push({ st, p[st] }); 25 | while (!Q.empty()) { 26 | PAIR cur = Q.front(); 27 | Q.pop(); 28 | for (int near : adj[cur.X]) { 29 | if (p[near] == cur.Y) { 30 | printf("IMPOSSIBLE"); 31 | return 0; 32 | } 33 | else if (p[near] == 0) { 34 | p[near] = -cur.Y; 35 | Q.push({ near, p[near] }); 36 | } 37 | } 38 | } 39 | } 40 | printf("POSSIBLE"); 41 | } 42 | -------------------------------------------------------------------------------- /2306.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char DNA[503]; 6 | int D[502][502]; // D[i][j] : DNA[i~j] 내의 가장 긴 유전자 길이 7 | int main(void) { 8 | scanf("%s", DNA); 9 | int dna_len = strlen(DNA); 10 | for (int len = 2; len <= dna_len; len++) { 11 | for (int st = 0; st < dna_len; st++) { // D[st][st+len-1]을 계산할 것임 12 | if (st + len > dna_len) 13 | break; 14 | int en = st + len - 1; 15 | for (int sep = st; sep <= en-1; sep++) // D[st][sep]+D[sep+1][en]으로 계산할 계획 16 | D[st][en] = max(D[st][en], D[st][sep] + D[sep + 1][en]); 17 | // 2개로 분리되지 않고 하나 안에 다 포함되는 경우 18 | if ((DNA[st] == 'a' && DNA[en] == 't') || (DNA[st] == 'g' && DNA[en] == 'c')) 19 | D[st][en] = max(D[st][en], D[st + 1][en - 1] + 2); 20 | } 21 | } 22 | printf("%d", D[0][dna_len - 1]); 23 | } 24 | -------------------------------------------------------------------------------- /2515.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair PAIR; 6 | int N, S; 7 | int D[300005]; // D[i] : pic[0~i]를 전시할 때 최댓값. 단 i번쨰 그림은 반드시 보여짐 8 | #define H first 9 | #define C second 10 | PAIR pic[300005]; 11 | int main(void) { 12 | scanf("%d %d", &N, &S); 13 | for (int i = 0; i < N; i++) 14 | scanf("%d %d", &pic[i].H, &pic[i].C); 15 | sort(pic, pic + N); 16 | D[0] = pic[0].C; 17 | int mx = D[0]; 18 | priority_queue PQ; // D[i]를 채울 때, PQ에 그림의 높이가 i번째 그림-C 이하인 k들에 대한 D[k]를 넣어두고 PQ의 top을 참고하면 된다. 19 | int pq_idx = 0; 20 | int mx_val = 0; 21 | for (int i = 1; i < N; i++) { 22 | while (pic[pq_idx].H <= pic[i].H - S) { 23 | mx_val = max(mx_val, D[pq_idx]); 24 | pq_idx++; 25 | } 26 | D[i] = mx_val + pic[i].C; 27 | mx = max(mx, D[i]); 28 | } 29 | printf("%d", mx); 30 | } 31 | -------------------------------------------------------------------------------- /2042.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX_N 1000000 3 | typedef long long LL; 4 | LL BIT[MAX_N + 1]; 5 | LL num[MAX_N + 1]; 6 | void add(int idx, LL val) { 7 | while (idx <= MAX_N) { 8 | BIT[idx] += val; 9 | idx += (idx & -idx); 10 | } 11 | } 12 | 13 | LL sum(int idx) { 14 | LL s = 0; 15 | while (idx > 0) { 16 | s += BIT[idx]; 17 | idx -= (idx & -idx); 18 | } 19 | return s; 20 | } 21 | 22 | int main(void) { 23 | int N, M, K; 24 | scanf("%d %d %d", &N, &M, &K); 25 | for (int i = 1; i <= N; i++) { 26 | scanf("%lld", &num[i]); 27 | add(i, num[i]); 28 | } 29 | for (int i = 0; i < M + K; i++) { 30 | int a, b, c; 31 | scanf("%d %d %d", &a, &b, &c); 32 | if (a == 1) { 33 | add(b, c - num[b]); 34 | num[b] = c; 35 | } 36 | else 37 | printf("%lld\n", sum(c) - sum(b - 1)); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /1034.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N, M, K; 6 | char lamp[51][51]; 7 | int D[51]; 8 | int main(void) { 9 | scanf("%d %d", &N, &M); 10 | for (int i = 0; i < N; i++) 11 | scanf("%s", lamp[i]); 12 | scanf("%d", &K); 13 | vector V; 14 | for (int i = 0; i < N; i++) { 15 | long long val = 0; 16 | int num0 = 0; 17 | for (int j = 0; j < M; j++) { 18 | val = 2 * val + (lamp[i][j] - '0'); 19 | num0 += (lamp[i][j] == '0'); 20 | } 21 | if (num0 > K || (K - num0) % 2 != 0) 22 | continue; 23 | V.push_back(val); 24 | } 25 | sort(V.begin(), V.end()); 26 | if (V.empty()) { 27 | printf("0"); 28 | return 0; 29 | } 30 | D[0] = 1; 31 | int mx = 1; 32 | 33 | for (int i = 1; i < V.size(); i++) { 34 | if (V[i] == V[i - 1]) { 35 | D[i] = D[i - 1] + 1; 36 | mx = max(mx, D[i]); 37 | } 38 | else 39 | D[i] = 1; 40 | } 41 | printf("%d", mx); 42 | } 43 | -------------------------------------------------------------------------------- /11504.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int A[1001]; 5 | int D1[1001]; // D1[i] = A[i]를 포함하는 LIS의 길이(A[0] to A[i]에서 생각) 6 | int D2[1001]; // D2[i] = A[i]를 포함하는 LDS의 길이(A[i] to A[N-1]에서 생각) 7 | int N; 8 | int main(void) { 9 | scanf("%d", &N); 10 | for (int i = 0; i < N; i++) 11 | scanf("%d", &A[i]); 12 | D1[0] = 1; 13 | for (int i = 1; i < N; i++) { 14 | D1[i] = 1; 15 | for (int j = 0; j < i; j++) { 16 | if (A[i] > A[j]) 17 | D1[i] = max(D1[i], D1[j] + 1); 18 | } 19 | } 20 | D2[N - 1] = 1; 21 | for (int i = N - 2; i >= 0; i--) { 22 | D2[i] = 1; 23 | for (int j = N - 1; j > i; j--) { 24 | if (A[i] > A[j]) 25 | D2[i] = max(D2[i], D2[j] + 1); 26 | } 27 | } 28 | int mx = 0; 29 | for (int i = 0; i < N; i++) 30 | mx = max(mx, D1[i] + D2[i]-1); 31 | printf("%d", mx); 32 | } 33 | -------------------------------------------------------------------------------- /2110.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N, C; 5 | int x[200005]; 6 | 7 | bool isPossibleDist(int dist) { // 공유기 사이의 거리를 dist로 하는 것이 가능한지 8 | int cnt = 1; 9 | int cur = x[0]; 10 | for (int i = 1; i < N; i++) { 11 | if (x[i] - cur >= dist) { 12 | cnt++; 13 | cur = x[i]; // x[i]에 공유기 설치 14 | } 15 | } 16 | return cnt >= C; 17 | } 18 | int main(void) { 19 | scanf("%d %d", &N, &C); 20 | for (int i = 0; i < N; i++) 21 | scanf("%d", &x[i]); 22 | sort(x, x + N); 23 | int lo = 1; 24 | int hi = 1000000000; // lo~hi-1 안에 답이 존재 25 | while (hi > lo + 1) { // 이분탐색 26 | int mid = (lo + hi) / 2; 27 | if (isPossibleDist(mid)) // 공유기 간 거리가 mid일 때 C개 이상 설치 가능하다면 28 | lo = mid; // 거리를 늘려볼 것임 29 | else // 공유기 간 거리가 mid일 때 C개 이상 설치할 수 없다면 30 | hi = mid; // 거리를 줄임 31 | } 32 | printf("%d", lo); 33 | } 34 | -------------------------------------------------------------------------------- /1644.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | vector p_list; 5 | bool isPrime[4000001]; 6 | void sieve() { 7 | for (int i = 2; i <= 4000000; i++) 8 | isPrime[i] = true; 9 | for (int curPrime = 2; curPrime <= 4000000; curPrime++) { 10 | if (!isPrime[curPrime]) 11 | continue; 12 | p_list.push_back(curPrime); 13 | for (int composite = 2 * curPrime; composite <= 4000000; composite += curPrime) 14 | isPrime[composite] = false; 15 | } 16 | } 17 | int main(void) { 18 | sieve(); 19 | int N; 20 | scanf("%d", &N); 21 | int cnt = 0; 22 | for (int i = 0; i < p_list.size(); i++) { 23 | if (N < p_list[i]) 24 | break; 25 | int tmp = i; 26 | int sum = 0; 27 | while (sum < N && tmp < p_list.size()) 28 | sum += p_list[tmp++]; 29 | if (sum == N) 30 | cnt++; 31 | } 32 | printf("%d", cnt); 33 | } 34 | -------------------------------------------------------------------------------- /1766.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | vector after[32003]; // after[i] : 문제 i를 풀고나서 시도해야할 문제들의 목록 8 | int indegree[32003]; 9 | int main(void) { 10 | int N, M; 11 | scanf("%d%d", &N, &M); 12 | while (M--) { 13 | int A, B; 14 | scanf("%d%d", &A, &B); 15 | indegree[B]++; 16 | after[A].push_back(B); 17 | } 18 | priority_queue, greater > PQ; // Priority Queue를 사용해야 지속적으로 혀내 풀 수 있는 문제들 중에서 가장 쉬운 문제를 고려한다. 19 | for (int i = 1; i <= N; i++) { 20 | if (indegree[i] == 0) 21 | PQ.push(i); 22 | } // indegree가 없는 건물들(=먼저 풀어야할 문제가 없는 문제들)을 큐에 삽입 23 | while (!PQ.empty()) { 24 | int cur = PQ.top(); 25 | PQ.pop(); 26 | printf("%d ", cur); 27 | for (auto near : after[cur]) { 28 | indegree[near]--; // 내가 지어져야 지을 수 있는 건물들의 indegree를 1 감소 29 | if (indegree[near] == 0) 30 | PQ.push(near); 31 | } 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /9663.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int state[3][50]; // state[0][i] : i번쨰 column에 말이 있는지 없는지 3 | // state[1][i] : i번쨰 대각선에(/ 방향) 말이 있는지 없는지 4 | // state[2][i] : i번째 대각선에(\ 방향) 말이 있는지 없는지 5 | int cnt = 0; 6 | int N; 7 | void board_recursive(int current) { // current번째 row에 말을 배치할 예정임 8 | 9 | if (current == N) { 10 | cnt++; 11 | return; 12 | } 13 | for (int i = 0; i < N; i++) { // (i, current)에 퀸을 놓을 예정 14 | if (state[0][i] || state[1][i + current] || state[2][current - i + N]) 15 | continue; 16 | state[0][i] = true; 17 | state[1][i + current] = true; 18 | state[2][current - i + N] = true; 19 | board_recursive(current + 1); 20 | state[0][i] = false; 21 | state[1][i + current] = false; 22 | state[2][current - i + N] = false; 23 | } 24 | } 25 | int main(void) { 26 | scanf("%d", &N); 27 | board_recursive(0); 28 | printf("%d", cnt); 29 | } 30 | -------------------------------------------------------------------------------- /11585.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int N; 3 | char S[2000004]; 4 | char P[1000004]; 5 | int f[1000004]; 6 | int gcd(int a, int b) { 7 | if (a == 0) 8 | return b; 9 | return gcd(b%a, a); 10 | } 11 | int main(void) { 12 | scanf("%d", &N); 13 | getchar(); 14 | for (int i = 0; i < N; i++) { 15 | scanf(" %c", &S[i]); 16 | S[N+i] = S[i]; 17 | } 18 | S[2 * N -1] = 0; 19 | for (int i = 0; i < N; i++) 20 | scanf(" %c", &P[i]); 21 | f[0] = -1; 22 | for (int i = 1; i < N; i++) { 23 | int j = f[i - 1]; 24 | while (j >= 0 && P[i] != P[j+1]) 25 | j = f[j]; 26 | if (P[i] == P[j + 1]) 27 | f[i] = j + 1; 28 | else 29 | f[i] = -1; 30 | } 31 | int i = 0, j = 0; 32 | int cnt = 0; 33 | while (i < 2*N - 1) { 34 | if (S[i] == P[j]) { 35 | i++; j++; 36 | } 37 | else if (j == 0) i++; 38 | else j = f[j - 1] + 1; 39 | if (j == N) { 40 | cnt++; 41 | j = f[j - 1] + 1; 42 | } 43 | } 44 | // cnt/N 45 | int g = gcd(cnt, N); 46 | printf("%d/%d", cnt/g, N/g); 47 | } 48 | -------------------------------------------------------------------------------- /1717.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int rank[1000003]; 3 | int parent[1000003]; 4 | 5 | int find(int u) { 6 | if (u == parent[u]) return u; 7 | return parent[u] = find(parent[u]); 8 | } 9 | void merge(int u, int v) { 10 | u = find(u); v = find(v); 11 | if (u == v) return; 12 | if (rank[u] > rank[v]) { 13 | int t = u; 14 | u = v; 15 | v = t; 16 | } 17 | parent[u] = v; 18 | if (rank[u] == rank[v]) ++rank[v]; 19 | } 20 | int main(void) { 21 | int n, m; 22 | scanf("%d %d", &n, &m); 23 | for (int i = 0; i <= n; i++) { 24 | rank[i] = 1; 25 | parent[i] = i; 26 | } 27 | while (m--) { 28 | int op, a, b; 29 | scanf("%d %d %d", &op, &a, &b); 30 | if (op == 0) 31 | merge(a, b); 32 | 33 | if (op == 1) { 34 | if (find(a) == find(b)) 35 | printf("YES\n"); 36 | else 37 | printf("NO\n"); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /11403.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void){ 5 | int N; 6 | int edge[101][101]; 7 | int reach[101][101] = {0, }; 8 | scanf("%d", &N); 9 | for(int i = 1; i <= N; i++){ 10 | for(int j = 1; j <= N; j++) 11 | scanf("%d", &edge[i][j]); 12 | } 13 | for(int st = 1; st <= N; st++){ 14 | int isVisited[101] = {0, }; 15 | queue Q; 16 | Q.push(st); 17 | while(!Q.empty()){ 18 | int cur = Q.front(); 19 | Q.pop(); 20 | for(int i = 1; i <= N; i++){ 21 | if(edge[cur][i] && !isVisited[i]){ 22 | Q.push(i); 23 | reach[st][i] = 1; 24 | isVisited[i] = true; 25 | } 26 | } 27 | } 28 | } 29 | for(int i = 1; i <= N; i++){ 30 | for(int j = 1; j <= N; j++){ 31 | printf("%d ", reach[i][j]); 32 | } 33 | printf("\n"); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /1253.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define X first 4 | #define Y second 5 | #define pb push_back 6 | typedef long long ll; 7 | 8 | int n; 9 | int a[2004]; 10 | map occur; 11 | vector add; 12 | int main(void){ 13 | ios::sync_with_stdio(0); 14 | cin.tie(0); 15 | int n; 16 | cin >> n; 17 | for(int i = 0; i < n; i++){ 18 | cin >> a[i]; 19 | occur[a[i]] += 1; 20 | } 21 | for(int i = 0; i < n; i++){ 22 | if(a[i] == 0) continue; 23 | for(int j = i+1; j < n; j++){ 24 | if(a[j] == 0) continue; 25 | add.pb(a[i]+a[j]); 26 | } 27 | } 28 | sort(add.begin(),add.end()); 29 | int cnt = 0; 30 | for(int i = 0; i < n; i++){ 31 | if(binary_search(add.begin(),add.end(),a[i])){ 32 | cnt++; 33 | continue; 34 | } 35 | if(a[i] == 0){ 36 | if(occur[0] >= 3){ 37 | cnt++; 38 | } 39 | continue; 40 | } 41 | if(occur[0] >= 1 and occur[a[i]] >= 2){ 42 | cnt++; 43 | } 44 | 45 | } 46 | cout << cnt; 47 | 48 | } 49 | -------------------------------------------------------------------------------- /9009.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(void) { 5 | vector F; 6 | F.push_back(1); 7 | F.push_back(2); 8 | int len = 2; 9 | while (true) { 10 | int val = F[len - 1] + F[len - 2]; 11 | if (val > 1000000000) 12 | break; 13 | F.push_back(val); 14 | len++; 15 | } 16 | int T; 17 | scanf("%d", &T); 18 | while (T--) { 19 | int N; 20 | scanf("%d", &N); 21 | 22 | vector ans; 23 | int idx = len - 1; 24 | while (N >= 1) { 25 | if (N == 1) { 26 | ans.push_back(1); 27 | break; 28 | } 29 | while (idx >= 0 && F[idx] > N) 30 | idx--; 31 | // 이제 F[idx] <= N인 상태 32 | ans.push_back(F[idx]); 33 | N -= F[idx]; 34 | } 35 | for (int i = ans.size() - 1; i >= 0; i--) 36 | printf("%d ", ans[i]); 37 | printf("\n"); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /11724.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | typedef pair PAIR; 7 | vector edge[1003]; 8 | int isVisited[1003]; 9 | int main(void) { 10 | int N, M; 11 | scanf("%d %d", &N, &M); 12 | while (M--) { 13 | int a, b; 14 | scanf("%d %d", &a, &b); 15 | edge[a].push_back(b); 16 | edge[b].push_back(a); 17 | } 18 | int CCcnt = 0; 19 | for (int i = 1; i <= N; i++) { 20 | if (isVisited[i]) 21 | continue; 22 | CCcnt++; 23 | queue Q; 24 | isVisited[i] = true; 25 | Q.push(i); 26 | while (!Q.empty()) { 27 | int cur = Q.front(); 28 | Q.pop(); 29 | for (auto const& near : edge[cur]) { 30 | if (!isVisited[near]) { 31 | Q.push(near); 32 | isVisited[near] = true; 33 | } 34 | } 35 | } 36 | } 37 | printf("%d", CCcnt); 38 | } 39 | -------------------------------------------------------------------------------- /14791.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | bool istidy(long long N) { 4 | int a = 10; 5 | while (N > 0) { 6 | if (a < N % 10) 7 | return false; 8 | a = N % 10; 9 | N = N / 10; 10 | } 11 | return true; 12 | } 13 | int len(long long N) { 14 | int cnt = 0; 15 | while (N > 0) { 16 | cnt++; 17 | N /= 10; 18 | } 19 | return cnt; 20 | } 21 | long long pow10(int e) { 22 | long long val = 1; 23 | while (e--) val *= 10; 24 | return val; 25 | } 26 | int main(void) { 27 | int T; 28 | scanf("%d", &T); 29 | for (int Case = 1; Case <= T; Case++) { 30 | printf("Case #%d: ", Case); 31 | long long N; 32 | scanf("%lld", &N); 33 | if (istidy(N)) { 34 | printf("%lld\n", N); 35 | continue; 36 | } 37 | int digitN = len(N); 38 | long long tmp = N; 39 | int cnt = 0; 40 | while (tmp > 0) { 41 | tmp /= 10; 42 | cnt++; 43 | if (tmp % 10 == 0) 44 | continue; 45 | long long val = tmp*pow10(cnt) - 1; 46 | if (istidy(val)) { 47 | printf("%lld\n", val); 48 | break; 49 | } 50 | } 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /1504.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int dist[801][801]; 5 | int N, E; 6 | int v1, v2; 7 | void set_dist(void) { 8 | for (int i = 1; i <= N; i++) { 9 | for (int j = 1; j <= N; j++) 10 | dist[i][j] = 0xfffffff; 11 | dist[i][i] = 0; 12 | } 13 | } 14 | int main(void) { 15 | scanf("%d %d", &N, &E); 16 | set_dist(); 17 | while (E--) { 18 | int a, b, c; 19 | scanf("%d %d %d", &a, &b, &c); 20 | dist[a][b] = c; 21 | dist[b][a] = c; 22 | } 23 | scanf("%d %d", &v1, &v2); 24 | for (int k = 1; k <= N; k++) { 25 | for (int i = 1; i <= N; i++) { 26 | for (int j = 1; j <= N; j++) { 27 | dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]); 28 | } 29 | } 30 | } 31 | int ans = min(dist[1][v1] + dist[v1][v2] + dist[v2][N], dist[1][v2] + dist[v1][v2] + dist[v1][N]); 32 | if (ans >= 0xfffffff) 33 | printf("-1"); 34 | else 35 | printf("%d", ans); 36 | } 37 | -------------------------------------------------------------------------------- /15509.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int n, k, m; 6 | bool D[1005]; 7 | vector adj[1005]; 8 | vector cc; 9 | bool isVisited[1005]; 10 | int main(void) { 11 | scanf("%d %d %d", &n, &m, &k); 12 | while (m--) { 13 | int a, b; 14 | scanf("%d %d", &a, &b); 15 | adj[a].push_back(b); 16 | adj[b].push_back(a); 17 | } 18 | for (int st = 1; st <= n; st++) { 19 | if (isVisited[st]) 20 | continue; 21 | int cnt = 0; 22 | isVisited[st]++; 23 | queue Q; 24 | Q.push(st); 25 | while (!Q.empty()) { 26 | cnt++; 27 | int cur = Q.front(); 28 | Q.pop(); 29 | for (int near : adj[cur]) { 30 | if (isVisited[near]) 31 | continue; 32 | isVisited[near] = true; 33 | Q.push(near); 34 | } 35 | } 36 | cc.push_back(cnt); 37 | } 38 | D[0] = true; 39 | for (int num : cc) { 40 | for (int i = 1000 - num; i >= 0; i--) 41 | if (D[i] == true) D[i + num] = true; 42 | } 43 | if (D[k]) 44 | printf("SAFE"); 45 | else 46 | printf("DOOMED"); 47 | } 48 | -------------------------------------------------------------------------------- /1068.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int parent[52]; 6 | int N; 7 | vector sibling[52]; 8 | int main(void) { 9 | int root = -1; 10 | int del_node; 11 | scanf("%d", &N); 12 | for (int i = 0; i < N; i++) { 13 | scanf("%d", &parent[i]); 14 | if (parent[i] == -1) 15 | root = i; 16 | else 17 | sibling[parent[i]].push_back(i); 18 | } 19 | scanf("%d", &del_node); 20 | if (del_node == root) { 21 | printf("0"); 22 | return 0; 23 | } 24 | int cnt = 0; 25 | stack S; 26 | S.push(root); 27 | while (!S.empty()) { 28 | int cur = S.top(); 29 | S.pop(); 30 | if (sibling[cur].size() == 0 || (sibling[cur].size() == 1 && sibling[cur][0] == del_node)) 31 | cnt++; 32 | for (auto const &next : sibling[cur]) { 33 | if (next != del_node) 34 | S.push(next); 35 | 36 | } 37 | } 38 | printf("%d", cnt); 39 | } 40 | -------------------------------------------------------------------------------- /1325.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | typedef pair PAIR; 7 | #define X first 8 | #define Y second 9 | int N, M; 10 | vector adj[10004]; // adj[i] : i를 해킹하면 해킹할 수 있는 컴퓨터들 11 | int D[10004]; // D[i] : i를 해킹했을 때 총 몇개의 컴퓨터를 해킹할 수 있는지 12 | int mx = 0; 13 | int main(void) { 14 | scanf("%d %d", &N, &M); 15 | while (M--) { 16 | int a, b; 17 | scanf("%d %d", &a, &b); 18 | adj[b].push_back(a); 19 | } 20 | for (int st = 1; st <= N; st++) { // st를 해킹할것임 21 | bool isVisited[10005] = { 0, }; 22 | isVisited[st] = true; 23 | stack S; 24 | S.push(st); 25 | int cnt = 1; 26 | while (!S.empty()) { 27 | int cur = S.top(); 28 | S.pop(); 29 | for (auto near : adj[cur]) { 30 | if (!isVisited[near]) { 31 | isVisited[near] = true; 32 | S.push(near); 33 | cnt++; 34 | } 35 | } 36 | } 37 | D[st] = cnt; 38 | mx = max(mx, cnt); 39 | } 40 | for (int i = 1; i <= N; i++) { 41 | if (D[i] == mx) 42 | printf("%d ", i); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /1562.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int D[105][10][1024]; // D[i][j][k] : i자리, 끝자리가 j, 사용된 숫자의 상태가 k 3 | const int MOD = 1000000000; 4 | bool stateIn(int state, int digit) { 5 | return state & (1 << (9 - digit)); 6 | } 7 | int bit_digit(int digit) { 8 | return 1 << (9 - digit); 9 | } 10 | int main(void) { 11 | 12 | for(int i = 1; i <= 9; i++) 13 | D[1][i][1<<(9-i)] = 1; 14 | int N; 15 | scanf("%d", &N); 16 | for (int i = 2; i <= N; i++) { 17 | for (int j = 0; j <= 9; j++) { 18 | for (int k = 1; k < 1024; k++) { 19 | if (!stateIn(k,j)) 20 | continue; 21 | if (j != 0) { 22 | D[i][j][k] = (D[i][j][k] + D[i-1][j - 1][k]) % MOD; 23 | D[i][j][k] = (D[i][j][k] + D[i-1][j - 1][k ^ bit_digit(j)]) % MOD; 24 | } 25 | if (j != 9) { 26 | D[i][j][k] = (D[i][j][k] + D[i-1][j + 1][k]) % MOD; 27 | D[i][j][k] = (D[i][j][k] + D[i-1][j + 1][k ^ bit_digit(j)]) % MOD; 28 | } 29 | } 30 | } 31 | } 32 | int result = 0; 33 | for (int j = 0; j <= 9; j++) 34 | result = (result + D[N][j][1023]) % MOD; 35 | printf("%d", result); 36 | } 37 | -------------------------------------------------------------------------------- /11778.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair, pair > MATRIX; 5 | #define X first 6 | #define Y second 7 | const long long MOD = 1000000007LL; 8 | 9 | MATRIX mul(MATRIX a, MATRIX b) { 10 | return { {(a.X.X*b.X.X + a.X.Y*b.Y.X) % MOD,(a.X.X*b.X.Y + a.X.Y*b.Y.Y) % MOD},{ (a.Y.X*b.X.X + a.Y.Y*b.Y.X) % MOD,(a.Y.X*b.X.Y + a.Y.Y*b.Y.Y) % MOD} }; 11 | } 12 | MATRIX pow(long long a) { 13 | if (a == 0) 14 | return { {1LL,0LL},{0LL,1LL} }; 15 | if (a == 1) 16 | return { {1LL, 1LL}, {1LL, 0LL} }; 17 | MATRIX tmp = pow(a / 2); 18 | if (a % 2 == 0) 19 | return mul(tmp, tmp); 20 | else 21 | return mul(mul(tmp, tmp), { {1LL,1LL},{1LL,0LL} }); 22 | } 23 | 24 | long long fibo(long long a) { 25 | return pow(a).X.Y; 26 | } 27 | long long gcd(long long n, long long m) { 28 | if (n == 0LL) 29 | return m; 30 | return gcd(m%n, n); 31 | } 32 | int main(void) { 33 | long long n, m; 34 | scanf("%lld %lld", &n, &m); 35 | long long g = gcd(n, m); 36 | printf("%lld", fibo(g)); 37 | } 38 | -------------------------------------------------------------------------------- /1025.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char map[10][10]; 6 | int N, M; 7 | bool isSquare(int x) { 8 | int t = (int)sqrt(x); 9 | for (int i = t - 2; i <= t + 2; i++) 10 | if (i*i == x) return true; 11 | return false; 12 | } 13 | bool isOutOfBounds(int x, int y) { 14 | return x < 0 || x >= N || y < 0 || y >= M; 15 | } 16 | int main(void) { 17 | scanf("%d %d", &N, &M); 18 | for (int i = 0; i < N; i++) 19 | scanf("%s", map[i]); 20 | int ans = -1; 21 | for (int x = 0; x < N; x++) { 22 | for (int y = 0; y < M; y++) { 23 | for (int dx = -N; dx < N; dx++) { 24 | for (int dy = -M; dy < M; dy++) { 25 | int val = 0; 26 | if (dx == 0 && dy == 0) 27 | continue; 28 | int curX = x; 29 | int curY = y; 30 | while (!isOutOfBounds(curX, curY)) { 31 | val = 10 * val + (map[curX][curY]-'0'); 32 | if (isSquare(val)) 33 | ans = max(ans, val); 34 | curX += dx; 35 | curY += dy; 36 | } 37 | } 38 | } 39 | } 40 | } 41 | printf("%d", ans); 42 | } 43 | -------------------------------------------------------------------------------- /2263.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int n; 3 | int in[100003]; 4 | int in_idx[1000003]; // inorder에서 번호 i는 in_idx[i]번째에 위치함 5 | int post[100003]; 6 | int pre[100003]; 7 | void solve(int in_st, int post_st, int len) { // in[in_st:in_st+len], post[post_st:post_st+len]를 보고 pre order를 출력하는 함수 8 | if (len == 0) 9 | return; 10 | if (len == 1) { 11 | printf("%d ", post[post_st]); 12 | return; 13 | } 14 | printf("%d ", post[post_st + len - 1]); // post[post_st+len-1]이 현재 subtree의 root의 값이다. preorder이므로 일단 출력. 15 | int rootidx_in = in_idx[post[post_st + len - 1]]; //rootidx_in에는 inorder 상에서의 index가 들어간다. 16 | int len_leftSubtree = rootidx_in - in_st; 17 | solve(in_st, post_st, len_leftSubtree); // left subtree 먼저 18 | int len_rightSubtree = len - len_leftSubtree - 1; 19 | solve(rootidx_in + 1, post_st + len_leftSubtree, len_rightSubtree); 20 | } 21 | int main(void) { 22 | scanf("%d", &n); 23 | for (int i = 0; i < n; i++) { 24 | scanf("%d", &in[i]); 25 | in_idx[in[i]] = i; 26 | } 27 | for (int i = 0; i < n; i++) 28 | scanf("%d", &post[i]); 29 | solve(0, 0, n); 30 | } 31 | -------------------------------------------------------------------------------- /3307.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | typedef long long ll; 9 | typedef pair pii; 10 | int dx[4] = { 1,-1,0,0 }; 11 | int dy[4] = { 0,0,1,-1 }; 12 | #define X first 13 | #define Y second 14 | int n; 15 | int x[200003]; 16 | int r[200003]; 17 | double ans[200003]; 18 | double max_radius(double d, double r) { 19 | return 0.25*d*d / r; 20 | } 21 | vector v; // 반지름 작아지고 오른쪽으로 가는 순으로 저장 22 | int main(void) { 23 | scanf("%d", &n); 24 | for (int i = 0; i < n; i++) 25 | scanf("%d %d", &x[i], &r[i]); 26 | ans[0] = r[0]; 27 | v.push_back(0); 28 | for (int i = 1; i < n; i++) { 29 | ans[i] = r[i]; 30 | while (!v.empty()) { 31 | double rr = max_radius((double)x[i] - x[v.back()], ans[v.back()]); 32 | 33 | ans[i] = min(rr, ans[i]); 34 | if (ans[i] > ans[v.back()]-1e-10) 35 | v.pop_back(); 36 | else 37 | break; 38 | } 39 | v.push_back(i); 40 | } 41 | for (int i = 0; i < n; i++) 42 | printf("%.10f\n", ans[i]); 43 | } 44 | -------------------------------------------------------------------------------- /1958.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char s1[104]; 6 | char s2[104]; 7 | char s3[104]; 8 | int len1, len2, len3; 9 | int D[104][104][104]; // D[i][j][k] : s1[0~i-1], s2[0~j-1], s3[0~k-1]의 subsequence 중 최대 길이 10 | 11 | bool eq3(char a, char b, char c) { 12 | return a == b && b == c; 13 | } 14 | int main(void) { 15 | int mx = 0; 16 | scanf("%s", s1); 17 | scanf("%s", s2); 18 | scanf("%s", s3); 19 | len1 = strlen(s1); 20 | len2 = strlen(s2); 21 | len3 = strlen(s3); 22 | for (int i = 1; i <= len1; i++) { 23 | for (int j = 1; j <= len2; j++) { 24 | for (int k = 1; k <= len3; k++) { 25 | if (eq3(s1[i - 1], s2[j - 1], s3[k - 1])) 26 | D[i][j][k] = D[i - 1][j - 1][k - 1] + eq3(s1[i - 1], s2[j - 1], s3[k - 1]); 27 | else 28 | D[i][j][k] = max(D[i - 1][j][k], max(D[i][j - 1][k], D[i][j][k - 1])); 29 | mx = max(D[i][j][k], mx); 30 | } 31 | } 32 | } 33 | printf("%d", mx); 34 | } 35 | -------------------------------------------------------------------------------- /1509.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int D[2503]; // D[i] : s[:i]의 분할 갯수 6 | bool isPalindrome[2503][2503]; // isPalindrome[i][j] : s[i:j]가 palindrome인지 7 | char s[2503]; 8 | int len; 9 | int main(void) { 10 | scanf("%s", s); 11 | len = strlen(s); 12 | if (len == 1) { 13 | printf("1"); 14 | return 0; 15 | } 16 | if (len == 2) { 17 | printf("%d", 1 + (s[0] != s[1])); 18 | return 0; 19 | } 20 | for (int l = 1; l <= len; l++) { 21 | for (int st = 0; st <= len - l; st++) { 22 | if (l == 1) 23 | isPalindrome[st][st + l] = true; 24 | else if (l == 2) 25 | isPalindrome[st][st + l] = (s[st] == s[st + 1]); 26 | else 27 | isPalindrome[st][st + l] = ((s[st] == s[st + l - 1]) && isPalindrome[st + 1][st + l - 1]); 28 | } 29 | } 30 | D[0] = 0; 31 | D[1] = 1; 32 | D[2] = 1 + (s[0] != s[1]); 33 | for (int i = 3; i <= len; i++) { 34 | D[i] = 0x7f7f7f7f; 35 | for (int j = i - 1; j >= 0; j--) { 36 | if(isPalindrome[j][i]) 37 | D[i] = min(D[i], D[j] + 1); 38 | } 39 | } 40 | printf("%d", D[len]); 41 | } 42 | -------------------------------------------------------------------------------- /3080.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef pair pll; 5 | typedef pair pii; 6 | #define X first 7 | #define Y second 8 | #define pb push_back 9 | int n; 10 | vector node[9000001]; 11 | int idx = 1; 12 | ll mod = 1e9+7; 13 | ll fact[28]; 14 | int main(){ 15 | ios::sync_with_stdio(0); 16 | cin.tie(0); 17 | cin >> n; 18 | fact[0] = 1; 19 | for(int i = 1; i <= 27; i++) fact[i] = fact[i-1]*i%mod; 20 | for(int i = 0; i < n; i++){ 21 | string s; 22 | cin >> s; 23 | s += '+'; 24 | int cur = 1; 25 | for(auto c : s){ 26 | bool find = 0; 27 | for(auto e : node[cur]){ 28 | if(e.X == c-'A'){ 29 | find = 1; 30 | cur = e.Y; 31 | } 32 | } 33 | if(!find){ 34 | idx++; 35 | node[cur].pb({c-'A',idx}); 36 | cur = idx; 37 | } 38 | } 39 | } 40 | ll ans = 1; 41 | for(int i = 1; i <= idx; i++){ 42 | //cout << i << ' ' << node[i].size() << '\n'; 43 | ans = ans * fact[node[i].size()] % mod; 44 | } 45 | cout << ans; 46 | } 47 | -------------------------------------------------------------------------------- /1406.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char init[100003]; 6 | int len = 0; 7 | int main(void) { 8 | scanf("%s", init); 9 | len = strlen(init); 10 | list L; 11 | for (int i = 0; i < len; i++) 12 | L.push_back(init[i]); 13 | auto cursor = L.end(); 14 | int Q; 15 | scanf("%d", &Q); 16 | while (Q--) { 17 | char op[3]; 18 | scanf("%s", op); 19 | if (op[0] == 'P') { 20 | char ins[3]; 21 | scanf("%s", ins); 22 | L.insert(cursor, ins[0]); 23 | } 24 | else if (op[0] == 'L') { 25 | if (cursor != L.begin()) 26 | cursor--; 27 | } 28 | else if (op[0] == 'D') { 29 | if (cursor != L.end()) 30 | cursor++; 31 | } 32 | else { 33 | if (cursor != L.begin()) { 34 | cursor--; 35 | cursor = L.erase(cursor); 36 | } 37 | } 38 | } 39 | for (const auto& elem : L) 40 | printf("%c", elem); 41 | } 42 | -------------------------------------------------------------------------------- /2084.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | int a[2003][2003]; 8 | int main(void){ 9 | ios::sync_with_stdio(0); 10 | cin.tie(0); 11 | int n; 12 | cin >> n; 13 | pair v[n]; 14 | int tot = 0; 15 | for(int i = 0; i < n; i++){ 16 | cin >> v[i].X; 17 | tot += v[i].X; 18 | v[i].Y = i; 19 | } 20 | if(tot%2==1){ 21 | cout << -1; 22 | return 0; 23 | } 24 | while(true){ 25 | sort(v,v+n,greater >() ); 26 | if(v[0].X == 0) break; 27 | int cnt = v[0].X; 28 | v[0].X = 0; 29 | int i = 1; 30 | while(cnt){ 31 | if(i==n){ 32 | cout << -1; 33 | return 0; 34 | } 35 | if(a[v[0].Y][v[i].Y]){ 36 | i++; 37 | continue; 38 | } 39 | a[v[0].Y][v[i].Y] = a[v[i].Y][v[0].Y] = 1; 40 | v[i].X--; 41 | i++; 42 | cnt--; 43 | } 44 | } 45 | for(int i = 0; i < n; i++){ 46 | for(int j = 0; j < n; j++) cout << a[i][j] << ' '; 47 | cout << '\n'; 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /1711.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | 8 | int n; 9 | pair original[1501]; 10 | ll tot = 0; 11 | void calc(int center){ 12 | map, int> M; 13 | int idx = 0; 14 | for(int i = 0; i < n; i++){ 15 | if(i==center) continue; 16 | ll tx = original[i].X-original[center].X; 17 | ll ty = original[i].Y-original[center].Y; 18 | ll g = __gcd(tx,ty); 19 | if(g<0) g = -g; 20 | tx /= g; 21 | ty /= g; 22 | M[{tx,ty}]++; 23 | } 24 | for(auto elem : M){ 25 | ll x = elem.X.X; 26 | ll y = elem.X.Y; 27 | // cout << x << ' ' << y << '\n'; 28 | if(M.find({-y,x}) != M.end()){ 29 | tot += elem.Y * M[{-y,x}]; 30 | // cout << x << ' ' << y << ' ' << tot << endl; 31 | } 32 | } 33 | 34 | } 35 | int main(void){ 36 | ios::sync_with_stdio(0); 37 | cin.tie(0); 38 | cin >> n; 39 | for(int i = 0; i < n; i++) cin >> original[i].X >> original[i].Y; 40 | for(int i = 0; i < n; i++) calc(i); 41 | // calc(0); 42 | cout << tot; 43 | 44 | 45 | } 46 | -------------------------------------------------------------------------------- /11404.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[101][101]; // D[i][j] : i에서 j로 가는 최소비용 5 | int main(void) { 6 | int n, m; 7 | scanf("%d %d", &n, &m); 8 | while (m--) { 9 | int a, b, c; 10 | scanf("%d %d %d", &a, &b, &c); 11 | if (D[a][b] == 0) 12 | D[a][b] = c; 13 | else 14 | D[a][b] = min(D[a][b], c); 15 | } 16 | for (int chk = 1; chk <= n; chk++) { 17 | for (int st = 1; st <= n; st++) { 18 | for (int en = 1; en <= n; en++) { 19 | if (st == en) 20 | continue; 21 | if (D[st][chk] == 0 || D[chk][en] == 0) 22 | continue; 23 | if (D[st][en] == 0) 24 | D[st][en] = D[st][chk] + D[chk][en]; 25 | else 26 | D[st][en] = min(D[st][en], D[st][chk] + D[chk][en]); 27 | } 28 | } 29 | } 30 | for (int i = 1; i <= n; i++) { 31 | for (int j = 1; j <= n; j++) 32 | printf("%d ", D[i][j]); 33 | printf("\n"); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /1933.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define pb push_back 4 | typedef long long ll; 5 | #define X first 6 | #define Y second 7 | int n; 8 | tuple b[100005]; 9 | 10 | vector> schedule; 11 | 12 | int main(){ 13 | ios::sync_with_stdio(0); 14 | cin.tie(0); 15 | cin >> n; 16 | for(int i = 0; i < n; i++){ 17 | int l,h,r; 18 | cin>>l>>h>>r; 19 | schedule.pb({l,h}); 20 | schedule.pb({r,-h}); 21 | } 22 | sort(schedule.begin(),schedule.end()); 23 | schedule.pb({0x7f7f7f7f,0x7f7f7f7f}); 24 | multiset S; 25 | S.insert(0); 26 | int beforex = schedule[0].X; 27 | int beforey = -1; 28 | int i = 0; 29 | while(i < 2*n){ 30 | while(beforex == schedule[i].X){ 31 | int x = schedule[i].X; 32 | int h = schedule[i].Y; 33 | if(h < 0) S.erase(S.find(-h)); 34 | else S.insert(h); 35 | i++; 36 | } 37 | int val = *prev(S.end()); 38 | if(val != beforey){ 39 | cout << beforex << ' ' << *prev(S.end()) << ' '; 40 | beforey = val; 41 | } 42 | beforex = schedule[i].X; 43 | } 44 | 45 | 46 | 47 | 48 | } 49 | 50 | -------------------------------------------------------------------------------- /1992.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | char pic[64][64]; 6 | int N; 7 | 8 | bool isAll0(int x, int y, int sz) { 9 | for (int i = x; i < x + sz; i++) { 10 | for (int j = y; j < y + sz; j++) { 11 | if (pic[i][j] == '1') 12 | return false; 13 | } 14 | } 15 | return true; 16 | } 17 | 18 | bool isAll1(int x, int y, int sz) { 19 | for (int i = x; i < x + sz; i++) { 20 | for (int j = y; j < y + sz; j++) { 21 | if (pic[i][j] == '0') 22 | return false; 23 | } 24 | } 25 | return true; 26 | } 27 | 28 | string quadtree(int x, int y, int sz) { 29 | if (isAll0(x, y, sz)) 30 | return "0"; 31 | if (isAll1(x, y, sz)) 32 | return "1"; 33 | return "(" + quadtree(x, y, sz / 2) + quadtree(x, y + sz / 2, sz / 2) + quadtree(x + sz / 2, y, sz / 2) + quadtree(x + sz / 2, y + sz / 2, sz / 2) + ")"; 34 | } 35 | int main(void) { 36 | scanf("%d", &N); 37 | for (int i = 0; i < N; i++) 38 | scanf("%s", pic[i]); 39 | cout << quadtree(0, 0, N); 40 | } 41 | -------------------------------------------------------------------------------- /1019.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int cnt[10]; 3 | // prefix = 47, sz = 3 -> 47000~47999 4 | // prefix = 5, sz = 2 -> 500~599 5 | // prefix = 1, sz = 1 -> 10~19 6 | // prefix = 42, sz = 0 -> 42~42 7 | int pow10(int a) { 8 | int t = 1; 9 | while (a--) t *= 10; 10 | return t; 11 | } 12 | void calc(int prefix, int sz) { 13 | if (prefix == 0) { 14 | if (sz == 0) 15 | return; 16 | for (int i = 0; i < 10; i++) 17 | cnt[i] += sz * pow10(sz - 1); 18 | for (int i = 1; i < sz; i++) { 19 | cnt[0] -= 9 * pow10(sz - 1 - i)*i; 20 | } 21 | cnt[0] -= sz; 22 | } 23 | else{ 24 | while (prefix) { 25 | cnt[prefix % 10] += pow10(sz); 26 | prefix /= 10; 27 | } 28 | if (sz == 0) 29 | return; 30 | for (int i = 0; i < 10; i++) 31 | cnt[i] += sz * pow10(sz - 1); 32 | } 33 | } 34 | int main(void) { 35 | int N; 36 | scanf("%d", &N); 37 | N++; 38 | int now = 0; 39 | while (now < N) { 40 | for (int i = 0; ; i++) { 41 | if (now + pow10(i) > N) { 42 | calc(now / pow10(i - 1), i - 1); 43 | now += pow10(i - 1); 44 | break; 45 | } 46 | } 47 | } 48 | for (int i = 0; i < 10; i++) 49 | printf("%d ", cnt[i]); 50 | } 51 | -------------------------------------------------------------------------------- /1991.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | char left[26]; 3 | char right[26]; 4 | void pre_travel(int idx){ 5 | printf("%c", (char)idx+'A'); 6 | if(left[idx] != '.') 7 | pre_travel(left[idx]-'A'); 8 | if(right[idx] != '.') 9 | pre_travel(right[idx]-'A'); 10 | } 11 | 12 | void in_travel(int idx){ 13 | if(left[idx] != '.') 14 | in_travel(left[idx]-'A'); 15 | printf("%c", (char)idx+'A'); 16 | if(right[idx] != '.') 17 | in_travel(right[idx]-'A'); 18 | } 19 | void post_travel(int idx){ 20 | if(left[idx] != '.') 21 | post_travel(left[idx]-'A'); 22 | if(right[idx] != '.') 23 | post_travel(right[idx]-'A'); 24 | printf("%c", (char)idx+'A'); 25 | 26 | } 27 | 28 | int main(void){ 29 | int N; 30 | scanf("%d", &N); 31 | for(int i = 0; i < N; i++){ 32 | char t1, t2, t3, t4, t5, t6; 33 | scanf("%c%c%c%c%c%c", &t1, &t2, &t3, &t4, &t5, &t6); // t2 t4 t6 34 | left[t2-'A'] = t4; 35 | right[t2-'A'] = t6; 36 | } 37 | pre_travel(0); 38 | printf("\n"); 39 | in_travel(0); 40 | printf("\n"); 41 | post_travel(0); 42 | printf("\n"); 43 | } 44 | -------------------------------------------------------------------------------- /1517.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int N; 5 | int A[500003]; 6 | long long cnt = 0; 7 | void swap(int* a, int* b) { 8 | int c = *a; 9 | *a = *b; 10 | *b = c; 11 | } 12 | void merge(int st, int mid, int en) { 13 | vector V; 14 | int i = 0, j = 0, len1 = mid - st, len2 = en - mid; 15 | while (i < len1 && j < len2) { 16 | if (A[st+i] > A[mid+j]) { 17 | cnt += len1 - i; 18 | V.push_back(A[mid+j++]); 19 | } 20 | else 21 | V.push_back(A[st+i++]); 22 | } 23 | while (i < len1) 24 | V.push_back(A[st+i++]); 25 | while (j < len2) 26 | V.push_back(A[mid+j++]); 27 | for (int i = st; i < en; i++) 28 | A[i] = V[i - st]; 29 | } 30 | void mergesort(int st, int en) { 31 | if (en == st+1) return; 32 | if (en == st + 2) { 33 | if (A[st] > A[st+1]) { 34 | cnt++; 35 | swap(&A[st], &A[st + 1]); 36 | } 37 | return; 38 | } 39 | int mid = (st + en) / 2; 40 | mergesort(st, mid); 41 | mergesort(mid, en); 42 | merge(st, mid, en); 43 | } 44 | int main(void) { 45 | scanf("%d", &N); 46 | for (int i = 0; i < N; i++) 47 | scanf("%d", &A[i]); 48 | mergesort(0, N); 49 | printf("%lld", cnt); 50 | } 51 | -------------------------------------------------------------------------------- /10216.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair PAIR; 6 | #define X first 7 | #define Y second 8 | int N; 9 | PAIR coor[3003]; 10 | int R[3003]; 11 | bool isVisited[3003]; 12 | int square(int a) { 13 | return a*a; 14 | } 15 | int dist(int i, int j) { 16 | return square(coor[i].X - coor[j].X) + square(coor[i].Y - coor[j].Y); 17 | } 18 | int main(void) { 19 | int T; 20 | scanf("%d", &T); 21 | while (T--) { 22 | scanf("%d", &N); 23 | fill(isVisited, isVisited + N, false); 24 | for (int i = 0; i < N; i++) 25 | scanf("%d %d %d", &coor[i].X, &coor[i].Y, &R[i]); 26 | int cnt = 0; 27 | stack S; 28 | for (int i = 0; i < N; i++) { 29 | if (isVisited[i]) 30 | continue; 31 | S.push(i); 32 | isVisited[i] = true; 33 | cnt++; 34 | while (!S.empty()) { 35 | int cur = S.top(); 36 | S.pop(); 37 | for (int cand = 0; cand < N; cand++) { 38 | if (!isVisited[cand] && dist(cur, cand) <= square(R[cur] + R[cand])) { 39 | isVisited[cand] = true; 40 | S.push(cand); 41 | } 42 | } 43 | 44 | } 45 | } 46 | printf("%d\n", cnt); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /2240.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[1003][31][2]; // D[i][j][k] : i초동안 j번 움직여서 얻을 수 있는 자두의 최대 갯수(마지막에 자두는 k번 자두나무 아래에 위치해있음) 5 | int num[1004]; 6 | int main(void) { 7 | int T, W; 8 | scanf("%d %d", &T, &W); 9 | for (int i = 1; i <= T; i++) { 10 | scanf("%d", &num[i]); 11 | num[i]--; // 처리를 편하게 하기 위해 나무 번호를 0/1로 저장함 12 | } 13 | 14 | 15 | D[0][0][0] = 0; 16 | D[0][0][1] = 0; 17 | for (int i = 1; i <= T; i++) { 18 | D[i][0][0] = D[i - 1][0][0] + (num[i] == 0); 19 | for (int j = 1; j <= W; j++) { 20 | if (i < j) // i초에 i번 이상 위치를 바꾸는건 불가능함 21 | continue; 22 | if (j % 2 == 0) // 반드시 1번 나무에서 0번 나무로 이동해와야하는 상황 23 | D[i][j][0] = max(D[i - 1][j - 1][1], D[i-1][j][0]) + (num[i] == 0); 24 | else // 반드시 0번 나무에서 1번 나무로 이동해와야하는 상황 25 | D[i][j][1] = max(D[i - 1][j - 1][0], D[i-1][j][1]) + (num[i] == 1); 26 | 27 | } 28 | } 29 | int mx = 0; 30 | for (int j = 0; j <= W; j++) { 31 | mx = max(mx, D[T][j][1]); 32 | mx = max(mx, D[T][j][0]); 33 | } 34 | printf("%d", mx); 35 | } 36 | -------------------------------------------------------------------------------- /12921.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int N,X0,A,B,M; 4 | int q[1001],st[1001],en[1001],mid[1001]; 5 | const int MOD = 1e9+7; 6 | int main(void){ 7 | ios::sync_with_stdio(0); 8 | cin.tie(0); 9 | cin>>N>>X0>>A>>B>>M; 10 | for(int i = 0; i < M; i++){ 11 | cin >> q[i]; 12 | q[i]++; 13 | st[i] = 0; 14 | en[i] = MOD-1; 15 | mid[i] = (st[i]+en[i])>>1; 16 | } 17 | sort(q,q+M); 18 | int isDone = 0; 19 | while(!isDone){ 20 | int delta[M+1] = {0,}; 21 | isDone = 1; 22 | int arr = X0; 23 | for(int i = 0; i < N; i++){ 24 | int r = lower_bound(mid,mid+M,arr)-mid; 25 | delta[r]++; 26 | arr = (1ll*arr*A+B)%MOD; 27 | } 28 | int cnt = 0; 29 | for(int i = 0; i < M; i++){ 30 | cnt += delta[i]; 31 | if(st[i] == en[i]) continue; 32 | if(cnt > q[i]) 33 | en[i] = mid[i]-1; 34 | else if(cnt == q[i]) 35 | en[i] = mid[i]; 36 | else 37 | st[i] = mid[i]+1; 38 | mid[i] = (st[i]+en[i])>>1; 39 | if(st[i] != en[i]) isDone = 0; 40 | } 41 | } 42 | long long tot = 0; 43 | for(int i = 0; i < M; i++){ 44 | tot += st[i]; 45 | } 46 | cout << tot; 47 | 48 | 49 | } 50 | -------------------------------------------------------------------------------- /1007.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | typedef long long LL; 7 | typedef pair PAIR; 8 | #define X first 9 | #define Y second 10 | int main(void) { 11 | int T; 12 | scanf("%d", &T); 13 | PAIR point[30]; 14 | while (T--) { 15 | int N; 16 | scanf("%d", &N); 17 | for (int i = 0; i < N; i++) 18 | scanf("%lld %lld", &point[i].X, &point[i].Y); 19 | LL MN = 0x7fffffffffffffffLL; 20 | vector brute(N); 21 | fill(brute.begin() + N / 2, brute.end(), 1); 22 | do { 23 | PAIR val = { 0LL, 0LL }; 24 | for (int i = 0; i < N; i++) { 25 | if (brute[i]) { 26 | val.X += point[i].X; 27 | val.Y += point[i].Y; 28 | } 29 | else { 30 | val.X -= point[i].X; 31 | val.Y -= point[i].Y; 32 | } 33 | } 34 | MN = min(MN, val.X*val.X + val.Y*val.Y); 35 | } while (next_permutation(brute.begin(), brute.end())); 36 | printf("%.6f\n", sqrt((double)MN)); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /2300.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair PAIR; 5 | #define X first 6 | #define Y second 7 | int N; 8 | PAIR building[10005]; 9 | int D[10005]; // D[i] : 0번째부터 i번째 건물까지 연결하는 설치비용의 최솟값 10 | int max3(int a, int b, int c) { 11 | return max(max(a, b), c); 12 | } 13 | int main(void) { 14 | scanf("%d", &N); 15 | for(int i = 0; i < N; i++){ 16 | scanf("%d %d", &building[i].X, &building[i].Y); 17 | if (building[i].Y < 0) 18 | building[i].Y = -building[i].Y; 19 | } 20 | sort(building, building + N); 21 | D[0] = building[0].Y * 2; 22 | for (int i = 1; i < N; i++) { 23 | int mx_height = building[i].Y; 24 | D[i] = D[i - 1] + building[i].Y * 2; 25 | for (int j = i-1; j >= 0; j--) { // j~i번째 건물까지 한 기지국으로 연결할 때 최솟값을 계산해서 D[i]를 갱신할 예정 26 | mx_height = max(mx_height, building[j].Y); 27 | if (j > 0) 28 | D[i] = min(D[i], max(2*mx_height, building[i].X - building[j].X) + D[j - 1]); 29 | else 30 | D[i] = min(D[i], max(2*mx_height, building[i].X - building[j].X)); 31 | } 32 | } 33 | printf("%d", D[N-1]); 34 | } 35 | -------------------------------------------------------------------------------- /7453.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int A[4001], B[4001], C[4001], D[4001]; 4 | int mid1[16000001], mid2[16000001]; 5 | int main(void) { 6 | 7 | int T, TT; 8 | scanf("%d", &T); 9 | TT = T*T; 10 | for (int i = 0; i < T; i++) 11 | scanf("%d %d %d %d", &A[i], &B[i], &C[i], &D[i]); 12 | for (int i = 0; i < T; i++) 13 | for (int j = 0; j < T; j++) 14 | mid1[i*T + j] = -(A[i] + B[j]); 15 | 16 | for (int i = 0; i < T; i++) 17 | for (int j = 0; j < T; j++) 18 | mid2[i*T + j] = C[i] + D[j]; 19 | 20 | sort(mid1, mid1 + TT); 21 | sort(mid2, mid2 + TT); 22 | mid1[TT] = mid2[TT] = 0x7f7f7f7f; 23 | long long cnt = 0; 24 | int idx1 = 0, idx2 = 0; 25 | while(idx1 < TT && idx2 < TT){ 26 | int cnt1 = 0, cnt2 = 0; 27 | if(mid1[idx1] != mid2[idx2]){ 28 | if(mid1[idx1] < mid2[idx2]) idx1++; 29 | else idx2++; 30 | continue; 31 | } 32 | idx1++; cnt1++; idx2++; cnt2++; 33 | while(mid1[idx1] == mid1[idx1-1]){ 34 | idx1++; 35 | cnt1++; 36 | } 37 | while(mid2[idx2] == mid2[idx2-1]){ 38 | idx2++; 39 | cnt2++; 40 | } 41 | cnt += 1ll * cnt1*cnt2; 42 | } 43 | 44 | printf("%lld", cnt); 45 | } 46 | -------------------------------------------------------------------------------- /1023.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef long long ll; 5 | ll D[52][130]; // D[i][j] : 시작 상태가 + (j + 60)일 때 길이 i이면서 괄호ㄴㄴ문자열인 갯수. 음수때문에 + 60을 해서 처리함 6 | int main(void) { 7 | for (int i = 1; i <= 120; i++) { 8 | D[1][i] = 2; 9 | D[0][i] = 1; 10 | } 11 | D[0][60] = 0; 12 | D[1][61] = 1; 13 | for (int i = 2; i <= 50; i++) { 14 | for (int j = 1; j < 60; j++) 15 | D[i][j] = (1ll << i); 16 | for (int j = 60; j <= 120; j++) 17 | D[i][j] = D[i - 1][j - 1] + D[i - 1][j + 1]; 18 | } 19 | ll N, K; 20 | scanf("%lld %lld", &N, &K); 21 | if (N % 2 == 0 && K >= D[N][60]) { // K이 괄호ㄴㄴ수 갯수보다 많은 경우 22 | printf("-1"); 23 | return 0; 24 | } 25 | ll cnt = 0; // 현재 prefix보다 사전순으로 빠른 것들의 갯수 26 | bool isFail = false; // 올바른 괄호쌍이 될 여지가 없으면 true 27 | int prefix_score = 60; // (가 있으면 +1, )가 있으면 -1 28 | for (int i = 1; i <= N; i++) { 29 | ll cmp_val = D[N - i][prefix_score+1]; // '('를 배치했을 때 추가되는 갯수 30 | if (isFail) 31 | cmp_val = 1ll << (N - i); 32 | if (cnt + cmp_val > K) { 33 | prefix_score++; 34 | printf("("); 35 | } 36 | else { 37 | cnt += cmp_val; 38 | prefix_score--; 39 | printf(")"); 40 | } 41 | if (prefix_score < 60) isFail = true; 42 | } 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /1030.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | char ans[101][101]; 5 | int s, N, K, R1, R2, C1, C2; 6 | int pow(int n, int a) { 7 | int val = 1; 8 | while (a--) 9 | val *= n; 10 | return val; 11 | } 12 | int isBlackSection(int i) { 13 | return !((i < (N - K) / 2) || ((N - 1 - i) < (N - K) / 2)); 14 | } 15 | int isContainsRange(int r1, int r2, int c1, int c2) { 16 | if (r1 > R2 || r2 < R1) 17 | return false; 18 | if (c1 > C2 || c2 < C1) 19 | return false; 20 | return true; 21 | } 22 | void solve(int x, int y, int time, int color) { 23 | int p = pow(N, s - time); 24 | if (!isContainsRange(x*p, x*p + p - 1, y*p, y*p + p - 1)) 25 | return; 26 | if (time == s) { 27 | ans[x-R1][y-C1] = color + '0'; 28 | return; 29 | } 30 | for (int i = 0; i < N; i++) { 31 | for (int j = 0; j < N; j++) { 32 | int new_color; 33 | if (color == 1) 34 | new_color = 1; 35 | else 36 | new_color = (isBlackSection(i) && isBlackSection(j)); 37 | solve(x*N + i, y*N + j, time + 1, new_color); 38 | } 39 | } 40 | 41 | } 42 | int main(void) { 43 | scanf("%d %d %d %d %d %d %d", &s, &N, &K, &R1, &R2, &C1, &C2); 44 | solve(0, 0, 0, 0); 45 | for (int i = 0; i < (R2 - R1 + 1); i++) 46 | printf("%s\n", ans[i]); 47 | } 48 | -------------------------------------------------------------------------------- /1565.py: -------------------------------------------------------------------------------- 1 | def gcd(a,b): 2 | if a == 0: return b 3 | return gcd(b%a,a) 4 | 5 | def PrimeFactorization(N): 6 | f = {} 7 | factor = 2 8 | while factor*factor <= N: 9 | while N % factor == 0: 10 | if factor in f: f[factor] += 1 11 | else: f[factor] = 1 12 | N //= factor 13 | factor += 1 14 | if N > 1: 15 | f[N] = 1 16 | return f 17 | 18 | def lcm(f1, f2): 19 | f = {} 20 | for factor in f1: 21 | if factor in f2: 22 | f[factor] = max(f1[factor],f2[factor]) 23 | else: 24 | f[factor] = f1[factor] 25 | for factor in f2: 26 | if not factor in f1: 27 | f[factor] = f2[factor] 28 | return f 29 | 30 | S = input() 31 | D = list(map(int, input().split())) 32 | M = list(map(int, input().split())) 33 | gcdM = M[0] 34 | lcmD = PrimeFactorization(D[0]) 35 | for m in M: 36 | gcdM = gcd(gcdM, m) 37 | 38 | for d in D: 39 | lcmD = lcm(lcmD, PrimeFactorization(d)) 40 | gcdM = PrimeFactorization(gcdM) 41 | val = 1 42 | for factor in lcmD: 43 | if not factor in gcdM: 44 | val = 0 45 | else: 46 | gcdM[factor] -= lcmD[factor] 47 | if gcdM[factor] < 0: 48 | val = 0 49 | if val == 0: 50 | print("0") 51 | else: 52 | for factor in gcdM: 53 | val *= (gcdM[factor]+1) 54 | print(val) 55 | -------------------------------------------------------------------------------- /1167.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define X first 5 | #define Y second 6 | using namespace std; 7 | typedef pair PAIR; // idx, dist 8 | int V; 9 | int d = 0; // 트리의 지름 10 | vector edge[100003]; 11 | bool isVisited[100003]; 12 | int longest_child(int root) { // root의 자식들 중에서 root와 가장 먼 것의 distance 13 | int mx1 = 0; // 가장 먼 dist 14 | int mx2 = 0; // 두번째로 먼 dist. d = max(d, mx1+mx2)로 갱신해주기 위해서. 15 | for (auto child : edge[root]) { 16 | if (isVisited[child.X]) // 이미 방문한 자식은 제외 17 | continue; 18 | isVisited[child.X] = true; // 방문했다고 기록 19 | int dist = longest_child(child.X) + child.Y; // recursive하게 처리 20 | if (dist > mx1) { 21 | mx2 = mx1; 22 | mx1 = dist; 23 | } 24 | else if (dist > mx2) { 25 | mx2 = dist; 26 | } 27 | } 28 | d = max(d, mx1 + mx2); 29 | return mx1; 30 | } 31 | int main(void) { 32 | scanf("%d", &V); 33 | for (int i = 0; i < V; i++) { 34 | int v; 35 | scanf("%d", &v); 36 | while (true) { 37 | int a; 38 | scanf("%d", &a); 39 | if (a == -1) 40 | break; 41 | else { 42 | int b; 43 | scanf("%d", &b); 44 | edge[v].push_back({ a,b }); 45 | } 46 | } 47 | } 48 | isVisited[1] = true; 49 | longest_child(1); 50 | printf("%d", d); 51 | } 52 | -------------------------------------------------------------------------------- /1520.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair PAIR; 6 | #define S second 7 | #define F first 8 | int map[501][501]; 9 | int D[501][501]; // D[i][j] : [0][0] to [i][j]의 경로의 수 10 | pair height[250001]; 11 | int M, N; 12 | int main(void) { 13 | //freopen("input.txt", "r", stdin); 14 | scanf("%d %d", &M, &N); 15 | for (int i = 0; i < M; i++) { 16 | for (int j = 0; j < N; j++) { 17 | scanf("%d", &map[i][j]); 18 | height[i*N + j] = make_pair(map[i][j], make_pair(i, j)); 19 | } 20 | } 21 | sort(height, height + M*N, greater >()); 22 | D[0][0] = 1; 23 | int dx[4] = { 1, -1, 0, 0 }; 24 | int dy[4] = { 0, 0, 1, -1 }; 25 | for (int i = 0; i < M*N; i++) { 26 | int x = height[i].S.F; 27 | int y = height[i].S.S; 28 | for (int dir = 0; dir < 4; dir++) { 29 | if (x + dx[dir] < 0 || x + dx[dir] >= M || y + dy[dir] < 0 || y + dy[dir] >= N) 30 | continue; 31 | if (map[x][y] >= map[x + dx[dir]][y + dy[dir]]) 32 | continue; 33 | D[x][y] += D[x + dx[dir]][y + dy[dir]]; 34 | } 35 | } 36 | printf("%d", D[M - 1][N - 1]); 37 | } 38 | -------------------------------------------------------------------------------- /11659.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int segment[400000]; 3 | int update(int i, int val, int node, int node_st, int node_en) { 4 | if (node_st > i || i > node_en) // i번째 값을 입력받았는데 node_st~node_en 범위 안에 i가 없을 경우 5 | return segment[node]; 6 | if (node_st == node_en) // leaf에 도달한 경우 7 | return segment[node] = val; 8 | int mid = (node_st + node_en) / 2; 9 | return segment[node] = (update(i, val, node * 2, node_st, mid) + update(i, val, node * 2 + 1, mid + 1, node_en)); 10 | } 11 | int query(int a, int b, int node, int node_st, int node_en) { 12 | if (node_en < a || b < node_st) // a~b와 node_st~node_en 범위가 아예 겹치지 않는 경우 13 | return 0; 14 | if (a <= node_st && node_en <= b) // node_st~node_en 범위가 a~b 범위 안에 완벽하게 들어가는 경우 15 | return segment[node]; 16 | int mid = (node_st + node_en) / 2; 17 | return query(a, b, node * 2, node_st, mid)+query(a, b, node * 2 + 1, mid + 1, node_en); 18 | } 19 | 20 | int main(void) { 21 | int N, M; 22 | scanf("%d %d", &N, &M); 23 | for (int i = 1; i <= N; i++) { 24 | int a; 25 | scanf("%d", &a); 26 | update(i, a, 1, 1, N); 27 | } 28 | while (M--) { 29 | int a, b; 30 | scanf("%d %d", &a, &b); 31 | printf("%d\n", query(a, b, 1, 1, N)); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /14444.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /////////////////////////////////////////////////////////////////////// 5 | ////// 1. Only odd-length palindrome ////////////////////////////////// 6 | ////// 2. If even-length palindrome also needed, use pad function ///// 7 | /////////////////////////////////////////////////////////////////////// 8 | class Manacher{ 9 | public: 10 | string S; 11 | vector A; 12 | int N; 13 | Manacher(string _S){ 14 | S = _S; 15 | N = S.size(); 16 | A.resize(N); 17 | } 18 | void calc(){ 19 | int r=-1,p=-1; 20 | for(int i = 0; i < N; i++){ 21 | if(i <= r) A[i] = min(A[2*p-i],r-i); 22 | else A[i] = 0; 23 | for(A[i]++; i-A[i] >= 0 and i+A[i] < N and S[i-A[i]]==S[i+A[i]]; A[i]++); 24 | A[i]--; 25 | if(r < i+A[i]) r = i+A[i],p=i; 26 | } 27 | } 28 | void pad(){ 29 | S.resize(2*N+1); 30 | A.resize(2*N+1); 31 | S[2*N]='.'; 32 | for(int i = N-1; i >= 0; i--){ 33 | S[2*i+1]=S[i]; 34 | S[2*i]='.'; 35 | } 36 | N = 2*N+1; 37 | } 38 | }; 39 | int main(){ 40 | ios::sync_with_stdio(0); 41 | cin.tie(0); 42 | string S; 43 | cin >> S; 44 | Manacher MA(S); 45 | MA.pad(); 46 | MA.calc(); 47 | cout << *max_element(MA.A.begin(),MA.A.end()); 48 | } 49 | -------------------------------------------------------------------------------- /1943.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair pii; 5 | #define X first 6 | #define Y second 7 | int N; 8 | pii coin[105]; 9 | bool D[50004]; // D[i] : i원을 만드는 것이 가능한지. 10 | int main(void) { 11 | for (int tt = 0; tt < 3; tt++) { 12 | for (int i = 0; i <= 50000; i++) 13 | D[i] = false; 14 | D[0] = true; 15 | scanf("%d", &N); 16 | int tot = 0; 17 | for (int i = 0; i < N; i++) { 18 | scanf("%d %d", &coin[i].X, &coin[i].Y); 19 | tot += coin[i].X * coin[i].Y; 20 | } 21 | if (tot % 2 == 1) { 22 | printf("0\n"); 23 | continue; 24 | } 25 | sort(coin, coin + N); 26 | for (int i = 1; i <= coin[0].Y; i++) { 27 | if (coin[0].X * i > tot / 2) 28 | break; 29 | D[i*coin[0].X] = true; 30 | } 31 | if (D[tot / 2]) { 32 | printf("1\n"); 33 | continue; 34 | } 35 | bool isPossible = false; 36 | for (int i = 1; i < N; i++) { 37 | for (int j = tot/2; j >= 0; j--) { 38 | if (!D[j]) 39 | continue; 40 | for (int k = 1; k <= coin[i].Y; k++) { 41 | if (j + k * coin[i].X > tot / 2) 42 | break; 43 | D[j + k * coin[i].X] = true; 44 | } 45 | if (D[tot / 2]) 46 | break; 47 | } 48 | if (D[tot / 2]) 49 | break; 50 | } 51 | printf("%d\n", D[tot / 2]); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /1027.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | typedef long long ll; 4 | using namespace std; 5 | int N; 6 | ll h[53]; 7 | ll left[53]; // 왼쪽으로 보이는 빌딩의 수 8 | ll right[53]; // 오른쪽으로 보이는 빌딩의 수 9 | 10 | int main(void) { 11 | scanf("%d", &N); 12 | for (int i = 0; i < N; i++) 13 | scanf("%lld", &h[i]); 14 | for (int i = 0; i < N; i++) { 15 | int highidx = -1; 16 | for (int l = i - 1; l >= 0; l--) { 17 | if (highidx == -1) { 18 | highidx = l; 19 | left[i]++; 20 | continue; 21 | } 22 | ll x1 = i - l; 23 | ll y1 = h[i] - h[l]; 24 | ll x2 = i - highidx; 25 | ll y2 = h[i] - h[highidx]; // y1/x1 < y2/x2 여야함 26 | if (y1*x2 < x1*y2) { 27 | highidx = l; 28 | left[i]++; 29 | } 30 | } 31 | } 32 | for (int i = 0; i < N; i++) { 33 | int highidx = -1; 34 | for (int r = i + 1; r < N; r++) { 35 | if (highidx == -1) { 36 | highidx = r; 37 | right[i]++; 38 | continue; 39 | } 40 | ll x1 = r - i; 41 | ll y1 = h[r] - h[i]; 42 | ll x2 = highidx - i; 43 | ll y2 = h[highidx] - h[i]; // y1/x1 > y2/x2 여야함 44 | if (y1*x2 > x1*y2) { 45 | highidx = r; 46 | right[i]++; 47 | } 48 | } 49 | } 50 | ll mx = left[0] + right[0]; 51 | for (int i = 0; i < N; i++) 52 | mx = max(mx, left[i] + right[i]); 53 | printf("%lld", mx); 54 | } 55 | -------------------------------------------------------------------------------- /1937.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | #define BAMBOO tuple // tuple => (i, j) 대나무의 길이는 h 6 | int forest[501][501]; // 대나무 길이 저장 7 | int D[501][501]; // D[i][j] : (i, j) 대나무에서 시작했을 때 최대로 생존할 수 있는 날의 수 8 | BAMBOO tmp[250001]; // 대나무를 길이순으로 sort해서 tmp에 저장, 긴 것부터 D[i][j]를 구해나갈 것임 9 | int main(void) { 10 | int n; 11 | scanf("%d", &n); 12 | for (int i = 0; i < n; i++) { 13 | for (int j = 0; j < n; j++) { 14 | scanf("%d", &forest[i][j]); 15 | tmp[i*n + j] = make_tuple( forest[i][j], i, j ); 16 | } 17 | } 18 | int mx = 0; 19 | sort(tmp, tmp + n*n); 20 | int dx[4] = { 1, -1, 0, 0 }; 21 | int dy[4] = { 0, 0, 1, -1 }; 22 | for (int i = n*n - 1; i >= 0; i--) { 23 | int x = get<1>(tmp[i]); 24 | int y = get<2>(tmp[i]); 25 | for (int dir = 0; dir < 4; dir++) { 26 | int x_new = x + dx[dir]; 27 | int y_new = y + dy[dir]; 28 | if (x_new < 0 || x_new >= n || y_new < 0 || y_new >= n || forest[x][y] >= forest[x_new][y_new]) 29 | continue; 30 | D[x][y] = max(D[x][y], D[x_new][y_new]+1); 31 | mx = max(D[x][y], mx); 32 | } 33 | } 34 | printf("%d", mx+1); 35 | } 36 | -------------------------------------------------------------------------------- /2467.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair pii; 6 | #define X first 7 | #define Y second 8 | int N; 9 | int arr[100003]; 10 | vector acid; 11 | vector base; 12 | vector V; 13 | int val1=1000000000, val2=1000000000; 14 | int main(void) { 15 | scanf("%d", &N); 16 | for (int i = 0; i < N; i++) { 17 | int t; 18 | scanf("%d", &t); 19 | if (t > 0) 20 | acid.push_back(t); 21 | else 22 | base.push_back(-t); 23 | } 24 | sort(acid.begin(), acid.end()); 25 | sort(base.begin(), base.end()); 26 | if (acid.size() >= 2) { 27 | if (abs(val2 + val1) > acid[0] + acid[1]) 28 | val1 = acid[0], val2 = acid[1]; 29 | } 30 | if (base.size() >= 2) { 31 | if (abs(val2 + val1) > abs(base[0] + base[1])) 32 | val1 = -base[1], val2 = -base[0]; 33 | } 34 | if (acid.empty() || base.empty()) { 35 | printf("%d %d", val1, val2); 36 | return 0; 37 | } 38 | for (int a : acid) { 39 | auto t = lower_bound(base.begin(), base.end(), a); 40 | if (t != base.begin()) { 41 | if (abs(val2 + val1) > abs(a - *(t - 1))) 42 | val1 = -*(t - 1), val2 = a; 43 | } 44 | if (t != base.end()) { 45 | if (abs(val2 + val1) > abs(a - *t)) 46 | val1 = -(*t), val2 = a; 47 | } 48 | } 49 | printf("%d %d", val1, val2); 50 | } 51 | -------------------------------------------------------------------------------- /1168.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int BIT[100010]; 4 | int N, M; 5 | int sum(int i) { 6 | int ret = 0; 7 | while (i > 0) { 8 | ret += BIT[i]; 9 | i -= (i & -i); 10 | } 11 | return ret; 12 | } 13 | void update(int i, int num) { 14 | while (i <= N) { 15 | BIT[i] += num; 16 | i += (i & -i); 17 | } 18 | } 19 | int count_person(int i, int j) { 20 | j = j % N; 21 | if (j == 0) j = N; 22 | if (j >= i) 23 | return sum(j) - sum(i); 24 | return sum(N) - sum(i) + sum(j); 25 | } 26 | int main(void) { 27 | scanf("%d %d", &N, &M); 28 | for(int i = 1; i <= N; i++) 29 | update(i, 1); 30 | printf("<%d", M); 31 | update(M, -1); 32 | int cur = M; 33 | int left = N-1; 34 | while (left > 0) { 35 | // count_person(cur, i) = N인 최소의 i를 찾고싶다. 36 | int st = cur + 1; 37 | int en = cur + N; 38 | while (st < en) { 39 | int mid = (st + en) / 2; 40 | int val = count_person(cur, mid); 41 | int M_mod = M % left; 42 | if (M_mod == 0) M_mod = left; 43 | if (val < M_mod) 44 | st = mid + 1; 45 | else if (val == M_mod) 46 | en = mid; 47 | else 48 | en = mid - 1; 49 | 50 | } 51 | assert(st == en); 52 | st = st % N; 53 | if (st == 0) st = N; 54 | printf(", %d", st); 55 | cur = st; 56 | update(st, -1); 57 | left--; 58 | } 59 | printf(">"); 60 | } 61 | -------------------------------------------------------------------------------- /1516.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | vector before[503]; // before[i] : i를 짓기 위해 이미 지어져있어야할 건물들 7 | vector after[503]; // after[i] : i가 지어져야 지을 수 있는 건물들 8 | int indegree[503]; 9 | int time[503]; // 그 건물 하나를 짓는데 드는 시간 10 | int D[503]; // 하위건물까지 고려했을 떄 드는 시간 11 | int main(void) { 12 | int N; 13 | scanf("%d", &N); 14 | for (int i = 1; i <= N; i++) { 15 | scanf("%d", &time[i]); 16 | while(true){ 17 | int a; 18 | scanf("%d", &a); 19 | if (a == -1) 20 | break; 21 | before[i].push_back(a); 22 | after[a].push_back(i); 23 | indegree[i]++; 24 | } 25 | } 26 | queue Q; 27 | for (int i = 1; i <= N; i++) { 28 | if (indegree[i] == 0) 29 | Q.push(i); 30 | } // indegree가 없는 건물들(=하위테크가 필요없는 건물들)을 큐에 삽입 31 | while (!Q.empty()) { 32 | int cur = Q.front(); 33 | Q.pop(); 34 | int mx_Subbuilding = 0; // 하위 건물들중에서 가장 오래 걸리는 건물을 짓는데 필요한 시간 35 | for (auto near : before[cur]) 36 | mx_Subbuilding = max(mx_Subbuilding, D[near]); 37 | D[cur] = mx_Subbuilding + time[cur]; 38 | for (auto near : after[cur]) { 39 | indegree[near]--; // 내가 지어져야 지을 수 있는 건물들의 indegree를 1 감소 40 | if (indegree[near] == 0) 41 | Q.push(near); 42 | } 43 | } 44 | for(int i = 1; i <= N; i++) 45 | printf("%d\n", D[i]); 46 | 47 | } 48 | -------------------------------------------------------------------------------- /1941.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | int dx[4] = {1,-1,0,0}; 8 | int dy[4] = {0,0,1,-1}; 9 | char s[6][6]; 10 | int main(void){ 11 | ios::sync_with_stdio(0); 12 | cin.tie(0); 13 | for(int i = 0; i < 5; i++) cin>> s[i]; 14 | vector brute(25); 15 | for(int i = 18; i < 25; i++) brute[i]=1; 16 | int tot = 0; 17 | do{ 18 | vector vis(25); 19 | int st = 0; 20 | while(!brute[st]) st++; 21 | int x = st/5; 22 | int y = st%5; 23 | queue Q; 24 | Q.push(st); 25 | vis[st]=1; 26 | int cnt1 = 0,cnt2=0; 27 | while(!Q.empty()){ 28 | int cur = Q.front(); Q.pop(); 29 | int cx = cur/5; int cy = cur%5; 30 | if(s[cx][cy]=='S')cnt1++; 31 | else cnt2++; 32 | for(int dir = 0; dir < 4; dir++){ 33 | int nx = cx+dx[dir]; 34 | int ny = cy+dy[dir]; 35 | if(0>nx or 0>ny or 4= 4) tot++; 43 | //cout << cnt1 << ' ' << cnt2<<'\n'; 44 | 45 | }while(next_permutation(brute.begin(),brute.end())); 46 | cout < 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | typedef pair PAIR; 7 | char str[1000004]; 8 | char explode[38]; 9 | char result[1000004]; 10 | int main(void) { 11 | scanf("%s", str); 12 | scanf("%s", explode); 13 | int str_len = strlen(str); 14 | int explode_len = strlen(explode); 15 | int st_idx = 0; 16 | stack S; 17 | int match_len = 0; 18 | for (int i = 0; i < str_len; i++) { 19 | if (str[i] == explode[match_len]) 20 | match_len++; 21 | else if (str[i] == explode[0]) 22 | match_len = 1; 23 | else 24 | match_len = 0; 25 | S.push({ str[i], match_len }); 26 | if (match_len == explode_len) { 27 | for (int i = 0; i < explode_len; i++) 28 | S.pop(); 29 | if (!S.empty()) 30 | match_len = S.top().second; 31 | else 32 | match_len = 0; 33 | } 34 | } 35 | int stack_sz = S.size(); 36 | if (stack_sz == 0) { 37 | printf("FRULA"); 38 | return 0; 39 | } 40 | result[stack_sz] = 0; 41 | for (int i = stack_sz - 1; i >= 0; i--) { 42 | result[i] = S.top().first; 43 | S.pop(); 44 | } 45 | printf("%s", result); 46 | } 47 | -------------------------------------------------------------------------------- /1063.py: -------------------------------------------------------------------------------- 1 | import sys 2 | def isOutOfRange(position): 3 | if position[0] > ord('H') or position[0] < ord('A'): return True 4 | if position[1] > ord('8') or position[1] < ord('1'): return True 5 | return False 6 | 7 | tmp1, tmp2, N = tuple(sys.stdin.readline().split()) 8 | N = int(N) 9 | position1 = [ord(tmp1[0]), ord(tmp1[1])] # A 1 10 | position2 = [ord(tmp2[0]), ord(tmp2[1])] # A 2 11 | dir0 = [1,-1,0,0,1,-1,1,-1] 12 | dir1 = [0,0,-1,1,1,1,-1,-1] 13 | for _ in range(N): 14 | mv = sys.stdin.readline()[:-1] 15 | tmp_pos1 = [None]*2 16 | tmp_pos2 = [None]*2 17 | if mv == 'R': dir = 0 18 | elif mv == 'L': dir = 1 19 | elif mv == 'B': dir = 2 20 | elif mv == 'T': dir = 3 21 | elif mv == 'RT': dir = 4 22 | elif mv == 'LT': dir = 5 23 | elif mv == 'RB': dir = 6 24 | else: dir = 7 25 | tmp_pos1 = [position1[0]+dir0[dir], position1[1]+dir1[dir]] 26 | if tmp_pos1 == position2: # 기존의 돌의 위치로 킹이 가게 됐을 경우 27 | tmp_pos2 = [position2[0]+dir0[dir], position2[1]+dir1[dir]] 28 | else: 29 | tmp_pos2 = position2 30 | if isOutOfRange(tmp_pos1) or isOutOfRange(tmp_pos2): continue # 밀고보니 체스판 밖으로 밀려날 경우 31 | position1 = [tmp_pos1[0], tmp_pos1[1]] 32 | position2 = [tmp_pos2[0], tmp_pos2[1]] 33 | sys.stdout.write(chr(position1[0])+chr(position1[1])+'\n'+chr(position2[0])+chr(position2[1])) 34 | -------------------------------------------------------------------------------- /1040.py: -------------------------------------------------------------------------------- 1 | def numkind(N): 2 | if type(N) == int: 3 | N = str(N) 4 | return len(set(list(N))) 5 | 6 | def numList(N): 7 | if type(N) == int: 8 | N = str(N) 9 | tmpL = [0]*10 10 | for c in N: 11 | tmpL[ord(c)-ord('0')] = 1 12 | unused = [] 13 | used = [] 14 | for i in range(10): 15 | if tmpL[i] == 0: unused.append(i) 16 | else: used.append(i) 17 | return unused,used 18 | 19 | def concat(L): 20 | s = '' 21 | for c in L: 22 | s += str(c) 23 | return s 24 | def solve(N,K): 25 | N = str(N) 26 | if numkind(N) == K: 27 | print(N) 28 | return 0 29 | for prefix_i in range(len(N)-1, -1,-1): 30 | for prefix_last in range(ord(N[prefix_i])-48+1,10): 31 | prefix = N[:prefix_i]+chr(prefix_last+48) 32 | leftnum = K-numkind(prefix) # 추가되어야 하는 종류의 갯수 33 | leftlen = len(N)-prefix_i-1 # leftlen만큼의 길이가 추가되어야 함 34 | if leftnum < 0 or leftnum > leftlen: continue # 잘 조정해도 절대 수의 종류를 K개로 만들 수 없다면 35 | unused,used = numList(prefix) 36 | if leftnum == 0: 37 | print(prefix+str(used[0])*leftlen) 38 | return 0 39 | print(prefix+'0'*(leftlen-leftnum)+concat(unused[:leftnum])) 40 | return 0 41 | # 여기에 도달했다는 것은 N자리로는 절대 완성이 불가능해서 N+1자리가 필요한 상황 42 | N = max(K,len(N)+1) 43 | print("1"+"0"*(N-K+1)+"23456789"[:K-2]) 44 | 45 | N,K=map(int,input().split()) 46 | solve(N,K) 47 | -------------------------------------------------------------------------------- /17261.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef pair pll; 5 | typedef pair pii; 6 | #define X first 7 | #define Y second 8 | #define pb push_back 9 | int n; 10 | int k; // 2**k-1 = n 11 | ll d[263000]; // 내 subtree의 용량 12 | ll w[263000]; 13 | ll earn[263000]; 14 | ll ans[263000]; 15 | bool solve(ll t, vector& arr, int idx){ 16 | ll tot = earn[idx]*t; 17 | for(auto e : arr) 18 | tot += max(0ll, t*earn[e]-d[e]); 19 | return tot >= d[idx]; 20 | } 21 | int main(){ 22 | ios::sync_with_stdio(0); 23 | cin.tie(0); 24 | cin >> n; 25 | while((1<> w[i]; 27 | for(int i = n; i >= 1; i--){ 28 | if(2*i > n){ d[i] = w[i]; earn[i] = 1;} 29 | else{ 30 | d[i] = w[i]+d[2*i]+d[2*i+1]; 31 | earn[i] = earn[2*i]*2; 32 | } 33 | } 34 | for(int i = 1; i <= n; i++){ 35 | ll st = 0; 36 | ll en = 2e9+10; 37 | vector arr; 38 | int zz = i; 39 | while(zz != 1){ 40 | if(zz%2 == 0) arr.push_back(zz+1); 41 | else arr.push_back(zz-1); 42 | zz /= 2; 43 | } 44 | 45 | while(st 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | vector edge[101]; 7 | #define PAIR pair 8 | #define X first 9 | #define Y second 10 | int N, M; 11 | int KBvalue(int i) { 12 | queue Q; // First : 사람의 index, Second : depth 13 | Q.push({ i,0 }); 14 | int val = 0; 15 | int isvisited[101] = { false, }; 16 | isvisited[i] = true; 17 | while (!Q.empty()) { 18 | int current = Q.front().X; 19 | int mydepth = Q.front().Y; 20 | Q.pop(); 21 | for (auto const& near : edge[current]) { 22 | if (isvisited[near]) 23 | continue; 24 | val += mydepth + 1; 25 | Q.push({ near, mydepth + 1 }); 26 | isvisited[near] = true; 27 | } 28 | } 29 | return val; 30 | 31 | } 32 | int main(void) { 33 | scanf("%d %d", &N, &M); 34 | while (M--) { 35 | int a, b; 36 | scanf("%d %d", &a, &b); 37 | edge[a].push_back(b); 38 | edge[b].push_back(a); 39 | } 40 | int mnidx = 1; 41 | int mnval = 0x7fffffff; 42 | for (int i = 1; i <= N; i++) { 43 | int val = KBvalue(i); 44 | if (val < mnval) { 45 | mnidx = i; 46 | mnval = val; 47 | } 48 | } 49 | printf("%d", mnidx); 50 | } 51 | -------------------------------------------------------------------------------- /1849.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | int seg[400005]; 8 | void upd(int i, int val, int node, int nl, int nr){ 9 | if(i < nl or i > nr) return; 10 | if(nl == nr){ 11 | seg[node] = val; 12 | return; 13 | } 14 | int mid = (nl+nr)/2; 15 | upd(i,val,2*node,nl,mid); 16 | upd(i,val,2*node+1,mid+1,nr); 17 | seg[node] = seg[2*node]+seg[2*node+1]; 18 | } 19 | int sum(int i, int j, int node, int nl, int nr){ 20 | if(j < nl or i > nr) return 0; 21 | if(i <= nl and nr <= j) return seg[node]; 22 | int mid = (nl+nr)/2; 23 | return sum(i,j,2*node,nl,mid)+sum(i,j,2*node+1,mid+1,nr); 24 | } 25 | int kth(int i, int node, int nl, int nr){ 26 | if(nl == nr) return 1; 27 | int mid = (nl+nr)/2; 28 | if(seg[2*node] >= i) return kth(i,2*node,nl,mid); 29 | else return (mid-nl+1)+kth(i-seg[2*node],2*node+1,mid+1,nr); 30 | } 31 | 32 | int main(void){ 33 | ios::sync_with_stdio(0); 34 | cin.tie(0); 35 | int n; 36 | int ord[100004]; 37 | int ans[100004]; 38 | cin >> n; 39 | for(int i = 1; i <= n; i++) upd(i,1,1,1,n); 40 | for(int i = 1; i <= n; i++){ 41 | int t; 42 | cin >> t; 43 | int kk = kth(t+1,1,1,n); 44 | ans[kk] = i; 45 | upd(kk,0,1,1,n); 46 | } 47 | for(int i = 1; i <= n ; i++) cout << ans[i] << '\n'; 48 | } 49 | -------------------------------------------------------------------------------- /1081.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | long long cnt[10]; 3 | // prefix = 47, sz = 3 -> 47000~47999 4 | // prefix = 5, sz = 2 -> 500~599 5 | // prefix = 1, sz = 1 -> 10~19 6 | // prefix = 42, sz = 0 -> 42~42 7 | long long pow10(int a) { 8 | long long t = 1; 9 | while (a--) t *= 10; 10 | return t; 11 | } 12 | void calc(int prefix, int sz) { 13 | if (prefix == 0) { 14 | if (sz == 0) 15 | return; 16 | for (int i = 0; i < 10; i++) 17 | cnt[i] += sz * pow10(sz - 1); 18 | for (int i = 1; i < sz; i++) { 19 | cnt[0] -= 9 * pow10(sz - 1 - i)*i; 20 | } 21 | cnt[0] -= sz; 22 | } 23 | else { 24 | while (prefix) { 25 | cnt[prefix % 10] += pow10(sz); 26 | prefix /= 10; 27 | } 28 | if (sz == 0) 29 | return; 30 | for (int i = 0; i < 10; i++) 31 | cnt[i] += sz * pow10(sz - 1); 32 | } 33 | } 34 | long long calc(int N) { 35 | if (N <= 0) 36 | return 0; 37 | for (int i = 0; i < 10; i++) 38 | cnt[i] = 0; 39 | N++; 40 | int now = 0; 41 | while (now < N) { 42 | for (int i = 0; ; i++) { 43 | if (now + pow10(i) > N) { 44 | calc(now / pow10(i - 1), i - 1); 45 | now += pow10(i - 1); 46 | break; 47 | } 48 | } 49 | } 50 | long long ans = 0; 51 | for (int i = 0; i < 10; i++) 52 | ans += i * cnt[i]; 53 | return ans; 54 | } 55 | int main(void) { 56 | int L, U; 57 | scanf("%d %d", &L, &U); 58 | printf("%lld", calc(U) - calc(L - 1)); 59 | } 60 | -------------------------------------------------------------------------------- /3665.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair PAIR; 6 | #define X first 7 | #define Y second 8 | int main(void) { 9 | int T; 10 | scanf("%d", &T); 11 | while (T--) { 12 | int n; 13 | scanf("%d", &n); 14 | int cnt[503]; // cnt[i] : 팀 i보다 등수가 높은 팀의 수 15 | int lastrank[503]; // lastrank[i] : 팀 i의 작년의 순위 16 | for (int i = 0; i < n; i++) { 17 | int num; 18 | scanf("%d", &num); 19 | cnt[num] = i; // 팀 num이 i+1등이므로 i개의 팀이 팀 i보다 등수가 높다. 20 | lastrank[num] = i + 1; 21 | } 22 | int m; 23 | scanf("%d", &m); 24 | while (m--) { 25 | int a, b; 26 | scanf("%d %d", &a, &b); 27 | if (lastrank[a] < lastrank[b]) { // a의 순위가 b보다 더 좋을 경우 28 | cnt[a]++; // 팀 a보다 등수가 높지 않던 팀 b가 높아졌으므로 29 | cnt[b]--; 30 | } 31 | else { 32 | cnt[a]--; 33 | cnt[b]++; 34 | } 35 | } 36 | PAIR tmp[503]; 37 | for (int i = 1; i <= n; i++) { 38 | tmp[i - 1] = { cnt[i], i }; 39 | } 40 | sort(tmp, tmp + n); 41 | bool isPossible = true; 42 | for (int i = 0; i < n; i++) { 43 | if (tmp[i].X != i) { // i+1등한 팀에서 그 팀보다 등수가 높은 팀의 수가 i가 아니라면 44 | isPossible = false; 45 | break; 46 | } 47 | } 48 | if (!isPossible) { 49 | printf("IMPOSSIBLE\n"); 50 | continue; 51 | } 52 | for(int i = 0; i < n; i++) 53 | printf("%d ", tmp[i].Y); 54 | printf("\n"); 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /10816.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef pair PAIR; 5 | #define X first 6 | #define Y second 7 | int N, M; 8 | int card[500003]; 9 | PAIR query[500003]; 10 | int ans[500003]; 11 | int main(void) { 12 | scanf("%d", &N); 13 | for (int i = 0; i < N; i++) 14 | scanf("%d", &card[i]); 15 | scanf("%d", &M); 16 | for (int i = 0; i < M; i++) { 17 | scanf("%d", &query[i].X); 18 | query[i].Y = i; 19 | } 20 | sort(card, card + N); 21 | sort(query, query + M); 22 | int idx1 = 0; 23 | int idx2 = 0; 24 | while (idx1 < N && idx2 < M) { 25 | if (idx2 != 0 && query[idx2].X == query[idx2 - 1].X) { 26 | ans[query[idx2].Y] = ans[query[idx2 - 1].Y]; 27 | idx2++; 28 | continue; 29 | } 30 | if (card[idx1] < query[idx2].X) 31 | idx1++; 32 | else if (card[idx1] > query[idx2].X) 33 | idx2++; 34 | else { 35 | ans[query[idx2].Y]++; 36 | idx1++; 37 | } 38 | } 39 | idx2++; 40 | while (idx2 < M) { 41 | if (idx2 != 0 && query[idx2].X == query[idx2 - 1].X) { 42 | ans[query[idx2].Y] = ans[query[idx2 - 1].Y]; 43 | idx2++; 44 | } 45 | else 46 | break; 47 | } 48 | for (int i = 0; i < M; i++) 49 | printf("%d ", ans[i]); 50 | } 51 | -------------------------------------------------------------------------------- /6324.py: -------------------------------------------------------------------------------- 1 | import sys 2 | N = int(sys.stdin.readline()) 3 | for i in range(N): 4 | url = sys.stdin.readline()[:-1] 5 | sys.stdout.write("URL #{}\n".format(i+1)) 6 | sys.stdout.write("Protocol = " + url.split("://")[0] + "\n") 7 | url = url[url.find("://")+3:] 8 | SlashIdx = -1 9 | ColonIdx = -1 10 | for i in range(len(url)): 11 | if url[i] == ":": 12 | if ColonIdx == -1: ColonIdx = i 13 | if url[i] == "/": 14 | if SlashIdx == -1: SlashIdx = i 15 | if ColonIdx == -1 and SlashIdx == -1: 16 | sys.stdout.write("Host = " + url + "\n") 17 | sys.stdout.write("Port = \nPath = \n") 18 | elif ColonIdx == -1 or (SlashIdx > -1 and SlashIdx < ColonIdx): 19 | sys.stdout.write("Host = " + url[:SlashIdx] + "\n") 20 | sys.stdout.write("Port = \n") 21 | sys.stdout.write("Path = " + url[SlashIdx+1:] + "\n") 22 | elif SlashIdx == -1: 23 | sys.stdout.write("Host = " + url[:ColonIdx] + "\n") 24 | sys.stdout.write("Port = " + url[ColonIdx+1:] + "\n") 25 | sys.stdout.write("Path = \n") 26 | else: 27 | sys.stdout.write("Host = " + url[:ColonIdx] + "\n") 28 | sys.stdout.write("Port = " + url[ColonIdx+1:SlashIdx] + "\n") 29 | sys.stdout.write("Path = " + url[SlashIdx+1:] + "\n") 30 | sys.stdout.write("\n") 31 | -------------------------------------------------------------------------------- /1033.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | typedef long long ll; 5 | typedef pair PAIR; // {2, 3} : 2/3을 의미 6 | #define X first 7 | #define Y second 8 | int N; 9 | PAIR material[11]; 10 | PAIR ratio[11][11]; // ratio[a][b] : a가 1일 때 b가 얼마인지. 11 | ll gcd(ll a, ll b) { 12 | if (a == 0ll) 13 | return b; 14 | return gcd(b%a, a); 15 | } 16 | ll lcm(ll a, ll b) { 17 | return a / gcd(a, b) * b; 18 | } 19 | PAIR mul(PAIR a, PAIR b) { 20 | ll c = a.X * b.X; 21 | ll d = a.Y * b.Y; 22 | ll g = gcd(c, d); 23 | return { c / g, d / g }; 24 | } 25 | int main(void) { 26 | scanf("%d", &N); 27 | if (N == 1) { 28 | printf("1"); 29 | return 0; 30 | } 31 | for (int i = 0; i < N - 1; i++) { 32 | int a, b, p, q; 33 | scanf("%d %d %d %d", &a, &b, &p, &q); 34 | ratio[a][b] = { q,p }; 35 | ratio[b][a] = { p,q }; 36 | } 37 | material[0] = { 1,1 }; 38 | for (int repeat = 0; repeat < N; repeat++) { 39 | for (int i = 0; i < N; i++) { 40 | if (material[i].X == 0) 41 | continue; 42 | for (int j = 0; j < N; j++) { // i로부터 j를 갱신할 예정 43 | if (ratio[i][j].X == 0 || material[j].X != 0) 44 | continue; 45 | material[j] = mul(material[i], ratio[i][j]); 46 | } 47 | } 48 | } 49 | ll l = lcm(material[0].Y, material[1].Y); 50 | for (int i = 2; i < N; i++) 51 | l = lcm(l, material[i].Y); 52 | for (int i = 0; i < N; i++) 53 | printf("%lld ", material[i].X * l / material[i].Y); 54 | } 55 | -------------------------------------------------------------------------------- /1753.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #define X first 7 | #define Y second 8 | #define PAIR pair 9 | using namespace std; 10 | vector edge[20001]; 11 | int dist[20001]; 12 | 13 | int main(void){ 14 | int st; 15 | int V, E; 16 | scanf("%d %d", &V, &E); 17 | for(int i = 1; i <= V; i++) 18 | dist[i] = 0x7ffff; 19 | scanf("%d", &st); 20 | while(E--){ 21 | int u, v, w; 22 | scanf("%d %d %d", &u, &v, &w); 23 | edge[u].push_back(make_pair(v, w)); 24 | } 25 | dist[st] = 0; 26 | priority_queue, greater > pq; 27 | pq.push(make_pair(0, st)); 28 | while(!pq.empty()){ 29 | int my_dist = pq.top().X; 30 | int current = pq.top().Y; 31 | pq.pop(); 32 | if(dist[current] < my_dist) 33 | continue; 34 | for(int i = 0; i < edge[current].size(); i++){ 35 | if(dist[edge[current][i].X] > my_dist + edge[current][i].Y){ 36 | dist[edge[current][i].X] = my_dist + edge[current][i].Y; 37 | pq.push(make_pair(dist[edge[current][i].X], edge[current][i].X)); 38 | } 39 | } 40 | } 41 | for(int i = 1; i <= V; i++){ 42 | if(dist[i] == 0x7ffff) 43 | printf("INF\n"); 44 | else 45 | printf("%d\n", dist[i]); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /1967.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef pair PAIR; 6 | #define X first 7 | #define Y second 8 | int N; 9 | int D[10004]; // D[i] : i를 root로 하는 subtree에 속한 node 중에서 i로부터 가장 멀리 떨어진 것과의 거리 10 | int mx = 0; 11 | vector child[10004]; // child[i] : i의 자식들 (node 번호, edge 길이) 12 | void calc(int i) { 13 | D[i] = 0; 14 | int fi = -1; // i를 root로 하는 subtree에 속한 node 중 i와 가장 멀리 떨어진 것의 거리 15 | int se = -1; // i를 root로 하는 subtree에 속한 node 중 i와 두번째로 멀리 떨어진 것의 거리 16 | for (PAIR c : child[i]) { 17 | if (D[c.X] == -1) // 아직 방문하지 않았다면 18 | calc(c.X); 19 | int cur_dist = D[c.X] + c.Y; 20 | D[i] = max(D[i], cur_dist); // D[i] 갱신 21 | if (fi < cur_dist) { // 제일 긴게 갱신된다면 22 | se = fi; 23 | fi = cur_dist; 24 | } 25 | else if (se < cur_dist) // 두번쨰로 긴게 갱신된다면 26 | se = cur_dist; 27 | } 28 | if (se != -1) { // 자식이 2명 이상이라면 29 | mx = max(mx, fi + se); // mx를 갱신 30 | } 31 | } 32 | int main(void) { 33 | scanf("%d", &N); 34 | fill(D, D + N, -1); 35 | for (int i = 0; i < N - 1; i++) { 36 | int a, b, c; 37 | scanf("%d %d %d", &a, &b, &c); 38 | child[a].push_back({ b,c }); 39 | } 40 | calc(1); 41 | for (int i = 1; i <= N; i++) 42 | mx = max(mx, D[i]); // subtree의 자식과 자기 자신이 지름이 될 수 있으므로 추가해줘야함 43 | printf("%d", mx); 44 | } 45 | -------------------------------------------------------------------------------- /6101.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef pair pll; 5 | typedef pair pii; 6 | #define X first 7 | #define Y second 8 | #define pb push_back 9 | 10 | int n,m; 11 | int p[40003]; 12 | int cnt[40003]; 13 | int d[40003]; 14 | int idx[40003][201]; 15 | int main(){ 16 | ios::sync_with_stdio(0); 17 | cin.tie(0); 18 | cin >> n >> m; 19 | for(int i = 1; i <= n; i++) cin >> p[i]; 20 | for(int sz = 1; sz <= 200; sz++){ 21 | fill(cnt,cnt+m+1,0); 22 | int st= 1, en = 1; 23 | int diff = 1; 24 | cnt[p[1]]++; 25 | while(en <= n and diff < sz){ 26 | en++; 27 | if(cnt[p[en]] == 0) diff++; 28 | cnt[p[en]]++; 29 | } 30 | if(en==n+1) break; 31 | while(true){ 32 | while(en <= n and diff == sz){ 33 | // printf("st : %d, en : %d") 34 | idx[en][sz] = st; 35 | en++; 36 | if(cnt[p[en]] == 0) diff++; 37 | cnt[p[en]]++; 38 | } 39 | if(en == n+1) break; 40 | while(diff == sz+1){ 41 | if(cnt[p[st]] == 1) diff--; 42 | cnt[p[st]]--; 43 | st++; 44 | } 45 | } 46 | } 47 | fill(d+2,d+40001,0x3f3f3f3f); 48 | d[1] = 1; 49 | for(int i = 2; i <= n; i++){ 50 | for(int sz = 1; sz <= 200; sz++){ 51 | if(idx[i][sz] == 0) break; 52 | //printf("idx[%d][%d] = %d\n",i,sz,idx[i][sz]); 53 | d[i] = min(d[i],d[idx[i][sz]-1]+sz*sz); 54 | } 55 | } 56 | cout << d[n]; 57 | } 58 | -------------------------------------------------------------------------------- /10711.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define pb push_back 4 | #define X first 5 | #define Y second 6 | typedef pair pii; 7 | char board[1005][1005]; 8 | int n,m; 9 | 10 | int dx[8] = {1,1,1,0,0,-1,-1,-1}; 11 | int dy[8] = {1,0,-1,1,-1,1,0,-1}; 12 | bool vis[1005][1005]; 13 | int chk(int x, int y){ 14 | int cnt = 0; 15 | for(int dir = 0; dir < 8; dir++){ 16 | if(board[x+dx[dir]][y+dy[dir]] == '.') cnt++; 17 | } 18 | return cnt; 19 | } 20 | int main(){ 21 | ios::sync_with_stdio(0); 22 | cin.tie(0); 23 | cin >> n >> m; 24 | int cnt = 0; 25 | vector sand; 26 | for(int i = 0; i < n; i++){ 27 | cin >> board[i]; 28 | } 29 | for(int i = 0; i < n; i++){ 30 | for(int j = 0; j < m; j++){ 31 | if(board[i][j] != '.' and chk(i,j) >= board[i][j]-'0'){ 32 | sand.pb({i,j}); 33 | vis[i][j]=1; 34 | } 35 | } 36 | } 37 | int ans = 0; 38 | while(!sand.empty()){ 39 | ans++; 40 | vector sand2; 41 | for(auto s : sand){ 42 | board[s.X][s.Y] = '.'; 43 | } 44 | for(auto s : sand){ 45 | int x = s.X, y = s.Y; 46 | for(int dir = 0; dir < 8; dir++){ 47 | int nx = x+dx[dir]; 48 | int ny = y+dy[dir]; 49 | if(!vis[nx][ny] and board[nx][ny] != '.' and chk(nx,ny) >= board[nx][ny]-'0'){ 50 | sand2.pb({nx,ny}); 51 | vis[nx][ny] = 1; 52 | } 53 | } 54 | } 55 | sand = sand2; 56 | } 57 | cout << ans; 58 | 59 | } 60 | -------------------------------------------------------------------------------- /11657.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | int edge[503][503]; 7 | int dist1[503]; // 1번 도시로부터 떨어진 거리 8 | const int MAX = 1e9; 9 | typedef pair PAIR; 10 | #define X first 11 | #define Y second 12 | int main(void) { 13 | int N, M; 14 | scanf("%d %d", &N, &M); 15 | for (int i = 1; i <= N; i++) { 16 | dist1[i] = MAX; // dist1 initialization 17 | for (int j = 1; j <= N; j++) 18 | edge[i][j] = MAX; // edge initialization 19 | } 20 | dist1[1] = 0; 21 | while (M--) { 22 | int A, B, C; 23 | scanf("%d %d %d", &A, &B, &C); 24 | edge[A][B] = min(edge[A][B], C); 25 | } 26 | vector adj[503]; // {index, dist} 27 | for (int i = 1; i <= N; i++) { 28 | for (int j = 1; j <= N; j++) { 29 | if (edge[i][j] < MAX) 30 | adj[i].push_back({ j, edge[i][j] }); 31 | } 32 | } 33 | bool negCycle = false; 34 | for (int edge_num = 1; edge_num <= N; edge_num++) { 35 | for (int st = 1; st <= N; st++) { 36 | if (dist1[st] == MAX) 37 | continue; 38 | for (auto near : adj[st]) { 39 | if (dist1[st] + near.Y < dist1[near.X]) { 40 | dist1[near.X] = dist1[st] + near.Y; 41 | if (edge_num == N) // negative cycle이 존재 42 | negCycle = true; 43 | } 44 | } 45 | } 46 | } 47 | if (negCycle) { 48 | printf("-1"); 49 | return 0; 50 | } 51 | for (int i = 2; i <= N; i++) { 52 | if (dist1[i] == MAX) 53 | dist1[i] = -1; 54 | printf("%d\n", dist1[i]); 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /2336.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define X first 4 | #define Y second 5 | #define pb push_back 6 | typedef long long ll; 7 | 8 | 9 | 10 | class Seg { // 0-indexed 11 | public: 12 | int n; 13 | vector a; 14 | Seg(int n) : n(n), a(2*n, 0x7f7f7f) {} 15 | void init() { 16 | for (int i = n - 1; i > 0; i--) a[i] = min(a[i << 1], a[i << 1|1]); 17 | } 18 | void update(int i, ll val) { // change i-th element to val(0-indexed) 19 | for (a[i += n] = val; i > 1; i >>= 1) a[i >> 1] = min(a[i], a[i ^ 1]); 20 | } 21 | // sum of l-th to r-th element(0-indexed) 22 | ll query(int l, int r) { 23 | ll ret = 0x7f7f7f; 24 | for (l += n, r += n+1; l < r; l >>= 1, r >>= 1) { 25 | if (l & 1) ret = min(ret,a[l++]); 26 | if (r & 1) ret = min(ret,a[--r]); 27 | } 28 | return ret; 29 | } 30 | void pushval(int i, ll val){ // set i-th element to val 31 | a[i+n]=val; 32 | } 33 | }; 34 | int n; 35 | int r[3][500003]; 36 | int ord[3][500003]; 37 | int cnt = 0; 38 | int main() { 39 | ios::sync_with_stdio(0); 40 | cin.tie(0); 41 | cin >> n; 42 | for(int i = 0; i < 3; i++){ 43 | for(int j = 1; j <= n; j++){ 44 | cin >> r[i][j]; 45 | ord[i][r[i][j]] = j; 46 | } 47 | } 48 | Seg S(n+10); 49 | for(int i = 1; i <= n; i++){ 50 | int user = r[0][i]; 51 | int r1 = ord[1][user]; 52 | int r2 = ord[2][user]; 53 | if(S.query(1,r1) > r2) cnt++; 54 | S.update(r1, r2); 55 | } 56 | cout << cnt; 57 | } 58 | -------------------------------------------------------------------------------- /2938.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | #define X first 5 | #define Y second 6 | #define pb push_back 7 | 8 | int n; 9 | vector a[3]; 10 | int main(void){ 11 | ios::sync_with_stdio(0); 12 | cin.tie(0); 13 | cin >> n; 14 | if(n==1){ 15 | int t; 16 | cin >> t; 17 | cout << t; 18 | return 0; 19 | } 20 | for(int i = 0; i < n; i++){ 21 | int t; 22 | cin>>t; 23 | a[t%3].pb(t); 24 | } 25 | if(a[0].size() == 0){ 26 | if(a[1].size() != 0 and a[2].size() != 0){ 27 | cout << -1; 28 | return 0; 29 | } 30 | for(auto e : a[1]) cout << e << ' '; 31 | for(auto e : a[2]) cout << e << ' '; 32 | return 0; 33 | } 34 | int sz0 = a[0].size(); 35 | if(sz0 == 1){ 36 | for(auto e : a[1]) cout << e << ' '; 37 | cout << a[0][0] << ' '; 38 | for(auto e : a[2]) cout << e << ' '; 39 | return 0; 40 | } 41 | if(a[1].size() + a[2].size() +1 < a[0].size()){ 42 | cout << -1; 43 | return 0; 44 | } 45 | vector seq; 46 | for(int i = 0 ; i < sz0; i++){ 47 | seq.pb(a[0][i]); 48 | if(i != sz0-1){ 49 | if(!a[1].empty()){ 50 | seq.pb(a[1].back()); 51 | a[1].pop_back(); 52 | } 53 | else{ 54 | seq.pb(a[2].back()); 55 | a[2].pop_back(); 56 | } 57 | } 58 | } 59 | for(auto e : a[1]) cout << e << ' '; 60 | for(auto e : seq) cout << e << ' '; 61 | for(auto e : a[2]) cout << e << ' '; 62 | } 63 | -------------------------------------------------------------------------------- /1029.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int D[1 << 15][17]; // D[i][j] -> i : bitmask j : 마지막으로 그림을 소유한 사람 6 | int N; 7 | char price[17][17]; 8 | int vec2i(vector V) { 9 | int a = 0; 10 | for (auto val : V) { 11 | a = ((a << 1) | val); 12 | } 13 | return a; 14 | } 15 | int bit(int i) { 16 | return 1 << (N-1-i); 17 | } 18 | int main(void) { 19 | scanf("%d", &N); 20 | for (int i = 0; i < N; i++) 21 | scanf("%s", price[i]); 22 | for (int i = 0; i < N; i++) 23 | for (int j = 0; j < N; j++) 24 | price[i][j] -= '0'; 25 | for (int i = 0; i < (1 << N); i++) 26 | for (int j = 0; j < N; j++) 27 | D[i][j] = 0x7ffff; 28 | D[bit(0)][0] = 0; 29 | int ans = 1; 30 | for (int buyer = 2; buyer <= N; buyer++) { 31 | vector tmp(N); 32 | for (int i = N - buyer; i < N; i++) 33 | tmp[i] = 1; 34 | do { // 소유자가 buyer명인 모든 조합에 대해 35 | int bitmask1 = vec2i(tmp); 36 | for (int i = 0; i < N; i++) { 37 | if (tmp[i] == 1) { 38 | // i번째 예술가가 마지막으로 획득하는 상황으로 만듬 39 | int bitmask2 = bitmask1 - bit(i); 40 | for (int lst = 0; lst < N; lst++) { // lst : 두번째 마지막으로 그림을 산 사람. lst가 i에게 그림을 팔 것임 41 | if (lst == i) 42 | continue; 43 | if (D[bitmask2][lst] <= price[lst][i] && price[lst][i] < D[bitmask1][i]) { 44 | D[bitmask1][i] = price[lst][i]; 45 | ans = buyer; 46 | } 47 | } 48 | } 49 | } 50 | } while (next_permutation(tmp.begin(), tmp.end())); 51 | } 52 | printf("%d", ans); 53 | } 54 | -------------------------------------------------------------------------------- /1707.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | vector edge[20001]; 6 | int depth[20001]; 7 | bool solve() { 8 | int V, E; 9 | scanf("%d %d", &V, &E); 10 | for (int i = 1; i <= V; i++) { 11 | depth[i] = -1; 12 | edge[i].clear(); 13 | } 14 | while (E--) { 15 | int a, b; 16 | scanf("%d %d", &a, &b); 17 | edge[a].push_back(b); 18 | edge[b].push_back(a); 19 | } 20 | queue Q; 21 | for (int st = 1; st <= V; st++) { 22 | if (depth[st] != -1) // 이미 방문한 node일 경우 23 | continue; 24 | Q.push(st); 25 | depth[st] = 0; 26 | while (!Q.empty()) { 27 | int cur = Q.front(); 28 | Q.pop(); 29 | for (auto const& a : edge[cur]) { 30 | if (depth[a] != -1) // 이미 방문한 노드일 경우 31 | continue; 32 | depth[a] = depth[cur] + 1; 33 | Q.push(a); 34 | } 35 | } 36 | } 37 | for (int v = 1; v <= V; v++) { 38 | for (auto const& a : edge[v]) { 39 | if ((depth[v] - depth[a]) % 2 == 0) // 인접한데 같은 그룹에 속해있는 경우 40 | return false; 41 | } 42 | } 43 | return true; 44 | } 45 | int main(void) { 46 | int K; 47 | scanf("%d", &K); 48 | while (K--) { 49 | bool tmp = solve(); 50 | if (tmp) 51 | printf("YES\n"); 52 | else 53 | printf("NO\n"); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /1983.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int D[410][410][410]; // D[a][b][c] : 윗칸의 수 a개, 밑칸의 수 b개를 2*c개의 칸에 배치했을 때 최댓값 5 | int box1[401]; 6 | int box2[401]; 7 | int idx1 = 0; 8 | int idx2 = 0; 9 | int max3(int v1, int v2, int v3) { 10 | return max(max(v1, v2), v3); 11 | } 12 | int main(void) { 13 | int N; 14 | scanf("%d", &N); 15 | for (int i = 0; i < N; i++) { 16 | int tmp; 17 | scanf("%d", &tmp); 18 | if (tmp != 0) 19 | box1[idx1++] = tmp; 20 | } 21 | for (int i = 0; i < N; i++) { 22 | int tmp; 23 | scanf("%d", &tmp); 24 | if (tmp != 0) 25 | box2[idx2++] = tmp; 26 | } 27 | 28 | for (int c = 1; c <= N; c++) { 29 | for (int a = 1; a <= min(idx1, c); a++) { 30 | for (int b = 1; b <= min(idx2, c); b++) { 31 | if (b > c - 1 && a > c - 1) 32 | D[a][b][c] = D[a - 1][b - 1][c - 1] + box1[a - 1] * box2[b - 1]; 33 | else if (b > c - 1) 34 | D[a][b][c] = max(D[a][b - 1][c - 1], D[a - 1][b - 1][c - 1] + box1[a - 1] * box2[b - 1]); 35 | else if (a > c - 1) 36 | D[a][b][c] = max(D[a - 1][b][c - 1], D[a - 1][b - 1][c - 1] + box1[a - 1] * box2[b - 1]); 37 | else 38 | D[a][b][c] = max3(D[a - 1][b][c - 1], D[a][b - 1][c - 1], D[a - 1][b - 1][c - 1] + box1[a - 1] * box2[b - 1]); 39 | 40 | } 41 | } 42 | } 43 | printf("%d", D[idx1][idx2][N]); 44 | } 45 | -------------------------------------------------------------------------------- /1693.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | #define X first 6 | #define Y second 7 | typedef pair PAIR; 8 | vector adj[100004]; 9 | vector child[100004]; 10 | const int MAX_COLOR = 20; 11 | bool isVisited[100004]; 12 | int n; 13 | int D[100004][MAX_COLOR + 1]; // D[i][color] : 나의 부모의 색깔이 color일 때 i번째 node를 root로 하는 subtree의 최솟값. color = 0이면 부모가 없는 경우를 의미 14 | void fill_table(int root) { // D[root][0~17]을 채우는 함수. 만약 자식 중에 fill_table() 함수를 수행하지 않은 것이 있다면 자식 먼저 fill_table()을 수행하도록 함 15 | for (auto c : adj[root]) { 16 | if (isVisited[c]) 17 | continue; 18 | isVisited[c] = true; 19 | child[root].push_back(c); 20 | fill_table(c); 21 | } 22 | PAIR min1 = { 0x7ffff000, 100 }; // 최솟값, root의 색깔 23 | PAIR min2 = { 0x7fffffff, 100 }; 24 | for (int i = 1; i <= MAX_COLOR; i++) { // root의 색깔이 i일 때 subtree의 cost의 합 25 | int cost = i; 26 | for (auto c : child[root]) 27 | cost += D[c][i]; 28 | if (make_pair(cost, i) < min1) { 29 | min2 = min1; 30 | min1 = { cost, i }; 31 | } 32 | else if (make_pair(cost, i) < min2) 33 | min2 = { cost, i }; 34 | } 35 | for (int i = 0; i <= MAX_COLOR; i++) 36 | D[root][i] = min1.X; 37 | D[root][min1.Y] = min2.X; // root의 parent의 색깔이 min1.Y일 경우 min1.X대신 min2.X를 써야함 38 | } 39 | int main(void) { 40 | scanf("%d", &n); 41 | for (int i = 0; i < n - 1; i++) { 42 | int a, b; 43 | scanf("%d %d", &a, &b); 44 | adj[a].push_back(b); 45 | adj[b].push_back(a); 46 | } 47 | isVisited[1] = true; 48 | fill_table(1); 49 | printf("%d", D[1][0]); 50 | } 51 | -------------------------------------------------------------------------------- /1196.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | typedef long long ll; 4 | ll N, K; 5 | double harmoni1(ll n) { // for문으로 H(n) 계산 6 | long double Hn = 0.0; 7 | for (ll i = 1; i <= n; i++) 8 | Hn += 1.0 * N / i; 9 | return Hn; 10 | } 11 | double harmoni2(ll n) { // 근사식으로 H(n) 계산 12 | long double Gamma = 0.57721566490153286060651209008240243104215933593992; // Euler–Mascheroni_constant 13 | return N * log1p(n - 1) + N * Gamma + N * 0.5 / n - N * 1.0 / 12 / n / n + N * 1.0 / 120 / n / n / n / n; 14 | } 15 | double brute_smallK() { 16 | long double ans = 0.0; 17 | for (ll i = N - K + 1; i <= N; i++) 18 | ans += 1.0 * N / i; 19 | return ans; 20 | } 21 | double harmoni(ll n) { 22 | if (n > 1000000) 23 | return harmoni2(n); 24 | else 25 | return harmoni1(n); 26 | } 27 | int sign(int n) { 28 | if (n % 2 == 0) 29 | return -1; 30 | return 1; 31 | } 32 | double ln_taylor2() { 33 | // x = K / (N-K); 34 | int approx = 100000; 35 | double ans = 0; 36 | double pow = 1.0 * N / (N - K) * K; 37 | for (int i = 1; i <= approx; i++) { 38 | ans += pow / i * sign(i); 39 | pow = pow * K / (N-K); 40 | if (pow == 0.0) 41 | break; 42 | } 43 | return ans; 44 | } 45 | int main(void) { 46 | scanf("%lld %lld", &N, &K); 47 | 48 | if (K < 20000000LL) { 49 | printf("%.10f\n", brute_smallK()); 50 | return 0; 51 | } 52 | if (K < 10000000000000LL && K < N/10) { 53 | ll A = N - K; 54 | printf("%.10f\n", ln_taylor2() + 0.5 - 0.5*N / A + 1.0 / 12 / N - 1.0*N / 12 / A / A); 55 | return 0; 56 | } 57 | printf("%.10f", harmoni(N) - harmoni(N - K)); 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /1865.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | int edge[503][503]; 7 | int dist1[503]; // 1번 지점으로부터 떨어진 거리 8 | const int MAX = 1e9; 9 | typedef pair PAIR; 10 | #define X first 11 | #define Y second 12 | int main(void) { 13 | int T; 14 | scanf("%d", &T); 15 | while (T--) { 16 | int N, M, W; 17 | scanf("%d %d %d", &N, &M, &W); 18 | for (int i = 1; i <= N; i++) { 19 | dist1[i] = MAX; // dist1 initialization 20 | for (int j = 1; j <= N; j++) 21 | edge[i][j] = MAX; // edge initialization 22 | } 23 | dist1[1] = 0; 24 | while (M--) { 25 | int S, E, T; 26 | scanf("%d %d %d", &S, &E, &T); 27 | edge[S][E] = min(edge[S][E], T); 28 | edge[E][S] = min(edge[E][S], T); 29 | } 30 | 31 | while (W--) { 32 | int S, E, T; 33 | scanf("%d %d %d", &S, &E, &T); 34 | edge[S][E] = min(edge[S][E], -T); 35 | } 36 | vector adj[503]; // {index, dist} 37 | for (int i = 1; i <= N; i++) { 38 | for (int j = 1; j <= N; j++) { 39 | if (edge[i][j] < MAX) 40 | adj[i].push_back({ j, edge[i][j] }); 41 | } 42 | } 43 | bool negCycle = false; 44 | for (int edge_num = 1; edge_num <= N+1; edge_num++) { 45 | for (int st = 1; st <= N; st++) { 46 | for (auto near : adj[st]) { 47 | if (dist1[st] + near.Y < dist1[near.X]) { 48 | dist1[near.X] = dist1[st] + near.Y; 49 | if (edge_num == N+1) // negative cycle이 존재 50 | negCycle = true; 51 | } 52 | } 53 | } 54 | } 55 | if (negCycle) 56 | printf("YES\n"); 57 | else 58 | printf("NO\n"); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /1289.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef long long LL; 6 | typedef pair PAIR; 7 | const LL MOD = 1000000007LL; 8 | #define X first 9 | #define Y second 10 | LL D[100004]; // D[i] : i를 도착지로 하는 경로의 가중치의 합. 단, i의 subtree에서 i로 가는 경로에 대해서만 생각 11 | bool isVisited[100004]; 12 | LL cost = 0; 13 | vector adj[100004]; // 14 | int N; 15 | 16 | LL mod(LL a) { 17 | if (a % MOD < 0) 18 | return a%MOD + MOD; 19 | return a%MOD; 20 | } 21 | LL square(LL a) { 22 | return mod(a*a); 23 | } 24 | void calc(int root) { // D[root]를 계산하고 cost에 root의 subtree간에 이동하는 경로를 추가하는 함수 25 | LL subtree_sum = 0; 26 | LL add_cost = 0; 27 | for (auto c : adj[root]) { 28 | if (isVisited[c.X]) 29 | continue; 30 | isVisited[c.X] = true; 31 | calc(c.X); 32 | LL elem = mod((D[c.X] + 1)*c.Y); 33 | subtree_sum = mod(subtree_sum+elem); 34 | add_cost = mod(add_cost-square(elem)); 35 | } 36 | // D의 subtree의 cost가 {a, b, c, d}라고 한다면 ab+ac+ad+bc+bd+cd를 cost에 추가해줘야하고 이건 ((a+b+c+d)^2-(a^2+b^2+c^2+d^2))/2으로 쉽게 계산 가능 37 | add_cost = mod(add_cost + square(subtree_sum)); 38 | if (add_cost % 2 == 0) 39 | cost = mod(cost + add_cost / 2); 40 | else 41 | cost = mod(cost + (add_cost + MOD) / 2); 42 | D[root] = mod(subtree_sum); 43 | cost = mod(cost + D[root]); 44 | } 45 | int main(void) { 46 | scanf("%d", &N); 47 | for (int i = 0; i < N - 1; i++) { 48 | int a, b, c; 49 | scanf("%d %d %d", &a, &b, &c); 50 | adj[a].push_back({ b,c }); 51 | adj[b].push_back({ a,c }); 52 | } 53 | isVisited[1] = true; 54 | calc(1); 55 | printf("%lld", cost); 56 | } 57 | -------------------------------------------------------------------------------- /2261.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | typedef long long LL; 6 | typedef pair PAIR; 7 | #define X first 8 | #define Y second 9 | #define MAX 1000000000000ll; 10 | PAIR point[500004]; 11 | int n; 12 | 13 | LL square(LL a) { 14 | LL ans = a*a; 15 | return ans; 16 | } 17 | LL dist(PAIR a, PAIR b) { 18 | LL ans = square(a.X - b.X) + square(a.Y - b.Y); 19 | return ans; 20 | } 21 | bool op(PAIR a, PAIR b) { 22 | if (a.Y != b.Y) 23 | return a.Y < b.Y; 24 | else 25 | return a.X < b.X; 26 | } 27 | LL solve(PAIR* point, int st, int en) { // point[st:en]에서의 가까운 두 점의 거리의 제곱을 반환하는 함수 28 | if (en - st == 1) 29 | return MAX; 30 | int mid = (st + en) / 2; 31 | LL d = min(solve(point, st, mid), solve(point, mid, en)); 32 | vector V; // point[st:en]에서 기준선으로부터 거리가 sqrt(d) 이하로 떨어진 점들을 담을 vector 33 | LL sep = point[mid].X; // x = point[mid].X가 기준선 34 | for (int i = st; i < en; i++) { 35 | if (square(point[i].X - sep) <= d) 36 | V.push_back(point[i]); 37 | } 38 | sort(V.begin(), V.end(), op); // y좌표 기준으로 정렬 39 | for (int i = 0; i < V.size(); i++) { 40 | for (int j = i + 1; j < V.size() && j < i + 7; j++) { // 인접한 6개의 점에 대해 41 | d = min(d, dist(V[i], V[j])); // d를 갱신 42 | } 43 | } 44 | return d; 45 | } 46 | 47 | int main(void) { 48 | scanf("%d", &n); 49 | for (int i = 0; i < n; i++) 50 | scanf("%lld %lld", &point[i].X, &point[i].Y); 51 | sort(point, point + n); 52 | printf("%lld\n", solve(point, 0, n)); 53 | 54 | } 55 | -------------------------------------------------------------------------------- /1922.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | tuple edge[100001]; // cost, com1, com2 6 | int parent[1001]; // union-find에 쓰일 예정 7 | int find(int i) { // find a root of i 8 | int root = i; 9 | while (parent[root] >= 0) { 10 | root = parent[root]; 11 | } 12 | int child = i; 13 | while (child != root) { 14 | int tmp = parent[child]; 15 | parent[child] = root; 16 | child = tmp; 17 | } 18 | return root; 19 | } 20 | void uni(int i, int j) { 21 | int tmp = parent[i] + parent[j]; 22 | if (parent[i] > parent[j]) { // i가 가지고 있는 자식이 j가 가지고 있는 자식보다 적을 경우 23 | parent[i] = j; // j가 i의 root가 됨 24 | parent[j] = tmp; // j가 거느리는 자식이 많아짐 25 | } 26 | else { 27 | parent[j] = i; // i가 j의 root가 됨 28 | parent[i] = tmp; // j가 거느리는 자식이 많아짐 29 | } 30 | } 31 | int main(void) { 32 | int N, M; 33 | scanf("%d %d", &N, &M); 34 | for (int i = 1; i <= N; i++) 35 | parent[i] = -1; 36 | for (int i = 0; i < M; i++) { 37 | scanf("%d %d %d", &get<1>(edge[i]), &get<2>(edge[i]), &get<0>(edge[i])); 38 | 39 | } 40 | sort(edge, edge + M); 41 | int cnt = 0; 42 | int cost = 0; 43 | int idx = 0; 44 | while (cnt < N - 1) { 45 | if (find(get<1>(edge[idx])) == find(get<2>(edge[idx]))) { // com1과 com2가 이미 묶여있으면 46 | idx++; continue; 47 | } 48 | //묶여있지 않으면 49 | uni(find(get<1>(edge[idx])), find(get<2>(edge[idx]))); 50 | cost += get<0>(edge[idx]); 51 | cnt++; 52 | } 53 | printf("%d", cost); 54 | } 55 | -------------------------------------------------------------------------------- /2250.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | int N; 6 | int left[10004]; 7 | int right[10004]; 8 | int depth[10004]; 9 | int parent[10004]; 10 | int place[10004]; 11 | int current_place = 1; 12 | int mn_lv[10004]; 13 | int mx_lv[10004]; 14 | void traversal(int cur) { 15 | if (parent[cur] != 0) 16 | depth[cur] = depth[parent[cur]] + 1; 17 | if (left[cur] != -1) 18 | traversal(left[cur]); 19 | place[cur] = current_place++; 20 | mn_lv[depth[cur]] = min(mn_lv[depth[cur]], place[cur]); 21 | mx_lv[depth[cur]] = max(mx_lv[depth[cur]], place[cur]); 22 | if (right[cur] != -1) 23 | traversal(right[cur]); 24 | } 25 | int main(void) { 26 | fill(mn_lv, mn_lv + 10004, 0xfffff); 27 | scanf("%d", &N); 28 | for (int i = 1; i <= N; i++) { 29 | int tmp; 30 | scanf("%d", &tmp); 31 | scanf("%d %d", &left[tmp], &right[tmp]); 32 | if(left[tmp] != -1) 33 | parent[left[tmp]] = tmp; 34 | if(right[tmp] != -1) 35 | parent[right[tmp]] = tmp; 36 | } 37 | int root = -1; 38 | for (int i = 1; i <= N; i++) { 39 | if (parent[i] == 0) { 40 | root = i; 41 | break; 42 | } 43 | } 44 | depth[root] = 1; 45 | traversal(root); 46 | int maxWidthIdx = 1; 47 | for (int i = 2; i < 10004; i++) { 48 | if (mn_lv[i] == 0xfffff) 49 | break; 50 | if (mx_lv[maxWidthIdx] - mn_lv[maxWidthIdx] < mx_lv[i] - mn_lv[i]) 51 | maxWidthIdx = i; 52 | } 53 | printf("%d %d", maxWidthIdx, mx_lv[maxWidthIdx] - mn_lv[maxWidthIdx] + 1); 54 | } 55 | -------------------------------------------------------------------------------- /7562.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define X first 5 | #define Y second 6 | using namespace std; 7 | typedef pair PAIR; 8 | 9 | bool isValid(PAIR tmp, int l) { 10 | if (tmp.X < 0 || tmp.X >= l || tmp.Y < 0 || tmp.Y >= l) 11 | return false; 12 | return true; 13 | } 14 | int calculate(int l, int x1, int y1, int x2, int y2) { 15 | int depth[302][302] = { 0, }; // isvisit의 역할도 겸하기 위해 원래 depth에 1을 더한 채로 가지고 있을 것임 16 | depth[x1][y1] = 1; 17 | queue Q; 18 | int dx[8] = { -2, -1, 1, 2, 2, 1, -1, -2 }; 19 | int dy[8] = { 1, 2, 2, 1, -1, -2, -2, -1 }; 20 | Q.push(make_pair(x1, y1)); 21 | while (!Q.empty()) { 22 | PAIR current = Q.front(); 23 | Q.pop(); 24 | for (int dir = 0; dir < 8; dir++) { 25 | PAIR candidate = make_pair(current.X + dx[dir], current.Y + dy[dir]); 26 | if (!isValid(candidate, l) || depth[candidate.X][candidate.Y] > 0) // 판을 벗어났거나 이미 방문한 곳이면 27 | continue; 28 | Q.push(candidate); 29 | depth[candidate.X][candidate.Y] = depth[current.X][current.Y] + 1; 30 | if (candidate == make_pair(x2, y2)) 31 | return depth[candidate.X][candidate.Y] - 1; 32 | } 33 | } 34 | return -1; 35 | } 36 | int main(void) { 37 | int n; 38 | scanf("%d", &n); 39 | while (n--) { 40 | int l, x1, y1, x2, y2; 41 | scanf("%d %d %d %d %d", &l, &x1, &y1, &x2, &y2); 42 | if (x1 == x2 && y1 == y2) { 43 | printf("0\n"); 44 | continue; 45 | } 46 | printf("%d\n", calculate(l, x1, y1, x2, y2)); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /14891.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | char gear[4][9]; 3 | int idx[4] = { 2,2,2,2 }; 4 | int K; 5 | int main(void) { 6 | for (int i = 0; i < 4; i++) 7 | scanf("%s", gear[i]); 8 | scanf("%d", &K); 9 | while (K--) { 10 | int a, b; 11 | scanf("%d %d", &a, &b); 12 | a--; // index의 편의를 위해 0~3으로 생각a 13 | bool isTurn[3] = { gear[0][idx[0]] != gear[1][(idx[1]+4)%8], gear[1][idx[1]] != gear[2][(idx[2]+4)%8],gear[2][idx[2]] != gear[3][(idx[3]+4)%8] }; 14 | idx[a] = (idx[a] + 8 - b) % 8; 15 | if (a == 0) { 16 | if (isTurn[0]) { 17 | idx[1] = (idx[1] + 8 + b) % 8; 18 | if (isTurn[1]) { 19 | idx[2] = (idx[2] + 8 - b) % 8; 20 | if (isTurn[2]) { 21 | idx[3] = (idx[3] + 8 + b) % 8; 22 | } 23 | } 24 | } 25 | } 26 | else if (a == 1) { 27 | if (isTurn[0]) { 28 | idx[0] = (idx[0] + 8 + b) % 8; 29 | } 30 | if (isTurn[1]) { 31 | idx[2] = (idx[2] + 8 + b) % 8; 32 | if (isTurn[2]) { 33 | idx[3] = (idx[3] + 8 - b) % 8; 34 | } 35 | } 36 | } 37 | else if (a == 2) { 38 | if (isTurn[1]) { 39 | idx[1] = (idx[1] + 8 + b) % 8; 40 | if (isTurn[0]) { 41 | idx[0] = (idx[0] + 8 - b) % 8; 42 | } 43 | } 44 | if (isTurn[2]) 45 | idx[3] = (idx[3] + 8 + b) % 8; 46 | } 47 | else { 48 | if (isTurn[2]) { 49 | idx[2] = (idx[2] + 8 + b) % 8; 50 | if (isTurn[1]) { 51 | idx[1] = (idx[1] + 8 - b) % 8; 52 | if (isTurn[0]) { 53 | idx[0] = (idx[0] + 8 + b) % 8; 54 | } 55 | } 56 | } 57 | } 58 | } 59 | int score = 1 * (gear[0][(idx[0]+6)%8] == '1') + 2 * (gear[1][(idx[1]+6)%8] == '1') + 4 * (gear[2][(idx[2]+6)%8] == '1') + 8 * (gear[3][(idx[3]+6)%8] == '1'); 60 | printf("%d", score); 61 | } 62 | --------------------------------------------------------------------------------