二分法

Date：2019-07-25 16:03:14

算法实现

/*---------------------------有序数组中查找给定数字x-------------------------*/
#include <stdio.h>

//left=0, right=n-1
int binarySearch(int A[], int left, int right, int x)
{
    int mid;    //mid为left和right的中点
    while(left <= right)
    {
        //
        // 若right超过int型上界的一半，则left+right可能溢出
        // mid = left + (right - left)/2; 替代
        //
        mid = (left+right) / 2;

        if(A[mid] == x)
        {
            return mid;
        }
        else if(A[mid] > x)        //中间数大于x，则往左区间查找
        {
            right = mid - 1;
        }
        else                    //中间数小于x，则往右区间查找
        {
            left = mid + 1;
        }
    }

    return -1;    //查找失败，返回-1
}

int main(void)
{
    const int n = 10;
    int A[n] = {1, 3, 4, 6, 7, 8, 10, 11, 12, 15};
    printf("%d %d\n", binarySearch(A,0,n-1,6), binarySearch(A,0,n-1,9));
    /*
    output:
        3 -1
    */

    return 0;
}

/*----------------------求序列中的第一个大于等于x的元素的位置-------------------*/

//left=0, right=n
int lower_bound(int A[], int left, int right, int x)
{
    int mid;
    while(left < right)        //当left==right时，找到该位置
    {
        mid = left + (right-left)/2;
        if(A[mid] >= x)
        {
            right = mid;
        }
        else
        {
            left = mid + 1;
        }
    }

    //
    // 若所有元素均大于x，则返回left的值为0，即x应插入的位置是A[0]
    // 若所有元素均小于x，则返回left的值为n，即x应插入的位置是A[n]
    //
    return left;
}

/*---------------------求序列中第一个大于x的元素位置---------------------------*/

//left=0, right=n
int upper_bound(int A[], int left, int right, int x)
{
    int mid;
    while(left < right)
    {
        mid = left + (right-left)/2;
        if(A[mid] <= x)
        {
            left = mid + 1;
        }
        else
        {
            right = mid;
        }
    }

    return left;
}

/*-------------------------------计算根号2的近似值-----------------------------*/
const double eps = 1e-5;        //精度为10^-5

double f(double x)
{
    return x*x;
}

double calSqrt()
{
    double left=1, right=2, mid;
    while(right - left > eps)
    {
        mid = left + (right-left)/2;
        if(f(mid) > 2)
        {
            right = mid;
        }
        else
        {
            left = mid;
        }
    }

    return mid;
}

/*--------------给定一个定义在[L,R]上的单调函数f(x)，求方程f(x)=0的根-----------*/
const double eps = 1e-1;

double f(double x)
{
    return /*f(x)*/;
}

double solve(double L, double R)
{
    double left=L, right=R, mid;
    while(right-left < eps)
    {
        if(f(mid) < 0)
        {
            left = mid;
        }
        else
        {
            right = mid;
        }
    }

    return mid;
}

/*-----------------------------装水问题---------------------------*/
/*
问题描述：
    有一个侧面看去是半圆的储水装置，该半圆的半径为R，要求往里面装入高度为h的水，使其
侧面看去的面积S1与半圆面积S2的比例恰好为r。现给定R和r，求高度h。
*/

#include <cstdio>
#include <cmath>

const double PI = acos(-1.0);
const double eps = 1e-5;

double f(double R, double h)
{
    double alpha = 2*acos((R-h)/R);
    double L = 2*sqrt(R*R-(R-h)*(R-h));
    double S1 = alpha*R*R/2 - L*(R-h)/2;
    double S2 = PI*R*R/2;

    return S1/S2;
}

double solve(double R, double r)
{
    double left=0, right=R, mid;
    while(right - left > eps)
    {
        mid = left + (right-left)/2;
        if(f(R, mid) < r)
        {
            left = mid;
        }
        else
        {
            right = mid;
        }
    }

    return mid;
}

int main(void)
{
    double R, r;
    scanf("%lf%lf", &R, &r);

    printf("%.4f\n", solve(R, r));

    return 0;
}

/*----------------------------木棒切割问题---------------------------*/
/*
问题描述：
    给出N根木棒，长度均已知，现在希望通过切割它们来得到至少K段长度相等的木棒（长度必须是整数），
问这些长度相等的木棒最长能有多长
输入样例：
    3 7
    10 15 24
输出样例：
    6
*/
#include <stdio.h>
#include <algorithm>

using namespace std;

const int MAX_SIZE = 100010;

int wood[MAX_SIZE];

int number(int len, int n)
{
    int ans=0;
    for(int i=0; i<n; i++)
    {
        ans += wood[i]/len;
    }

    return ans;
}

int main(void)
{
    int n, k;
    scanf("%d%d", &n, &k);

    for(int i=0; i<n; i++)
    {
        scanf("%d", &wood[i]);
    }

    sort(wood, wood+n);

    /*
    随着每段木棒长度的增加，获得最大段数的木棒数递减
    即所求最后一个段数大于等于k的点，对应的长度即为所求
    即if(number(mid,n) >= k)，这样的判定条件会出现死循环
    可以转化为，求第一个长度小于k的点，即if(number(mid,n) > k)
    */
    int left=1, right=wood[n-1], mid;
    while(left < right)
    {
        mid = left + (right-left)/2;
        if(number(mid, n) > k)
        {
            left = mid + 1;
        }
        else
        {
            right = mid;
        }

    }

    printf("%d\n", left);

    return 0;
}

/*-------------------------------快速幂-------------------------------*/
/*
问题描述：
    求a^b，采用循环for(i=0; i<b; i++){ans *= a;}，时间复杂度为O(b)
    当b = 10^8甚至更大时，时间效率很低
    因此，可以采用二分法达到O(logb)的时间复杂度

    试求，a^b % m 的结果
*/

//
// 递归写法
//
typedef long long LL;

LL binaryPow(LL a, LL b, LL m)
{
    if(b == 0)
    {
        return 1;    //a^0 = 1
    }

    // b%2==1 等价于 b&1，即进行位与操作，判断b的末位是否为1，执行速度较快
    if(b%2 == 1)    //b为奇数
    {
        return a * binaryPow(a, b-1, m) % m;
    }
    else            //b为偶数
    {
        //此处若return binary()*binary；则时间复杂度会翻倍
        LL mul = binaryPow(a, b/2, m);
        return mul*mul%m;
    }
}

//
// 迭代写法
//
typedef long long LL;

LL binaryPow(LL a, LL b, LL m)
{
    LL ans=1;

    //b = 13 = 8 + 4 + 1 = 2^3 + 2^2 + 2^0
    //b                  = (1 1 0 1)2;
    while(b > 0)
    {
        if(b&1)    //b的二进制个位==1， ans累乘
        {
            ans *= a % m;
        }

        a = a * a % m;
        b >>= 1;    //将b的二进制右移1位，即b=b>>1或b=b/2;
    }

    return ans%m;
}