djtaka님의 노트

3.2.6 Sweet Butter

Thu, 04 Sep 2008 18:35:11 +0900

Test 1: TEST OK [0.022 secs, 5352 KB]

Test 2: TEST OK [0.022 secs, 5356 KB]

Test 3: TEST OK [0.000 secs, 5356 KB]

Test 4: TEST OK [0.022 secs, 5356 KB]

Test 5: TEST OK [0.022 secs, 5356 KB]

Test 6: TEST OK [0.065 secs, 5352 KB]

Test 7: TEST OK [0.475 secs, 5356 KB]

> Run 8: Execution error: Your program (`butter') used more than the

allotted runtime of 1 seconds (it ended or was stopped at 1.566

seconds) when presented with test case 8. It used 5356 KB of

memory.

일단 문제 자체는 별로 어려울 것이 없는 간단한 그래프 문제. 모든 노드간의 최단 거리를 구할 필요가 있어서 Floyd-Warshall으로

풀면 엄청 간단하게 풀 수 있기는 한데 노드가 800개까지 가능하다보니 조금 걱정을 하기는 했는데

3.2.5 Magic Squares #2

Wed, 03 Sep 2008 18:26:39 +0900

Test 1: TEST OK [0.000 secs, 3160 KB]
Test 2: TEST OK [0.011 secs, 3160 KB]
Test 3: TEST OK [0.011 secs, 3160 KB]
Test 4: TEST OK [0.000 secs, 3160 KB]
Test 5: TEST OK [0.011 secs, 3164 KB]
Test 6: TEST OK [0.032 secs, 3164 KB]
Test 7: TEST OK [0.022 secs, 3164 KB]
Test 8: TEST OK [0.043 secs, 3160 KB]

뭔가 길어질 것 같아서 글을 2개로 나눴는데 생각보다 쉽게 끝났음 -_-

BFS하면서 큐에 Push하는 코드의 위치를 잘못 넣어서 중복되는 테이블을 다시 평가하는

문제가 있어서 1번 실패(아마 시간이 오래지나면 답이 찾아지긴 할텐데 큐에 데이터가 쌓여서

메모리 제한을 넘어버린 것 같음)

사실 BFS가 엄청 간단해서 시간이 걸릴게 별로 없는데 자료 구조를 이랬다저랬다 하면서 좀 오래걸렸음. 반성.

/*
ID: djtaka2
PROG: msquare
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <queue>
#include <stack>
using namespace std;
// [0][1][2][3] -> [0][1][2][3][4][5][6][7] 으로 컨버팅
// [7][6][5][4]
int doTable[3][8] = {{7,6,5,4,3,2,1,0},{3,0,1,2,5,6,7,4},{0,6,1,3,4,2,5,7}};
int undoTable[3][8] = {{7,6,5,4,3,2,1,0},{1,2,3,0,7,4,5,6},{0,2,5,3,4,6,1,7}};
struct Data
{
Data()
{
  int i;
  for(i=0;i<8;i++)
   table[i] = i+1;
  encodedData = -1;
}
int encode()
{
if(encodedData != -1)
return encodedData;
int i,j;
int result = 0;
  for(i=0;i<7;i++)
  {
   int wrongOrdered=0;
   for(j=i+1;j<8;j++)
   {
    if(table[j] < table[i])
     wrongOrdered++;
   }
   result = result*(8-i) + wrongOrdered;
  }
  encodedData = result;
  return result;
}
int encodedData;
int table[8];
};
queue<Data> answerList;
void doAction(Data &source,Data &dest,int type)
{
int i;
for(i=0;i<8;i++)
dest.table[i] = source.table[doTable[type][i]];
}
int visited[40321];
int steps[40321];
int main()
{
int i,j,k;

// Variables
Data basic,target;
int finish;
// Get input
ifstream fin ("msquare.in");
ofstream fout ("msquare.out");
for(i=0;i<8;i++)
fin >> target.table[i];
for(i=0;i<40321;i++)
visited[i] = -1;
finish = target.encode();
answerList.push(basic);
// Function test
//cout << encode(targetTable) << "\n";
//cout << finish << "\n";
// Processing
bool finished = false;
while(!finished)
{
  // 꺼내고
  Data curData = answerList.front();
  answerList.pop();
  for(i=0;i<3;i++) // Do the A! B! C!
  {
   Data tempData;
   doAction(curData,tempData,i);
   int cur = tempData.encode();
   if(visited[cur] == -1)
   {
    answerList.push(tempData);
    visited[cur] = curData.encode();
    steps[cur] = i;
    if(cur == finish)
    {
     finished = true;
     break;
    }
   }
  }
}
// Output
int cursor = finish;
char moveTable[3] = {'A','B','C'};
stack<int> s;
while(cursor)
{
  s.push(steps[cursor]);
  cursor = visited[cursor];
}
fout << s.size() << "\n";;
while(s.size())
{
  fout << moveTable[s.top()];
  s.pop();
}
fout << "\n";
return 0;
}

3.2.5 Magic Squares #1

Mon, 01 Sep 2008 19:02:29 +0900

이건 좀 복잡하군 -_-..

BFS같은걸로 일일히 해본다.
그리디? 라든지 해서 간단히 구할 수 있는 방법이 있을까?

한참 생각해봤는데 2번은 영 아닌것 같음. 1번으로 진로 결정.

[1][2][3][4]

[8][7][6][5]

일단은 매직 스퀘어는 요런 형의 테이블인데 일렬로 배열한다고 치고 생각 해 보면 1/2/3/4/5/6/7/8 8개로 만들 수 있는

순열이라고 생각 할 수 있겠지. 그럼 만들어 질 수 있는 가지수는 8! = 40320개니까 처리하기 불가능 한 수는 아니겠군.

그럼 만들 수 있는 순열의 각 가지수를 1~40320으로 각각 매치시킬 수 있는 방법을 가지고 있어야하겠음.

여기서 꽤 고민했는데 Dish에게 물어봤더니 "Dynamic으로 하면 구해질 것 같다."는 답변. 이렇게 하면 문제가 되는 것이

Dynamic으로 계산을 하려면 앞에서부터 순차적으로 실제 탐색 과정에서 쓰이지 않을지도 모르는 경우의 수 까지도 다

계산해야하며 [순열] -> [순서] 형태의 map까지 하나 가지고 있어야하니 별로 탐탁지가 않다.

결국 발견한 가장 간단한 방법은 순서가 엉켜있는 것을 이용하는 것

12345867이 있다고 하면 1의 뒤에는 1보다 작은 것이 0개, 2의 뒤에는 2보다 작은 것이 0개,..., 8의 뒤에는 8보다 작은 것이 2개,...

하는 요 꼬인 것을 이용해서 계산하는 것이 가장 간단한 듯 하다. 검색을 좀 해보니 대회에서도 이런 경우에는 보통 이 방법을 사용하는듯

이걸 더 수행시간을 줄이기위해서 Table 만들어가지고 이렇게저렇게하는 짓도 있던데 사실 차이가 클 것 같지는 않다.

int arr[8] = {i1,i2,i3,i4,i5,i6,i7,i8}

int i,j,answer;

for( i = 0; i < 7;i++)

{

int count = 0;

for(j=i+1;j < 8;j++)

if(arr[j] < arr[i]) count++;

answer = answer * (8-i) + count;

}

정도로 하면 되겠다 'ㅅ'

3.2.4 Feed Ratios

Fri, 29 Aug 2008 13:40:31 +0900

Test 1: TEST OK [0.022 secs, 2840 KB]
Test 2: TEST OK [0.022 secs, 2844 KB]
Test 3: TEST OK [0.022 secs, 2840 KB]
Test 4: TEST OK [0.022 secs, 2844 KB]
Test 5: TEST OK [0.011 secs, 2840 KB]
Test 6: TEST OK [0.022 secs, 2840 KB]

노가다 노가다 노가다 노가다.

쉽게 풀릴 줄 알았는데 의외로 이것 저것 하다보니 고생...

/*
ID: djtaka2
PROG: ratios
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
int i,j,k;
// Variables
int mixtures[3][3],objective[3];
int l;
// Get input
ifstream fin ("ratios.in");
ofstream fout ("ratios.out");
fin >> objective[0] >> objective[1] >> objective[2];
fin >> mixtures[0][0] >> mixtures[0][1] >> mixtures[0][2];
fin >> mixtures[1][0] >> mixtures[1][1] >> mixtures[1][2];
fin >> mixtures[2][0] >> mixtures[2][1] >> mixtures[2][2];
// Function test
// Processing
int result[3];
int answer[3]={1000,1000,1000},totalRatio;
int tempAnswer[3] = {-1,-1,-1};
if(objective[0] == 0 && objective[1] == 0 && objective[2] == 0)
fout << "0 0 0 0\n";
for(i=0 ; i<100 ; i++)
{
  for(j=0 ; j<100 ; j++)
  {
   for(k=0 ; k<100 ; k++)
   {
    if(i==0 && j==0 && k==0)
     continue;
    tempAnswer[0] = tempAnswer[1] = tempAnswer[2];
    result[0] = mixtures[0][0] * i + mixtures[1][0] * j + mixtures[2][0] * k;
    result[1] = mixtures[0][1] * i + mixtures[1][1] * j + mixtures[2][1] * k;
    result[2] = mixtures[0][2] * i + mixtures[1][2] * j + mixtures[2][2] * k;

    bool isNotAnswer=false;
    for(l=0 ; l<3 ; l++)
    {
     if(objective[l])
     {
      if((result[l] % objective[l]) == 0)
      {
       tempAnswer[l] = result[l] / objective[l];
       if(tempAnswer[l] > answer[l]) // 답은 답인데 최소 답이 아님
       {
        isNotAnswer = true;
        break;
       }
      }
      else // 답 불가능
      {
       isNotAnswer = true;
       break;
      }
     }
     else
     {
      tempAnswer[l] = (result[0] + result[1] + result[2]) / (objective[0] + objective[1] + objective[2]);
     }
    }
if(isNotAnswer)
continue;
    if(tempAnswer[0] == tempAnswer[1] && tempAnswer[1] == tempAnswer[2]) // 답이쿠나
    {
     answer[0] = i;//tempAnswer[0];
     answer[1] = j;//tempAnswer[1];
     answer[2] = k;//tempAnswer[2];
     totalRatio = tempAnswer[0];
    }
   }
  }
}
// Output
if(answer[0] == 1000)
fout << "NONE\n";
else
fout << answer[0] << " " << answer[1] << " " << answer[2] << " " << totalRatio << "\n";
return 0;
}

3.2.3 Spinning Wheels

Thu, 28 Aug 2008 13:48:09 +0900

Test 1: TEST OK [0.000 secs, 2856 KB]
Test 2: TEST OK [0.011 secs, 2852 KB]
Test 3: TEST OK [0.000 secs, 2852 KB]
Test 4: TEST OK [0.000 secs, 2856 KB]
Test 5: TEST OK [0.000 secs, 2852 KB]
Test 6: TEST OK [0.011 secs, 2852 KB]
Test 7: TEST OK [0.000 secs, 2852 KB]
Test 8: TEST OK [0.000 secs, 2856 KB]

메모리는 좀 많이 먹지만 빠르게 풀 수 있는 방법 선택. 문제가 안 풀려서 이거 대체 왜 이러나 한참

고생을 했는데 >이냐 >=이냐의 선택에서 마지막 1가지 경우의 수가 안 걸려서 문제가 안풀리고있었음..

/*
ID: djtaka2
PROG: spin
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;
struct Wheel
{
int surface[721]; // 0 : normal / 1 : wedge
int cursor;
int speed;
Wheel()
  : cursor(0), speed(0)
{
  for(int i=0 ; i <= 720 ; i++)
   surface[i] = 0;
}
int getSurfaceStatus(int offset)
{
return surface[cursor + offset];
}
};
Wheel wheels[5];
void OutputStatus()
{
ofstream fo("test.out");
for(int i=0;i<360;i++)
fo << i << "\t" << wheels[0].getSurfaceStatus(i) << wheels[1].getSurfaceStatus(i) << wheels[2].getSurfaceStatus(i) << wheels[3].getSurfaceStatus(i) << wheels[4].getSurfaceStatus(i) << "\n";
}
int main()
{
int i,j,k;
// Variables
int wedgeCount;
// Get input
ifstream fin ("spin.in");
ofstream fout ("spin.out");
for(i=0 ; i<5 ; i++)
{
  fin >> wheels[i].speed >> wedgeCount;
  for(j=0 ; j < wedgeCount ; j++)
  {
   int start,extent;
   fin >> start >> extent;
   for(k = start ; k <= start+extent ; k++)
    wheels[i].surface[(k%360)] = wheels[i].surface[(k%360)+360] = 1;
  }
}

// Function test
// Processing
int answer = -1;
for(i=0 ; i<360 ; i++)
{
//if(i == 357)
// OutputStatus();
  for(j=0 ; j<360 ; j++)
  {
   if(wheels[0].getSurfaceStatus(j) == 1 && wheels[1].getSurfaceStatus(j) == 1 && wheels[2].getSurfaceStatus(j) == 1 && wheels[3].getSurfaceStatus(j) == 1 && wheels[4].getSurfaceStatus(j) == 1)
   {
    answer = i;
    break;
   }
  }
  if(answer != -1) // 답 찾았으니 스톱
   break;
for(j=0 ; j<5 ; j++) // 끝났으니 돌려주자
wheels[j].cursor = (360 + wheels[j].cursor - wheels[j].speed) % 360;
}
// Output
if(i == 360) // no answer
fout << "none\n";
else
fout << answer << "\n";
return 0;
}

3.2.2(다시) Stringsobits

Tue, 26 Aug 2008 15:52:01 +0900

기본적으로 Combination을 만들어서 접근한다는 면에서는 올바르게 시작을 했는데, S가 정렬되어 있어야 한다는

것에서 실수를 했음. 여기있는건 하도 모르겠어서 고민하고 구글링하다가 발견한 답안 카피해서 만든거. 나중에 다시 풀자.

Printbits같은 아이디어는 굉장히 좋은데 지금은 별로 분석 할 마음도 안든다.

/*
ID: djtaka2
PROG: kimbits
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <list>
using namespace std;
// a C b 를 계산
int combination(int a,int b)
{
if(b == 1)
return a;
if(a == b)
return 1;
int result = 1;
int i;
for(i=0 ; i<b ;i++)
{
result *= (a-i);
result /= (i+1);
}

return result;
}
ofstream fout ("kimbits.out");
long long combinationTable[33][33];
void printbits(int nbits, int nones, long long index)
{
long long s;

if(nbits == 0)
return;
s = combinationTable[nbits-1][nones];
if(s <= index)
{
  fout << "1";
  printbits(nbits-1, nones-1, index-s);
}
else
{
  fout << "0";
  printbits(nbits-1, nones, index);
}
}
int main()
{
int i,j,k;
// Variables
int stringLength, checkedCount;
long long targetCount;
int curCount=0;
// Get input
ifstream fin ("kimbits.in");
fin >> stringLength >> checkedCount >> targetCount;
// Function test
// cout << combination(8,8) << "\n";
// Processing
for(j=0; j<=32; j++)
combinationTable[0][j] = 1;
for(i=1; i<=32; i++)
{
  for(j=0; j<=32; j++)
  {
   if(j == 0)
    combinationTable[i][j] = 1;
   else
    combinationTable[i][j] = combinationTable[i-1][j-1] + combinationTable[i-1][j];
  }
}
// Output
printbits(stringLength,checkedCount,targetCount-1);
fout << "\n";
return 0;
}

3.2.1 Factorials

Tue, 26 Aug 2008 11:43:35 +0900

Test 1: TEST OK [0.022 secs, 2844 KB]
Test 2: TEST OK [0.011 secs, 2844 KB]
Test 3: TEST OK [0.000 secs, 2840 KB]
Test 4: TEST OK [0.000 secs, 2844 KB]
Test 5: TEST OK [0.000 secs, 2844 KB]
Test 6: TEST OK [0.000 secs, 2844 KB]
Test 7: TEST OK [0.011 secs, 2844 KB]
Test 8: TEST OK [0.000 secs, 2840 KB]
Test 9: TEST OK [0.011 secs, 2844 KB]
Test 10: TEST OK [0.000 secs, 2840 KB]

아 뭐야 쉬운 문제잖아 'ㅅ'~ 하다가 미끄러짐. 곱셈을 할 때 "마지막 자리 수"만 보존하고있으면 최종 결과의 마지막 자리 숫자를 알 수 있는 것은

맞는데 이 문제의 조건처럼 0이 아닌 마지막 수..같은게 되어서 여러 자리의 변수가 생기게 되면 그렇게 간단하게 생각하면 안된다능... 적어도

승수의 자리수만큼의 자리 올림이 발생 할 수 있는 정도의 여유는 마련 해 주어야한다능...

/*
ID: djtaka2
PROG: fact4
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <list>
using namespace std;
int main()
{
int i,j,k;
// Variables
int  n;
int  val = 1;
int  jari = 10;
// Get input
ifstream fin ("fact4.in");
ofstream fout ("fact4.out");
fin >> n;
// Function test
// Processing
for(i=1 ; i<=n ; i++)
{
  if(i == 10) jari = 100;
  else if(i == 100) jari = 1000;
  else if(1 == 1000) jari = 10000;
  val *= i;
  // 뒤에 0 떼고
  while(val % 10 == 0)
   val /= 10;
  // 초과 떼고
  if(val > jari)
   val %= jari;
}
while(val % 10 == 0)
val /= 10;
if(val > 10)
val %= 10;
// Output
fout << val << "\n";
return 0;
}

USACO

Mon, 25 Aug 2008 17:59:20 +0900

2008년 8월 8일 : Section 3.1 시작
2008년 8월 25일 : Section 3.2 시작

3.1.4 Shaping Regions

Mon, 25 Aug 2008 17:56:56 +0900

Test 1: TEST OK [0.000 secs, 2848 KB]
Test 2: TEST OK [0.000 secs, 2848 KB]
Test 3: TEST OK [0.011 secs, 2848 KB]
Test 4: TEST OK [0.011 secs, 2848 KB]
Test 5: TEST OK [0.011 secs, 2852 KB]
Test 6: TEST OK [0.000 secs, 2848 KB]
Test 7: TEST OK [0.000 secs, 2848 KB]
Test 8: TEST OK [0.011 secs, 2848 KB]
Test 9: TEST OK [0.000 secs, 2852 KB]
Test 10: TEST OK [0.022 secs, 2852 KB]
Test 11: TEST OK [0.032 secs, 2852 KB]

좀 대충대충 풀다가 귀찮아서 예제 input만 돌려보고 제출했는데 한 방에 OK -_-)b

Divide하면 사각형이 1개~4개로 쪼개지기 때문에 막 불어나서 시간이 좀 오래 걸리진 않을까 걱정했는데

다행히 사각형이 원래 2500개 밖에 안되기도 하고 별 문제 없었던 듯... 겹치는 부분 어떻게 효율적으로 잘

체크하는 법 없나 싶어서 사각형 충돌 체크에 관한거 찾아보고 했는데 그냥 노가다가 제일인듯

/*
ID: djtaka2
PROG: rect1
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <list>
using namespace std;
struct Rectangle
{
int color;
int x1,x2,y1,y2;

int getSize()
{
return (x2-x1)*(y2-y1);
}
};
list<Rectangle> rects;
typedef list<Rectangle>::iterator RectangleListIt;
int colorCount[2501];
void InsertRect(Rectangle& newRect)
{
RectangleListIt it;
RectangleListIt delIt=rects.end();
for(it = rects.begin() ; it != rects.end() ; advance(it,1))
{
  if(delIt != rects.end())
  {
   rects.erase(delIt);
   delIt = rects.end();
  }
Rectangle oldRect = *it;
  // 안겹치면
  if(oldRect.x2 <= newRect.x1 || oldRect.x1 >= newRect.x2 || oldRect.y2 <= newRect.y1 || oldRect.y1 >= newRect.y2)
   continue;
  // 아예 덮어버리면
  if(oldRect.x1 >= newRect.x1 && oldRect.x2 <= newRect.x2 && oldRect.y1 >= newRect.y1 && oldRect.y2 <= newRect.y2)
  {
   delIt = it;
   continue;
  }
  // Left
  Rectangle tempRect = oldRect;
  if(oldRect.x1 <= newRect.x1)
  {
   tempRect.x2 = newRect.x1;
   if(tempRect.x1 < tempRect.x2) // 유효한가?
    rects.push_back(tempRect);
   oldRect.x1 = newRect.x1;
  }
  // Right
  if(oldRect.x2 >= newRect.x2)
  {
   tempRect = oldRect;
   tempRect.x1 = newRect.x2;
   if(tempRect.x1 < tempRect.x2) // 유효한가?
    rects.push_back(tempRect);
   oldRect.x2 = newRect.x2;
  }
  // Up
  if(oldRect.y1 <= newRect.y1)
  {
   tempRect = oldRect;
   tempRect.y2 = newRect.y1;
   if(tempRect.y1 < tempRect.y2) // 유효한가?
    rects.push_back(tempRect);
   oldRect.y1 = newRect.y1;
  }
  // Down
  if(oldRect.y2 >= newRect.y2)
  {
   tempRect = oldRect;
   tempRect.y1 = newRect.y2;
   if(tempRect.y1 < tempRect.y2) // 유효한가?
    rects.push_back(tempRect);
   oldRect.y2 = newRect.y2;
  }

  delIt = it;
}

// 추가
rects.push_back(newRect);
}
int main()
{
int i,j,k;
// Variables
int width,height,rectCount;
int x1,x2,y1,y2,color;
for(i=0;i<2500;i++)
colorCount[i] = 0;
// Get input
ifstream fin ("rect1.in");
ofstream fout ("rect1.out");
fin >> width >> height >> rectCount;

// 배경 Rect
Rectangle tempRect;
tempRect.color = 1;
tempRect.x1 = 0;
tempRect.x2 = width;
tempRect.y1 = 0;
tempRect.y2 = height;
InsertRect(tempRect);
for(i=0 ; i<rectCount ; i++)
{
  fin >> x1 >> y1 >> x2 >> y2 >> color;
  tempRect.x1 = x1;
  tempRect.x2 = x2;
  tempRect.y1 = y1;
  tempRect.y2 = y2;
  tempRect.color = color;
  InsertRect(tempRect);
}
// Function test
// Processing
RectangleListIt it;
for(it = rects.begin() ; it != rects.end() ; advance(it,1))
colorCount[it->color] += it->getSize();
// Output
for(i=0;i<2501;i++)
{
if(colorCount[i])
fout << i << " " << colorCount[i] << "\n";
}
return 0;
}

3.1.6 Stamps

Fri, 22 Aug 2008 14:04:30 +0900

Test 1: TEST OK [0.011 secs, 10652 KB]
Test 2: TEST OK [0.011 secs, 10656 KB]
Test 3: TEST OK [0.000 secs, 10656 KB]
Test 4: TEST OK [0.000 secs, 10652 KB]
Test 5: TEST OK [0.000 secs, 10652 KB]
Test 6: TEST OK [0.000 secs, 10656 KB]
Test 7: TEST OK [0.000 secs, 10652 KB]
Test 8: TEST OK [0.000 secs, 10656 KB]
Test 9: TEST OK [0.000 secs, 10656 KB]
Test 10: TEST OK [0.097 secs, 10656 KB]
Test 11: TEST OK [0.626 secs, 10656 KB]
Test 12: TEST OK [0.216 secs, 10652 KB]
Test 13: TEST OK [0.011 secs, 10656 KB]

DP문제. 동전으로 몇 개 이하로 써서 얼마 만들기 이런 류의 정석적인 문제랑 유사한 느낌

/*
ID: djtaka2
PROG: stamps
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;
int minStampCount[10000*200+2];
int main()
{
int i,j,k;
// Variables
int fitCount,stampCount,maxStampCost=0;
int stampCosts[51];
// Get input
ifstream fin ("stamps.in");
ofstream fout ("stamps.out");
fin >> fitCount >> stampCount;
for(i=0 ; i<stampCount ; i++)
{
fin >> stampCosts[i];
if(stampCosts[i] > maxStampCost) maxStampCost = stampCosts[i];
}
minStampCount[0] = 0;
for(i=1 ; i<maxStampCost*fitCount + 1 ; i++)
minStampCount[i] = 100000;
// Function test
// Processing
for(i=1 ; i<maxStampCost*fitCount + 1 ; i++)
{
  for(j=0 ; j<stampCount ; j++)
  {
   if(i - stampCosts[j] < 0)
    continue;
   if(minStampCount[i] > minStampCount[i - stampCosts[j]] + 1)
    minStampCount[i] = minStampCount[i - stampCosts[j]] + 1;
  }
  if(minStampCount[i] > fitCount)
   break;
}
// Output
fout << i-1 << "\n";
return 0;
}

3.1.5 Contact

Fri, 22 Aug 2008 11:23:34 +0900

Test 1: TEST OK [0.000 secs, 4044 KB]
Test 2: TEST OK [0.000 secs, 4044 KB]
Test 3: TEST OK [0.011 secs, 4044 KB]
Test 4: TEST OK [0.022 secs, 4044 KB]
Test 5: TEST OK [0.032 secs, 4044 KB]
Test 6: TEST OK [0.032 secs, 4040 KB]
Test 7: TEST OK [0.054 secs, 4040 KB]

제법 빠르게 통과 'ㅅ')b

itoa atoi 같은게 c++ 표준이 아니라는 것을 주의 -_- 아놔

문자열 0101 같은 패턴을 그냥 2진수로 변환해서 배열에 넣고 값이 똑같은 것 끼리 비교하는 것이

가장 기본 idea. DP로 하면 빠르게 계산 된다. 남들은 어찌 풀었나 궁금했는데 Analysis보니까 세부 구현은

좀 달라도 기본 착안점은 똑같음.

+ 추가 이 방식대로라면 01과 0001이 같은 수가 되어버리므로 length를 따로 저장해야하서 코드가 복잡해지는데

답안에 보면 숫자 앞에 무조건 1을 하나 더 붙여서 이를 구분하는 방법을 썼음(01 -> 101, 0001 -> 10001)

굉장히 간단건데 굉장히 유용한 아이디어인듯

처음에는 엄청나게 큰 배열 [13][200001]짜리를 잡고 데이터를 저장하는 것을 생각

-> 실질적으로는 [13][2]만 가지고 있으면 계속해서 다음 값을 만들어 낼 수 있다는 것을 착안

-> (발전) 귀찮아서 안했지만 tableShift를 하는 대신에 그냥 배열의 [0]행 [1]행의 용도를 번갈아가면서 쓰면

더 빨라질 듯.

priority_queue를 쓰는데 대해서 걱정했는데 이거 생각보다 느리지는 않은 듯?

덩치 큰 데이터들은 qsort로 정렬하는 것 보다는 이게 빠를수도 있겠다 싶음. 근데 쓰기가 꽤 귀찮네...

/*
ID: djtaka2
PROG: contact
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <stack>
#include <queue>
using namespace std;
int  str[200001];
int  table[13][2];
int  countTable[13][8193];
void getBinNumber(char* buf,int val,int len)
{
stack<int> st;
while(val)
{
st.push(val%2);
val /= 2;
}
int i;
for(i=0;i<len-st.size();i++)
  buf[i] = '0';
while(!st.empty())
{
  buf[i++] = '0'+st.top();
  st.pop();
}
buf[i] = '\0';
}
struct CountData
{
int len;
int val;
int count;
};
class Comparison
{
bool reverse;
public:
Comparison(const bool& revparam=false)
{reverse=revparam;}
bool operator() (const CountData& lhs, const CountData& rhs) const
{
    //if (reverse)
// return (lhs.count>rhs.count);
if(lhs.count == rhs.count)
{
  if(lhs.len == rhs.len)
  {
   return (lhs.val > rhs.val);
  }
  else
   return (lhs.len > rhs.len);
}
else
  return (lhs.count < rhs.count);
}
};
void shiftTable()
{
int i;
for(i=0;i<13;i++)
table[i][1] = table[i][0];
}
int main()
{
int i,j,k;
// Variables
int minLength,maxLength,outputCount,strLength,valMax=2;
// Get input
ifstream fin ("contact.in");
ofstream fout ("contact.out");
fin >> minLength >> maxLength >> outputCount;
for(i=0;i<maxLength;i++)
{
valMax *= 2;
}
memset(table,0,sizeof(table));
memset(countTable,0,sizeof(countTable));
i = 0;
char c;
while(1)
{
  fin >> c;
  if(fin.eof())
   break;
  if(c == '0')
   str[i] = 0;
  else if(c == '1')
   str[i] = 1;
  else
   continue;
  i++;
}
strLength = i;
// Function test
// Processing
// Table을 만들고
for(i=strLength-1 ; i >= 0 ; i--)
{
int lineVal = str[i];
  for(j=1 ; j <= maxLength ; j++)
  {
   if(i + j > strLength) // 오버
    break;
   table[j][0] = lineVal + (table[j-1][1]);
   countTable[j][table[j][0]]++;
   lineVal *= 2;
  }
  shiftTable();
}
// PQueue에 넣고
priority_queue<CountData,vector<CountData>,Comparison> pq;
for(i=minLength ; i <= maxLength ; i++)
{
  for(j=0 ; j < valMax ; j++)
  {
   if(countTable[i][j])
   {
    CountData tempData;
    tempData.len = i;
    tempData.val = j;
    tempData.count = countTable[i][j];
    pq.push(tempData);
   }
  }
}
// Output
int count=0;
int curCount = 0;
int printedCount;
char buf[15];
while(!pq.empty())
{
  if(curCount != pq.top().count)
  {
   curCount = pq.top().count;
   count++;
   if(count > outputCount)
    break;
   if(count != 1)
    fout << "\n";
   fout << curCount << "\n";
   printedCount = 0;
  }
  else
  {
   if(printedCount && printedCount % 6 == 0)
    fout << "\n";
   else
    fout << " ";
  }
  getBinNumber(buf,pq.top().val,pq.top().len);
  printedCount++;
  fout << buf;
  pq.pop();
}
fout << "\n";
return 0;
}