月度归档：2009年09月

乐队

发表回复

问题描述
你刚刚继承了流行的“破锣摇滚”乐队录制的尚未发表的N(1 <= N <= 600)首歌的版权。你打算从中精选一些歌曲，发行M(1 <= M <= 600)张CD。 每一张CD最多可以容纳T(1 <= T <= 10000)分钟的音乐，一首歌不能分装在 两张CD中。 不巧你是一位古典音乐迷，不懂如何判定这些歌的艺术价值。于是你决定根据以下标准进行选择： · 歌曲必须按照创作的时间顺序在CD盘上出现。 · 选中的歌曲数目尽可能地多。 Input

第一行： 三个整数：N, T, M.；

第二行： N个整数，分别表示每首歌的长度，按创作时间顺序排列。

Output

一个整数，表示可以装进M张CD盘的乐曲的最大数目。

Sample Input

4 5 2

4 3 4 2

Sample Output

3

算法分析
动态规划。

定义数组f[MAXN]。f[i]表示前i张光盘可以装下的音乐的最小长度

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <stdio.h>
#include <string.h>
 
#define MAXN 605
#define inf 1000000001
int main()
{
 
       int f[MAXN]; //f[i]表示前i张光盘可以装下的音乐的长度
       int n, m, i, j, temp, max, ans, t, s;
 
       while (scanf("%d%d%d", &n, &t, &m) != EOF)
       {
              max = 0;
              ans = 0;
              m = m * t;
              memset(f, 0, sizeof(f));
 
              for (i = 0; i < n; i++)     //对于每首歌曲
              {
                     scanf("%d", &temp);
                     if (temp <= t) //当一首歌曲的长度大于光盘的长度时,这首歌曲就不能用了.
                     {
                            max++;
                            f[max] = inf;
 
                            for (j = max; j >= 1; j--)
                            {
                                   if (t - f[j - 1] % t < temp)    //如果这张光盘无法装下这首歌曲,那么就添加一张光盘  
                                          s = (f[j - 1] / t  + 1) * t + temp;
                                   else                                            //否则直接放在这张光盘上
                                          s = f[j - 1] + temp;
 
                                   if (s < f[j])
                                          f[j] = s;
 
                                   if (f[j] <= m && j > ans)             //更新结果
                                          ans = j;
                            }
                     }
              }
 
              printf("%d\n", ans);
       }
 
       return 0;
}

方法2:

算法分析：

首先把一盘CD装不下的歌全部踢掉！！！

剩下的工作就是DP了。用f[i,j]表示在前i首歌中选出j首在CD上占的最小时间。这里说的时间包括除最后一盘外的CD上浪费的时间。f[i,j]=min{f[i-1,j],sum(f[i-1,j-1],第i首歌的长度)}。这里的sum的含义是：如果最后一盘CD剩下的时间正好可以放下第i首歌，那么直接相加即可，否则要再加上最后一盘CD剩下的时间（这些时间已被浪费了）。找一个最大的j使f[n,j]<=t*m,这个j就是答案。 【代码】 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <stdio.h>
 
#define MAXN 605
#define inf 1000000001
#define min(a,b) a<b?a:b
int a[MAXN], f[MAXN][MAXN];
int main()
{
 
       int n, m, i, j, k, s, t, ans, temp;
       while (scanf("%d%d%d", &n, &t, &m) != EOF)
       {
              s = 0;
              for (i = 1; i <= n; i++)
              {
                     scanf("%d", &temp);
                     if (temp <= t)
                            a[++s] = temp;
              }
 
              for (i = 0; i <= s; i++)   //init
              {
                     for (j = 0; j <= s; j++)
                            f[i][j] = inf;
              }
 
              f[0][0] = 0;
 
              for (i = 1; i <= s; i++)   //for everyone
              {
                     for (j = 1; j <= i; j++)
                     {
                            if (t - f[i - 1][j - 1] % t < a[i])      //if the last one is not enough for a[i]
                                   k = (f[i - 1][j - 1] / t + 1) * t + a[i];
                            else
                                   k = f[i - 1][j - 1] + a[i];
 
                            f[i][j] = min(f[i - 1][j], k);    //select the min one
                     }
              }
 
              ans = 0;
 
              for (i = 1; i <= s; i++)          //search the ans
              {
                     if (f[s][i] <= t * m && i > ans)
                            ans = i;
              }
 
              printf("%d\n", ans);       //output
       }
 
       return 0;
}

打包

发表回复

【问题描述】
假如你现在拿到了许多的礼物，你要把这些礼物放进袋子里。你只有一个最多能装下V 体积物品的袋子，你不能全部放进去。因为你拿不动那么重的东西。你估计你能拿的最大重量为 G。现在你了解每一个物品的完美值、重量和体积，你当然想让袋子中装的物品的完美值总和最大，你又得计划一下了。
【输入】
第一行：V 和 G 表示最大重量和体积。
第二行：N 表示拿到 N 件礼物。
第三到N+2行：每行3个数 Ti Vi Gi 表示各礼物的完美值、重量和体积
【输出】
输出共一个数，表示可能获得的最大完美值。
【输入输出样例】
输入(pack.in)：
6 5
4
10 2 2
20 3 2
40 4 3
30 3 3
输出(pack.out)：
50

【数据范围】
对于20%的数据 N，V，G，Ti，Vi，Gi≤10
对于50%的数据 N，V，G，Ti，Vi，Gi≤100
对于80%的数据 N，V，G，Ti，Vi，Gi≤300
80%到100%的数据是N，V，G，Ti，Vi，Gi≤380 的离散随机数据。

算法描述：动态规划。
看到这道题，首先想到的就是0/1背包问题模型。然而这里有两个限制条件，所以会有一定的困难。转变思想，发现这题同样也可以用装箱问题模型来做。不同的是这里要开一个二维的数F[V][G]。表示V的体积G的重量可以达到的最大完美值。具体做法见程序代码。

【代码】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <stdio.h>
#include <string.h>
#define max(a,b) a>b?a:b
typedef struct 
{
	int v, t, g;
}node;//用结构体存储每个礼物。
int main()
{
	node a[400];
	int f[400][400];
	int i, j, n, v, g, t, max, k;
	scanf("%d%d", &v, &g);
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
		scanf("%d%d%d", &a[i].t, &a[i].v, &a[i].g);
	memset(f, 0, sizeof(f));
	f[0][0] = 1;
	for (i = 1; i <= n; i++) //对于每个礼物
	{
		for (j = v - a[i].v; j >= 0; j--)//对于总体积小于v的
		{
			for (k = g - a[i].g; k>= 0; k--)//对于总重量小于g的
			{
				if (f[j][k] > 0)//如果存在这种情况，找出最大值。
				{
					f[j + a[i].v][k + a[i].g] = max(f[j + a[i].v][k + a[i].g], f[j][k] + a[i].t);
				}
			}
		}
	}
	max = 0;
	for (j = v; j >= 0; j--)
	{
		for (k = g; k >= 0; k--)
			if (f[j][k] > max)
				max = f[j][k];
	}
	printf("%d\n", max - 1);//由于开始的时候初始化f[0][0]为1，所以这里要减去1.
	return 0;
}

双子塔

发表回复

【Description】
为了纪念9.11,大家决定重修双子塔. 材料是立方体的水晶{这么阔！}， 问对于给定的水晶，可否修起等高的 双子塔(高度<＝2000).

【Input】
第一个数字N(100000以内)代表水晶的个数.
接下来N行每行一个数(<1000),代表水晶体的边长.

【Output】
如果可以建成就输入高度，不能建则输出0.

【Sample Input】
4
11
11
11
11

【Sample Output】
22

【算法描述】

动态规划。
由于这道题目已经给出了相等的高度不会大于2000，所有可以用装箱问题的模型来做这个道题。
【代码】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <stdio.h>
#include <string.h>
 
int main()
{
       int n, i, j, a[3000]; //a[i]存储是可以搭建的塔高为i时的方法种数。
     int b[100001], sum = 0;
       scanf("%d", &n);
 
       for (i = 1; i <= n; i++)
       {
              scanf("%d", &b[i]);
              sum += b[i];
       }     
 
       memset(a, 0, sizeof(a));
       sum = sum / 2;
       a[0] = 1;
 
       if (sum > 2000)
              sum = 2000;
 
       for (i = 1; i < n; i++)//对于每个立方体
       {
              for (j = sum - b[i]; j >= 0; j--)//从后面往前面找已经存在的高度。
              {
                     if (a[j] >= 1)
                            a[j + b[i]]++;//这里是与装箱问题不同的地方。
              }
       }
 
       for (i = sum; i >= 0; i--) //找最大值
              if (a[i] > 1)
                     break;
 
       if (i <= 0)//特殊情况，比赛时就因为这里所以错了两次。切记切记！
              printf("0\n");
       else
           printf("%d\n", i);
       return 0;
 
}