๐ก์์ ์ค์ผ์ค๋ง
- ์ํํด์ผํ ๋ค์์ Job์ ์ฃผ์ด์ง ๋ชฉ์ ์๋ฐ๋ผ ์ด๋ป๊ฒ ์ํํ ์ง๋ฅผ ๊ฒฐ์ ํ๋ ๋ฌธ์
- ์ฃผ์ด์ง ๋ชฉ์ ์๋ฐ๋ผ ์์ ์ค์ผ์ค๋ง์ ๋ค์ํ๊ฒ ์ ์ํ ์ ์๋ค.
- ์ด๋ฌํ ๋ฌธ์ ๋ค์ ๋๋ถ๋ถ NP-hard๋ฌธ์ ์ด๋, ์ผ๋ถ ๋ชฉ์ ์ ๋ํด์ ๋๋ ๋ฌธ์ ๋ฅผ ๋จ์ํ ์ํฌ ๊ฒฝ์ฐ polynomial time์ ํด๊ฒฐํ ์ ์๋ค.
๐ก์์ ์ค์ผ์ค๋ง ๋ฌธ์
- ์์ ์ ์ํ์๊ฐ์ด ์ค๋ณต๋์ง ์๋๋ก ๋ชจ๋ ์์ ์ ๊ฐ์ฅ ์ ์ ์์ ๊ธฐ๊ณ์ ๋ฐฐ์ ํ๋ ๋ฌธ์ ์ด๋ค.
- n๊ฐ์ ๊ฐ์์ ์ ์์์๊ฐ๊ณผ ์ข ๋ฃ์๊ฐ์ด ์๋ค.
- ์ฃผ์ด์ง ๋ฌธ์ ์์
- ์์ ์ ์
- ๊ฐ ์์ ์ ์์๊ณผ ์ข ๋ฃ์๊ฐ : ์ด๋ ์ ํด์ ธ ์์ผ๋ฏ๋ก ์์ ์ ๊ธธ์ด๋ ์ฃผ์ด์ง ๊ฒ์ด ๋๋ค.
- ์๊ฐ์๊ฐ, ์ข
๋ฃ์๊ฐ, ์์
์ ๊ธธ์ด์ ๋ํด ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐํด ๋ณผ ์ ์๋๋ฐ
- ๋น ๋ฅธ ์์์๊ฐ ์์ ์ฐ์ ๋ฐฐ์
- ๋น ๋ฅธ ์ข ๋ฃ์๊ฐ ์์ ์ฐ์ ๋ฐฐ์
- ์งง์ ์์ ์ฐ์ ๋ฐฐ์
- ๊ธด ์ก์ ์ฐ์ ๋ฐฐ์
- ์ด์ค 1๋ฒ์งธ ์๊ณ ๋ฆฌ์ฆ๋ง์ด ์ต์ ํด๋ฅผ ์ฐพ์ ์ ์๋ค.
๐ก์์ฌ์ฝ๋
- ์ ๋ ฅ : n๊ฐ์ ์์ t1~tn
- ์ถ๋ ฅ : ๊ฐ ๊ธฐ๊ณ์ ๋ฐฐ์ ๋ ์์ ์์
-
1. ์์ ์๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ์์ ๋ฆฌ์คํธ L 2. while(L!=∅){ 3. L์์ ๊ฐ์ฅ ์ด๋ฅธ ์์์๊ฐ์ ์์ ti๋ฅผ ๊ฐ์ ธ์จ๋ค. 4. if(ti๋ฅผ ์ํํ ๊ธฐ๊ณ๊ฐ ์๋ค๋ฉด) 5. ti๋ฅผ ์ํํ ์ ์๋ ๊ธฐ๊ณ์ ๋ฐฐ์ ํ๋ค. 6. else 7. ์๋ก์ด ๊ธฐ๊ณ์ ti๋ฅผ ๋ฐฐ์ ํ๋ค. 8. ti๋ฅผ L์์ ์ ๊ฑฐํ๋ค. } 9. return ๊ฐ ๊ธฐ๊ณ์ ๋ฐฐ์ ๋ ์์ ์์
๐กC++ ์ฝ๋
#include <iostream>
#include <vector> // ๋ฒกํฐ ๋ฆฌ์คํธ์ ์ฌ์ฉ
#include <utility> // ์
๋ ฅ๊ฐ -> ๋ฒกํฐ๋ฆฌ์คํธ ํ์์ผ๋ก
#include <algorithm>
using namespace std;
#define X first
#define Y second
// ์
์ถ๋ ฅ ์๋ ๊ฐ์
#define IOFAST ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
vector<pair<int,int> > task;
vector< vector<int> > machine;
int nMachine = 0;
int Operating(int start)
{
int i;
// ์
๋ฌด๊ฐ ํ ๋น๋ ๊ธฐ๊ณ๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ
if (nMachine > 0)
{
for (i = 0; i < nMachine; i++)
{
// ์
๋ฌด๋ฅผ ์ํํ๊ณ ์๋ ๊ธฐ๊ณ๊ฐ ์๊ณ ,
// ๊ทธ ๊ธฐ๊ณ๊ฐ ๋ค์ ์
๋ฌด๋ฅผ ์ํํ ์ ์๋ ๊ฒฝ์ฐ ํด๋น ๊ธฐ๊ณ๋ฅผ ๋ฐฐ์น
if (machine[i].size() > 0 && task[machine[i].back()].second <= start)
{
return i;
}
}
// ์
๋ฌด๋ฅผ ์ํํ ๋งํ ๊ธฐ๊ณ๊ฐ ์์ผ๋ฉด ์ ๊ธฐ๊ณ๋ฅผ ๋ฐฐ์น
nMachine++;
return i;
}
// ์
๋ฌด๊ฐ ํ ๋น๋ ๊ธฐ๊ณ๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ
else
{
nMachine++;
return 0;
}
}
void Scheduling(int nTask)
{
int i = 0;
while (i < nTask)
{
// ๊ธฐ๊ณ ๋ฒํธ๋ฅผ ํ ๋น ๋ฐ๊ณ ,
// ํด๋น ๊ธฐ๊ณ์ ์
๋ฌด ๋ฐฐ์
int machineNum=Operating(task[i].first);
machine[machineNum].push_back(i);
i++;
}
}
int main(){
IOFAST;
int N; // ์์
์ ์
cin >> N;
cin.ignore();
for(int i=0;i<N;i++){
int a,b;
cin >> a >> b ;
task.push_back(make_pair(a,b));
}
for (int i = 0; i < N; i++)
{
vector<int> element(0);
machine.push_back(element);
}
sort(task.begin(), task.end());
Scheduling(task.size());
cout<<nMachine;
}
โฐ์๊ฐ๋ณต์ก๋
- Line1 : O(nlogn)
- while-๋ฃจํ์์๋ ์์ ์ L์์ ๊ฐ์ ธ๋ค๊ฐ ์ํ๊ฐ๋ฅํ ๊ธฐ๊ณ๋ฅผ ์ฐพ์์ ๋ฐฐ์ ํ๋ ์๊ฐ : O(m) (m์ ์ฌ์ฉ๋ ๊ธฐ๊ณ์ ํ์)
- while๋ฃจํ๊ฐ ์ํ๋ ์ด ํ์๊ฐ n๋ฒ์ด๋ฏ๋ก, line2~9๊น์ง๋ O(m)xn = O(nm)
- ๋ฐ๋ผ์, O(nlogn) + O(mn)
โฐ์์ฉ
- ๋น์ฆ๋์ค ํ๋ก์ธ์ฑ
- ๊ณต์ฅ ์์ฐ ๊ณต์
- ๊ฐ์์ค/์ธ๋ฏธ๋ ๋ฃธ ๋ฐฐ์
- ์ปดํจํฐ ํ์คํฌ ์ค์ผ์ค๋ง
Reference
์์ธ๊ณผํ๊ธฐ์ ๋ํ๊ต ์ปดํจํฐ๊ณตํ๊ณผ ์๊ณ ๋ฆฌ์ฆ ์์
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] ๋์ ๊ณํ ์๊ณ ๋ฆฌ์ฆ (0) | 2021.10.20 |
---|---|
[Algorithm] ํํ๋ง ์์ถ (0) | 2021.10.13 |
[Algorithm] ์งํฉ ์ปค๋ฒ ๋ฌธ์ (Set Covering Problem) (0) | 2021.10.13 |
[Algorithm] ๋ถ๋ถ ๋ฐฐ๋ญ ๋ฌธ์ (0) | 2021.10.13 |
[Algorithm] ์ต๋จ ๊ฒฝ๋ก ์ฐพ๊ธฐ : ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ (0) | 2021.10.11 |