Beispiel #1
0
int main()
{
    const int kProblemSize = 2;
    std::vector<std::pair<float, float>> searchSpace(kProblemSize, std::make_pair(-5.0f, 5.0f));
    const int kMaxIter = 1000;

    CleverAlgorithms::RandomSearch::Candidate best = CleverAlgorithms::RandomSearch::search(searchSpace, kMaxIter);
    printResult(best);
}
Beispiel #2
0
/**
 *	@brief		move array
 *	@param[out]	ac_NextState		next state
 *	@param[in]	ac_clearState		clear state
 *	@param[in]	ac_clearState		move log
 */
static	void	moveState(char* ac_MoveState, char* ac_InitState, char* ac_MoveLog)
{
    UINT	ui_SpcPos	= (UINT)searchSpace(ac_InitState, FIELD_SIZE),
              ui_NextPos;
    UINT	uii;

    memcpy(ac_MoveState, ac_InitState, FIELD_SIZE);

    for(uii = 0; ac_MoveLog[uii] != '\0'; uii++) {
        ui_NextPos	= (UINT)getMovePlace(ui_SpcPos, ac_MoveLog[uii]);

        ac_MoveState[ui_SpcPos]		= ac_MoveState[ui_NextPos];
        ac_MoveState[ui_NextPos]	= 0;
        ui_SpcPos					= ui_NextPos;
    }
}
Beispiel #3
0
/**
 *	@brief		search 3x4 -> 3x3
 *	@param[in]	ac_InitState		state on start
 *	@param[in]	ac_MidState			state on first search end
 *	@param[in]	ac_MoveLog			space moved log
 */
void	search3x4(char* ac_InitState, char* ac_MidState, char* ac_MoveLog)
{
	char		ac_CurrState[FIELD_SIZE],
				ac_CurrMoveLog[SUM_MOVE_MAX],
				c_CurrSpcPos	= searchSpace(ac_InitState, FIELD_SIZE);
	AVAIL_STATE	ac_AvailState[AVAIL_STATE_NUM];
	const UINT	ui_GoalScore	= ANSWER_PLACE;
	UINT		ui_MaxScore		= checkScore(ac_InitState);

	memcpy(ac_CurrState, ac_InitState, FIELD_SIZE);

	while(ui_MaxScore != ui_GoalScore) {
		AVAIL_STATE	*p_NowState,
					*p_NextState;
		UINT	ui_SpcPos,
				ui_AdjaPos;
		UINT	ui_Score	= 0,
				ui_Anum		= 0,
				uii;
		char	ac_Move[2]	= {'\0', '\0'};

		ui_Score	= 0;
		ui_Anum		= 0;

		memset(ac_AvailState, 0, sizeof(ac_AvailState));
		memcpy(ac_AvailState[ui_Anum].ac_Array, ac_CurrState, FIELD_SIZE);
		ac_AvailState[ui_Anum].c_SpcPos		= c_CurrSpcPos;
		ac_AvailState[ui_Anum].c_PrevPos	= 0x7F;

		for(ui_Anum = 0; ui_Anum < (AVAIL_STATE_NUM - 3); ui_Anum += uii) {
			ui_SpcPos	= ac_AvailState[ui_Anum].c_SpcPos;

			for(uii = 0;
				(ui_AdjaPos = (UINT)ac_Adjacent[ui_SpcPos][uii]) != -1;
				uii++) {
				if((ac_AvailState[ui_Anum].ac_Array[ui_AdjaPos] == ac_AvailState[ui_Anum].c_PrevPos) ||
				   (ac_AvailState[ui_Anum].ac_Array[ui_AdjaPos] == '=')) {
					continue;
				}

				p_NowState	= &ac_AvailState[ui_Anum];
				p_NextState	= &ac_AvailState[ui_Anum + 1];

				/* 状態をコピー */
				memcpy(p_NextState->ac_Array,
					   p_NowState->ac_Array,
					   FIELD_SIZE);

				/* 移動 */
				p_NextState->ac_Array[ui_SpcPos]	= p_NextState->ac_Array[ui_AdjaPos];
				p_NextState->ac_Array[ui_AdjaPos]	= 0;
				p_NextState->c_SpcPos				= (char)ui_AdjaPos;
				p_NextState->c_PrevPos				= p_NowState->c_SpcPos;

				ac_Move[0]	= getMoveDirection(p_NowState->c_SpcPos, p_NextState->c_SpcPos);
				strcat(p_NextState->ac_mMoveLog, ac_Move);

				ui_Score	= checkScore(p_NextState->ac_Array);
				if(ui_Score > ui_MaxScore) {
					ui_MaxScore	= ui_Score;

					memcpy(ac_CurrState, p_NextState->ac_Array, FIELD_SIZE);
					c_CurrSpcPos	= p_NextState->c_SpcPos;
					strcat(ac_CurrMoveLog, p_NextState->ac_mMoveLog);

					ui_Anum	= AVAIL_STATE_NUM;		/* break */
					break;
				}
			}
		}
	}

	printf("3x4 clear !\n");
	printState((char(*)[FIELD_WIDTH])ac_CurrState);

	convertState(ac_MidState, ac_CurrState);
	strcat(ac_MoveLog, ac_CurrMoveLog);
}