usaco-3.1-humble-pass

这个,用set:

/*
ID: qq104801
LANG: C++
TASK: humble
*/

#include <iostream>
#include <fstream>
#include <cstring>
#include <vector>
#include <list>
#include <set>
#include <queue>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;

#define NMAX 11111
int k,n;
int h[101];
set<long int> ss;

void test()
{
    freopen("humble.in","r",stdin);
    freopen("humble.out","w",stdout);
    cin>>k>>n;
    for(int i=1;i<=k;i++)
    {
        cin>>h[i];
        ss.insert(h[i]);
    }
    for(int i=1;i<=k;i++)
    {
        set<long int>::iterator it=ss.begin();
        while(true)
        {
            long int temp=(*it)*h[i];
            if(temp<0)break;
            if(ss.size()>n)
            {
                ss.erase(--ss.end());
                if(temp>(*(--ss.end())))break;
            }
            ss.insert(temp);
            it++;
        }
    }
    cout<<*(--ss.end())<<endl;
}

int main ()
{
    test();
    return 0;
}

test data:

USACO Training
Grader Results
11 users online
CHN/5 IND/1 IRN/1 SVK/1 USA/2 YUG/1

USER: cn tom [qq104801]
TASK: humble
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.005 secs, 3508 KB]
   Test 2: TEST OK [0.003 secs, 3508 KB]
   Test 3: TEST OK [0.003 secs, 3508 KB]
   Test 4: TEST OK [0.019 secs, 3640 KB]
   Test 5: TEST OK [0.027 secs, 4036 KB]
   Test 6: TEST OK [0.103 secs, 5752 KB]
   Test 7: TEST OK [0.041 secs, 4168 KB]
   Test 8: TEST OK [0.035 secs, 4168 KB]
   Test 9: TEST OK [0.005 secs, 3508 KB]
   Test 10: TEST OK [0.005 secs, 3508 KB]
   Test 11: TEST OK [0.005 secs, 3508 KB]
   Test 12: TEST OK [0.240 secs, 5752 KB]

All tests OK.

YOUR PROGRAM (‘humble‘) WORKED FIRST TIME! That‘s fantastic -- and a rare thing. Please accept these special automated congratulations.

Here are the test data inputs:

------- test 1 ----
2 7
3 5
------- test 2 ----
4 19
2 3 5 7
------- test 3 ----
1 20
2
------- test 4 ----
6 10000
2 3 5 7 11 13
------- test 5 ----
6 25000
2 3 5 7 11 13
------- test 6 ----
8 100000
2 3 5 7 11 13 17 19
------- test 7 ----
7 30000
2 3 5 7 11 17 23
------- test 8 ----
7 28888
2 3 5 11 17 23 31
------- test 9 ----
1 30
2
------- test 10 ----
4 300
11 17 23 31
------- test 11 ----
5 300
11 17 19 23 31
------- test 12 ----
100 100000
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541

Keep up the good work!
Thanks for your submission!
时间: 2024-12-25 04:45:33

usaco-3.1-humble-pass的相关文章

usaco 3.1 Humble Numbers

给出K个素数,从这些数中取出任意个,每个数乘上任意遍,得到的这些数的集合叫做丑数,求集合中第N小的数. 一般的做法是,将这些素数放入优先队列,将队首元素弹出,将这个队首元素乘上每个素数的结果存入队列,从队列中pop出的第N个数就是第N小. 但这种做法在一些特殊输入下会导致队列内存爆掉. 另一种效率更高的的做法是:给每个素数设置一个计数器,计数器中的值表示它和已知的前i小个丑数已经乘 /* ID: modengd1 PROG: humble LANG: C++ */ #include <iostr

USACO Humble Numbers

这道题的意思是给你一个素数的集合, 定义丑数为集合中的数相乘, 问你第N个丑数是多少?假设我们现在已经得到了n个丑数, 要寻找地n+1个丑数的话就用当前的素数乘以之前得到的丑数之后找出大于最后一个丑数的最小值即可,代码如下: /* ID: m1500293 LANG: C++ PROG: humble */ #include <cstdio> #include <cstring> #include <algorithm> #include <queue> s

USACO humble

用set构造,优先队列和堆也可以 /* ID:kevin_s1 PROG:humble LANG:C++ */ #include <iostream> #include <cstdio> #include <string> #include <cstring> #include <vector> #include <map> #include <set> #include <algorithm> #includ

洛谷P2723 丑数 Humble Numbers [2017年 6月计划 数论07]

P2723 丑数 Humble Numbers 题目背景 对于一给定的素数集合 S = {p1, p2, ..., pK},考虑一个正整数集合,该集合中任一元素的质因数全部属于S.这个正整数集合包括,p1.p1*p2.p1*p1.p1*p2*p3...(还有其 它).该集合被称为S集合的“丑数集合”.注意:我们认为1不是一个丑数. 题目描述 你的工作是对于输入的集合S去寻找“丑数集合”中的第N个“丑数”.所有答案可以用longint(32位整数)存储. 补充:丑数集合中每个数从小到大排列,每个丑

插入排序的优化【不靠谱地讲可以优化到O(nlogn)】 USACO 丑数

首先我们先介绍一下普通的插排,就是我们现在一般写的那种,效率是O(n^2)的. 普通的插排基于的思想就是找位置,然后插入进去,其他在它后面的元素全部后移,下面是普通插排的代码: 1 #include<iostream> 2 #include<fstream> 3 #include<stdio.h> 4 using namespace std; 5 int a[200000]; 6 int p[200000]; 7 8 int main(){ 9 ios::sync_wi

洛谷P2723 丑数 Humble Numbers

P2723 丑数 Humble Numbers 52通过 138提交 题目提供者该用户不存在 标签USACO 难度普及/提高- 提交  讨论  题解 最新讨论 暂时没有讨论 题目背景 对于一给定的素数集合 S = {p1, p2, ..., pK},考虑一个正整数集合,该集合中任一元素的质因数全部属于S.这个正整数集合包括,p1.p1*p2.p1*p1.p1*p2*p3...(还有其它).该集合被称为S集合的“丑数集合”.注意:我们认为1不是一个丑数. 题目描述 你的工作是对于输入的集合S去寻找

Usaco Open09 Gold

Problem 1: Ski Lessons [Brian Jacokes, 2002] Farmer John wants to take Bessie skiing in Colorado. Sadly, Bessie is not really a very good skier. Bessie has learned that the ski resort is offering S (0 <= S <= 100) ski classes throughout the day. Les

COGS 696. [IOI1996][USACO 2.3] 最长前缀

★   输入文件:prefix.in   输出文件:prefix.out   简单对比时间限制:1 s   内存限制:128 MB 描述 USACO 2.3.1 IOI96 在生物学中,一些生物的结构是用包含其要素的大写字母序列来表示的.生物学家对于把长的序列分解成较短的序列(即元素)很感兴趣. 如果一个集合 P 中的元素可以通过串联(元素可以重复使用,相当于 Pascal 中的 “+” 运算符)组成一个序列 S ,那么我们认为序列 S 可以分解为 P 中的元素.元素不一定要全部出现(如下例中B

Humble Numbers(丑数) 超详解!

给定一个素数集合 S = { p[1],p[2],...,p[k] },大于 1 且素因子都属于 S 的数我们成为丑数(Humble Numbers or Ugly Numbers),记第 n 大的丑数为 h[n]. 算法 1: 一种最容易想到的方法当然就是从 2 开始一个一个的判断一个数是否为丑数.这种方法的复杂度约为 O( k * h[n]),铁定超时(如果你这样做而没有超时,请跟 tenshi 联系) 算法 2: 看来只有一个一个地主动生成丑数了 : 我最早做这题的时候,用的是一种比较烂的

zoj 1095 - Humble Numbers

题目:找到用2,3,5,7为数的因第n个数字. 分析:dp,数据结构.类似于合并果子的队列维护,用4根指针分别指向队列,用当前的数乘以对应数字即可. 说明:(2011-09-19 01:42) #include <iostream> using namespace std; int F[ 5845 ]; int n[ 4 ] = {2,3,5,7}; int p[ 4 ]; int main() { F[ 1 ] = 1; for ( int i = 0 ; i < 4 ; ++ i )