이미난

백준 1213 - 팰린드롬 만들기

hvv_an — Fri, 1 Aug 2025 13:54:04 +0900

문제 설명

임한수와 임문빈은 서로 사랑하는 사이이다.

임한수는 세상에서 팰린드롬인 문자열을 너무 좋아하기 때문에, 둘의 백일을 기념해서 임문빈은 팰린드롬을 선물해주려고 한다.

임문빈은 임한수의 영어 이름으로 팰린드롬을 만들려고 하는데, 임한수의 영어 이름의 알파벳 순서를 적절히 바꿔서 팰린드롬을 만들려고 한다.

임문빈을 도와 임한수의 영어 이름을 팰린드롬으로 바꾸는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 주어진 문자열을 재배열해 만들 수 있는 팰린드롬 중 사전순으로 가장 빠른 문자열을 출력하면 된다.

우선 팰린드롬을 만들 수 있는 조건이 있다.

홀수인 문자의 개수가 1개 이하일 때만 팰린드롬을 만들 수 있다.

홀수인 문자가 1개일 때만 가운데 문자를 배치한 후 좌우 대칭으로 문자를 배치할 수 있기 때문이다.

따라서 모든 문자의 개수를 세고 홀수인 문자가 1개 초과라면 종료한다.

for (int i = 0; i < str.length(); i++)
{
    spellCnt[str[i] - 'A']++;
}

int odd = 0;
char oddChar = ' ';
for (auto spell = 'A'; spell <= 'Z'; spell++)
{
    auto cnt = spellCnt[spell - 'A'];
    if (cnt % 2 == 1)
    {
        odd++;
        oddChar = spell;
    }
}

if (odd > 1)
{
    cout << "I'm Sorry Hansoo";
    return 0;
}

이제 팰린드롬은 만들 수 있기 때문에 모든 문자의 절반을 차례로 더해가며 팰린드롬의 왼쪽을 구성한다.

이후 만약 홀수인 문자가 있다면 추가하고 나머지 절반을 뒤집어 더해주면 된다.

string ans;
for (auto spell = 'A'; spell <= 'Z'; spell++)
{
    auto cnt = spellCnt[spell - 'A'];
    auto half = cnt / 2;

    for (int i = 0; i < half; i++)
    {
        ans += spell;
    }
}

auto rev = ans;
reverse(rev.begin(), rev.end());

if (odd == 1)
{
    ans += oddChar;
}
ans += rev;

cout << ans;

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
string str;
vector<int> spellCnt(26, 0);

int main()
{
    INPUT_OPTIMIZE;

    cin >> str;

    for (int i = 0; i < str.length(); i++)
    {
        spellCnt[str[i] - 'A']++;
    }

    int odd = 0;
    char oddChar = ' ';
    for (auto spell = 'A'; spell <= 'Z'; spell++)
    {
        auto cnt = spellCnt[spell - 'A'];
        if (cnt % 2 == 1)
        {
            odd++;
            oddChar = spell;
        }
    }

    if (odd > 1)
    {
        cout << "I'm Sorry Hansoo";
        return 0;
    }

    string ans;
    for (auto spell = 'A'; spell <= 'Z'; spell++)
    {
        auto cnt = spellCnt[spell - 'A'];
        auto half = cnt / 2;

        for (int i = 0; i < half; i++)
        {
            ans += spell;
        }
    }

    auto rev = ans;
    reverse(rev.begin(), rev.end());

    if (odd == 1)
    {
        ans += oddChar;
    }
    ans += rev;

    cout << ans;

    return 0;
}

백준 9084 - 동전

hvv_an — Wed, 30 Jul 2025 12:05:45 +0900

문제 설명

우리나라 화폐단위, 특히 동전에는 1원, 5원, 10원, 50원, 100원, 500원이 있다. 이 동전들로는 정수의 금액을 만들 수 있으며 그 방법도 여러 가지가 있을 수 있다. 예를 들어, 30원을 만들기 위해서는 1원짜리 30개 또는 10원짜리 2개와 5원짜리 2개 등의 방법이 가능하다.

동전의 종류가 주어질 때에 주어진 금액을 만드는 모든 방법을 세는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 동전 N개가 주어졌을 때 목표를 만들 수 있는 경우의 수를 모두 구하는 것이다.

해당 문제는 유명한 dp문제이다.

dp에는 i를 만들 수 있는 경우의 수를 기록할 것이다.

그럼 dp에 i를 만드는 수를 기록하는 방법은 i에서 돈을 뺐을 때 경우의 수를 합하여 만들 수 있다.

예를 들어 돈이 1, 2가 있다고 해 보자.

그럼 i를 만드는 방법은 dp[i-1] + dp[i-2]로 만들 수 있다.

물론 1과 2를 여러 번 사용할 수 있기 때문에 이렇게 두 개만 확인하면 안 된다.

따라서 사용할 동전을 정해놓고 해당 동전을 사용해 만들 수 있는 i를 업데이트하면서 진행하면 된다.

dp[0] = 1;

for (auto& coin : coins)
{
    for (int i = coin; i <= target; i++)
    {
        dp[i] += dp[i - coin];
    }
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int T;

int main()
{
    INPUT_OPTIMIZE;

    cin >> T;

    while (T--)
    {
        int N, target;
        cin >> N;

        vector<int> coins;
        vector<int> dp;
        coins.resize(N);

        for (int i = 0; i < N; i++)
        {
            cin >> coins[i];
        }

        cin >> target;
        dp.resize(target + 1, 0);
        dp[0] = 1;

        for (auto& coin : coins)
        {
            for (int i = coin; i <= target; i++)
            {
                dp[i] += dp[i - coin];
            }
        }

        cout << dp[target] << "\n";
    }
}

백준 2458 - 키 순서

hvv_an — Mon, 28 Jul 2025 10:34:10 +0900

문제 설명

1번부터 N번까지 번호가 붙여져 있는 학생들에 대하여 두 학생끼리 키를 비교한 결과의 일부가 주어져 있다. 단, N명의 학생들의 키는 모두 다르다고 가정한다. 예를 들어, 6명의 학생들에 대하여 6번만 키를 비교하였고, 그 결과가 다음과 같다고 하자.

1번 학생의 키 < 5번 학생의 키
3번 학생의 키 < 4번 학생의 키
5번 학생의 키 < 4번 학생의 키
4번 학생의 키 < 2번 학생의 키
4번 학생의 키 < 6번 학생의 키
5번 학생의 키 < 2번 학생의 키

이 비교 결과로부터 모든 학생 중에서 키가 가장 작은 학생부터 자신이 몇 번째인지 알 수 있는 학생들도 있고 그렇지 못한 학생들도 있다는 사실을 아래처럼 그림을 그려 쉽게 확인할 수 있다. a번 학생의 키가 b번 학생의 키보다 작다면, a에서 b로 화살표를 그려서 표현하였다.

1번은 5번보다 키가 작고, 5번은 4번보다 작기 때문에, 1번은 4번보다 작게 된다. 그러면 1번, 3번, 5번은 모두 4번보다 작게 된다. 또한 4번은 2번과 6번보다 작기 때문에, 4번 학생은 자기보다 작은 학생이 3명이 있고, 자기보다 큰 학생이 2명이 있게 되어 자신의 키가 몇 번째인지 정확히 알 수 있다. 그러나 4번을 제외한 학생들은 자신의 키가 몇 번째인지 알 수 없다.

학생들의 키를 비교한 결과가 주어질 때, 자신의 키가 몇 번째인지 알 수 있는 학생들이 모두 몇 명인지 계산하여 출력하는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 키를 비교한 관계가 M개 주어졌을 때 위치를 정확히 알 수 있는 노드의 개수를 구하면 된다.

처음 문제를 보았을 때는 위상 정렬을 통해 풀 수 있다고 생각했다.

하지만 위상 정렬은 느슨한 정렬을 수행하므로 정확한 위치를 알 수 있는 개수를 구하지 못한다.

따라서 다른 접근이 필요한데 생각보다 간단하다.

특정 노드 a에서 다른 노드들까지의 거리를 구한다고 해보자.

이때 모든 노드까지의 거리를 구했을 때 그 거리를 모두 알고 있다면 a의 위치는 명확해진다.

따라서 모든 노드 간의 거리를 구했을 때 거리가 구해지는 노드의 개수를 세면 된다.

거리를 구하는 과정은 플로이드-와샬 알고리즘을 이용했다.

모든 노드의 거리를 구해야 했기 때문이다.

for (int k = 1; k <= N; k++)
{
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= N; j++)
        {
            if (dist[i][j] > dist[i][k] + dist[k][j])
            {
                dist[i][j] = dist[i][k] + dist[k][j];
            }
        }
    }
}

이후 거리가 기록된 개수를 세고 그 개수가 N-1개이면 정확한 위치가 구해진 노드로 판정했다.

int ans = 0;
for (int i = 1; i <= N; i++)
{
    int cnt = 0;
    for (int j = 1; j <= N; j++)
    {
        if (dist[i][j] != MAX || dist[j][i] != MAX) cnt++;
    }

    if (cnt == N - 1) ans++;
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N, M;
vector<vector<int>> adj;
vector<vector<int>> dist;

int main()
{
    INPUT_OPTIMIZE;

    cin >> N >> M;

    adj.resize(N + 1, vector<int>());
    dist.resize(N + 1, vector<int>(N+1, MAX));

    for (int i = 0; i < M; i++)
    {
        int a, b;
        cin >> a >> b;

        dist[a][b] = 1;
    }

    for (int k = 1; k <= N; k++)
    {
        for (int i = 1; i <= N; i++)
        {
            for (int j = 1; j <= N; j++)
            {
                if (dist[i][j] > dist[i][k] + dist[k][j])
                {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    int ans = 0;
    for (int i = 1; i <= N; i++)
    {
        int cnt = 0;
        for (int j = 1; j <= N; j++)
        {
            if (dist[i][j] != MAX || dist[j][i] != MAX) cnt++;
        }

        if (cnt == N - 1) ans++;
    }

    cout << ans;
}

백준 2812 - 크게 만들기

hvv_an — Sun, 27 Jul 2025 13:51:48 +0900

문제 설명

사이클 게임은 두 명의 플레이어가 차례대로 돌아가며 진행하는 게임으로, 선 플레이어가 홀수 번째 차례를, 후 플레이어가 짝수 번째 차례를 진행한다. 게임 시작 시 0 부터 n − 1 까지 고유한 번호가 부여된 평면 상의 점 n 개가 주어지며, 이 중 어느 세 점도 일직선 위에 놓이지 않는다. 매 차례 마다 플레이어는 두 점을 선택해서 이를 연결하는 선분을 긋는데, 이전에 그린 선분을 다시 그을 수는 없지만 이미 그린 다른 선분과 교차하는 것은 가능하다. 게임을 진행하다가 처음으로 사이클을 완성하는 순간 게임이 종료된다. 사이클 C는 플레이어가 그린 선분들의 부분집합으로, 다음 조건을 만족한다.

C에 속한 임의의 선분의 한 끝점에서 출발하여 모든 선분을 한 번씩만 지나서 출발점으로 되돌아올 수 있다.

문제는 선분을 여러 개 그리다 보면 사이클이 완성 되었는지의 여부를 판단하기 어려워 이미 사이클이 완성되었음에도 불구하고 게임을 계속 진행하게 될 수 있다는 것이다. 이 문제를 해결하기 위해서 게임의 진행 상황이 주어지면 몇 번째 차례에서 사이클이 완성되었는지, 혹은 아직 게임이 진행 중인지를 판단하는 프로그램을 작성하려 한다.

입력으로 점의 개수 n과 m 번째 차례까지의 게임 진행 상황이 주어지면 사이클이 완성 되었는지를 판단하고, 완성되었다면 몇 번째 차례에서 처음으로 사이클이 완성된 것인지를 출력하는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 선분을 하나씩 그어갈 때 사이클이 생기는지 여부를 판단하면 된다.

만약 모든 성분을 그어도 사이클이 생기지 않는다면 0을 중간에 사이클이 생긴다면 해당 차례를 출력하면 된다.

이미 완성된 그래프에서 사이클을 판정하는 것이 아니라 하나씩 선분을 만들어 가면서 사이클을 판정해야 한다.

이는 유니온 파인드로 판단할 수 있다.

부모를 정하는 기준을 정하고 각 선분을 그으며 최상위 부모가 무엇인지 확인한다.

이때 최상위 부모가 같다면 사이클에 포함되었다고 할 수 있다.

이때 부모를 정하는 기준은 크게 중요하지 않고 일관되기만 하면 된다.

int Find(int a)
{
    if (parent[a] == a) return a;
    return parent[a] = Find(parent[a]);
}

void Union(int a, int b)
{
    a = Find(a);
    b = Find(b);

    if (a != b)
    {
        if (a > b) swap(a, b);
        parent[b] = a;
    }
}

작은 번호가 부모가 되도록 설정하였다.

이런 과정을 각 입력마다 처리하면 된다.

for (int i = 0; i < M; i++)
{
    int a, b;
    cin >> a >> b;

    a = Find(a);
    b = Find(b);

    if (a == b)
    {
        cout << i + 1;
        return 0;
    }

    Union(a, b);
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N, M;
vector<int> parent;

int Find(int a)
{
    if (parent[a] == a) return a;
    return parent[a] = Find(parent[a]);
}

void Union(int a, int b)
{
    a = Find(a);
    b = Find(b);

    if (a != b)
    {
        if (a > b) swap(a, b);
        parent[b] = a;
    }
}

int main()
{
    INPUT_OPTIMIZE;

    cin >> N >> M;
    parent.resize(N);

    for (int i = 0; i < N; i++)
    {
        parent[i] = i;
    }

    for (int i = 0; i < M; i++)
    {
        int a, b;
        cin >> a >> b;

        a = Find(a);
        b = Find(b);

        if (a == b)
        {
            cout << i + 1;
            return 0;
        }

        Union(a, b);
    }

    cout << 0;
}

백준 2812 - 크게 만들기

hvv_an — Tue, 22 Jul 2025 09:41:11 +0900

문제 설명

N자리 숫자가 주어졌을 때, 여기서 숫자 K개를 지워서 얻을 수 있는 가장 큰 수를 구하는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 길이가 N인 숫자가 주어졌을 때 K개의 숫자를 제거해 가장 큰 수를 만들면 된다.

시간을 제외하고 풀이를 생각해 보면 K개의 숫자 조합을 만들고 이를 제거해 보며 최댓값을 구하면 된다.

하지만 N, K가 최대 500,000이기 때문에 시간 초과가 발생할 것이다.

따라서 다른 전략이 필요하다.

우선 가장 큰 수를 만들기 위해서는 왼쪽(앞쪽)수가 커야 한다.

따라서 앞에서 부터 가장 큰 수를 선택하면 된다.

예를 들어 보자.

4 2
1924

1은 앞에 아무 것도 없기 때문에 선택할 것이다.

9를 선택할지 결정할 때 1을 제거하고 9를 선택하는 것이 가장 큰 수를 만드는 방법이다.

그리고 2를 선택할 때는 일단 선택을 해야 한다.

2를 검사할 때는 뒤에 어떤 수가 있는지 모르기 때문이다.

4를 선택하는 상황에서는 2를 제거하고 4를 선택하는 것이 정답이 된다.

따라서 i번째 수를 포함할지 결정할 때 i번째 수보다 앞의 수가 작다면 제거하면 된다.

이때 제거하는 수를 K에서 빼주며 K번만 뺄 수 있게 하면 된다.

한 가지 의문이 들 수 있는 부분이 있는데 앞에서 수를 제거하지 않는 경우 최적해가 나올 수 있지 않을까 생각할 수 있다.

하지만 앞에서 작은 수를 선택하면 뒤에 9999로 아무리 큰 수를 선택해도 앞이 작아 결국 작은 수가 완성된다.

따라서 그리디하게 앞에서부터 최대한 큰 수를 선택하는 것이 정답이 된다.

이를 구현하기 위해서는 스택의 개념을 이용하면 된다.

i번째 수보다 스택에 top에 있는 수가 작다면 하나씩 제거하면 된다.

int num = input[i] - '0';
while (K > 0 && !temp.empty() && temp.back() < num)
{
    temp.pop_back();
    K--;
}

마지막으로 주의할 점은 N이 500,000이기 때문에 int, long long으로 표현이 불가능하다.

따라서 정답을 string으로 구성해야 한다.

string ans;
for (int i = 0; i < temp.size(); i++)
{
    ans += temp[i] + '0';
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N, K;
string input;

int main()
{
	INPUT_OPTIMIZE;
	
	cin >> N >> K;
	cin >> input;

	vector<int> temp;
	for (int i = 0; i < N; i++)
	{
		int num = input[i] - '0';
		while (K > 0 && !temp.empty() && temp.back() < num)
		{
			temp.pop_back();
			K--;
		}

		temp.push_back(num);
	}
		
	while (K > 0)
	{
		K--;
		temp.pop_back();
	}

	string ans;
	for (int i = 0; i < temp.size(); i++)
	{
		ans += temp[i] + '0';
	}

	cout << ans;
}

백준 17135 - 캐슬 디펜스

hvv_an — Sun, 20 Jul 2025 14:37:16 +0900

문제 설명

캐슬 디펜스는 성을 향해 몰려오는 적을 잡는 턴 방식의 게임이다. 게임이 진행되는 곳은 크기가 N×M인 격자판으로 나타낼 수 있다. 격자판은 1×1 크기의 칸으로 나누어져 있고, 각 칸에 포함된 적의 수는 최대 하나이다. 격자판의 N번행의 바로 아래(N+1번 행)의 모든 칸에는 성이 있다.

성을 적에게서 지키기 위해 궁수 3명을 배치하려고 한다. 궁수는 성이 있는 칸에 배치할 수 있고, 하나의 칸에는 최대 1명의 궁수만 있을 수 있다. 각각의 턴마다 궁수는 적 하나를 공격할 수 있고, 모든 궁수는 동시에 공격한다. 궁수가 공격하는 적은 거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다. 같은 적이 여러 궁수에게 공격당할 수 있다. 공격받은 적은 게임에서 제외된다. 궁수의 공격이 끝나면, 적이 이동한다. 적은 아래로 한 칸 이동하며, 성이 있는 칸으로 이동한 경우에는 게임에서 제외된다. 모든 적이 격자판에서 제외되면 게임이 끝난다.

게임 설명에서 보다시피 궁수를 배치한 이후의 게임 진행은 정해져있다. 따라서, 이 게임은 궁수의 위치가 중요하다. 격자판의 상태가 주어졌을 때, 궁수의 공격으로 제거할 수 있는 적의 최대 수를 계산해보자.

격자판의 두 위치 (r1, c1), (r2, c2)의 거리는 |r1-r2| + |c1-c2|이다.

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

제한 사항

풀이

문제를 요약하면 N x M 격자에 적들에 대한 정보가 주어졌을 때 궁수 3명을 배치해 최대한 많은 적을 처리한다면 몇 명을 처리하는지 구하면 된다.

적들은 한 턴에 한 칸씩 아래로 전진한다.

궁수가 처리할 수 있는 적은 D거리 이내에 위치해야 하고 만약 거리가 같은 적이 여러 명이라면 가장 왼쪽의 적을 처리한다.

거리 공식은 |r1-r2| + |c1-c2|이다.

해당 문제는 주어진 조건대로 구현하면 되는 문제이다.

구현해야 하는 부분을 정리하면 다음과 같다.

궁수 3명을 배치한다.
적들이 한 칸씩 이동한다.
가장 가까운(가장 왼쪽인) 적을 탐색한다.
적을 처리한다.

우선 궁수 3명을 배치하는 방법을 알아보자.

문제의 조건은 N, M이 15 이하이므로 매우 작은 경우의 수가 나온다.

따라서 3명의 궁수를 배치하는 조합을 만들어 처리하면 된다.

void DFS(vector<int>& archers, int idx)
{
    if (archers.size() == 3)
    {
        ans = max(ans, Simulate(archers));
        return;
    }

    for (int i = idx; i < M; i++)
    {
        archers.push_back(i);
        DFS(archers, i + 1);
        archers.pop_back();
    }
}

이제 적들이 이동하고 처리하는 부분을 구현해 보자.

적은 한 턴에 한 칸씩 움직인다.

격자의 모든 적을 찾아 한 칸씩 밑으로 내려주는 방법도 있겠지만 시간이 오래 걸릴 것이다.

따라서 처음 위치에서 몇 턴이 지났는지 기록한다면 위치를 계산할 수 있다.

이때 적들이 이동하여 성벽에 도달한다면 더 이상 공격할 수 없으므로 체크해 주고 다음 적을 이동시킨다.

for (int j = 0; j < enemies.size(); j++)
{
    if (!movable[j]) continue;
    auto [y, x] = enemies[j];
    y += moves;
    
    if (y >= N)
    {
        movable[j] = false;
        enemiesCnt--;
        continue;
    }
    ...
}

그럼 이제 배치된 궁수들에서 적들과의 거리를 계산하여 타깃을 설정하면 된다.

거리는 위에서 언급된 공식으로 간단하게 구할 수 있다.

만약 거리가 D초과라면 공격이 불가능하므로 다음 적을 탐색한다.

int dist = abs(y - N) + abs(x - archers[i]);
if (dist > D) continue;

if (dist < minDist)
{
    minDist = dist;
    minEnemy = j;
}


if (minEnemy != -1)
{
    target.insert(minEnemy);
}

거리가 가장 가까운 적을 찾았다면 바로 처리하지 않고 타깃에 추가한 후 모든 궁수의 타겟 설정이 완료되었을 때 동시에 처리해야 한다.

그렇지 않으면 다른 궁수가 먼저 처리한 적을 제외하고 다른 타깃을 찾을 수 있기 때문에 문제의 조건에 맞지 않게 된다.

이때 주의할 점이 거리가 같은 적이 있으면 왼쪽의 적을 타깃으로 설정해야 하기 때문에 적들을 x좌표 기준으로 정렬을 해줘야 한다.

bool cmp(pair<int, int>& a, pair<int, int>& b)
{
    return a.second < b.second;
}

이를 반복하며 모든 적이 처리되거나 성벽에 도달하여 공격할 수 없게 되면 종료한다.

이 과정에서 처치한 적의 수의 최댓값을 갱신하면 된다.

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N, M, D;
vector<vector<int>> grid;
vector<pair<int, int>> enemies;
int ans = 0;

int Simulate(vector<int>& archers)
{
    int moves = 0;
    int killCnt = 0;
    int enemiesCnt = enemies.size();
    vector<bool> movable(enemiesCnt, true);
    while (enemiesCnt > 0)
    {
        set<int> target;

        for (int i = 0 ; i < archers.size(); i++)
        {
            int minDist = MAX;
            int minEnemy = -1;

            for (int j = 0; j < enemies.size(); j++)
            {
                if (!movable[j]) continue;
                auto [y, x] = enemies[j];
                y += moves;
                if (y >= N)
                {
                    movable[j] = false;
                    enemiesCnt--;
                    continue;
                }

                int dist = abs(y - N) + abs(x - archers[i]);
                if (dist > D) continue;

                if (dist < minDist)
                {
                    minDist = dist;
                    minEnemy = j;
                }
            }

            if (minEnemy != -1)
            {
                target.insert(minEnemy);
            }
        }

        for (auto enemy : target)
        {
            movable[enemy] = false;
            enemiesCnt--;
            killCnt++;
        }

        moves++;
    }

    return killCnt;
}

void DFS(vector<int>& archers, int idx)
{
    if (archers.size() == 3)
    {
        ans = max(ans, Simulate(archers));
        return;
    }

    for (int i = idx; i < M; i++)
    {
        archers.push_back(i);
        DFS(archers, i + 1);
        archers.pop_back();
    }
}

bool cmp(pair<int, int>& a, pair<int, int>& b)
{
    return a.second < b.second;
}

int main()
{
    INPUT_OPTIMIZE;

    cin >> N >> M >> D;

    grid.resize(N, vector<int>(M));
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            cin >> grid[i][j];
            if (grid[i][j])
            {
                enemies.push_back({ i,j });
            }
        }
    }

    sort(enemies.begin(), enemies.end(), cmp);

    vector<int> temp;
    DFS(temp, 0);

    cout << ans;
}

백준 1915 - 가장 큰 정사각형

hvv_an — Tue, 15 Jul 2025 10:25:03 +0900

문제 설명

n×m의 0, 1로 된 배열이 있다. 이 배열에서 1로 된 가장 큰 정사각형의 크기를 구하는 프로그램을 작성하시오.

0	1	0	0
0	1	1	1
1	1	1	0
0	0	1	0

위와 같은 예제에서는 가운데의 2×2 배열이 가장 큰 정사각형이다.

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

제한 사항

풀이

문제를 요약하면 주어진 2차원 배열에서 1로 만들 수 있는 최대 정사각형의 크기를 구하면 된다.

해당 문제는 완전 탐색에서 점차 발전시키면 간단하게 풀 수 있다.

우선 완전 탐색으로 정답을 구하기 위해서는 모든 칸에서 시작하여 그릴 수 있을 만큼 정사각형을 그려보면 된다.

0	1	0	0
0	1	1	1
1	1	1	0
0	0	1	0

이러한 입력이 있다고 가정해 보자.

그럼 (0 ,0)은 0이기 때문에 정사각형을 그릴 수 없다.

즉, 1인 칸만 확인하면 된다.

(0, 1)은 1이기 때문에 정사각형을 그려볼 수 있다.

우선 크기가 1인 정사각형을 그릴 수 있다.

이후 크기가 2인 정사각형을 그리려 했을 때 오른쪽 칸이 0이기 때문에 크기가 2인 정사각형은 그리지 못한다.

따라서 현재까지 그릴 수 있는 최대 정사각형은 크기가 1이다.

(1, 1)에도 동일한 방법을 통해 정사각형을 그렸을 때 최대 크기가 4인 정사각형을 그릴 수 있다.

정사각형을 그릴 수 있는지 판단하는 방법은 정해진 크기가 모두 1인지 확인하는 것이다.

하지만 이렇게 모든 칸을 다 더해보면 시간 초과가 발생할 것이다.

그렇기 때문에 정사각형을 그릴 수 있는지 여부를 빠르게 확인하는 방법이 필요하다.

정사각형을 그릴 수 있는 여부는 정해진 크기를 모두 더하는 것이다.

즉, 누적합을 이용하면 효율적으로 개선할 수 있다.

2차원 누적합을 통해 현재 탐색 지점을 기준으로 한 변의 길이가 x인 정사각형을 그린다 했을 때 다음과 같은 식으로 계산할 수 있다.

bool Check(int i, int j)
{
    int next = ans + 1;
    if (i + ans > N || j + ans > M) return false;
    return next * next == sum[i + ans][j + ans] - sum[i - 1][j + ans] - sum[i + ans][j - 1] + sum[i - 1][j - 1];
}

이때 ans는 현재 알고 있는 최대 크기의 정사각형의 한 변의 길이이다.

즉, 이미 찾은 최대 크기 이전은 검사하지 않도록 하는 것이다.

이것을 이제 모든 칸에서 진행하면 된다.

for (int i = 0; i < N; i++)
{
    for (int j = 0; j < M; j++)
    {
        if (grid[i][j] == '0') continue;

        while (Check(i + 1, j + 1))
        {
            ans++;
        }
    }
}

그리고 누적합을 구하는 방법은 다음과 같다.

//가로
for (int i = 1; i <= N; i++)
{
    for (int j = 1; j <= M; j++)
    {
        sum[i][j] = sum[i][j - 1] + (grid[i-1][j-1] - '0');
    }
}

//세로
for (int j = 1; j <= M; j++)
{
    for (int i = 1; i <= N; i++)
    {
        sum[i][j] += sum[i - 1][j];
    }
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N, M;
vector<string> grid;
vector<vector<int>> sum;
int ans = 0;

bool Check(int i, int j)
{
    int next = ans + 1;
    if (i + ans > N || j + ans > M) return false;
    return next * next == sum[i + ans][j + ans] - sum[i - 1][j + ans] - sum[i + ans][j - 1] + sum[i - 1][j - 1];
}

int main()
{
    INPUT_OPTIMIZE;

    cin >> N >> M;
    grid.resize(N);
    sum.resize(N + 1, vector<int>(M + 1, 0));

    for (int i = 0; i < N; i++)
    {
        cin >> grid[i];
    }

    //가로
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
        {
            sum[i][j] = sum[i][j - 1] + (grid[i-1][j-1] - '0');
        }
    }

    //세로
    for (int j = 1; j <= M; j++)
    {
        for (int i = 1; i <= N; i++)
        {
            sum[i][j] += sum[i - 1][j];
        }
    }

    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            if (grid[i][j] == '0') continue;

            while (Check(i + 1, j + 1))
            {
                ans++;
            }
        }
    }

    cout << ans * ans;

    return 0;
}

백준 1744 - 수 묶기

hvv_an — Mon, 14 Jul 2025 10:01:55 +0900

문제 설명

길이가 N인 수열이 주어졌을 때, 그 수열의 합을 구하려고 한다. 하지만, 그냥 그 수열의 합을 모두 더해서 구하는 것이 아니라, 수열의 두 수를 묶으려고 한다. 어떤 수를 묶으려고 할 때, 위치에 상관없이 묶을 수 있다. 하지만, 같은 위치에 있는 수(자기 자신)를 묶는 것은 불가능하다. 그리고 어떤 수를 묶게 되면, 수열의 합을 구할 때 묶은 수는 서로 곱한 후에 더한다.

예를 들면, 어떤 수열이 {0, 1, 2, 4, 3, 5}일 때, 그냥 이 수열의 합을 구하면 0+1+2+4+3+5 = 15이다. 하지만, 2와 3을 묶고, 4와 5를 묶게 되면, 0+1+(2*3)+(4*5) = 27이 되어 최대가 된다.

수열의 모든 수는 단 한번만 묶거나, 아니면 묶지 않아야한다.

수열이 주어졌을 때, 수열의 각 수를 적절히 묶었을 때, 그 합이 최대가 되게 하는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 주어진 수들의 합을 최대로 만드는 것이다.

이때 임의의 두 수를 한 번씩만 곱해서 더할 수도 있다.

합을 최대로 만들어야 하므로 큰 수는 큰 수끼리 곱하는 것이 이득이다.

음수끼리의 곱도 해당된다.

따라서 음수와 양수를 구분하여 저장한 후 정렬을 통해 절댓값이 큰 수부터 곱하며 합을 구해 나가면 된다.

-1 2 1 3

4개의 입력이 주어졌다고 가정해 보자.

이를 음수와 양수로 나누면 {-1}, {1, 2, 3}으로 나눌 수 있다.

이때 큰 수부터 차례로 곱해서 더하면 $2*3$을 더할 수 있고 남은 수들은 곱할 것이 없어 그대로 더하게 된다.

$2*3 + 1 + (-1) = 6$이 된다.

기본적인 구조는 이렇게 진행되지만 몇 가지 예외가 존재한다.

바로 1과 0에 대해 처리해줘야 한다.

우선 1은 양수이지만 곱해도 이득이 없다.

따라서 1은 곱하는 것보다 바로 더해주는 것이 합을 최대로 만드는 전략이 된다.

if (num == 1) ans += num;
else positive.push_back(num);

그리고 0에 대해 처리해야 한다.

0은 사실 양수도 아니고 음수도 아니다.

하지만 합을 최대로 만들기 위해서는 0을 음수 쪽에 포함해야 한다.

음수와 0을 곱해 0으로 만들게 되면 음수를 더하지 않을 수 있기 때문이다.

if (num <= 0)
{
    negative.push_back(num);
}

마지막으로 정렬 기준에 대해서만 유의하면 된다.

양수의 경우 당연히 큰 수부터 곱해 나간 뒤 남은 요소는 더해주는 방법이 최대를 만드는 전략이 된다.

음수의 경우 절댓값이 큰 수(더 작은 수)끼리 곱해야 최댓값을 만드는 전략이 된다.

따라서 다음과 같이 정렬해 주어야 한다.

sort(negative.begin(), negative.end(), greater<int>());
sort(positive.begin(), positive.end());

이제 음수, 양수에서 각각 2개씩 뽑아 곱해서 더하면 된다.

while (negative.size() > 1)
{
    int a = negative.back();
    negative.pop_back();
    
    int b = negative.back();
    negative.pop_back();
    
    ans += a * b;
}

while (!negative.empty())
{
    ans += negative.back();
    negative.pop_back();
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
int N;
vector<int> positive, negative;

int main()
{
	INPUT_OPTIMIZE;
	
	cin >> N;
	int ans = 0;

	for (int i = 0; i < N; i++)
	{
		int num;
		cin >> num;

		if (num <= 0)
		{
			negative.push_back(num);
		}
		else
		{
			if (num == 1) ans += num;
			else positive.push_back(num);
		}
	}

	sort(negative.begin(), negative.end(), greater<int>());
	sort(positive.begin(), positive.end());

	while (negative.size() > 1)
	{
		int a = negative.back();
		negative.pop_back();

		int b = negative.back();
		negative.pop_back();

		ans += a * b;
	}

	while (!negative.empty())
	{
		ans += negative.back();
		negative.pop_back();
	}

	while (positive.size() > 1)
	{
		int a = positive.back();
		positive.pop_back();

		int b = positive.back();
		positive.pop_back();

		ans += a * b;
	}

	while (!positive.empty())
	{
		ans += positive.back();
		positive.pop_back();
	}

	cout << ans;

	return 0;
}

백준 10799 - 쇠막대기

hvv_an — Sun, 13 Jul 2025 10:28:38 +0900

문제 설명

여러 개의 쇠막대기를 레이저로 절단하려고 한다. 효율적인 작업을 위해서 쇠막대기를 아래에서 위로 겹쳐 놓고, 레이저를 위에서 수직으로 발사하여 쇠막대기들을 자른다. 쇠막대기와 레이저의 배치는 다음 조건을 만족한다.

쇠막대기는 자신보다 긴 쇠막대기 위에만 놓일 수 있다. - 쇠막대기를 다른 쇠막대기 위에 놓는 경우 완전히 포함되도록 놓되, 끝점은 겹치지 않도록 놓는다.
각 쇠막대기를 자르는 레이저는 적어도 하나 존재한다.
레이저는 어떤 쇠막대기의 양 끝점과도 겹치지 않는다.

아래 그림은 위 조건을 만족하는 예를 보여준다. 수평으로 그려진 굵은 실선은 쇠막대기이고, 점은 레이저의 위치, 수직으로 그려진 점선 화살표는 레이저의 발사 방향이다.

이러한 레이저와 쇠막대기의 배치는 다음과 같이 괄호를 이용하여 왼쪽부터 순서대로 표현할 수 있다.

레이저는 여는 괄호와 닫는 괄호의 인접한 쌍 ‘( ) ’ 으로 표현된다. 또한, 모든 ‘( ) ’는 반드시 레이저를 표현한다.
쇠막대기의 왼쪽 끝은 여는 괄호 ‘ ( ’ 로, 오른쪽 끝은 닫힌 괄호 ‘) ’ 로 표현된다.

위 예의 괄호 표현은 그림 위에 주어져 있다.

쇠막대기는 레이저에 의해 몇 개의 조각으로 잘려지는데, 위 예에서 가장 위에 있는 두 개의 쇠막대기는 각각 3개와 2개의 조각으로 잘려지고, 이와 같은 방식으로 주어진 쇠막대기들은 총 17개의 조각으로 잘려진다.

쇠막대기와 레이저의 배치를 나타내는 괄호 표현이 주어졌을 때, 잘려진 쇠막대기 조각의 총 개수를 구하는 프로그램을 작성하시오.

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

제한 사항

풀이

문제를 요약하면 (, )로 이루어진 문자열로 막대와 레이저를 표현할 때 레이저에 의해 토막 난 막대의 총개수를 구하면 된다.

레이저는 인접한 ()로 표현된다.

해당 문제는 stack을 이용하여 풀 수 있다.

레이저에 의해 잘리는 토막의 개수는 레이저가 있기 전 막대의 개수와 동일하다.

예를 들어 보자.

첫 번째 레이저는 막대가 없기 때문에 무시해도 된다.

두 번째 레이저는 이전에 막대가 3개 존재했다.

따라서 두 번째 레이저에 의해 이전의 막대의 토막이 3개 생긴다.

세 번째 레이저도 마찬가지이다.

그리고 토막이 하나 더 생기는 경우가 있는데 바로 막대의 끝 부분에서 하나 생긴다.

즉 정리하자면 ')'가 나오는 지점에서 토막이 생기는데 이게 레이저인지 막대의 끝인지만 판단하면 된다.

레이저라면 레이저 이전의 토막의 개수를 막대의 끝이라면 1을 더해주면 된다.

따라서 레이저 이전의 막대의 개수를 관리하기 위해 stack을 통해 '('가 나오면 추가해 주자.

for (int i = 0; i < stick.length(); i++)
{
	auto current = stick[i];

	if (current == '(')
	{
		temp.push_back(current);
	}
	else
	{
		if (prev == '(')
		{
			// 레이저
			temp.pop_back();
			ans += temp.size();
		}
		else
		{
			//막대 끝
			temp.pop_back();
			ans++;
		}
	}

	prev = current;
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
string stick;

int main()
{
	INPUT_OPTIMIZE;
	
	cin >> stick;
	
	vector<char> temp;
	char prev = ' ';

	int ans = 0;

	for (int i = 0; i < stick.length(); i++)
	{
		auto current = stick[i];

		if (current == '(')
		{
			temp.push_back(current);
		}
		else
		{
			if (prev == '(')
			{
				// 레이저
				temp.pop_back();
				ans += temp.size();
			}
			else
			{
				//막대 끝
				temp.pop_back();
				ans++;
			}
		}

		prev = current;
	}

	cout << ans;

	return 0;
}

백준 1016 - 제곱 ㄴㄴ 수

hvv_an — Sat, 12 Jul 2025 15:41:35 +0900

문제 설명

어떤 정수 X가 1보다 큰 제곱수로 나누어 떨어지지 않을 때, 그 수를 제곱ㄴㄴ수라고 한다. 제곱수는 정수의 제곱이다. min과 max가 주어지면, min보다 크거나 같고, max보다 작거나 같은 제곱ㄴㄴ수가 몇 개 있는지 출력한다.

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

제한 사항

풀이

문제를 요약하면 min과 max사이의 수 중 제곱수로 나누어 떨어지지 않는 수의 개수를 세면 된다.

해당 문제는 에라토스테네스의 체를 응용하여 풀 수 있다.

문제에서 말한 제곱 ㄴㄴ수는 소수의 조건과 유사하다.

i에 제곱으로 나누어 떨어지지 않는지 확인하면 되기 때문이다.

따라서 소수 판별 알고리즘은 에라토스테네스의 체를 응용하여 개수를 확인하면 된다.

2부터 시작하여 제곱으로 min을 나눈 몫부터 시작하여 false를 체크해준다.

만약 아직 체크되지 않은 숫자라면 개수를 하나씩 줄여나가면 된다.

auto cnt = Max - Min + 1;

for (long long i = 2; i * i <= Max; i++)
{
	auto n = Min / (i * i);
	if (Min % (i * i)) n++;

	while (n * i * i <= Max)
	{
		if (!dp[n * i * i - Min])
		{
			cnt--;
			dp[n * i * i - Min] = true;
		}

		n++;
	}
}

전체 코드

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define INPUT_OPTIMIZE cin.tie(NULL); cout.tie(NULL); ios::sync_with_stdio(false);
#define INF 2e9
#define MAX 987654321

using namespace std;
long long Min, Max;

vector<bool> dp(1000001, false);

int main()
{
	INPUT_OPTIMIZE;
	
	cin >> Min >> Max;
	auto cnt = Max - Min + 1;

	for (long long i = 2; i * i <= Max; i++)
	{
		auto n = Min / (i * i);
		if (Min % (i * i)) n++;

		while (n * i * i <= Max)
		{
			if (!dp[n * i * i - Min])
			{
				cnt--;
				dp[n * i * i - Min] = true;
			}

			n++;
		}
	}

	cout << cnt;

	return 0;
}