題目 :

完美正方形

請提交緊貼著下邊沿的正方形的邊長，從左到右，用空格分開。

===================== 華麗的分割線 ===============================

當時在考場上看見這道題目的時候, 我果斷選擇了跳過, 首先當時就沒太多思路, 其次吧, 好不容易有了思路, 覺得貌似需要線段樹加深搜暴力破解, 想想肯定要耗不少時間來寫程式碼, 對於一道填空題而言, 不太划算啊, 所有就放棄了. 直到最近, 突然回想起此題, 就花了點時間做了一下( 主要是因為在度娘上沒有找到別人發的題解,所以想自己拿個沙發什麼的... ).

至於思路, 我們可以效仿[俄羅斯方塊]的思想, 在玩俄羅斯方塊的時候, 我們總會下意識地把方塊放置到高度最低的層上,同理,對於完美正方形的搭建, 由於題目已經規定了上邊緣的三個塊, 所以我們由上往下搭建, 而且我們知道邊長為154, 由此,可以定義 : 

1 .完美正方形的上邊沿表示為區間[L,R]=[0,153], 區間長度為R-L+1=154 .

2 .當我們沒有往裡面放置任何小正方形時, 區間[0,153]的高度為0, 且整體平滑.

3 .如果區間[L, R]不平滑, 則其高度定義為-1, 表示無意義.

4 .如果區間[L, R]平滑, 則其子區間[P, Q]平滑( 其中L<=P<=Q<=R)且高度相等.

5 .如果區間[L, R]不平滑,則其父區間[P, Q]不平滑( 其中P<=L<=R<=Q).

6 .每次只能往高度最小的平滑區間內從左向右地放置小正方形M, 但M的邊長不能大於區間長度.

大家看明白我的定義了嗎 ? 雖然有點難理解, 但我們可以舉個例子, 區間[0,153]的初始化高度為0, 整體平滑, 我們向裡面放置一個邊長為47的小正方形後, 區間[0,153]開始變得不平滑, 則置其高度為-1, 但其子區間[0,46]平滑且高度為47, 區間[47,153]平滑且高度依然為0. 我們繼續放置一個邊長為46和61的正方形後, 區間[0,153]則被分成了高度不同的三個平滑段, 其中高度最低的46.

有了上述定義, 那我們的目標就是, 每次找出高度最低的平滑區間, 嘗試在上面放置正方形, 直到區間[0,153]重新平滑且高度為154時, 結果成立.

為此, 我們需要以下的一些全域性變數:

#include <iostream>
using namespace std;

// 全域性變數 
namespace Global{ 
	const int MaxS = 46+47+61;	// 正方形的邊長 
	int All[] = {2,5,9,11,16,17,19,21,22,
			24,26,30,31,33,35,36,41,50,52};// 備選正方形邊長 
	int Length = sizeof(All)/sizeof(All[0]);// 備選正方形的數量 
	int Square[MaxS][MaxS]={0};	// 表示結果的完美正方形 
}

// 線段樹結點
struct TNode{
	int L, R;			// [L, R]
	int height;			// 段高度( -1時表示該段不平滑,高度無意義 )
	int inc;			// 高度增量
	// 計算寬度 
	inline int Width()const{ return R-L+1;}
	// 計算中點
	inline int Mid()const{ return (L+R)>>1; } 
}NSet[1024];

inline int LSon( int i ){ return i<<1;}
inline int RSon( int i ){ return LSon(i)+1; }
inline int Parent( int i){ return i>>1;}

// 建立線段樹 
void BuildTree( int i, int L, int R )
{
	TNode* p = NSet+i;
	p->L = L;
	p->R = R;
	p->height = 0;	
	p->inc = 0;
	
	if( L < R ){
		int m = p->Mid();
		BuildTree( LSon(i), L, m );
		BuildTree( RSon(i), m+1, R);
	}
}

// 增量的向下傳遞調整 
// 注: NSet[i]必須為平滑區間 
inline void Adjust( int i )
{
	if( NSet[i].inc != 0 ){
		NSet[i].height += NSet[i].inc;
		if( NSet[i].L != NSet[i].R )
		{
			NSet[LSon(i)].inc += NSet[i].inc;
			NSet[RSon(i)].inc += NSet[i].inc;
		}
		NSet[i].inc = 0;
	}
}

// 將區間[L,R]的高度統一增加(或減少)inc
// 注: 區間 [L, R] 必須平滑 
void Add(int i, int L, int R, int inc )
{
	TNode* p = NSet+i;
	if( p->L == L && p->R == R ){
	  // 操作後平滑性不變 
		p->inc += inc;
		Adjust(i);
	}
	else{
		int m = p->Mid();
		
		if( p->height != -1 ) // 表示該段本是平滑的 
		{
			Adjust(i);
			p->height = -1;	  // 現在開始該段不再平滑 
		}
		
		int ls = LSon(i), rs = RSon(i);
		if( R <= m )
			Add( ls, L, R, inc );
		else if( L > m )
			Add( rs, L, R, inc );
		else{
			Add( ls, L, m, inc );
			Add( rs, m+1, R, inc );
		}
		
		// 平滑性恢復檢驗
		if(NSet[ls].height != -1){
			Adjust(ls);
			if(NSet[rs].height != -1){
				Adjust(rs);
				if(NSet[ls].height == NSet[rs].height)
					p->height = NSet[ls].height;
			}
		}		
	} // end else
}

// 獲取最低段區間 
void GetLowestInterval(int i, TNode* prev, TNode* lowest )
{
	TNode* p = NSet+i;
	if( p->height == -1 )
	{
		GetLowestInterval( LSon(i), prev, lowest );
		GetLowestInterval( RSon(i), prev, lowest );
	}
	else
	{
		prev->R = p->R;
		// 檢驗等高區間連續性 
		if( p->height != prev->height )
		{
			prev->L = p->L;	
			prev->height = p->height;
		}
		
		// 更新最低區間
		if( prev->height <= lowest->height )
		{
			lowest->height = prev->height;
			lowest->L = prev->L;
			lowest->R = prev->R;
		}
	}
}

bool Dfs( int L, int R ,int H )
{	
	if( L > R )
	{
		TNode p, m;
		m.height = 1000;
		m.L = m.R = 1000;
		p.height = 1000;
		p.L = p.R = -1;
		
		GetLowestInterval(1, &p, &m);
		L = m.L;
		R = m.R;
		H = m.height;
	}
	
	int Width = R-L+1, temp=0;
	if( Width == Global::MaxS && H != 0 ) return true;
	
	for( int i = Global::Length; i-- > 0 ;)
	{
		temp = Global::All[i];
		if( temp != 0 && temp <= Width )
		{
			Global::All[i] = 0;
			Add( 1, L, L+temp-1, temp);
			Global::Square[ H+temp-1 ][ L ] = temp;
			if( Dfs( L+temp, R, H ) == true ) return true;
			Add( 1, L, L+temp-1, -temp);
			Global::All[i] = temp;
		}
	}
	return false;
}

int main(int argc, char** argv) {
	BuildTree( 1, 0, Global::MaxS-1 );
		
	Add( 1, 0, 46, 47);
	Add( 1, 47, 92, 46);
	Add( 1, 93, 153, 61);

	if( Dfs( 1, 0, 0 ) ) {
		for( int i = 0,t=0; i < Global::MaxS; i+=t){
			t = Global::Square[ Global::MaxS-1 ][i];
			cout << t << ' ';
		}
	}
	return 0;
}