51nod 1117 聪明的木匠 (贪心)

http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1117

跟挑战程序书上例题一样,将要切割的n断木板,分别对应二叉树树的叶子节点,则切割的总开销为木板的长度×节点的深度,可以画图理解,那么最短的木板(L1)应当是深度最大的叶子节点之一,次短的板(L2)和它是兄弟节点,由一块长度是(L1+L2) 的木板切割而来,这样可以变成(n-1)块木板,然后递归求解到n==1。

书上贪心部分用的是O(n×n) 的算法  在这里会超时,需要2.4节优先队列O(NlogN)的算法。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cmath>
 4 #include <vector>
 5 #include <cstring>
 6 #include <string>
 7 #include <algorithm>
 8 #include <string>
 9 #include <set>
10 #include <functional>
11 #include <numeric>
12 #include <sstream>
13 #include <stack>
14 #include <map>
15 #include <queue>
16
17 #define CL(arr, val)    memset(arr, val, sizeof(arr))
18
19 #define ll long long
20 #define inf 0x7f7f7f7f
21 #define lc l,m,rt<<1
22 #define rc m + 1,r,rt<<1|1
23 #define pi acos(-1.0)
24
25 #define L(x)    (x) << 1
26 #define R(x)    (x) << 1 | 1
27 #define MID(l, r)   (l + r) >> 1
28 #define Min(x, y)   (x) < (y) ? (x) : (y)
29 #define Max(x, y)   (x) < (y) ? (y) : (x)
30 #define E(x)        (1 << (x))
31 #define iabs(x)     (x) < 0 ? -(x) : (x)
32 #define OUT(x)  printf("%I64d\n", x)
33 #define lowbit(x)   (x)&(-x)
34 #define Read()  freopen("a.txt", "r", stdin)
35 #define Write() freopen("b.txt", "w", stdout);
36 #define maxn 1000000000
37 #define N 50005
38 using namespace std;
39
40 int L[N];
41 int main()
42 {
43    // Read();
44     int n;
45     long long ans=0;
46     scanf("%d",&n);
47     for(int i=0;i<n;i++) scanf("%d",&L[i]);
48     while(n>1)
49     {
50         int m1=0,m2=1;
51         if(L[m1]>L[m2]) swap(m1,m2);
52         for(int i=2;i<n;i++)
53         {
54             if(L[m1]>L[i])
55             {
56                 m2=m1;
57                 m1=i;
58             }
59             else if(L[m2]>L[i])
60             {
61                 m2=i;
62             }
63         }
64         //printf("%d %d\n",L[m1],L[m2]);
65         int t=L[m1]+L[m2];
66         ans+=t;
67         if(m1==n-1) swap(m1,m2);
68         L[m1]=t;
69         L[m2]=L[n-1];
70         n--;
71     }
72     printf("%lld\n",ans);
73     return 0;
74 }

优化后的代码:每次只需要选择长度最小的两块木板,则用优先队列从小到大排序,每次把取出来的两块木板之和压进队列即可。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cmath>
 4 #include <vector>
 5 #include <cstring>
 6 #include <string>
 7 #include <algorithm>
 8 #include <string>
 9 #include <set>
10 #include <functional>
11 #include <numeric>
12 #include <sstream>
13 #include <stack>
14 //#include <map>
15 #include <queue>
16
17 #define CL(arr, val)    memset(arr, val, sizeof(arr))
18
19 #define ll long long
20 #define inf 0x7f7f7f7f
21 #define lc l,m,rt<<1
22 #define rc m + 1,r,rt<<1|1
23 #define pi acos(-1.0)
24
25 #define L(x)    (x) << 1
26 #define R(x)    (x) << 1 | 1
27 #define MID(l, r)   (l + r) >> 1
28 #define Min(x, y)   (x) < (y) ? (x) : (y)
29 #define Max(x, y)   (x) < (y) ? (y) : (x)
30 #define E(x)        (1 << (x))
31 #define iabs(x)     (x) < 0 ? -(x) : (x)
32 #define OUT(x)  printf("%I64d\n", x)
33 #define lowbit(x)   (x)&(-x)
34 #define Read()  freopen("a.txt", "r", stdin)
35 #define Write() freopen("b.txt", "w", stdout);
36 #define maxn 1000000000
37 #define N 50005
38 using namespace std;
39
40 int L[N];
41 priority_queue<int, vector<int>, greater<int> >que;
42 int main()
43 {
44     //Read();
45     int n;
46     scanf("%d",&n);
47     for(int i=0;i<n;i++)
48     {
49         scanf("%d",&L[i]);
50         que.push(L[i]);
51     }
52     ll ans=0;
53     while(que.size()>1)
54     {
55         int l1,l2;
56         l1=que.top();
57         que.pop();
58         l2=que.top();
59         que.pop();
60         ans+=l1+l2;
61         que.push(l1+l2);
62     }
63     printf("%lld\n",ans);
64     return 0;
65 }
时间: 2024-10-01 03:52:14

51nod 1117 聪明的木匠 (贪心)的相关文章

51Nod - 1117 聪明的木匠

51Nod - 1117 聪明的木匠 一位老木匠需要将一根长的木棒切成N段.每段的长度分别为L1,L2,......,LN(1 <= L1,L2,-,LN <= 1000,且均为整数)个长度单位.我们认为切割时仅在整数点处切且没有木材损失. 木匠发现,每一次切割花费的体力与该木棒的长度成正比,不妨设切割长度为1的木棒花费1单位体力.例如:若N=3,L1 = 3,L2 = 4,L3 = 5,则木棒原长为12,木匠可以有多种切法,如:先将12切成3+9.,花费12体力,再将9切成4+5,花费9体力

51nod 1117 聪明的木匠 (哈夫曼树)

题目:传送门. 题意:中文题. 题解:就是构造一颗哈夫曼树,数据结构里的知识. #include <iostream> #include <cstdio> #include <cmath> #include <queue> #include <algorithm> using namespace std; struct cmp { bool operator ()(long long &a,long long &b) { retu

聪明的木匠 (哈夫曼树)

假设有n个权值,则构造出的哈夫曼树有n个叶子结点. n个权值分别设为 w1.w2.….wn,则哈夫曼树的构造规则为[1]: (1) 将w1.w2.…,wn看成是有n 棵树的森林(每棵树仅有一个结点): (2) 在森林中选出两个根结点的权值最小的树合并,作为一棵新树的左.右子树,且新树的根结点权值为其左.右子树根结点权值之和: (3)从森林中删除选取的两棵树,并将新树加入森林: (4)重复(2).(3)步,直到森林中只剩一棵树为止,该树即为所求得的哈夫曼树. 51nod 1117 #include

51nod 1163 最高的奖励(贪心+优先队列)

题目链接:51nod 1163 最高的奖励 看着这题我立马就想到昨天也做了一道贪心加优先队列的题了奥. 按任务最晚结束时间从小到大排序,依次选择任务,如果该任务最晚结束时间比当前时间点晚,则将该任务的奖励值压入队列,否则将队列中最小的任务的奖励值替换,优先队列按奖励值小的优先. 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #include<queue> 5 using name

51Nod 1091 线段的重叠(贪心+区间相关,板子题)

1091 线段的重叠 基准时间限制:1 秒 空间限制:131072 KB 分值: 5         难度:1级算法题 X轴上有N条线段,每条线段包括1个起点和终点.线段的重叠是这样来算的,[10 20]和[12 25]的重叠部分为[12 20]. 给出N条线段的起点和终点,从中选出2条线段,这两条线段的重叠部分是最长的.输出这个最长的距离.如果没有重叠,输出0. Input 第1行:线段的数量N(2 <= N <= 50000). 第2 - N + 1行:每行2个数,线段的起点和终点.(0 

51nod 1091 线段的重叠(贪心)

题目意思: http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1091 X轴上有N条线段,每条线段包括1个起点和终点.线段的重叠是这样来算的,[10 20]和[12 25]的重叠部分为[12 20]. 给出N条线段的起点和终点,从中选出2条线段,这两条线段的重叠部分是最长的.输出这个最长的距离.如果没有重叠,输出0. Input 第1行:线段的数量N(2 <= N <= 50000). 第2 - N + 1行:每行2个数

【51Nod】1519 拆方块 贪心+递推

[题目]1519 拆方块 [题意]给定n个正整数,\(A_i\)表示第i堆叠了\(A_i\)个石子.每轮操作将至少有一面裸露的石子消除,问几轮所有石子均被消除.\(n \leq 10^5\). [算法]贪心+递推 观察每轮操作的变化: \[A_i=min \{ A_i-1,A_{i-1},A_{i+1} \} \] 继续推导,因为每一轮要么-1要么取左右,那么也就是一个数传递到另一个位置要加上它们之间距离的代价(一轮一格,每轮少一个 -1 ),也就是每个数字都可以更新为: \[A_x=\min_

CodeForces 558 C. Amr and Chemistry &amp;&amp; 51NOD 1483 化学变换(暴力 + 贪心)

传送门 Amr loves Chemistry, and specially doing experiments. He is preparing for a new interesting experiment. Amr has n different types of chemicals. Each chemical i has an initial volume of ai liters. For this experiment, Amr has to mix all the chemic

51Nod 1344 走格子 (贪心)

有编号1-n的n个格子,机器人从1号格子顺序向后走,一直走到n号格子,并需要从n号格子走出去.机器人有一个初始能量,每个格子对应一个整数A[i],表示这个格子的能量值.如果A[i] > 0,机器人走到这个格子能够获取A[i]个能量,如果A[i] < 0,走到这个格子需要消耗相应的能量,如果机器人的能量 < 0,就无法继续前进了.问机器人最少需要有多少初始能量,才能完成整个旅程. 例如:n = 5.{1,-2,-1,3,4} 最少需要2个初始能量,才能从1号走到5号格子.途中的能量变化如下