C++博客-RePorridge-随笔分类-HDU题解

HDU 1059 Dividing DP 背包 + 二进制优化

Porridge — Fri, 01 Nov 2013 04:44:00 GMT

Problem Description
Marsha and Bill own a collection of marbles. They want to split the collection among themselves so that both receive an equal share of the marbles. This would be easy if all the marbles had the same value, because then they could just split the collection in half. But unfortunately, some of the marbles are larger, or more beautiful than others. So, Marsha and Bill start by assigning a value, a natural number between one and six, to each marble. Now they want to divide the marbles so that each of them gets the same total value.
Unfortunately, they realize that it might be impossible to divide the marbles in this way (even if the total value of all marbles is even). For example, if there are one marble of value 1, one of value 3 and two of value 4, then they cannot be split into sets of equal value. So, they ask you to write a program that checks whether there is a fair partition of the marbles.

Input
Each line in the input describes one collection of marbles to be divided. The lines consist of six non-negative integers n1, n2, ..., n6, where ni is the number of marbles of value i. So, the example from above would be described by the input-line ``1 0 1 2 0 0''. The maximum total number of marbles will be 20000.

The last line of the input file will be ``0 0 0 0 0 0''; do not process this line.

Output
For each colletcion, output ``Collection #k:'', where k is the number of the test case, and then either ``Can be divided.'' or ``Can't be divided.''.

Output a blank line after each test case.

Sample Input
1 0 1 2 0 0
1 0 0 0 1 1
0 0 0 0 0 0

Sample Output
Collection #1:
Can't be divided.

Collection #2:
Can be divided.

题目大意：输入价值为1-6的玻璃球的数量，然后让你判断能否将它们平分成价值相等的两份

思路：刚开始想到的是普通的0-1背包，遍历每个玻璃球然后刷新状态就可以的。结果交上去TLE了

然后网上找到了半天说是要用二进制优化。然后让我来解释一下我理解的二进制优化吧

用mar[i]表示价值为i的玻璃球的总数量。二进制优化就是把你的等价值的玻璃球分成系数为1,2,4,8,...,2^(k-1),mar[i]-2^k+1.其中k 为满足 mar[i]-2^k+1 > 0 的最大值.

这样就可以分别组合成1,2,3,4,5,6,7,...,mar[i]了。玻璃球就被分为1*i,2*i,4*i,8*i,...,2^(k-1)*i,(mar[i]-2^k+1)*i

然后就可以根据0-1背包的原理做了。这样就不会超时了

Dividing
#include
#include
#include
#include
using namespace std;
#define MAXN 120000 + 10
int DP[MAXN];
int mar[7];
int items[MAXN];
int main(){
    int T = 1;
    while(scanf("%d",&mar[1]) != EOF){
        int sum = mar[1];
        for(int i = 2;i <= 6;i++){
            scanf("%d",&mar[i]);
            sum += mar[i] * i;
        }
        if (sum == 0)
        break;
        printf("Collection #%d:\n",T++);
        if (sum % 2){
            printf("Can't be divided.\n");
            printf("\n");
            continue;
        }
        int temp = sum / 2;
        int tot = 0;
        for(int i = 1;i <= 6;i++){
            int j;
            for(j = 1;j * 2 - 1 < mar[i];j *= 2){
                items[tot++] = i * j;
            }
            items[tot++] = (mar[i] - j  + 1) * i;
        }
        memset(DP,0,sizeof(DP));
        //for(int i = 0;i <= mar[1] && i <= temp;i++) DP[i] = 1;
        /*
        for(int i = 2;i <= 6;i++){
            for(int j = 0;j < mar[i];j++){
                for(int k = temp;k >= 0;k--){
                    if (DP[k] <= temp && k >= i){
                        if (DP[k-i] + i <= temp)
                        DP[k] = max(DP[k-i]+i,DP[k]);
                    }
                }
            }
        }*/
        for(int i = 0;i < tot;i++){
            for(int k = temp;k >= 0;k--){
                if (DP[k] <= temp && k >= items[i]){
                    if (DP[k-items[i]] + items[i] <= temp)
                        DP[k] = max(DP[k-items[i]] + items[i],DP[k]);
                }
            }
        }
        if (DP[temp] == temp) printf("Can be divided.\n");
        else printf("Can't be divided.\n");
        printf("\n");
    }
    return 0;
}

Porridge 2013-11-01 12:44 发表评论

HDU 2088 Box of Bricks 题解

Porridge — Sun, 08 Sep 2013 13:04:00 GMT

ox of Bricks

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 8910 Accepted Submission(s): 3032

Problem Description
Little Bob likes playing with his box of bricks. He puts the bricks one upon another and builds stacks of different height. “Look, I've built a wall!”, he tells his older sister Alice. “Nah, you should make all stacks the same height. Then you would have a real wall.”, she retorts. After a little consideration, Bob sees that she is right. So he sets out to rearrange the bricks, one by one, such that all stacks are the same height afterwards. But since Bob is lazy he wants to do this with the minimum number of bricks moved. Can you help?

Input
The input consists of several data sets. Each set begins with a line containing the number n of stacks Bob has built. The next line contains n numbers, the heights hi of the n stacks. You may assume 1≤n≤50 and 1≤hi≤100.

The total number of bricks will be divisible by the number of stacks. Thus, it is always possible to rearrange the bricks such that all stacks have the same height.

The input is terminated by a set starting with n = 0. This set should not be processed.

Output
For each set, print the minimum number of bricks that have to be moved in order to make all the stacks the same height.
Output a blank line between each set.

Sample Input
6
5 2 4 1 7 5
0

Sample Output
5

题意：给你一些参差不齐的砖块然后让你把它们摆成每堆都一样高。

算法：直接算出他们的平均值，然后找到高于平均值每堆，把高出的数量加起来就是答案了

BoxOfBricks.cpp

Porridge 2013-09-08 21:04 发表评论

HDU 2090 算菜价题解

Porridge — Sun, 08 Sep 2013 12:56:00 GMT

算菜价

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 11284 Accepted Submission(s): 6168

Problem Description
妈妈每天都要出去买菜，但是回来后，兜里的钱也懒得数一数，到底花了多少钱真是一笔糊涂帐。现在好了，作为好儿子（女儿）的你可以给她用程序算一下了，呵呵。

Input
输入含有一些数据组，每组数据包括菜种（字串），数量（计量单位不论，一律为double型数）和单价（double型数，表示人民币元数），因此，每组数据的菜价就是数量乘上单价啊。菜种、数量和单价之间都有空格隔开的。

Output
支付菜价的时候，由于最小支付单位是角，所以总是在支付的时候采用四舍五入的方法把分头去掉。最后，请输出一个精度为角的菜价总量。

Sample Input
青菜 1 2
罗卜 2 1.5
鸡腿 2 4.2

Sample Output
13.4

这里就是利用了sscanf和sprintf函数用法和scanf printf类似

sprintf的功能是将变量写到字符串中去用法 sprintf(char*,/*输出格式如*/"%d",/*要输出的量如*/2)这样输出的结果就是"2\0";

而sscanf恰好相反是将字符串中的内容写入变量 sscanf(char*,"%d",&n) 就是将char*中的内容写入n 我是利用sprintf先保留一位小数输出然后再存回去。

我去百度了一下，直接把每次的钱加起来最后保留一位小数居然可以过。
代码

HDU2090exp.cpp

我的算法的代码

HDU2090.cpp

Porridge 2013-09-08 20:56 发表评论

HDU 2089 不要62 题解

Porridge — Sun, 08 Sep 2013 12:46:00 GMT

不要62

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 13604 Accepted Submission(s): 4362

Problem Description
杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。
杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。
不吉利的数字为所有含有4或62的号码。例如：
62315 73418 88914
都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属于不吉利数字之列。
你的任务是，对于每次给出的一个牌照区间号，推断出交管局今次又要实际上给多少辆新的士车上牌照了。

Input
输入的都是整数对n、m（0

Output
对于每个整数对，输出一个不含有不吉利数字的统计个数，该数值占一行位置。

Sample Input
1 100
0 0

Sample Output
80

本题如果直接暴力搜索会超时。我的办法是事先把0到10000000中的所有含有'4'或者"62"的筛选出来

然后建立一个数组a[] a[i]表示从0到i有多少个可用的车牌

这样输入的时候直接读这个数组输出 a[m]-a[n-1]就可以了。

HDU2089.cpp

Porridge 2013-09-08 20:46 发表评论

HDU 2072 单词数题解

Porridge — Sun, 08 Sep 2013 11:59:00 GMT

单词数

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 22457 Accepted Submission(s): 5433

Problem Description
lily的好朋友xiaoou333最近很空，他想了一件没有什么意义的事情，就是统计一篇文章里不同单词的总数。下面你的任务是帮助xiaoou333解决这个问题。

Input
有多组数据，每组一行，每组就是一篇小文章。每篇小文章都是由小写字母和空格组成，没有标点符号，遇到#时表示输入结束。

Output
每组只输出一个整数，其单独成行，该整数代表一篇文章里不同单词的总数。

Sample Input
you are my friend
#

Sample Output
4

题意就很简单了。计算没有重复的单词数量。我的做法是按位遍历，遇到字母串就记录字母串到temp里面，存到一个字符串数组中。

遇见新的单词与已经存放的单词对比如果没有重复就加入。这里要考虑的是最后。比如 "abc def"在遍历结束后最后再加一次判断def是否重复

本题主要是输入一行的函数fgets(char*,MAXNLENGTH,stdin)函数的使用，也可以使用getline或者cin.getline使用方法可以百度

我仅介绍fgets的使用方法char*就是char数组的头，MAXLENGTH是最大输入的量，stdin是控制台

由fgets输入得到的字符串的\0前面还有一个\n所以需要把这个\n改成\0 str[strlen(str)-1] = '\0';

然后就是cctype或者ctype.h头文件的函数里面有isalpha(char)判断是不是字母isdigit(char)判断是不是数字还有其他的一些函数这里就介绍两个其他的可以度娘谷歌

HDU2072.cpp
#include
#include
#include
#include
#include
using namespace std;
#define MAXN 500
#define MAX 100
char str[MAXN]; //读取的一行的字符串
char svstr[MAXN][MAX];//储存每个已搜索到的单词
char temp[MAXN]; //暂时储存正在搜索的单词的字母
int main()
{
    while(fgets(str,MAXN,stdin),str[0] != '#')
    {
        str[strlen(str)-1] = '\0';
        int w = 0;
        int ok = 0;
        int l = 0;
        for(int i = 0;i < strlen(str);i++)
        {
            if (isalpha(str[i]) && !ok)
            {
                temp[l++] = str[i];
                ok = 1;
            }
            else if (isalpha(str[i])&& ok)
            {
                temp[l++] = str[i];
            }
            else if (!isalpha(str[i]) && ok)
            {
                temp[l++] = '\0';
                int cf = 0;
                for(int j = 0;j < w;j++) //遍历svstr数组检查和搜索到的新单词有没有重复
                {
                    if (!strcmp(temp,svstr[j]))
                    {
                        cf = 1;
                        break;
                    }
                }
                if (cf == 0) //没重复就存进去然后单词数量+1
                {
                    strcpy(svstr[w++],temp);
                }
                ok = 0;
                l = 0;
            }
        }
        if (ok)
        {
            temp[l++] = '\0';
            int cf = 0;
            for(int j = 0;j < w;j++)
            {
                if (!strcmp(temp,svstr[j]))
                {
                    cf = 1;
                    break;
                }
            }
            if (cf == 0)
            {
                strcpy(svstr[w++],temp);
            }
            ok = 0;
            l = 0;
        }
        printf("%d\n",w);
        //printf("%s\n",str);
    }
    return 0;
}

Porridge 2013-09-08 19:59 发表评论

HDU 2084 数塔题解

Porridge — Sun, 01 Sep 2013 14:07:00 GMT

数塔

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 16400 Accepted Submission(s): 9853

Problem Description
在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的：

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？

已经告诉你了，这是个DP的题目，你能AC吗?

Input
输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中第i行有个i个整数，且所有的整数均在区间[0,99]内。

Output
对于每个测试实例，输出可能得到的最大和，每个实例的输出占一行。

Sample Input
1
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

Sample Output
30

貌似不是DP，很简单的从塔底往上走，取一个顶点下两个分支最大值加到这个顶点。加到塔顶就是最优解了。

HDU2084.cpp

Porridge 2013-09-01 22:07 发表评论

HDU 2081 手机短号题解

Porridge — Sun, 01 Sep 2013 13:47:00 GMT

手机短号

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 13321 Accepted Submission(s): 8443

Problem Description
大家都知道，手机号是一个11位长的数字串，同时，作为学生，还可以申请加入校园网，如果加入成功，你将另外拥有一个短号。假设所有的短号都是是 6+手机号的后5位，比如号码为13512345678的手机，对应的短号就是645678。
现在，如果给你一个11位长的手机号码，你能找出对应的短号吗？

Input
输入数据的第一行是一个N(N <= 200)，表示有N个数据，接下来的N行每一行为一个11位的手机号码。

Output
输出应包括N行，每行包括一个对应的短号，输出应与输入的顺序一致。

Sample Input
2
13512345678
13787654321

Sample Output
645678
654321

水题。简单读取字符串输出“6”+字符串的后五位就行了

HDU2081.cpp

Porridge 2013-09-01 21:47 发表评论

HDU 2070 Fibbonacci Number 题解

Porridge — Sun, 01 Sep 2013 13:43:00 GMT

Fibbonacci Number

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 10868 Accepted Submission(s): 5549

Problem Description
Your objective for this question is to develop a program which will generate a fibbonacci number. The fibbonacci function is defined as such:

f(0) = 0
f(1) = 1
f(n) = f(n-1) + f(n-2)

Your program should be able to handle values of n in the range 0 to 50.

Input
Each test case consists of one integer n in a single line where 0≤n≤50. The input is terminated by -1.

Output
Print out the answer in a single line for each test case.

Sample Input
3
4
5
-1

Sample Output
2
3
5

水题，先预处理就可以到前50个然后按输入读数组就可以了

HDU2070.cpp

Porridge 2013-09-01 21:43 发表评论

HDU 2071 Max Num 题解

Porridge — Sun, 01 Sep 2013 13:39:00 GMT

Max Num

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 10948 Accepted Submission(s): 7029

Problem Description
There are some students in a class, Can you help teacher find the highest student .

Input
There are some cases. The first line contains an integer t, indicate the cases; Each case have an integer n ( 1 ≤ n ≤ 100 ) , followed n students’ height.

Output
For each case output the highest height, the height to two decimal plases;

Sample Input
2
3 170.00 165.00 180.00
4 165.00 182.00 172.00 160.00

Sample Output
180.00
182.00
水题，不解释了

HDU2071.cpp

Porridge 2013-09-01 21:39 发表评论

HDU 2068 RPG的错排

Porridge — Sat, 31 Aug 2013 11:34:00 GMT

RPG的错排
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5666 Accepted Submission(s): 2325

Problem Description
今年暑假杭电ACM集训队第一次组成女生队,其中有一队叫RPG,但做为集训队成员之一的野骆驼竟然不知道RPG三个人具体是谁谁。RPG给他机会让他猜猜，第一次猜：R是公主，P是草儿，G是月野兔；第二次猜：R是草儿，P是月野兔，G是公主；第三次猜：R是草儿，P是公主，G是月野兔；......可怜的野骆驼第六次终于把RPG分清楚了。由于RPG的带动，做ACM的女生越来越多，我们的野骆驼想都知道她们，可现在有N多人，他要猜的次数可就多了，为了不为难野骆驼，女生们只要求他答对一半或以上就算过关，请问有多少组答案能使他顺利过关。

Input
输入的数据里有多个case,每个case包括一个n，代表有几个女生，（n<=25）, n = 0输入结束。

Sample Input
1 2 0

Sample Output
1 1

本题主要是全错位排列。开始先考虑人数n奇偶，奇数就从猜对n/2+1开始，偶数就从n/2开始，一直循环到n.

假设猜对s个，没猜对t个，其中t = n-s。组数为C（n,s)*剩余t个人全部没猜中的所有情况。剩余t个人全部没有猜中就是全错位排列

百度一下可知道其递推公式为 f(n)=nf(n-1)+(-1)^(n-2) 又知道 1个元素没有全错位排列，2个元素的全错位排列有1种，3个元素的全错位排列有2种，4个元素的全错位排列有9种，5个元素的全错位排列有44种。

于是可以用for循环递推到13

HDU2068.cpp

Porridge 2013-08-31 19:34 发表评论

HDU OJ 1004 Let the Balloon Rise

Porridge — Wed, 12 Jun 2013 11:42:00 GMT

Let the Balloon Rise

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 60483 Accepted Submission(s): 22247

Problem Description
Contest time again! How excited it is to see balloons floating around. But to tell you a secret, the judges' favorite time is guessing the most popular problem. When the contest is over, they will count the balloons of each color and find the result.

This year, they decide to leave this lovely job to you.

Input
Input contains multiple test cases. Each test case starts with a number N (0 < N <= 1000) -- the total number of balloons distributed. The next N lines contain one color each. The color of a balloon is a string of up to 15 lower-case letters.

A test case with N = 0 terminates the input and this test case is not to be processed.

Output
For each case, print the color of balloon for the most popular problem on a single line. It is guaranteed that there is a unique solution for each test case.

Sample Input
5
green
red
blue
red
red
3
pink
orange
pink
0

Sample Output
red
pink

题意：给你很多字符串，让你找到数量最多的字符串,而且保证数量最多的字符串是唯一的

本题其实直接利用string读入然后直接利用string可比较大小排序后遍历每一个内容并记录每个对应项的个数然后按顺序从大到小把对应项输出就行了。

注意：题目中所指的气球不仅仅是气球，其实是对应的字符串。你把各种颜色列出来是没用的。

HDU1004.cpp

Porridge 2013-06-12 19:42 发表评论