搜索法

请用二分法求方程的根，精确到小数点后9位。

#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;


long double f(long double mid)
{
    return mid*mid*mid-5*mid*mid+10*mid-80;
}

long double solve(long double t,long double x)
{
    long double eps=1e-11;
    while((x-t)>eps)
    {
        long double mid=(t+x)/2;
        if(f(mid)>0)
        {
            x=mid;
        }
        
        else
        {
            t=mid;
        }    
    }
        return x;
}

int main()
{
    cout<<setiosflags(ios::fixed)<<setprecision(9)<<solve(5,6);
    return 0;
}

给定一个浮点数n，求它的三次方根。

数据范围:−10000≤n≤10000

 

#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;

double n;

int main()
{
    bool sign;
    cin>>n;
    double l=-10000,r=10000;
    while(r-l>=1e-8)
    {
        double mid=(l+r)/2;
        if(mid*mid*mid>=n)
        r=mid;
        else
        l=mid;
    }
    cout<<setiosflags(ios::fixed)<<setprecision(6)<<l;
    return 0;
}

 

为了升级希卡之石林克来到了阿卡莱研究所。这个海拉鲁大陆最顶级的研究所，每天都要消耗大量的研究经费，

然而令人惊奇的是这个研究所的经费从不短缺，这完全得益于研究所制定预算的能力。

如果谁能搞清楚阿卡来研究所制定预算的算法，并且给出最佳预算的值，那么他就可以免费升级希卡之石。

林克显然不擅长做预算，作为他好朋友的你，可以出手相助吗？

已知研究所接下来N天（1≤N≤ 100,000）每日的固定支出预计为X(N)卢比。

研究所需要将未来的N天分为M组(1 ≤M≤N)，每组是1天或者连续的几天。

（假如第1，2，3天为一组，那么该组的总固定支出Total(1)是这三天的固定支出之和X(0)+X(1)+X(2)）

请问，如果一定要将未来的N天分为M组，假设分配给每组的预算是一个固定值Budget，并且不同组所得到的卢比即便有结余也不可以挪用。

求能够完全满足每组支出需要的最小的Budget值是多少。

 

输入

 

第一行包含两个整数N,M，用单个空格隔开。

第二行有N个从1到10000之间的整数，表示接下来N天里每天的固定支出预算。

 

输出

 

一个整数，即满足每组支出需要的最小的预算值。

 

输入样例 1 

7 5
100 400 300 100 500 101 400

输出样例 1

500

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std; 
int cost[100005];
int N,M,mincost=0,total=0;

bool isbudgetenough(int c_budget)
{
    int m=1,mtotal=0;
    for(int i=0;i<N;i++)
    {
        if(cost[i]>c_budget)        return false;
        if(cost[i]+mtotal>c_budget)
        {
            mtotal=cost[i];
            m++;
            if(m>M)
            return false;
        }
        else
        {
            mtotal+=cost[i];
        }
    }
    return true;
}

int binarysearch(int nums[],int n)
{
    int left=mincost,right=total;
    int lastvalidbudget=0;
    while(left<right)
    {
        int mid=(right+left)/2;
        if(isbudgetenough(mid))
        {
            lastvalidbudget=mid;
            right=mid;
        }
        else
        left=mid+1;
    }
    return lastvalidbudget;
}
int main()
{
    int r;
    cin>>N>>M;
    for(int i=0;i<N;i++)
    {
        cin>>cost[i];
        if(mincost>cost[i])        mincost=cost[i];
        total+=cost[i];
    }
    int budget=binarysearch(cost,N);
    cout<<budget<<endl;
    return 0;
}

 

林克被造的纪念日快要到了。根据任天堂公司的惯例，每年到这个时间都会一些蛋糕分给林克的朋友。

这些蛋糕有不同的口味，比如南瓜蛋糕、坚果蛋糕、西瓜蛋糕、胡萝卜蛋糕、水果蛋糕等等（有N种不同口味，大小不同的蛋糕）。
为了公平，每个朋友都会分到一块大小相同的蛋糕（不需要同样形状，但是要同一种口味，不允许混合口味，否则就会变成奇怪的菜肴）。
假设每个蛋糕都是一个高为1，半径不等的圆柱体，一共有F+1个人（F是林克的朋友个数，还要加上林克的设计者)。

所有人拿到的蛋糕是同样大小的，请问每个人拿到的蛋糕最大尺寸可以是多少？

 

输入

 

第一行包含两个正整数N和F，1 ≤ N, F ≤ 10 000，表示蛋糕的数量和朋友的数量。

第二行包含N个1到10000之间的整数，表示每个蛋糕的半径。

 

输出

 

输出每个人能得到的最大的蛋糕的体积，精确到小数点后三位。

 

输入样例 1 

3 3
4 3 3

输出样例 1

25.133

#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const double pi=acos(-1.0);
const double eps=1e-6;
double Cakes[10005];
int N,F;

bool hasenoughcake(double size)
{
    if(size<eps)    return true;
    int count=0;
    for(int i=0;i<N;i++)
    {
        if(size>Cakes[i])    continue;
        int pieces=Cakes[i]/size;
        count+=pieces;
        if(count>=F)    return true;
    }    
    return false;
} 

double binsearch(double nums[],int n)
{
    double left=nums[0]/F,right=nums[n-1];
    while(right-left>eps)
    {
        double mid=left+(right-left)/2;
        if(hasenoughcake(mid))
            left=mid+eps;
        else
            right=mid;
    }
    return left;
}

int main()
{
    int r;
    scanf("%d%d",&N,&F);
    F++;
    for(int i=0;i<N;i++)
    {
        scanf("%d",&r);
        Cakes[i]=r*r;
    }
    sort(Cakes,Cakes+N);
    double size=binsearch(Cakes,N);
    printf("%.3lf\n",size*pi);
}