SRM 599 div2 250 500

Problem Statement

 Dachshund is a popular dog breed. In this problem, a miniature dachshund is defined as a dachshund whose weight is not more than 5,000 grams.

Lun the miniature dachshund loves mikan (satsuma oranges). She has just bought some mikan. You are given a vector <int> mikan. It gives the weight of all mikan she bought. For each valid i, mikan[i] is the weight of the i-th mikan in grams.

You are also given an int weight. Currently, Lun weighs weight grams. When she eats i-th mikan, her weight increases by mikan[i] grams. If she eats multiple mikan, her weight increases by their total weight. She cannot eat just a part of a mikan. In other words, if she chooses to eat a mikan, she eats it completely.

She wants to remain being a miniature dachshund. That is, she wants her weight not to exceed 5,000 grams. Under this condition, calculate and return the maximum number of mikan Lun can eat.

Definition

 
Class:MiniatureDachshund
Method:maxMikan
Parameters:vector <int>, int
Returns:int
Method signature:int maxMikan(vector <int> mikan, int weight)
(be sure your method is public)
 
 

Constraints

-mikan will contain between 1 and 50 elements, inclusive.
-Each element of mikan will be between 50 and 200, inclusive.
-weight will be between 3,000 and 5,000, inclusive.

Examples

0) 
 
{100, 100, 100, 100, 100}
4750
Returns: 2
Here, Lun weighs 4,750 grams and has bought 5 mikan, each of which weighs 100 grams. When she eats 2 of these, her weight will be 4,950 grams. She should not eat more.
1) 
 
{100, 100, 100, 100, 50}
4750
Returns: 3
This time, one of the mikan is smaller. She can eat it with 2 of the 100-gram mikan. Note that her weight is allowed to be exactly 5,000 grams.
2) 
 
{120, 90, 130, 100, 110, 80}
3000
Returns: 6
When she is light enough, she can eat all of the mikan she has bought.
3) 
 
{50}
5000
Returns: 0
When her weight is already 5,000 grams, she should not eat anything.
4) 
 
{200, 50, 200, 50, 200, 50, 200, 50}
4800
Returns: 4

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.     


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
class MiniatureDachshund {
public:
    int maxMikan(vector <int>, int);
};
int MiniatureDachshund::maxMikan(vector <int> mikan, int weight)
{
    int t=mikan.size(),ans=0,v=5000-weight;
    sort(mikan.begin(),mikan.end());
    for(int i=0;i<t&&v>0&&mikan[i]<=v;i++)
    {
        v-=mikan[i];ans++;
    }
    return ans;
}
//<%:testing-code%>
//Powered by [KawigiEdit] 2.0!
//<%:start-tests%>


Problem Statement

 

This problem statement contains superscipts that may not display properly outside the applet.


You are given four ints ABC and D. Return "divisible" (quotes for clarity) if AB is divisible by CD. Return "not divisible" otherwise.

Definition

 
Class:BigFatInteger2
Method:isDivisible
Parameters:int, int, int, int
Returns:string
Method signature:string isDivisible(int A, int B, int C, int D)
(be sure your method is public)
 
 

Notes

-The return value is case-sensitive.
-Positive integer y divides a positive integer x if and only if there is a positive integer z such that y*z=x. In particular, for each positive integer x, both 1 and x divide x.

Constraints

-ABC and D will each be between 1 and 1,000,000,000 (109), inclusive.

Examples

0) 
 
6
1
2
1
Returns: "divisible"
Here, AB = 61 = 6 and CD = 21 = 2. 6 is divisible by 2.
1) 
 
2
1
6
1
Returns: "not divisible"
2 is not divisible by 6.
2) 
 
1000000000
1000000000
1000000000
200000000
Returns: "divisible"
Now the numbers are huge, but we can see that AB is divisible by CD from the fact that A=C and B>D.
3) 
 
8
100
4
200
Returns: "not divisible"
We can rewrite 8100 as (23)100 = 2300. Similarly, 4200 = (22)200 = 2400. Thus, 8100 is not divisible by 4200.
4) 
 
999999937
1000000000
999999929
1
Returns: "not divisible"
Here A and C are distinct prime numbers, which means AB cannot have C as its divisor.
5) 
 
2
2
4
1
Returns: "divisible"

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.     



#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
class BigFatInteger2 {
public:
    string isDivisible(int, int, int, int);
};
string BigFatInteger2::isDivisible(int A, int B, int C, int D)
{
    string div("divisible"),nodiv("not divisible");
    map<int,long long int> primeA,primeB;
    int ta=sqrt(A),tc=sqrt(C);
    for(int i=2;i<=ta;i++)
    {
        long long int cnt=0;
        while(A%i==0)
        {
            A/=i; cnt++;
        }
        if(cnt)
        {
            primeA.insert(make_pair(i,(long long )cnt*B));
        }
    }
    if(A!=1LL) primeA.insert(make_pair(A,(long long )B));
    bool flag=true;
    for(int i=2;i<=tc;i++)
    {
        long long int cnt=0;
        while(C%i==0)
        {
            C/=i; cnt++;
        }
        if(cnt)
        {
            if(primeA.count(i)==0)
            {
                flag=false;break;
            }
            else if(primeA[i]<(long long )D*cnt)
            {
                flag=false;break;
            }
        }
    }
    if(C!=1LL&&flag)
    {
        if(primeA.count(C)==0||primeA[C]<D)
        {
            flag=false;
        }
    }
    if(flag)
    {
        return div;
    }
    else return nodiv;
}
//<%:testing-code%>
//Powered by [KawigiEdit] 2.0!
//<%:start-tests%>





  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器学习模型机器
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值