C++博客-雪黛依梦-随笔分类-背包----贪心、回溯、分支界限

ZOJ 3197 贪心最小区间覆盖问题

雪黛依梦 — Wed, 25 Aug 2010 04:14:00 GMT

/*求解过程如下：首先对每个区间，以其起始坐标为关键字，从小到大排序。再依次找每查询一次能覆盖

到的最大的区间，假设还没有看过的书页为(sta , end)，每次可以查询的小段区间用(xi , yi) 表示，

那么对于没有找过的每段区间，我们都是找 xi<=sta，并且yi > sta的区间中yi最大的区间，直到yi = end为止。

最后统计区间的个数，即为最少的查询次数。*/

1#include <iostream>
2#include <algorithm>
3using namespace std;
4#include <string.h>
5
6struct book
7{
8       int ai;
9       int bi;
10}page[5001];
11
12bool cmp (const book &a, const book &b)
13{
14        return a.ai < b.ai;
15}
16int main ()
17{
18    int t, n;
19    while ( scanf ("%d", &t) != EOF )
20    {
21          for ( int i = 0; i < t; i ++ )  //t 组测试数据
22          {
23
24              memset (page, 0, sizeof (page));
25              scanf ("%d", &n);
26              for ( int i = 0; i < n; i ++ )    //总共有 n 页书
27              {
28                  scanf ("%d %d", &page[i].ai, &page[i].bi);
29              }
30
31              sort (page, page + n, cmp);   //进行排序
32
33
34              //找到最多发送请求的次数: 思路：找到第一个end 值之后，通过设定满足题意的条件 while (i < n && page[i].ai <= sta)
35              //找到新的end 值并且赋值为 j 通过比较 j 和上一次的 end 看看是否得到了新的页数信息，出口时end == n
36              int count = 1;
37              int sta = page[0].ai;
38              int end = page[0].bi;
39              int j, i = 1;
40
41              while ( i < n && page[i].ai == sta )
42              {
43                    if (end < page[i].bi)
44                       end = page[i].bi;
45                       i ++;
46              }
47
48              while ( end != n )
49              {
50                    sta = end + 1;
51                    j = page[i].bi;
52                    i ++;
53                    while (i < n && page[i].ai <= sta)    //
54                    {
55                          if ( page[i].bi > j)
56                          {
57                            j = page[i].bi;        //以最小的覆盖找到最大的区间长度，即 j 保存当前这一组sta 的end
58                          }
59                           i ++;
60                    }
61                    if ( j > end )
62                    {
63                         count ++;
64                         end = j;
65                    }
66              }
67              printf ("%d\n", count);
68      }
69}
70   // system ("pause");
71    return 0;
72}
73

雪黛依梦 2010-08-25 12:14 发表评论

hdu 1009

雪黛依梦 — Tue, 24 Aug 2010 10:41:00 GMT

这个题目如果直接在sort中比较 Ji / Fi 会出现RUNTIME ERROR 因为分母不能为 0 ，这里在输入时直接将它算出来用weight 表示
贪心策略：weight最大的

1#include <iostream>
2using namespace std;
3
4struct food
5{
6    int ji;
7    int fi;
8    double weight;
9}a[1001];
10
11/*int cmp (const void *a, const void *b)
12{
13    return  (*((food *)a)).weight < (*((food *)b)).weight;
14}*/
15
16bool cmp1 (const food &a, const food &b)
17{
18     return a.weight > b.weight;
19}
20
21int main ()
22{
23    int m, n;
24    while ( scanf ("%d %d", &m, &n) != EOF && (m != -1 && n != -1))
25    {
26          double sum = 0;
27          //输入处理
28          for (int i = 0; i < n; i ++)
29          {
30              scanf ("%d %d", &a[i].ji, &a[i].fi);
31              a[i].weight = (1.0 * a[i].ji) / a[i].fi;
32          }
33
34          printf ("\n");
35          //按每个房间 1 的猫食能够得到最大数量的Javabeans排序
36          //qsort (a, n, sizeof(a[0]), cmp);
37          sort (a, a + n, cmp1);
38
39          for (int i = 0; i < n; i ++)
40          {
41              printf ("%d %d\n", a[i].ji, a[i].fi);
42          }
43
44          //求的最大量的食物
45          for (int i = 0; i < n; i ++)
46          {
47              if ( m >= a[i].fi)
48              {
49                   m -= a[i].fi;
50                   sum += a[i].ji;
51              }
52              else if ( m < a[i].fi )
53              {
54                   sum += ( m * (1.0 * a[i].ji / a[i].fi ) );  //猫食不够了
55                   break;
56              }
57          }
58
59          printf ("%.3f\n", sum);
60    }
61   // system ("pause");
62    return 0;
63}
64

雪黛依梦 2010-08-24 18:41 发表评论

hdu 2037

雪黛依梦 — Sun, 22 Aug 2010 13:04:00 GMT

简单的贪心题：只需要将结束时间利用qsort进行排序后，贪心准则应当是：在未安排的活动中挑选结束时间最早的活动安排，
好给后面的活动安排留出更多的空间，从而达到安排最多活动的目标。加上一个判断条件就可以搞定了

1#include <stdio.h>
2#include <stdlib.h>
3struct time
4{
5    int start;
6    int end;
7}a[100];
8
9int cmp (const void *a, const void *b)
10{
11    return (*(time *)a).end - (*(time *)b).end;
12}
13
14int main ()
15{
16    int n;
17    while (scanf ("%d", &n) != EOF && n != 0)
18    {
19          for (int i = 0; i < n; i ++)
20          {
21              scanf ("%d %d", &a[i].start, &a[i].end);
22          }
23          //对结束时间进行从小到大的排序
24          qsort (a, n, sizeof (a[0]), cmp);
25
26          int count = 1;
27          int temp = 0;
28          for (int i = 1; i < n; i ++)
29          {
30              if (a[i].start >= a[temp].end)
31              {
32                 temp = i;
33                 count ++;
34              }
35          }
36
37          printf ("%d\n", count);
38    }
39    //system ("pause");
40    return 0;
41}
42

雪黛依梦 2010-08-22 21:04 发表评论

hdu 1050

雪黛依梦 — Sun, 22 Aug 2010 12:25:00 GMT

//虽然说是一道贪心题，可我没见到用了贪心的知识啊
//思路：如果有某个值出现在另一个区间中则必然会使a[i] 加 1 相反如果不在任何一个界限内a[i] 都会是 1
//缩小比较的范围思想方法挺值得借鉴的

#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;

int main()
{
    int NumOfTest,pair;
    int i,Max;
    int a[201];
    int b,c,n1,n2;
    scanf("%d",&NumOfTest);
    while (NumOfTest--)
    {
        scanf("%d",&pair);
        memset(a,0,sizeof(a));
        while (pair--)
        {
            scanf("%d%d",&b,&c);
            if(b>c)/**//*交换数值，让小值在前，大值在后，从而使得n1<=n2*/
                swap(b,c);
            /**//*求n1和n2*/
            if(b%2==1)
                n1 = (b-1)/2+1;
            else
                n1 = b/2;
            if(c%2==1)
                n2 = (c-1)/2+1;
            else
                n2 = c/2;
            if(n1!=n2)
                for(i=n1;i<=n2;i++)
                    a[i]++;
            else
                a[n1]++;
        }
        Max = -1;
        for(i=1;i<=200;i++)
            if(Max<a[i])
                Max = a[i];
        printf("%d\n",10*Max);
    }
    return 0;
}

雪黛依梦 2010-08-22 20:25 发表评论

hdu 1069 DP 猴子取香蕉

雪黛依梦 — Mon, 16 Aug 2010 02:03:00 GMT

//解题思路：每一个立方体必然有 3 个面积，所以 N 种类型的立方体，必然有 3 * N 个面积组合
//将所有的面积从小到大排列之后，每组面积必然对应一个高的值，依据题意，要使高之和最大，所
//以这个问题就转化成了求最长子列和的最大值

  1#include <stdio.h>
  2#include <stdlib.h>
  3#include <string.h>
  4
  5//定义一个结构体存立方体的面积和  边长
  6struct cube
  7{
  8       int x;
  9       int y;
10       int z;
11       int area;
12}b[200];    //结构体变量
13
14//这是调用qsort 函数时必须要用的
15int compare(const void* a,const void* b)
16{
17    return (*(cube *)a).area-(*(cube *)b).area;   //如果 < 则返回负数  如果 = 则返回0  如果 > 则返回 1
18}
19
20// 判断上面的两条边都要 < 下面的两条边
21int com (cube a, cube b)
22{
23    if ( (a.x < b.x && a.y < b.y) || (a.y < b.x && a.x < b.y) )   如：10     20       与 40      50
24       return 1;
25
26       else
27       return 0;
28}
29
30int main ()
31{
32    int sum[200];
33
34    //用来控制下标的
35    int dir[3][3] = { {0, 1, 2}, {0, 2, 1}, {1, 2, 0} };
36
37    int n;
38    int a[3];
39    int count = 0;
40    while (scanf ("%d", &n))
41    {
42          if (!n)
43          break;
44          int num = 0;
45          memset (sum, 0, sizeof (sum));
46          for (int i = 0; i < n; i ++)
47          {
48              scanf ("%d%d%d", &a[0], &a[1], &a[2]);  //读入输入的三个数据
49
50              for (int j = 0; j < 3; j ++)  //将所有可能的立方体构成存入到数组 b 中
51              {
52                     b[num].x = a[ dir[j][0] ];
53                     b[num].y = a[ dir[j][1] ];
54                     b[num].z = a[ dir[j][2] ];
55                     b[num].area = b[num].x * b[num].y;
56                     num ++;    //错点
57              }
58
59          }
60
61          //对 b 数组按面积进行快速排序
62          qsort (b, n * 3, sizeof (b[0]), compare);
63
64          /*
65          测试排序是否正确
66          for (int i = 0; i < 3 * n; i ++)
67          {
68              printf ("%d\t%d\t%d\t%d\n",b[i].x, b[i].y, b[i].z, b[i].area);
69          }*/
70
71          //在满足题目条件：上面的两条边都要 < 下面的两条边的情况下找到最大的高的和
72          sum[0] = b[0].z;
73          for (int i = 1; i < 3 * n; i++)
74          {
75              int temp = 0;
76              for (int j = 0; j < i; j ++)
77              {
78                  if ( sum[j] > temp && ( com(b[j],b[i]) ) ) //要比较的高的值  满足题目的条件累加求和
79                  {
80                       temp = sum[j];
81                  }
82              }
83              sum[i] = temp + b[i].z;
84
85              //printf ("%d\t",sum[i]);
86          }
87
88          //printf ("\n");
89
90          //输出高的和
91          int max = -1;
92          for (int i = 0; i < 3 * n; i ++)
93          {
94              if (max < sum[i])
95                 max = sum[i];
96          }
97
98          printf ("Case %d: maximum height = %d\n", ++count , max);
99
100    }
101
102    return 0;
103}
104