ACM解题总结——HihoCoder1048

最新推荐文章于 2020-03-24 22:21:19 发布

octopusflying

最新推荐文章于 2020-03-24 22:21:19 发布

阅读量1.5k

点赞数 2

分类专栏： ACM 文章标签： acm dp 状态压缩

本文链接：https://blog.csdn.net/octopusflying/article/details/51329699

版权

ACM 专栏收录该内容

43 篇文章 1 订阅

订阅专栏

(p.s：第一次做状态压缩dp的题目，真是把俺折腾到死。。。。)

题目来源：

HihoCoder 1048

题目要求：
小Hi和小Ho领到了一个大小为N*M的长方形盘子，他们可以用这个盒子来装一些大小为2*1的蛋糕。但是根据要求，他们一定要将这个盘子装的满满的，一点缝隙也不能留下来，才能够将这些蛋糕带走。
于是他们提出了一个问题——他们有多少种方案来装满这个N*M的盘子呢？

解答：
题目的要求是用一个1×2的蛋糕来完美覆盖N×M大小的盘子，计算不同的覆盖方案的数目。由于要求盘子的任何角落都被覆盖，因此，我们在解答时可以对盘子的每个位置进行分析，枚举每一个位置的蛋糕的摆放方式，进行求解。具体求解如下：

·枚举：
采用二维坐标系对于盘子的每一个位置进行定义，左上角为(1, 1), 右下角为(N, M),以从上到下、从左到右的方式用蛋糕填满每一个位置。在对某一个位置(i, j)进行摆放时，可以分为如下几种情况：
(1) 该位置已经被之前摆放的蛋糕覆盖。此时，我们需要枚举下一个位置：

(2)该位置尚未被覆盖。此时需要枚举蛋糕的摆放位置，此时有“横放”和“竖放”两种情况：

对于某些情况，并不是横放和竖放都可以：

还有一些情况，可能无解：

·计算：

基于以上的枚举方法，可以发现：当枚举到位置(i,j)时，前1 ~ (i-1)行一定是全部填满的；第i行和第i+1行的情况则不确定；(i+2) ~ N 行则一定为空，如下图：

利用这样的特性，就可以定义每一种摆放方案。由于前1 ~ (i-1)行的情况和最后的(i+2) ~ N行的情况是确定的，因此不需要记录。需要记录的是第i行和第i+1行的情况。
记：第i行的状态为：p1, p2, ... pk ... pm，其中pk表示第i行第k个位置的覆盖情况，0为未覆盖，1为已覆盖；
    同理：记第i+1行的状态为：q1, q2, ... qk ... qm，其中qk第i+1行第k个位置的覆盖情况，0为未覆盖，1为已覆盖。
同时记录当前枚举的位置为(i, j)。
定义在当前状态下继续摆放的可行的方法数为sum(i, j; p1, p2, ... pm；q1, q2, ... qm)。此时，计算sum的值需要分情况考虑。尝试在(i, j)位置以横放或竖放的方式摆放蛋糕就会得到不同的摆放方案。而不同的摆放方式就会将问题引入新的子问题求解。具体情况如下：
(1) 如果位置(i,j)已经被覆盖，那么当前sum值就等于下一枚举位置对应的sum值:
      下一个枚举位置可能和当前位置是同一行:
        sum(i, j; p1, p2, ... pm；q1, q2, ... qm)
            = sum(i, j+1; p1, p2, ... pm；q1, q2, ... qm)
      如果当前位置是本行的最后一个位置，那么下一个枚举位置是下一行的第1个位置：
              sum(i, j; p1, p2, ... pm；q1, q2, ... qm)
            = sum(i+1, 1; q1, q2, ... qm；0, 0, ... 0)
      注意此时操作的行有变化，因此p序列和q序列也要对应变化。
（2) 如果位置(i,j)未被覆盖，则根据横放和竖放的方式进行考虑：
         横放：

sum(i, j; p1, p2, ...pj=1, pj+1=1, pm；q1, q2, ... qm)
竖放：

  sum(i, j; p1, p2, ...pj=1, pm；q1, q2, ... qj=1, qm)
      注意，并不是所有的位置都可以横放和竖放，因此还需要对具体情况进行具体分析。
      (3) 如果位置(i,j)未被覆盖，但是横放和竖放均不可以进行，这表明从当前的局面出发，不管以何种方式继续摆放，位置(i,j)，均无法被覆盖，此时没有合法的方案，sum值为0。
      (4) 对于盘子中个最后一个位置(N,M)，还需要进行特殊考虑。考虑sum(N, M; 1, 1, ... 1; q1, q2, ... qm)的值，它表示当前所有的位置均被覆盖，这是一个我们需要的结果，此时的q序列没有意义，因为下一行根本不存在。这里为了便于理解可以假设存在第N+1行，由于我们已经摆放完成，因此如果继续枚举下去，摆放方式只有1种就是“不放”。因此：
        sum(N, M; 1, 1, ... 1; q1, q2, ... qm) = 1
这个值作为整个递推求解的初始化操作。

最后总结一下sum值的计算方式：
sum(i, j; p1, p2, ... pm；q1, q2, ... qm) =
① sum(i, j+1; p1, p2, ... pm；q1, q2, ... qm)
            (i≤N, j<M, pj=1) [当前位置已覆盖，下一位置在同一行]
  ② sum(i+1, 1; q1, q2, ... qm; 0, 0, ... 0)
          (i<N, j≤M，pj=1) [当前位置已覆盖，下一位置在下一行]
  ③ sum(i,j; p1, p2 ...pj=1, pj+1=1, ... pm; q1, q2, ... qm)
          (i<N∧qj=1∨i=N, j<M, pj=0, pj+1=0) [当前位置未覆盖，仅可以横放]
  ④ sum(i,j; p1, p2 ... pj=1 ... pm; q1, q2, ... qj=1 ... qm)
          (i<N, j<M∧pj+1=1∨j=M, pj=0, qj=0) [当前位置未覆盖，仅可以竖放]
⑤ sum(i,j; p1, p2 ...pj=1, pj+1=1, ... pm; q1, q2, ... qm)
      + sum(i,j; p1, p2 ... pj=1 ... pm; q1, q2, ... qj=1 ... qm)
          (i<N, j<M, pj=0, pj+1=0, qj=0) [当前位置未覆盖，可以横放也可以竖放]
  ⑥ 0 (i<N∧qj=1∨i=N,j<M∧pj+1=1∨j=M, pj=0) [当前位置未覆盖，不可以横放也不可以竖放]
  ⑦ 1 (i=N, j=M, p=1, 1, ... 1) [(N,M)位置的特殊情况，初始状态]

    可以发现，(i,j)位置的sum值的求解依赖于(i,j)位置后面的位置，因此，在递推求解时，首先知道的是(N,M)位置的sum值，然后从下到上，从右到左，和枚举顺序相反的顺序依次就可以依次求解每个位置的sum值。最后sum(1, 1, 0, 0, ... 0; 0, 0, ... 0)就是我们需要的最后的答案。

·状态压缩：
上文中提供了一种计算方式。但问题在于sum值包含太多的参数，编程很不方便。考虑到题目中M的值只有：3, 4, 5 三种情况，且数值很小，因此可以对于p序列和q序列进行状态压缩，具体思想就是，由于p序列和q序列的每个元素只可能取值1或0，因此可以将其看作一个二进制数，这样，用最多10位二进制位(M=5)就可以满足程序的要求。因此，sum值的表示方法就可以改为：sum(i,j,k)，其中：i,j表示当前的枚举位置，k则表示压缩后的第i行和第i+1行的覆盖情况，高位部分表示第i行，低位部分是第i+1行。对于不同的M值，k值的范围是：0~2^(2*M)-1

·备注：
注意在枚举过程中，可能有些状态是不合法的，例如：
         sum(i，j; 0, 0, ... 0; 0, 0, ... 0)
如果j>0,那么该值包含的p序列表明在(i,j)位置的左边还有位置没有被覆盖，根据我们前面枚举的从上到下、从左到右的顺序，这种情况是不可能存在的。但是，这并不会影响到最后的结果，因为，我们一定是在覆盖了(i,j)位置的情况下，才会递推到后面的状态进行求解，因此，对于最终的结果 sum(1, 1, 0, 0, ... 0; 0, 0, ... 0)，它一定不会依赖于这些非法状态的值。

    以上就是本题的求解过程，算法的时间和空间复杂度都是O[N*M*2^(2*M)]，效率不高，但本题宗旨不在于在数据量和执行效率上设定难度，因此这样算法可以通过。

输入输出格式：
    输入：每个测试点（输入文件）有且仅有一组测试数据。为两个正整数N、M，表示盘子的大小。
输出：输出一行，不同的摆放方案的数目，考虑到总的方案数可能非常大，只需要输出方案数除以1000000007的余数

数据范围：
      2 ≤ N ≤ 1,000
  3 ≤ M ≤ 5

程序代码：

/****************************************************/
/* File        : HihoCoder1048                      */
/* Author      : Zhang Yufei                        */
/* Date        : 2016-05-03                         */
/* Description : HihoCoder ACM program. (submit:g++)*/
/****************************************************/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define MOD 1000000007

// Record the input.
int N, M;

// Define the matrix for dp.
int ***dp;

/*
 * This function gets the bit from the state according to the given position.
 * Parameters:
 *		@state: The state value.
 *		@position: The position to get.
 *		@tag: If tag = 0, get bit from p1, p2 ... pm; if tag = 1, get bit from
 *			q1, q2 ... qm.
 * Returns:
 *		The result bit;
 */
int get_bit(int state, int position, int tag);

/*
 * This function puts a piece of cake in the given postion.
 * Parameters:
 *		@state: The original state.
 *		@y: The position to put (only y coordinate value).
 *		@tag: If tag = 1, put the cake in horizontical way, or in vertical way.
 * Returns:
 *		The new status value after putting.
 */
int put_cake(int state, int y, int tag);

int main (void) {

	scanf ("%d %d", &N, &M);

	int state_cnt = pow (2, M * 2);
		
	dp = (int***) malloc (sizeof (int**) * N);
	
	for(int i = 0; i < N; i++) {
		dp[i] = (int**) malloc (sizeof (int*) * M);
		for(int j = 0; j < M; j++) {
			dp[i][j] = (int*) malloc (sizeof (int) * state_cnt);
		}
	}
	
	for(int i = N - 1; i >= 0; i--) {
		for(int j = M - 1; j >= 0; j--) {
			for(int k = state_cnt - 1; k >= 0; k--) {
				int pj = get_bit(k, j, 0);
				if(pj == 1) {
					if(j < M - 1) {
						dp[i][j][k] = dp[i][j + 1][k];
					} else if(j == M - 1){
						if(i == N - 1) {
							dp[i][j][k] = 1;
						} else {
							dp[i][j][k] = dp[i + 1][0][(k << M) % state_cnt];
						}
					}
				} else {
					dp[i][j][k] = 0;
					
					if(j < M - 1) {
						int pj1 = get_bit(k, j + 1, 0);
						
						if(pj1 == 0) {
							int state = put_cake(k, j, 0);
							dp[i][j][k] += dp[i][j][state]; 
						}
					}
					
					if(i < N - 1) {
						int qj = get_bit(k, j, 1);
						if(qj == 0) {
							int state = put_cake(k, j, 1);
							dp[i][j][k] += dp[i][j][state];
							dp[i][j][k] %= MOD;
						}
					}
				}
			}		
		}
	}
	
	printf("%d\n", dp[0][0][0]);
	
	return 0;
} 

/*
 * This function gets the bit from the state according to the given position.
 * Parameters:
 *		@state: The state value.
 *		@position: The position to get.
 *		@tag: If tag = 0, get bit from p1, p2 ... pm; if tag = 1, get bit from
 *			q1, q2 ... qm.
 * Returns:
 *		The result bit;
 */
int get_bit(int state, int position, int tag) {
	if(tag == 0) {
		state = state >> M;
	}
	
	int r = 0;
	for(int i = 0; i < M - position; i++) {
		r = state % 2;
		state /= 2; 
	}	
	
	return r;
}

/*
 * This function puts a piece of cake in the given postion.
 * Parameters:
 *		@state: The original state.
 *		@y: The position to put (only y coordinate value).
 *		@tag: If tag = 1, put the cake in horizontical way, or in vertical way.
 * Returns:
 *		The new status value after putting.
 */
int put_cake(int state, int y, int tag) {
	int r = 1;
	for(int i = 0; i < M - y - 1; i++) {
		r = r << 1;
	}
	
	if(tag == 0) {
		r = r << M;
		state = state | r;
		r = r >> 1;
		state = state | r;
	} else {
		state = state | r;
		r = r << M;
		state = state | r; 
	}
	
	return state;
}