BNU 49103 贪心【二分+贪心】

贪心

Time Limit: 1000ms

Memory Limit: 65536KB

64-bit integer IO format: %lld      Java class name: Main

Prev 

Submit Status Statistics Discuss

 Next

Type: 

None

 None Graph Theory     2-SAT     Articulation/Bridge/Biconnected Component     Cycles/Topological Sorting/Strongly Connected Component     Shortest Path         Bellman Ford         Dijkstra/Floyd Warshall     Euler Trail/Circuit     Heavy-Light Decomposition     Minimum Spanning Tree     Stable Marriage Problem     Trees     Directed Minimum Spanning Tree     Flow/Matching         Graph Matching             Bipartite Matching             Hopcroft–Karp Bipartite Matching             Weighted Bipartite Matching/Hungarian Algorithm         Flow             Max Flow/Min Cut             Min Cost Max Flow DFS-like     Backtracking with Pruning/Branch and Bound     Basic Recursion     IDA* Search     Parsing/Grammar     Breadth First Search/Depth First Search     Advanced Search Techniques         Binary Search/Bisection         Ternary Search Geometry     Basic Geometry     Computational Geometry     Convex Hull     Pick's Theorem Game Theory     Green Hackenbush/Colon Principle/Fusion Principle     Nim     Sprague-Grundy Number Matrix     Gaussian Elimination     Matrix Exponentiation Data Structures     Basic Data Structures     Binary Indexed Tree     Binary Search Tree     Hashing     Orthogonal Range Search     Range Minimum Query/Lowest Common Ancestor     Segment Tree/Interval Tree     Trie Tree     Sorting     Disjoint Set String     Aho Corasick     Knuth-Morris-Pratt     Suffix Array/Suffix Tree Math     Basic Math     Big Integer Arithmetic     Number Theory         Chinese Remainder Theorem         Extended Euclid         Inclusion/Exclusion         Modular Arithmetic     Combinatorics         Group Theory/Burnside's lemma         Counting     Probability/Expected Value Others     Tricky     Hardest     Unusual     Brute Force     Implementation     Constructive Algorithms     Two Pointer     Bitmask     Beginner     Discrete Logarithm/Shank's Baby-step Giant-step Algorithm     Greedy     Divide and Conquer Dynamic Programming                  Tag it!

小明喜欢养小鸡，小鸡喜欢吃小米。小明很贪心，希望养s只不同种类的小鸡，小鸡也很贪心，每天除了吃固定的ai粒小米外，还想多吃bi*s粒小米。

小明每天有M（0<=M<=10^9）粒小米可以喂小鸡，小鸡共有N（0<=N<=1000）种。问小明最多可以养多少只小鸡？

 

Input

多组数据，请读到文件尾

第一行，整数N，M，以空格分隔，之后两行，第一行为N个整数ai，第二行为N个整数bi。

ai、bi都在int范围内

Output

一行一个整数，s。

 

Sample Input

2 414 09 4

Sample Output

2

Source

第十三届北京师范大学程序设计竞赛决赛

Author

dlj

思路：

1、考虑到随着选择鸡的个数增加，而会升高花费，那么我们肯定直接贪心或者是Dp之类的解法肯定是不行的。

2、既然随着选择鸡的个数的增加，会升高花费，那么我们部分囊二分选择鸡的个数。

选的鸡越多，越不能养的起。

所以我们二分选择鸡的个数，然后按照花费贪心一下判定即可。

Ac代码：

#include<stdio.h>#include<string.h>#include<algorithm>using namespace std;#define ll long long intstruct node{    ll x,y,ss;}a[150000];ll n,m;ll cmp(node a,node b){    return a.ss<b.ss;}int Slove(ll mid){    ll sum=0;    for(ll j=1;j<=n;j++)a[j].ss=mid*a[j].y+a[j].x;    sort(a+1,a+1+n,cmp);    for(ll j=1;j<=mid;j++)    {        sum+=a[j].ss;    }    if(sum<=m)return 1;    else return 0;}int main(){    while(~scanf("%lld%lld",&n,&m))    {        ll output=0;        for(ll i=1;i<=n;i++)scanf("%lld",&a[i].x);        for(ll i=1;i<=n;i++)scanf("%lld",&a[i].y);        ll l=0;        ll r=n;        while(r-l>=0)        {            ll mid=(l+r)/2;            if(Slove(mid)==1)            {                output=mid;                l=mid+1;            }            else r=mid-1;        }        printf("%lld\n",output);    }}