ACM ICPC/PrepareAsiaRegionalContest - Revision history

Maintenance script: Quality repair v1

2026-03-27T04:58:06Z

Quality repair v1

← Older revision		Revision as of 04:58, 27 March 2026
Line 5:		Line 5:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
	* AlgorithmStudy/2015 \| ACM_ICPC/2015년스터디		* [[AlgorithmStudy/2015\|ACM_ICPC/2015년스터디]]
	== Past Problems ==		== Past Problems ==

Maintenance script: Repair batch-0001 pages from live compare

2026-03-26T23:55:59Z

Repair batch-0001 pages from live compare

← Older revision		Revision as of 23:55, 26 March 2026
Line 5:		Line 5:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
	* [[AlgorithmStudy/2015 \| ACM_ICPC/2015년스터디]]		* AlgorithmStudy/2015 \| ACM_ICPC/2015년스터디
	== Past Problems ==		== Past Problems ==

Line 27:		Line 27:

	const int MAX = 1001;		const int MAX = 1001;
	static int workspace[MAX][MAX];		static int workspace[MAX][MAX];

	for ( int i = 0 ; i < MAX ; i++ )		for ( int i = 0 ; i < MAX ; i++ )
	for ( int j = 0 ; j < MAX ; j++ )		for ( int j = 0 ; j < MAX ; j++ )
	workspace[i][j] = 0;		workspace[i][j] = 0;

	int x, y;		int x, y;
Line 37:		Line 37:
	for ( int m = 0 ; m < nMine ; m++ ){		for ( int m = 0 ; m < nMine ; m++ ){
	fin >> x >> y;		fin >> x >> y;
	workspace[x][y] = 1;		workspace[x][y] = 1;
	}		}

Line 49:		Line 49:
	for ( int sx = 0 ; sx < SQUARE_SIZE ; sx++ )		for ( int sx = 0 ; sx < SQUARE_SIZE ; sx++ )
	for ( int sy = 0 ; sy < SQUARE_SIZE ; sy++ )		for ( int sy = 0 ; sy < SQUARE_SIZE ; sy++ )
	if ( workspace[x+sx][y+sy] == 1 )		if ( workspace[x+sx][y+sy] == 1 )
	count++;		count++;
	if ( count > max )		if ( count > max )
Line 81:		Line 81:
	{		{
	private:		private:
	Coin coins[SIZE][SIZE];		Coin coins[SIZE][SIZE];
	public:		public:
	void constructCoins( const char input[SIZE][SIZE] );		void constructCoins( const char input[SIZE][SIZE] );
	void flipRow(int rowNum);		void flipRow(int rowNum);
	void flipCol(int colNum);		void flipCol(int colNum);
Line 127:		Line 127:

	////////////////////////////////////////////////////////////////////////////////		////////////////////////////////////////////////////////////////////////////////
	void Gamer::constructCoins( const char input[SIZE][SIZE] )		void Gamer::constructCoins( const char input[SIZE][SIZE] )
	{		{
	for ( int row = 0 ; row < SIZE ; row++ )		for ( int row = 0 ; row < SIZE ; row++ )
	for ( int col = 0 ; col < SIZE ; col++ )		for ( int col = 0 ; col < SIZE ; col++ )
	coins[row][col].set(input[row][col]);		coins[row][col].set(input[row][col]);
	}		}

Line 137:		Line 137:
	{		{
	for ( int col = 0 ; col < SIZE ; col++ )		for ( int col = 0 ; col < SIZE ; col++ )
	coins[rowNum][col].flip();		coins[rowNum][col].flip();
	}		}

Line 143:		Line 143:
	{		{
	for ( int row = 0 ; row < SIZE ; row++ )		for ( int row = 0 ; row < SIZE ; row++ )
	coins[row][colNum].flip();		coins[row][colNum].flip();

	}		}
Line 149:		Line 149:
	void Gamer::flipAsc()		void Gamer::flipAsc()
	{		{
	coins[2][0].flip();		coins[2][0].flip();
	coins[1][1].flip();		coins[1][1].flip();
	coins[0][2].flip();		coins[0][2].flip();
	}		}

	void Gamer::flipDsc()		void Gamer::flipDsc()
	{		{
	coins[0][0].flip();		coins[0][0].flip();
	coins[1][1].flip();		coins[1][1].flip();
	coins[2][2].flip();		coins[2][2].flip();
	}		}

Line 177:		Line 177:
	for ( int row = 0 ; row < SIZE ; row++ )		for ( int row = 0 ; row < SIZE ; row++ )
	for ( int col = 0 ; col < SIZE ; col++ )		for ( int col = 0 ; col < SIZE ; col++ )
	if ( !coins[row][col].equals( coins[0][0] ) )		if ( !coins[row][col].equals( coins[0][0] ) )
	return false;		return false;
	return true;		return true;
Line 189:		Line 189:
	Gamer gamer;		Gamer gamer;
	GameEngine engine;		GameEngine engine;
	char input[SIZE][SIZE];		char input[SIZE][SIZE];
	for ( int row = 0 ; row < SIZE ; row++ )		for ( int row = 0 ; row < SIZE ; row++ )
	for ( int col = 0 ; col < SIZE ; col++ )		for ( int col = 0 ; col < SIZE ; col++ )
	cin >> input[row][col];		cin >> input[row][col];

	gamer.constructCoins( input );		gamer.constructCoins( input );
Line 233:		Line 233:
	return fall(round(N/2),K-1)+1;		return fall(round(N/2),K-1)+1;
	}		}

imported>minn951120 at 12:29, 15 September 2015

2015-09-15T12:29:55Z

← Older revision		Revision as of 12:29, 15 September 2015
Line 1:		Line 1:
	__TOC__		__TOC__
	== 관련 페이지 ==		== 관련 페이지 ==
			* [[ACM_ICPC]]
	* [[ACM_ICPC/2011년스터디]]		* [[ACM_ICPC/2011년스터디]]
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]

imported>minn951120 at 12:28, 15 September 2015

2015-09-15T12:28:20Z

← Older revision		Revision as of 12:28, 15 September 2015
Line 4:		Line 4:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
	* [[~~algorithmstudy~~/2015 \| ACM_ICPC/2015년스터디]]		* [[AlgorithmStudy/2015 \| ACM_ICPC/2015년스터디]]
	== Past Problems ==		== Past Problems ==

imported>minn951120 at 12:28, 15 September 2015

2015-09-15T12:28:08Z

← Older revision		Revision as of 12:28, 15 September 2015
Line 4:		Line 4:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
	* [[ACM_ICPC/2015년스터디 ~~\| algorithmstudy/2015~~]]		* [[algorithmstudy/2015 \| ACM_ICPC/2015년스터디]]
	== Past Problems ==		== Past Problems ==

imported>minn951120 at 12:27, 15 September 2015

2015-09-15T12:27:54Z

← Older revision		Revision as of 12:27, 15 September 2015
Line 4:		Line 4:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
	* [[ACM_ICPC/~~2013년스터디~~ \| algorithmstudy/2015]]		* [[ACM_ICPC/2015년스터디 \| algorithmstudy/2015]]
	== Past Problems ==		== Past Problems ==

imported>minn951120 at 12:27, 15 September 2015

2015-09-15T12:27:43Z

← Older revision		Revision as of 12:27, 15 September 2015
Line 4:		Line 4:
	* [[ACM_ICPC/2012년스터디]]		* [[ACM_ICPC/2012년스터디]]
	* [[ACM_ICPC/2013년스터디]]		* [[ACM_ICPC/2013년스터디]]
			* [[ACM_ICPC/2013년스터디 \| algorithmstudy/2015]]
	== Past Problems ==		== Past Problems ==

imported>jereneal20 at 04:10, 4 November 2013

2013-11-04T04:10:50Z

New page

__TOC__
== 관련 페이지 ==
* [[ACM_ICPC/2011년스터디]]
* [[ACM_ICPC/2012년스터디]]
* [[ACM_ICPC/2013년스터디]]
== Past Problems ==

=== at On-line Preliminary Contest(Oct. 2, 2004) ===
==== Solution of Problem C. Mine Sweeper ====
#include <iostream>
#include <fstream>
using namespace std;

int main()
{
ifstream fin;
fin.open("C.in");

int nTest;
fin >> nTest;

int nMine;
for ( int t = 0 ; t < nTest ; t++ ){
fin >> nMine;

const int MAX = 1001;
static int workspace[MAX][MAX];

for ( int i = 0 ; i < MAX ; i++ )
for ( int j = 0 ; j < MAX ; j++ )
workspace[i][j] = 0;

int x, y;

for ( int m = 0 ; m < nMine ; m++ ){
fin >> x >> y;
workspace[x][y] = 1;
}

int max = 0;

const int SQUARE_SIZE = 11;
int count;
for ( x = 0 ; x < MAX-SQUARE_SIZE ; x++ ){
for ( y = 0 ; y < MAX-SQUARE_SIZE ; y++ ){
count = 0;
for ( int sx = 0 ; sx < SQUARE_SIZE ; sx++ )
for ( int sy = 0 ; sy < SQUARE_SIZE ; sy++ )
if ( workspace[x+sx][y+sy] == 1 )
count++;
if ( count > max )
max = count;
}
}
cout << " " << max << endl;
}
fin.close();
return 0;
}
==== Solution of Problem F. Coin Game ====

[http://acm.kaist.ac.kr/Problems/2004of.pdf Original Problem Text]

class Coin
{
private:
char face;
public:
void flip(){face = ( face == 'H' ) ? 'T' : 'H';}
bool equals(const Coin & coin){ return this->face == coin.face; }
void set(const char face ){ this->face = face; }
};
////////////////////////////////////////////////////////////////////////////////
const int MAX = 4;
const int SIZE = 3;
const int INT_MAX = 20000000;
////////////////////////////////////////////////////////////////////////////////
class Gamer
{
private:
Coin coins[SIZE][SIZE];
public:
void constructCoins( const char input[SIZE][SIZE] );
void flipRow(int rowNum);
void flipCol(int colNum);
void flipAsc();
void flipDsc();
void flipLine(int direction);
bool isEnd();
};
////////////////////////////////////////////////////////////////////////////////

class GameEngine
{
private:
int minimum;
public:
GameEngine(){ minimum = INT_MAX; }
void storeCounts(Gamer & gamer, int count);
int report();
};
////////////////////////////////////////////////////////////////////////////////
void GameEngine::storeCounts(Gamer & gamer, int count )
{
for ( int i = 0 ; i < 8 ; i++ )
{
gamer.flipLine(i);
count++;
if ( gamer.isEnd() )
minimum = ( minimum > count ) ? count : minimum;
else if ( count < MAX )
storeCounts( gamer, count );
gamer.flipLine(i);
count--;
}
}

int GameEngine::report()
{
if ( minimum == INT_MAX )
return -1;
else
return minimum;
}

////////////////////////////////////////////////////////////////////////////////
void Gamer::constructCoins( const char input[SIZE][SIZE] )
{
for ( int row = 0 ; row < SIZE ; row++ )
for ( int col = 0 ; col < SIZE ; col++ )
coins[row][col].set(input[row][col]);
}

void Gamer::flipRow(int rowNum)
{
for ( int col = 0 ; col < SIZE ; col++ )
coins[rowNum][col].flip();
}

void Gamer::flipCol(int colNum)
{
for ( int row = 0 ; row < SIZE ; row++ )
coins[row][colNum].flip();

}

void Gamer::flipAsc()
{
coins[2][0].flip();
coins[1][1].flip();
coins[0][2].flip();
}

void Gamer::flipDsc()
{
coins[0][0].flip();
coins[1][1].flip();
coins[2][2].flip();
}

void Gamer::flipLine(int direction)
{
if ( direction < 3 )
flipRow( direction % 3 );
else if ( direction < 6 )
flipCol( direction % 3 );
else if ( direction == 6 )
flipAsc();
else if ( direction == 7 )
flipDsc();
}

bool Gamer::isEnd()
{
for ( int row = 0 ; row < SIZE ; row++ )
for ( int col = 0 ; col < SIZE ; col++ )
if ( !coins[row][col].equals( coins[0][0] ) )
return false;
return true;
}

#include <iostream>
using namespace std;

int main()
{
Gamer gamer;
GameEngine engine;
char input[SIZE][SIZE];
for ( int row = 0 ; row < SIZE ; row++ )
for ( int col = 0 ; col < SIZE ; col++ )
cin >> input[row][col];

gamer.constructCoins( input );
engine.storeCounts(gamer, 0);
cout << engine.report() << endl;
system("pause");
return 0;
}
==== Solution of Problem G. Safe ====

[http://acm.kaist.ac.kr/Problems/2004og.pdf Original Problem Text]

#include <iostream>
using namespace std;

int round(double n);
int fall(int N, int K);
int main()
{
int nTest;
cin >> nTest;
int N,K;
for ( int t = 0 ; t < nTest ; t++ ){
cin >> N >> K;
cout << fall(N,K) << endl;
}
return 0;
}

int round(double n)
{
return n+0.5;
}

int fall(int N, int K)
{
if(K == 1 || N <= 1)
return N;
else
return fall(round(N/2),K-1)+1;
}