标签归档：动态规划

战略游戏(Tree dynamic)

发表回复

问题描述
Bob喜欢玩电脑游戏，特别是战略游戏。但是他经常无法找到快速玩过游戏的办法。现在他有个问题。他要建立一个古城堡，城堡中的路形成一棵树。他要在这棵树的结点上放置最少数目的士兵，使得这些士兵能了望到所有的路。注意，某个士兵在一个结点上时，与该结点相连的所有边将都可以被了望到。
　　请你编一程序，给定一树，帮Bob计算出他需要放置最少的士兵。

Input
输入文件中数据表示一棵树，描述如下：
　　第一行 N，表示树中结点的数目。
　　第二行至第N+1行，每行描述每个结点信息，依次为：该结点标号i，k(后面有k条边与结点I相连)，接下来k个数，分别是每条边的另一个结点标号r1，r2，…，rk。
　　对于一个n(0 < n <= 1500)个结点的树，结点标号在0到n-1之间，在输入文件中每条边只出现一次。 Output

输出文件仅包含一个数，为所求的最少的士兵数目。

Sample Input
4
0 1 1
1 2 2 3
2 0
3 0

Sample Output
1

算法分析
树型DP

首先建树，得到根结点。设置数组F[N][2]，f[x][1]表示要看守住以x为根的子树中所有边，x处有士兵时需要的最少士兵数，f[x][0] 表示要看守住以x为根的子树中所有边，x处无士兵时需要的最少士兵数。自下而上地计算每个结点的两种值：一个结点的有士兵的值等于它所有子树的有士兵的值与没有士兵的值的较小值之和再加1；一个结点没有士兵的值等于它所有子树的有士兵的值之和。根结点有士兵的值和没有士兵的值中的较小值即为答案。

【代码】

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
55
56
57

#include <stdio.h>
#include <string.h>
#define min(a,b) a<b?a:b
typedef struct
{
       int num;
       int child[1501];
}node;     //树型结构
node a[1501];
int f[1501][2];       
int n;
 
void dp(int root)
{
       int i;
       if (a[root].num == 0)
       {
              f[root][1] = 1;
              f[root][0] = 0;
              return;
       }
 
       f[root][1] = 1;
       f[root][0] = 0;
 
       for (i = 0; i < a[root].num; i++)
       {
              dp(a[root].child[i]);       //先dp再相加 从下往上
              f[root][1] += min(f[a[root].child[i]][1], f[a[root].child[i]][0]);
              f[root][0] += f[a[root].child[i]][1];
       }
}
 
int main()
{
       int i, j, k, r, root;
       scanf("%d", &n);
       r = 0;
       root = 0;
       for (i = 0; i < n; i++)
       {
              scanf("%d", &k);
              r += k;
              scanf("%d", &a[k].num);
 
              for (j = 0; j < a[k].num; j++)
              {
                     scanf("%d", &a[k].child[j]);
                     root += a[k].child[j];
              }
       }
       root = r - root;       //求根结点
       memset(f, 0, sizeof(f));
       dp(root);
       printf("%d\n", min(f[root][1], f[root][0]));
       return 0;
}

小胖守皇宫（Tree dynamic）

2条回复

问题描述
huyichen世子事件后，xuzhenyi成了皇上特聘的御前一品侍卫。

皇宫以午门为起点，直到后宫嫔妃们的寝宫，呈一棵树的形状；某些宫殿间可以互相望见。大内保卫森严，三步一岗，五步一哨，每个宫殿都要有人全天候看守，在不同的宫殿安排看守所需的费用不同。
可是xuzhenyi手上的经费不足，无论如何也没法在每个宫殿都安置留守侍卫。
帮助xuzhenyi布置侍卫，在看守全部宫殿的前提下，使得花费的经费最少。

输入格式 Input Format

输入文件中数据表示一棵树，描述如下：
第1行 n，表示树中结点的数目。
第2行至第n+1行，每行描述每个宫殿结点信息，依次为：该宫殿结点标号i（0 对于一个n（0 < n <= 1500）个结点的树，结点标号在1到n之间，且标号不重复。
输出格式 Output Format
输出文件仅包含一个数，为所求的最少的经费。

样例输入 Sample Input
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0

样例输出 Sample Output

25

注释 Hint

如图

算法分析
树型动态规划
本题既可以用有向树来做,也可以用无向图随机选根结点

分析可见,对于当前结点i,它有num个子结点,它有它有3种状态:

1:在当前位放置守卫的情况(被自己所控制)
2:不在当前位放置守卫,但是它已经被它的子结点所控制
3:不在当前位放置守卫,它还没有被它的子结点所影响(即被其父结点控制)

用f[i,x]表示结点i的第x种情况:

1情况的值由其子结点的1,2,3情况得到最优
2情况的值由其子结点的1,2情况得到最优
3情况的值只可由其2情况求和.

第2种情况要特别注意,要求它的子结点中必须有一个是1状况的,所以可以先将最小值求和,
然后加上这num个子结点中每个的1情况与最优情况的f值之差–most

方程:
f[i,1]:=Σ(min{f[son[j],1],f[son[j],2],f[son[j],3]})+a[i]
f[i,2]:=Σ(min{f[son[j],1],f[son[j],2]})+most
f[i,3]:=Σ(f[son[j],2]),　　　　　　　　　　 1<=j<=num

还有要注意的一点就是对于极限数据,树被拉成了一条链.
有向图解法如果每次递归都开一个数组那么内存会爆,对此,可以不用数组记录子结点,而直接用链表就
可以大大节约空间了.甚至把数组改成全局变量也是可行的,就是注意递归调用要在DP之前.

【代码】

#include 
#define MAXN 1501
#define MAXINT 2000000000
typedef struct
{
        int v, num;
        int child[MAXN];
}node;
 
node a[MAXN];
int f[MAXN][4];
int min2(int x, int y)
{
       return x

乐队

发表回复

问题描述
你刚刚继承了流行的“破锣摇滚”乐队录制的尚未发表的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;
}