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 41	
4 0
9 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 int
struct 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);
    }
}