plzrun's algorithm

plzrun.com을 새로 만들었습니다.

plzrun — Sun, 23 Nov 2025 02:41:22 +0900

이 사이트를 만든지 9년정도 됐군요.

20년도 정도부터 계속 방치되어왔는데,

다시 포스팅을 시작해보려고 합니다.

오랜만에 이전에 적은 글들을 보니

고등학생이 쓴 글 같네요.. 하하

새로 올리는 글은 좀 더 잘 작성해보겠습니다.

요즘은 종만북을 다시보며 algospot문제를 풀고 있습니다.

문제 하나씩 풀면서 글을 올려보겠습니다.

제게 하고싶은 말이 있으시면 https://plzrun.com 오셔서 방명록에 글 남겨주시면 됩니다.

감사합니다.

Edu 80. Div2 E - 수열의 x번째 수를 꺼내서 계속 앞으로 가져다 놓기.

plzrun — Sun, 19 Jan 2020 16:21:40 +0900

https://codeforces.com/contest/1288/problem/E

Problem - E - Codeforces

codeforces.com

[1 2 3 4 5] 라는 수열이 있을 때

3이라고 입력하면

[3 1 2 4 5]를 만들고

여기서 4라고 입력하면

[4 3 1 2 5]를 만들려고 한다.

이 때 각 숫자마다 숫자가 존재했던 위치의 max값을 구하는 문제다.

segtree나 fenwick을 이용하는 전형적인 문제.

x의 suffix sum이 현재 x보다 앞에 있는 숫자들의 개수를 알려준다고 하면

suffix sum은 fenwick이나 segtree등으로 쉽게 구할 수 있다.

다만 x의 suffix sum을 구하고 난 다음 이 x라는 숫자를 맨 앞으로 가져가야 하는데,

이를 위해 x를 제외한 나머지 숫자들을 오른쪽으로 한칸씩 움직이면 답이 없다.

그래서 애초에 suffix sum을 구하는 방을 n+m+1개만큼 만들고

[m+1, n+m] 구간부터 사용한다.

처음 x라는 숫자가 맨 앞으로 이동한다면,

1. query(m+x)로 max를 업데이트

2. update(m+x, -1)로 x위치를 없애주고

3. update(m+1 -1, 1)로 맨 앞에 위치하게될 x를 표현해준다.

물론 x의 위치가 계속 변하기 때문에 lastPos같은 배열을 만들어서 마지막으로 x가 저장된 fenwick tree의 인덱스를 표현해야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
typedef pair<int,int> pii;
int n,m;
vector<int> fen,a;
pii ans[300001];
int lastPos[300001];
void update(int at, int by) {
    for(; at<=n+m; at+=at&-at) fen[at] += by;
}
int query(int at) {
    int ret = 0;
    for(; at>0; at-=at&-at) ret += fen[at];
    return ret;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> m;
    fen.clear(); fen.resize(n+m+1, 0);
    for(int i=1; i<=n; i++) {
        update(m+i,1);
        lastPos[i] = m+i;
        ans[i].first = i;
    }
    for(int i=1; i<=m; i++) {
        int x; cin >> x;
        a.push_back(x);
 
        ans[x].first = 1;
        ans[x].second = max(ans[x].second, query(lastPos[x]));
        update(lastPos[x],-1);
        update(m-i+1, 1);
        lastPos[x] = m-i+1;
    }
    for(int i=1; i<=n; i++) {
        ans[i].second = max(ans[i].second, query(lastPos[i]));
        printf("%d %d\n", ans[i].first, ans[i].second);
    }
 
    return 0;
}
Colored by Color Scripter

cs

이와 유사한 문제로는 BOJ 3653이 있다.

https://www.acmicpc.net/problem/3653

3653번: 영화 수집

문제 상근이는 영화 DVD 수집가이다. 상근이는 그의 DVD 콜렉션을 쌓아 보관한다. 보고 싶은 영화가 있을 때는, DVD의 위치를 찾은 다음 쌓아놓은 콜렉션이 무너지지 않게 조심스럽게 DVD를 뺀다. 영화를 다 본 이후에는 가장 위에 놓는다. 상근이는 DVD가 매우 많기 때문에, 영화의 위치를 찾는데 시간이 너무 오래 걸린다. 각 DVD의 위치는, 찾으려는 DVD의 위에 있는 영화의 개수만 알면 쉽게 구할 수 있다. 각 영화는 DVD 표지에 붙어있는 숫

www.acmicpc.net

Codeforces Edu80. Div2. D

plzrun — Sat, 18 Jan 2020 16:56:12 +0900

https://codeforces.com/contest/1288/problem/D

Problem - D - Codeforces

codeforces.com

n=6 m=5
a1: 5 0 3 1 2
a2: 1 8 9 1 3
a3: 1 2 3 4 5
a4: 9 1 0 3 7
a5: 2 3 0 6 3
a6: 6 4 1 7 0

a수열 2개만 뽑아서 각 자리마다 max값을 취함. 이 수열을 c라고 하자.

c = { max(a11,a21), max(a12, a22), max(a13,a23), max(a14, a24), max(a15, a25) } 인 셈.

이제 수열 c값들의 minimum값을 구함.

이 min값의 최대값을 구하는 문제

min값을 이분탐색으로 추정한다.

그럼 이 min값 이상인 것들은 1이라 표시하고 미만인 것들은 0이라 표시하면

수열이 1과 0으로만 이루어진 상태가 된다.

n 제한이 30만이나 돼서 두 a수열의 OR(|) 결과가 111...1이 되는 것들을 찾기 힘들어 보이지만,

m 제한이 8밖에 안되므로 두 a수열의 OR(|) 결과값은 많아야 2^8 = 256개 만큼만 나오는 것을 알 수 있다.

그러므로 n개의 수열 a를 256개 이하의 1과 0으로 이루어진 수열로 줄여놓고

여기서 두 수열의 'OR(|)'값이 모두 1로 이루어진 것을 찾는다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <cstdio>
#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
using namespace std;
vector<vector<int>> a;
map<int,vector<int>> dic;
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    int n,m; cin >> n >> m;
    a.clear(); a.resize(n, vector<int>(m));
    int mn=0x3f3f3f3f, mx=-1;
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            cin >> a[i][j];
            mn = min(mn, a[i][j]);
            mx = max(mx, a[i][j]);
        }
    }
 
    unsigned char mask = ((1<<m)-1);
    int lo=mn, hi=mx;
    int ansl, ansr;
    while(lo<=hi) {
        int mid = (lo+hi)/2;
        dic.clear();
        for(int i=0; i<n; i++) {
            int bit = 0;
            for(int j=0; j<m; j++) {
                if(a[i][j]>=mid) bit|=(1<<j);
            }
            dic[bit].push_back(i);
        }
 
        bool good =false;
        for(map<int,vector<int>>::iterator it = dic.begin(); it!=dic.end(); it++) {
            for(auto jt = it; jt!=dic.end(); jt++) {
                if((it->first | jt->first) == mask) {
                    good = true;
                    ansl = it->second[0];
                    ansr = jt->second[0];
                    break;
                }
            }
            if(good) break;
        }
 
        if(good) lo = mid+1;
        else hi = mid-1;
    }
    printf("%d %d\n", ansl+1, ansr+1);
    return 0;
}
Colored by Color Scripter
cs

같은 것 포함인 오름차순(내림차순이 아닌) 경우의 수

plzrun — Sat, 18 Jan 2020 16:37:51 +0900

https://codeforces.com/contest/1288/problem/C

Problem - C - Codeforces

codeforces.com

Edu 80. div2. C

콘테중에는 못풀었지만 그래도 콘테 끝나고 나서 풀 수 있었음.

나중에 알고보니 아이디어가 참 좋은 문제.

a1, a2, ..., am

b1, b2, ..., bm

이렇게 m개의 수열 a, b가 있을 때,

ai <= bi가 되는 경우의 수는? (a, b 수열은 [1,n]의 수로 구성)

답: 2m+(n-1) C 2m

일단 b수열을 거꾸로 하게 되면,

a1, a2, ..., am, bm, bm-1, ..., b2, b1이 같은것을 포함

그럼 2m 길이에 [1,n]숫자를 차례로 부여하면 된다.

만약 숫자를 반드시 하나라도 꼭 써야 한다면 답은 2m C n이 될 것이다.

하지만, 모든 수를 반드시 써야하지 않으니까

숫자1이 쓰이는 개수를 x1, 2는 x2, ..., n은 xn이라고 하면,

x1 + x2 + ... + xn = 2m이 되고 x1을 |형태로 나타내면

|| + ||||| + + ... + ||| = 2m 형태로 볼 수 있다.

즉, '+'는 n-1개 '|' 2m개 존재하므로,

어렸을 때 배웠던 aaaaabbb의 Permutation을 생각해보면 (전체)! / ((a개수)! (b개수)!) 이므로,

(2m + (n-1))! / ((2m)! * (n-1)!) 이다. (즉, 2m+n-1 C 2m인 셈)

나머지는 조합 이용해서 구하면 된다.

순열/조합 부분이 잘 이해가 되지 않으면 아래 사이트를 보면 됨.

https://sites.math.northwestern.edu/~mlerma/courses/cs310-05s/notes/dm-gcomb

불러오는 중입니다...

근데.. 나는 좀 다르게 풀었음.

위에서 언급했던 Key Idea가 생각나지 않아서

우선은 m길이를 같은것 포함하는 오름차순 경우의 수를 셌더니

m=1일때 m=2일때.. 이렇게 조사해보니 (n+m-1)C(m)이라는 것을 알아냄. (여기까지 한참 걸림)

그 다음 am 숫자가 1이면 a 수열은 m-1길이에 대해서 (1+(m-1)-1)C(m-1)만큼 존재할 것이고,

b수열은 m길이에 대해서 아까와 같은 경우의 수 (n+m-1Cm)만큼이 존재할 것임.

그래서 a수열의 am 숫자(i)가 1부터 n까지 반복문 돌면서 (i+(m-1)-1)C(m-1) * ((n-i+1)+m-1)C(m) 값을 모두 더해서 답을 구함.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <cstdio>
using namespace std;
typedef long long ll;
ll d[1111][11];
ll mod = 1e9+7;
ll f(int n, int r) {
    if(r==0 || n==r) return d[n][r]=1LL;
    ll &ret = d[n][r];
    if(ret > 0LL) return ret;
 
    return ret = (f(n-1,r) + f(n-1,r-1)) % mod;
}
int main() {
    int n,m; scanf("%d%d",&n,&m);
    ll ans = 0LL;
    for(int i=1; i<=n; i++) {
        ans += f(i+(m-1)-1,m-1) * f((n-i+1)+m-1,m);
        ans %= mod;
    }
    printf("%lld", ans);
    return 0;
}
 
Colored by Color Scripter

cs

XOR 문제. bit단위로 max(a_i xor X)를 최소로 하는 값 구하기

plzrun — Sun, 12 Jan 2020 20:08:52 +0900

Codeforces Round #613 Div2. D - Dr. Evil Underscores

Problem - D - Codeforces

codeforces.com

Q. XOR 문제. bit단위로 max(a_i xor X)를 최소로 하는 값 구하기

콘테중 못푸는 문제가 있는데,

그 중 어떤 문제는 답을 봐도 내가 나중에 절대 풀 수 있을 것 같지 않은 문제가 있다.

이 문제가 그런 문제중 하나..

[0, 2^30-1] 범위의 정수를 N개(최대 10만) 받고,

max(a_i xor X)을 구하는데, 이 값이 최소가 되도록 X라는 정수값을 골라보자.

문제는 X를 구하는게 아니라 max(a_i xor X)의 가능한 최소값을 구하는 것이다.

푸는 방법.

최상위 비트부터 X값을 만들어본다고 생각하자.

a배열의 최상위 비트(ex. 30번째 bit)는 0 or 1 모두 존재한다고 하면,

가능한 최소값을 구하는 X의 최상위 비트는 0 or 1을 모두 선택할 수 있다.

어떤 값을 선택하든 우리가 구하고자 하는 가능한 최소값의 최상위 비트는 1이 될 것이기 때문이다.

하지만 X의 최상위 비트는 0이나 1중에 아무거나 선택할 수 없다.

왜냐하면 X의 최상위 비트로 0을 선택하게 된 경우,

a_i의 최상위 비트가 0인 경우는 그 아래의 하위비트가 뭐든지 간에 max(a_i xor X)값이 될 수 없다.

(즉, max값이 될 수 없다.)

당연한 얘기지만, a_i xor X의 최상위 비트가 1이 만들어질 수 있는 환경에서 0이 되었다는 것은 절대 max값이 아니란 얘기기 때문이다.

그럼 a_i의 최상위 비트가 0만 있는 경우는 어떨까?

X의 최상위 비트는 0이 될 수 밖에 없다.

a_i xor X 연산중 최상위 비트끼리의 연산은 0이 되는것이 max(a_i xor X)의 가능한 최소값을 구하는 일이기 때문이다.

a_i의 최상위 비트가 1만 있는 경우는 위와 반대로 X의 최상위 비트가 1이 될 수 밖에 없다.

그럼 그 다음 하위 bit(최상위 비트의 바로 다음 bit)를 고려해보자.

max(a_i xor x)의 가능한 최소값을 구하는 것이 목적이므로

가장 최하위 비트부터 어떻게 구해왔든간에 max(a_i xor X)중 최소값을 답으로 가지고 있다면,

현재 최상위 비트의 상태에 따라 답을 갱신해주기만 하면 된다.

이는 현재 보고 있는 bit가 0이나 1인 a_i가 있을 땐 가능한 최소값이 min(solve(left, bit-1), solve(right, bit-1)) | (1<<bit) 꼴이 될 것이고,

현재 보고 있는 bit가 모두 0이거나 모두 1로 구성되어 있을 땐 가능한 최소값이 solve(right, bit-1) or solve(left, big-1)이 될 것이다.

이를 코드로 구현하면 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> a;
int f(vector<int> &v, int bit) {
    if(v.empty() || bit<0) return 0LL;
 
    vector<int> l,r;
    for(int &x: v) {
        if((x>>bit)&1) r.push_back(x);
        else l.push_back(x);
    }
 
    if(l.empty() || r.empty()) return f(l.empty()?r:l, bit-1);
    else return min(f(l,bit-1), f(r,bit-1)) | (1<<bit);
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    int n; cin >> n;
    a.clear(); a.resize(n,0);
    for(int i=0; i<n; i++) cin >> a[i];
 
    printf("%d", f(a,30));
    return 0;
}
Colored by Color Scripter

cs

LIS(Longest Increasing Subsequence) 구하는데 정확히는 Subsequence가 모두 붙어있는 수열(Substring)을 구하는 경우.

plzrun — Sat, 11 Jan 2020 20:06:52 +0900

Codeforces Round #613 Div2. B - Just Eat It! 1000Pts.

Problem - B - Codeforces

codeforces.com

LIS(Longest Increasing Subsequence) 구하는데 정확히는 Subsequence가 모두 붙어있는 수열을 구하는 경우.

수열은 v[1], v[2], ..., v[n], n=10만, v[x]는 [-10억,10억] 범위

1. 상태공간 정의

dp[x] = x번째 배열을 반드시 포함하는 최대값

2. 점화식

dp[x] = max(0, dp[x-1]) + v[x];

DP문제 자체는 쉬운데 한가지 조건이 있었으니 n개를 모두 포함하는 수열은 답에서 제외해야 했다.

그래서 나는 f(n-1)을 구하고 v[1]=0으로 만든 뒤 f(n)을 한번 더 구했다.

실수 할 부분이 많았음. ㅠ 앞으로는 주의하자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
vector<ll> v;
ll dp[100010];
int chk[200020];
 
ll f(int x, int z) {
    ll &ret = dp[x];
    if(x==1) return ret=v[x];
    if(chk[x] == z) return ret;
 
    return ret = max(0LL, f(x-1,z)) + v[x];
}
int main() {
    int tc; scanf("%d", &tc);
    for(int z=1; z<=tc; z++) {
        int n; scanf("%d", &n);
        v.clear(); v.resize(n+1, 0LL);
        ll yasser=0LL, adel=0LL;
        for(int i=1; i<=n; i++) {
            scanf("%lld", &v[i]);
            yasser += v[i];
        }
 
        f(n-1,z);
        for(int i=1; i<=n-1; i++) {
            adel = max(adel, dp[i]);
        }
 
        v[1]=0LL;
        f(n,z+tc);
 
        for(int i=2; i<=n; i++) {
            adel = max(adel, dp[i]);
        }
        if(yasser > adel) puts("YES");
        else puts("NO");
    }
    return 0;
}
 
Colored by Color Scripter

cs

 

임의의 X에 대해 LCM(a,b) = X를 만족하는 a,b중 max(a,b)를 최소로 하는 a,b 구하기

plzrun — Sat, 11 Jan 2020 19:58:35 +0900

Codeforces Round #613 Div2. C - Fadi and LCM 1250Pts.

Problem - C - Codeforces

codeforces.com

Q. 임의의 X에 대해 LCM(a,b) = X를 만족하는 a,b중 max(a,b)를 최소로 하는 a,b 구하기

LCM(a,b) = a * b / GCD(a,b) 이므로

X가 정해진 이상 max(a,b)를 최소로 하기 위해선 a*b/GCD(a,b)를 최소로 해야 하며,

GCD(a,b)가 1일때 max(a,b)는 최소가 될 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
inline ll gcd(ll b, ll s) {
    return (s==0LL)?b:gcd(s, b%s);
}
int main() {
    ll mn=0x3f3f3f3f3f3f3f3fLL,a=0,b=0;
    ll n; scanf("%lld", &n);
    for(ll i=1; i*i<=n; i++) {
        if(n%i == 0) {
            ll j=n/i;
            if(gcd(i,j) == 1LL) {
                if(max(i,j) < mn) {
                    mn = max(i,j);
                    a=i; b=j;
                }
            }
        }
    }
    printf("%lld %lld\n", a,b);
    return 0;
}
 
Colored by Color Scripter

cs

[Codeforces] Two Pointers Div2. C~D 난이도 (Update 19.12.29)

plzrun — Fri, 27 Dec 2019 02:58:38 +0900

Problems	Solved	Name	Difficulty	Solved
580B	O	Kefa and Company	1500	x9884
		binary search, sortings, two pointers
676C	O	Vasya and String	1500	x7629
		binary search, dp, strings, two pointers
701C	O	They Are Everywhere	1500	x6398
		binary search, strings, two pointers
1190A	O	Tokitsukaze and Discard Items	1500	x6336
		implementation, two pointers
788A	O	Functions again	1500	x5823
		dp, two pointers
1208B		Uniqueness	1500	x5496
		binary search, brute force, implementation, two pointers
6C		Alice, Bob and Chocolate	1500	x5383
		greedy, two pointers
1041C		Coffee Break	1500	x5356
		binary search, data structures, greedy, two pointers
1251C		Minimize The Integer	1500	x5286
		greedy, two pointers
920C		Swap Adjacent Elements	1500	x4854
		dfs and similar, greedy, math, sortings, two pointers
1066B		Heaters	1500	x4391
		greedy, two pointers
702C		Cellular Network	1500	x4113
		binary search, implementation, two pointers
875B		Sorting the Coins	1500	x3977
		dsu, implementation, sortings, two pointers
1158A		The Party and Sweets	1500	x3918
		binary search, constructive algorithms, greedy, implementation, math, sortings, two pointers
224B		Array	1500	x3741
		bitmasks, implementation, two pointers
384B		Multitasking	1500	x2481
		greedy, implementation, sortings, two pointers
165C		Another Problem on Strings	1600	x6030
		binary search, brute force, dp, math, strings, two pointers
1166C		A Tale of Two Lands	1600	x5129
		binary search, sortings, two pointers
1036D		Vasya and Arrays	1600	x4816
		greedy, two pointers
1196D2		RGB Substring (hard version)	1600	x4714
		data structures, dp, implementation, two pointers
749C		Voting	1600	x4502
		greedy, implementation, two pointers
777C		Alyona and Spreadsheet	1600	x4254
		binary search, data structures, dp, greedy, implementation, two pointers
660C		Hard Process	1600	x4125
		binary search, dp, two pointers
734C		Anton and Making Potions	1600	x3967
		binary search, dp, greedy, two pointers
924B		Three-level Laser	1600	x3936
		binary search, greedy, two pointers
814C		An impassioned circulation of affection	1600	x3711
		brute force, dp, strings, two pointers
939C		Convenient For Everybody	1600	x3418
		binary search, two pointers
237C		Primes on Interval	1600	x3217
		binary search, number theory, two pointers
1060C		Maximum Subrectangle	1600	x3187
		binary search, implementation, two pointers
229A		Shifts	1600	x2681
		brute force, two pointers
769B		News About Credit	1600	x2674
		*special problem, greedy, two pointers
645C		Enduring Exodus	1600	x2153
		binary search, two pointers
873C		Strange Game On Matrix	1600	x2077
		greedy, two pointers
175C		Geometry Horse	1600	x869
		greedy, implementation, sortings, two pointers
466C		Number of Ways	1700	x15111
		binary search, brute force, data structures, dp, two pointers
446A		DZY Loves Sequences	1700	x7118
		dp, implementation, two pointers
372A		Counting Kangaroos is Fun	1700	x5816
		binary search, greedy, sortings, two pointers
427C		Checkposts	1700	x5450
		dfs and similar, graphs, two pointers
1198A		MP3	1700	x5442
		sortings, two pointers
279C		Ladder	1700	x4488
		dp, implementation, two pointers
1148B		Born This Way	1700	x4383
		binary search, brute force, two pointers
493C		Vasya and Basketball	1700	x4157
		binary search, brute force, data structures, implementation, sortings, two pointers
1257D		Yet Another Monster Killing Problem	1700	x3921
		binary search, data structures, dp, greedy, sortings, two pointers
231C		To Add or Not to Add	1700	x3901
		binary search, sortings, two pointers
1041D		Glider	1700	x3753
		binary search, data structures, two pointers
616D		Longest k-Good Segment	1700	x3541
		binary search, data structures, two pointers
1043D		Mysterious Crime	1700	x3003
		brute force, combinatorics, math, meet-in-the-middle, two pointers
895B		XK Segments	1700	x2408
		binary search, math, sortings, two pointers
1044A		The Tower is Going Home	1700	x2018
		binary search, two pointers
281B		Nearest Fraction	1700	x1997
		brute force, implementation, two pointers
46C		Hamsters and Tigers	1700	x1341
		two pointers
180E		Cubes	1700	x946
		binary search, dp, two pointers
577B		Modulo Sum	1800	x5184
		combinatorics, data structures, dp, two pointers
1203D2		Remove the Substring (hard version)	1800	x3664
		binary search, greedy, implementation, two pointers
1073C		Vasya and Robot	1800	x2773
		binary search, two pointers
1042D		Petya and Array	1800	x2667
		data structures, divide and conquer, two pointers
733C		Epidemic in Monstropolis	1800	x2613
		constructive algorithms, dp, greedy, two pointers
1282C		Petya and Exam	1800	x1812
		greedy, sortings, two pointers
652C		Foe Pairs	1800	x1720
		combinatorics, sortings, two pointers
222D		Olympiad	1800	x1578
		binary search, greedy, sortings, two pointers
533E		Correcting Mistakes	1800	x1516
		constructive algorithms, dp, greedy, hashing, strings, two pointers
79C		Beaver	1800	x1139
		data structures, dp, greedy, hashing, strings, two pointers
216D		Spider's Web	1800	x812
		binary search, sortings, two pointers
519D		A and B and Interesting Substrings	1900	x3948
		data structures, dp, two pointers
439D		Devu and his Brother	1900	x2953
		binary search, sortings, ternary search, two pointers
1200D		White Lines	1900	x2658
		brute force, data structures, dp, implementation, two pointers
650B		Image Preview	1900	x2590
		binary search, brute force, dp, two pointers
853B		Jury Meeting	1900	x2000
		greedy, sortings, two pointers

[Asgard] 익스트림너클 - 테트라 성공!

plzrun — Sun, 23 Jun 2019 02:16:35 +0900

2019. 06. 20일 11시 30분경

사냥하기엔 이미 시간이 늦었고

할게 없어서 수다 조금 떨었는데

갑자기 업글이 하고싶어졌다

요즘 린네 1봉 각반 팔아서 10억글로드 가까이 있기도 했고ㅎㅎ

아무튼 그래서 이카루스 가서 코어를 2개 사서 질렀는데

즈런 님께서 익스트림너클-테트라 업그레이드에 성공하셨습니다. 축하해주세요!!

크으으ㅡ으으으으으으

아스 하다보니 이런날도 있다

이전에 쓰던 트라이는 제대로 찍은 스샷이 없는데,

왜 찍었는지 모를 스샷에 트라이가 찍혀있었다 ㅎㅎ

확실히 트라이랑 테트라랑 생긴게 많이 다르다

트라이 사자마자 코어 2번 해보고,

20일날 밤에 해본 코어 2번이 전부였으나

4억으로 트라이 -> 테트라 간 셈이다

으하핳ㅎ헤헤헿

이전에 쓰던 익스트림너클-트라이

익스트림너클-테트라

기분이 넘 좋다 :)

축하해주신 분들 모두 감사합니다~!

UVa Online Judge 10137. (The Trip)

plzrun — Sat, 24 Nov 2018 21:15:40 +0900

< 문제 경로: https://uva.onlinejudge.org/external/101/10137.pdf >

일단 이 문제도 알고리즘 트레이닝 북 42페이지에 있는걸 보고 가볍게 풀려했으나,

알덕력이 모자라서 소수점에서 한참 헤매게 됐다.

나는 보통 소수점과 관련된 문제라면 int로 바꿔서 많이 풀었는데,

오늘은 int로 바꾸는 과정에서 문제가 있었다.

일단 컴퓨터는 부동소수점으로 소수를 표현하기 때문에 뭔가 문제가 많다.

소수와 관련된 연산은 결합법칙, 분배법칙도 성립하지 않고,

0.1은 사실상 정확히 표현이 불가능하며,

int(278.78 * 100)을 printf로 찍어보면 27877이 나오는 신비한 경험도 할 수 있다.

(이 부분은 int(278.78 * 100 + 0.5)로 해결할 수 있긴하다.)

문제는 이것말고도 상당히 많은데,

결론은.. 소수로 들어오는 input 데이터는 웬만하면 정수로 받자는 것이다.

1
2
3
4
5
6
7
8
#include <stdio.h>
int main() {
    double a;
    scanf("%lf", &a); //X
 
    int x,y;
    scanf("%d.%d", &x,&y); //O
}
cs

물론 언제나 예외사항은 있지만,

소수 계산은 조심.. 또 조심..

10137 문제는 사람 수 N이 주어지고,

N개수만큼 달러값이 input으로 들어온다.

이 달러를 N명이 모두 골고루 나눠 갖을 때,

달러를 최소한만 이동시켜서 모두 골고루 나눠 갖으려한다.

모두 달러를 나눠 가졌을 때 1센트는 차이가 날 수 있다.

그럼 나는 N명의 달러 합을 sum이라 하고,

sum = a*q + b*(q+1)이 되는 a,b를 구했다.

여기서 q는 달러로.. N명중 a명은 q달러를 갖고, b명은 q+1달러를 가질 것이다.

그럼 q값은 int(sum/N)으로 구할 수 있고,

b값은 sum%N으로 구할 수 있다.

a = N-b이므로

이동시킬 최소 달러 값을 계산할 수 있다.

코드는 아래와 같다.

(정렬을.. 그냥 count sorting으로 해봤다.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdio.h>
const int mask = (1<<10)-1;
int v[1001], cnt[mask+1], idx[2][mask+1];
inline int abs(int x) { return x<0?-x:x; }
int main() {
    while(true) {
        int n, sum=0; scanf("%d", &n);
        if(n==0) break;
 
        for(int i=0; i<n; i++) {
            int x,y; scanf("%d.%d",&x,&y);
            v[i]=x*100+y;
            sum += v[i];
        }
 
        //count sorting start
        for(int i=0; i<=mask; i++) cnt[i]=0;
        for(int i=0; i<n; i++) cnt[v[i]&mask]++;
        for(int i=1; i<=mask; i++) cnt[i]+=cnt[i-1];
        for(int i=n-1; i>=0; i--) idx[0][--cnt[v[i]&mask]] = i;
 
        for(int i=0; i<=mask; i++) cnt[i]=0;
        for(int i=0; i<n; i++) cnt[(v[i]>>10)&mask]++;
        for(int i=1; i<=mask; i++) cnt[i]+=cnt[i-1];
        for(int i=n-1; i>=0; i--) idx[1][--cnt[(v[idx[0][i]]>>10)&mask]] = idx[0][i];
 
        for(int i=0; i<=mask; i++) cnt[i]=0;
        for(int i=0; i<n; i++) cnt[v[i]>>20]++;
        for(int i=1; i<=mask; i++) cnt[i]+=cnt[i-1];
        for(int i=n-1; i>=0; i--) idx[0][--cnt[v[idx[1][i]]>>20]] = idx[1][i];
        //count sorting end
 
        int q=sum/n, r=sum%n;
        int a=n-r, ans=0;
 
        for(int i=0; i<a; i++) {
            if(v[idx[0][i]]<q) ans+=q-v[idx[0][i]];
            else break;
        }
        for(int i=a; i<n; i++) {
            if(v[idx[0][i]]<q+1) ans+=q+1-v[idx[0][i]];
            else break;
        }
        printf("$%d.%02d\n", ans/100, ans%100);
    }
    return 0;
}
Colored by Color Scripter
cs